一、对象和接口兼容
多的可以赋值给少的，少的不能赋值多的。
兼容时，会进行层层递归进行检查
interface Testinterface{
name:string
}
let p = { name:'wds'} ;
let p1 = { age:23};
let p3 = { age:23,name:'www'};
let t:Testinterface;
t=p;
t=p1;//报错
t=p3;
//多层兼容
interface Testinterface{
name:string,
children:{
age:number//层层递归进行检查
}
}
let p = { name:'wds' ,children:{ age:35}} ;
let p2 = { name:'wds' ,children:{ age:'eeee'}} ;
let t:Testinterface;
t=p;
t=p2;//报错
二、函数兼容性
1、参数兼容
参数少的可以兼容参数多的，参数多的不能兼容参数少的
let fn = (x:number,y:number)=>{}
let fn1 = (x:number)=>{}
fn = fn1;
fn1 = fn//报错
2、返回值类性兼容
不同类性不能兼容
- 返回值个数兼容的规则与参数类性兼容规则一致
let fn = (x:number):number=>123;
let fn1 = (x:number):number=>4567;
let fn2 = (x:number):string=>'234';
fn = fn1;
fn2 = fn1//报错
3、函数双向协变
（1）参数双向协变
确定类性和联合类性可以相互兼容。
let fn = (x:(number|string))=>{}
let fn1 = (x:(number))=>{}
fn = fn1
fn1 = fn
（2）返回值双向协变
确定类性的不能兼容联合类型的。
let fn = (x:(number)):(number|string)=>{ return x?123:'str'}
let fn1 = (x:(number)):number=>{return 123}
fn = fn1
fn1 = fn//报错
4、函数重载兼容
重载多的可以兼容重载少的，反之则不可以。
function add (x:number,y:string):number
function add (x:string,y:string):string
function add(x,y){
return x+y
}
function sub (x:string,y:string):string
function sub(x,y){
return x+y
}
let fn = add;
let fn1 = sub
fn1 = fn
fn = fn1//报错
三、枚举兼容
- 数字枚举可以兼容数字
- 不同的枚举之间不能兼容
- 字符串枚举不能兼容字符串
enum Myenum{
male,
female,
}
let q=Myenum.male;
q=2//不报错
enum Myenum2{
male,
female,
}
enum Myenumone{
dog,
cat,
}
let a = Myenum.male;
a = myenumone.dog//报错
enum Myenum3{
male='str',
female='female',
}
let p = Myenum.male
p = '123234234'//报错
四、类的兼容性
- 参数多的可以兼容参数少的，判断依据仅判断实例的参数和方法，而静态方法和属性则不会影响类的兼容性，
- protected和private会影响类的兼容性
class Person{
protected name:string
// public age:number
}
class Son{
protected name:string
}
let p : Person
let s : Son
p = s//报错
s = p//报错
五、泛型兼容
声明不影响兼容，只有使用才会影响兼容
interface setNubmer<T>{
age:T
}
let t:setNubmer<number>;
let s:setNubmer<string>;
t = s;
s = t
