ts学习笔记（2）

类型推论

let str='1'
str=0;

let arr=['xx',1];//等同于 let arr:Array<string,number>=['xx',1]
arr=[1,2,false]

上面两个会报错，因为第一个会把str推断为string类型，再赋值为其他类型就会报错。arr也一样，会推断为联合类型，就是包含字符串和number的类型，再添加布尔类型会报错

兼容性

interface A{name:string,age:number}
var obj1={name:'xx',age:20}
var obj2={name:'zz'}
obj1=obj2;//报错
obj2=obj1;//正确 少的可以兼容多的

函数参数双向协变

 let func1=(arg:number|string):void=>{}
 let func2=(arg:number):void=>{}
 func2=func1
//正确

var a=():number|string=>0;
var b=():string=>'xx';
a=b;//正确

var a=():number=>0;
var b=():string=>'xx';
a=b;//错误

函数重载

function fn(a:number,b:number):number
function fn(a:string,b:string):string
function fn(a:any,b:any):any{
    if(typeof a=='number'){
        return a+b;
    }else if(typeof a=='string'){
        return a+b+"!"
    }else
    {
        return null;
    }
}
console.log(fn(1,2))
console.log(fn('xx','zz'))

类继承

class Animal{
  
    constructor(){
        //this.name=name;
    }
    public age:string;
}
class Cat extends Animal{
    public name:string;
    constructor(){
        super();    
    }
}

var a:Animal;
var b:Cat;
a=b;//正确 
b=a;//错误
//父类可以兼容子类，子类不可以兼容父类

class Cat {
    public name:string;
    constructor(){
       
    }
}
class Dog{
    public static age:number;
    public name:string;
    constructor(){}

}
var a:Cat;
var b:Dog;
b=a;//a和b可以相互兼容，不管静态属性和方法，只管实例对象

接口兼容

interface A<T>{}
var a:A<string>
var b:A<number>
a=b;//正确

interface A<T>{name:T}
var a:A<string>
var b:A<number>
a=b;
//错误