【TS04——接口的多态——泛型接口】-CFANZ编程社区

接口的多态，同一个方法，传入不同的参数，他所对应的操作不同成为多态【参数不同】
或者可以理解为同一个方法，返回不同的结果，称之多态。

interface IfnPerson {
    run():void
    run(id:number):void
    run(id:number,name:string):void
}

class Person implements IfnPerson{
    run():void
    run(id:number):void
    run(id:number,name:string):void
    run(id?:number,name?:string):void{
        console.log(id,name);   
    }
}

const p  = new Person();
p.run()
p.run(12)
p.run(12,"wwqiew")

interface IfnPerson {
    run():void
    run(id:number):void
    run(id:number,name:string):void
}

class Person implements IfnPerson{
    run():void
    run(id:number):void
    run(id:number,name:string):void
    run(id?:number,name?:string):void|string|number{
        if(arguments.length===0){
            return "没有参数"
        }else if(id as number>0 && name === undefined){
            return id;
        }else{
            return id as number+<string>name
        }
    }
}

const p  = new Person();
p.run()
p.run(12)
console.log(p.run(12,"wwqiew"));

泛型：宽泛的类型，在定义时指占位，不确定类型，在调用时才给定类型。
定义一个函数或类时，在定义时还无法确定它参数或返回值是什么类型，这时可以用any或unknown来解决，当然也可以使用泛型定占位。

参数是任意类型，返回也是任意类型来规避，ts的类型检查。

function fn(arg:any):any{
    console.log(arg);
    
    return arg
}
fn(1)
fn("wqw")
fn(false)

泛型函数

在定义时不指定类型，返回时指定类型；

function fn<T>(arg:T):T{
    console.log(arg);
    
    return arg
}

fn<string>("1")
fn<Array<string>>(["1","ok"])

实例化类——的函数

function fn<T>(classname:{new():T}){
    return new classname();
}
//箭头函数写法
//const fn = <T>(classname:{new() :T}):T=>new classname()
class A{}
class B{}
// 类也可以作为类型
let a = fn<A>(A);
let b = fn<B>(B);

泛型类型限制
定义一个泛型类。

class  User<T>{
    private useList:T[] = []
    push = (value:T)=>{
        this.useList.push(value)
    }
}

let user = new User<string>();

user.push("a")

console.log(user);


//用接口来规范泛型类
interface Ic{
    id:number,
    name:string
}

let user = new User<Ic>()
user.push({id:1,name:"niuniu"})

console.log(user);

泛型是可以多个的。多个以逗号隔开。

class User<T,K>{
    name!:T;
    age!:K;
    constructor(name:T,age:K){
        this.age = age;
        this.name = name;
    }
}

let user =new User("niuniu",25)

泛型也可以限制类型。
当前的T类型中一定要与在extends指定的父类型（接口）中得有此属性，没有那就嗝屁。

interface Ic{
    length:number
}

function test<T extends Ic>(arg:T){
    console.log(arg.length);
    return arg.length
}

test({length:123})
test<string>("wqewq")
test<number[]>([1,2])

【TS04——接口的多态——泛型接口】_前端

// 条件交换
type Excludetype<T,K> = T extends K ? never:T
// 类型的范围限制
type Test = Excludetype<object|string,string|number|boolean>

泛型默认值

function test<T = number>(arg:T):number{
    return (arg as unknown as string).length
}
// 可以不写为自动类型
test("1")

class Person<T=string,k=number>{
    name!:T
    age!:k
}

const p = new Person()

泛型接口

定义接口时，没有指定类型。
声明的时候去指定类型

interface Isum<T,K>{
    (a:T,b:K):void
}
const fn:Isum<number,string> = (a:number,b:string)=>{
    console.log(a,b);       
}

或者
给函数使用，在调用时给定类型

interface Isum{
    <T,K>(a:T,b:K):void
}

const fn:Isum = <T,K>(a:T,b:K):void=>{
    console.log(a,b);       
}

fn<number,string>(1,"2")

函数的协变和逆变

函数中返回值就是协变，函数形参就是逆变。
协变：类型是自己或子类
逆变：类型是自己或父类