说明

当一个类型Y可以被赋值给另一个类型X时，就可以说类型X兼容类型Y。广泛存在与接口、函数和类中 当原类型必须具备目标类型的必要属性时就可以赋值

Eg

ts
//类型兼容性  
interface user1 {
	name:string
}

interface user2 {
	name:string
	age:number
	sex:number
}

let a:user1 = {name:"xiao"}
let b:user2 = {name:"ming",age:18,sex:0}

a = b //当原类型必须具备目标类型的必要属性时就可以赋值

b= // error

函数的兼容性

两个函数是否兼容，函数做为参数的情况

目标函数兼容原函数需要满足三个条件

1. 参数个数

原函数参数个数小于目标函数参数个数(成员少的兼容成员多的)

ts
// 简单情况 两个函数参数都是固定参数  
type myFn=(a:number,b:number)=>void
function num(myFn:myFn){
	return myFn
}

// 原函数参数个数小于目标函数参数个数  
let myFn1=(a:number)=>{}
num(myFn1)
let myFn2=(a:number,b:number,c:number)=>{}
//num(myFn2)//error 类型“(a: number, b: number, c: number) => void”的参数不能赋给类型“myFn”的参数。

.......  

//复杂情况  
//1. 参数个数
//函数可选参数和剩余参数  
let a = (x:number,y:number)=>{} //含有固定参数
let b = (x?:number,y?:number)=>{} // 含有可选参数
let c = (x:number,...y:number[])=>{} //含有剩余参数
//固定参数可以兼容可选参数和剩余参数
a = b 
a = c
//可选参数不兼容固定参数和剩余参数  启用tsconfig.json中strictFunctionTypes:false，则不会报错可以兼容  
b = a
b = c
//剩余参数可以兼容固定参数和可选参数  
c = a
c = b

2. 参数类型

若两个函数的参数类型都是对象，参数多的兼容参数少的 两个函数相互赋值的情况称之为双向协变

ts
interface point3D {
  x: number;
  y: number;
  z: number;
}

interface point2D {
  x: number;
  y: number;
}

let p3d = (point: point3D) => {};
let p2d = (point: point2D) => {};

p3d = p2d;

// p2d = p3d;//error

3. 返回值类型

目标函数的返回值类型与原函数的返回值类型相同或为其子类型,成员少的兼容成员多的

ts
let a = () => ({ x: 1, y: 2 });
let b = () => ({ x: 1, y: 2, z: 3 });
a = b
b = a//error

......

function myfn(x: number, y: number): number;
function myfn(x: number, y: number): string;
// function myfn(x: any, y: any): any {}
// function myfn(x: any, y: any,z:any): any {} //error  重载列表的目标函数参数小于原函数的参数报错，应该大于原函数参数才兼容  
function myfn(x: any, y: any,){} //返回值类型必须与重载列表中目标函数的类型相同或为其子类型  

### 枚举类型兼容性

//枚举类型  
enum info1 {name}
enum info2 {age,sex}
enum info3 {active="move"}
let man:info1.name = 3  
let human:number = info2.age
let manActive:string = info3.active
// let people:info1.name = info2.age  //error

类的兼容性

两个类的属性相同且都是公共属性，相互兼容

ts
class aBox {
	constructor() {
	}

	name: string = "123"
	age: number = 18
}

class bBox {
	constructor() {
	}

	name: string = "123"
	age: number = 18
}

let a = new aBox()
let b = new bBox()

a = b
b = a

两个类的属性不同都是公共属性，属性少的兼容属性多的

ts

class aBox {
	constructor() {
	}

	name: string = "123"
	age: number = 18
}

class bBox {
	constructor() {
	}

	name: string = "123"
}

let a = new aBox()
let b = new bBox()

a = b//error
b = a

两个类属性不管是否相同，只要一个具有私有属性则无法相互兼容

ts
class aBox {
	constructor() {
	}

	private name: string = "123"
}

class bBox {
	constructor() {
	}

	name: string = "123"
}

let a = new aBox()
let b = new bBox()

a = b
b = a

父类和子类可以相互兼容

ts
class aBox {
	constructor() {
	}

	private name: string = "123"
}

class bBox extends aBox{}

let a = new aBox()
let b = new bBox()

a = b
b = a

泛型的兼容性

两个泛型的兼容性

当泛型T被使用时无法兼容

ts
interface name<T>{
	value:T
}

let obj1:name<number>={value:18}
let obj2:name<string>={value:"小明"}

obj1 = obj2//error
obj2 = obj1//error

两个泛型函数的兼容性

可以相互兼容

ts
let getname=<T>(x:T):T =>{return x}
let getage=<U>(x:U):U =>{return x}

getage = getname

Tips

记忆规则

当一个类型Y可以赋值给类型X时，则称之为类型X可以兼容类型Y 结构之间兼容：成员少的可以兼容成员多的 函数之间兼容：参数多的可以兼容参数少的