TS进阶（三）接口类型的兼容性（鸭子检测）

接口类型的兼容和接口的类型没有关系，只能属性有关系

1.函数参数的兼容性

函数参数的兼容性只需要传入的数据包含参数类型的属性就可以了，不关心类型，只关心属性

  interface  Animal {
        name:string,
        age:number,
    }
    interface Persion{
        name:string,
        speak:(word:string)=>string
    }

    function getName(anim :Animal):string
    {
        return anim.name;
    }
    let p ={
        name:"vvv",
        age:10,
        gender:0
    }
    getName(p); //接口的兼容和类型没有关系，只能属性有关系

2.基本类型的兼容

 let number1:string | number = null
    let string1:string = "vvv"
     number1 = string1 //成功

 let number1:string | number = null
    let string1:string = "vvv"
    // number1 = string1
    string1 = number1 //报错，不能把string | number 联合类型赋值给string类型

接口和对象的兼容

 let string2:{
        //这里面其实表示一个内部注释

        toString():string
    }
    let str2 :string = "dddd"
    string2 = str2 //这是因为str2里面包含一个toStrong() valueOf()方法
    // 也可以理解为 string的接口为下面这个接口
    // interface string :{
    //     toString():string,
    //     ValueOf():string 
    // }
    // 所以str2可以赋值给

类的兼容性

类的兼容性和类型无关，只跟属性有关，没有其他面向对象语言的中的父类的变量指向之类，子类不能指向父类实例的说法，只要属性相同，那么他们之间可以直接赋值

    class a {
        name:string
    }
    class  c extends a {
    }
    let A: a ;
    A = new c() //只需要类型一样就可以
//也可以这样赋值
 A ={
         name:"DDD"
     }  

函数兼容性

函数的兼容对于参数来说，可以少于定义的参数，或者没有参数，但是不能多参数，不然无法兼容。但是要保证参数的类型和返回值必须一样的，也就是函数的结构一致

 type sum = (a: number, b: number) => number
    let A1: sum;
    function A2(A: number, b: number): number {
        return A
    }
    A1 = A2
    function A3(A: number): number {
        return A
    }
    A1 = A3
    function A4(): number {
        return 1
    }
    A1 = A4
    function A5(A: number, b: number,c: number): number {
        return A
    }
    A1 = A5 //这个不能够兼容

函数比较返回值

对于函数返回值属性只能多不能少于，如果一定要返回少于类型的对象，那么可以使用返回值类型为any

 type man = () =>{name:string,age:number}
    let AM: man
    let c2 = function (){
        return  {name:"string"}
    }
    AM = c2 //不兼容
    console.log(AM());

如果改成这样

    type man = () =>{name:string,age:number}
    let AM: man
    let c2 = function (){
        return  {name:"string",age:1,p:2}
    }
    AM = c2 //返回属性对于也兼容
    console.log(AM());

 type man = () =>{name:string,age:number}
    let AM: man
    let c2 = function ():any{
        return  {name:"string"}
    }
    AM = c2 //可以兼容
    console.log(AM());

注意：赋值不尝试兼容

函数参数的协变

协变表示可以对于函数的参数进行扩展，也支持缩减类型的范围。实例如下

  type some = (a:number | string,c:number) =>number;
    let a:some;
    let c = function(a:number|string|boolean,c:number):number{
        return 1
    }
    a = c
    let c2 = function(a:number,c:number|string):number{
        return 1
    }
    a = c2
//两者都支持

枚举的兼容

枚举和数字是兼容的

  enum Colors {
        red,
        yellow
    }
   let c1 = Colors.red
   c1 =1