TS类型推论和兼容性

1.类型推断

不用明确告诉编译器具体是什么类型, 编译器就知道是什么类型。

(1)根据初始化值自动推断

如果是先定义在初始化, 那么是无法自动推断的

	let value;
	value = 123;
	value = false;
	value = 'abc';

如果是定义的同时初始化, 那么TS就会自动进行类型推荐

	let value = 123; // let value:number = 123;
	value = 456;
	value = false;
	value = 'abc';
	
	let arr = [1, 'a']; // let arr:(number | string) = [1, 'a'];
	arr = ['a', 'b', 'c', 1, 3, 5, false]

(2)根据上下文类型自动推断

	window.onmousedown = (event)=>{
	    console.log(event.target);
	}

2.类型兼容性

	interface TestInterface {
	    name:string;
	}
	
	let p1 = {name:'lnj'};
	let p2 = {age:18};
	let p3 = {name:'lnj', age:18};
	
	let t:TestInterface;
	t = p1;
	t = p2;
	t = p3; // 可多不可少
	
	interface TestInterface {
	    name:string;
	    children:{
	        age:number
	    };
	}
	
	let p1 = {name:'lnj', children:{age:18}};
	let p2 = {name:'lnj',children:{age:'abc'}};
	let t:TestInterface;
	t = p1;
	t = p2; // 会递归检查

3.函数兼容

(1)参数个数

	let fn1 = (x:number, y:number)=>{};
	let fn2 = (x:number)=>{};
	fn1 = fn2;
	fn2 = fn1; // 可少不可多

(2)参数类型

	let fn1 = (x:number)=>{};
	let fn2 = (x:number)=>{};
	let fn3 = (x:string)=>{};
	fn1 = fn2;
	fn2 = fn1;
	fn1 = fn3; // 必须一模一样
	fn3 = fn1;

(3)返回值类型

	let fn1 = ():number=> 123;
	let fn2 = ():number=> 456;
	let fn3 = ():string=> 'abc';
	fn1 = fn2;
	fn2 = fn1;
	fn1 = fn3; // 必须一模一样
	fn3 = fn1;

(4)函数双向协变

参数的双向协变：

	let fn1 = (x:(number | string)) =>{};
	let fn2 = (x:number) =>{};
	fn1 = fn2;
	fn2 = fn1;

返回值双向协变：

	let fn1 = (x:boolean):(number | string) => x ? 123 : 'abc';
	let fn2 = (x:boolean):number => 456;
	// fn1 = fn2; // 但是可以将返回值是具体类型的赋值给联合类型的
	fn2 = fn1; // 不能将返回值是联合类型的赋值给具体类型的

(5)函数重载

	function add(x:number, y:number):number;
	function add(x:string, y:string):string;
	function add(x, y) {
	    return x + y;
	}
	
	function sub(x:number, y:number):number;
	function sub(x, y) {
	    return x - y;
	}
	// let fn = add;
	// fn = sub; // 不能将重载少的赋值给重载多的
	let fn = sub;
	fn = add; // 可以将重载多的赋值给重载少

4.枚举兼容性

(1)数字枚举与数值兼容

	enum Gender{
	    Male,
	    Female
	}
	let value:Gender;
	value = Gender.Male;
	value = 1

(2)数字枚举与数字枚举不兼容

	enum Gender{
	    Male, // 0
	    Female // 1
	}
	enum Animal{
	    Dog, // 0
	    Cat // 1
	}
	let value:Gender;
	value = Gender.Male;
	value = Animal.Dog; // 报错

(3)字符串枚举与字符串不兼容

	enum Gender{
	    Male = 'abc',
	    Female  = 'def'
	}
	let value:Gender;
	value = Gender.Male;
	value = 'abc';

5.类兼容性

只比较实例成员, 不比较类的构造函数和静态成员

	class Person {
	    public name:string;
	    // public age:number;
	    public static age:number;
	    constructor(name:string, age:number){}
	}
	class Animal {
	    public name:string;
	    constructor(name:string){}
	}
	let p: Person;
	let a: Animal;
	p = a;
	a = p; // 可多不少

类的私有属性和受保护属性会响应兼容性

	class Person {
	    protected name:string;
	}
	class Animal {
	    protected name:string;
	}
	let p: Person;
	let a: Animal;
	p = a;
	a = p; // 可多不少

6.泛型兼容性

泛型只影响使用的部分, 不会影响声明的部分。

	interface TestInterface<T> {
	    // age:T;
	}
	let t1: TestInterface<number>; // age:number
	let t2: TestInterface<string>; // age:string
	t1 = t2;
	t2 = t1;