你要的我有就可以，没有就不行

接口兼容性

interface Person1 {
  name: string
}
interface Person2 {
  name: string;
  age: number;
}

let obj1: Person1 = {
  name: 'xxx'
}

let obj2: Person2 = {
  name: 'xxx',
  age: 18
}

obj2 = obj1 // 错误：无法赋值，因为缺少属性，多了不影响，但是少了属性绝对不行

obj1 = obj2 是可以的

基本类型的兼容性

let num1: number
let num2: number | string

num1 = 10;
num2 = 'xxx'

num1 = num2 // 错误：无法赋值，因为缺少类型，多了不影响，但是少了类型绝对不行

num2 = num1 是可以的

类的兼容性

class Animal {
  name: string
}
class Bird extends Animal {
  age: number
}

let a: Animal;
let b = Bird;

b = a  // 错误：无法赋值，因为缺少类型，多了不影响，但是少了类型绝对不行

a = b 是可以的

函数的兼容性

type Func = (a: number, b: number) => number;

let sum: Func;
function f1 (a: number, b: number):void {
 // todo
}

sum = f1 // 错误：无法赋值，因为返回值类型不同

除了对比参数，还要对比返回值

type Func = (a: number, b: number) => number;

let sum: Func;
function f1 (a: number, b: number, c: number):number {
  return a
}

sum = f1 // 错误：无法赋值，多了参数不行，但是少参数可以
type GetPerson = () => {name: string, age: number};
let getPerson :GetPerson;
function g1 () {
  return {name: 'xxx'}
}
function g2 () {
  return {name: 'xxx', age: 18}
}
function g3 () {
  return {name: 'xxx', age: 18, sex: 1}
}

// getPerson = g1; 报错
// getPerson = g2; 正常
// getPerson = g3 正常

参数可以传自己和自己的父类，返回值可以传自己和自己的子类