TS-兼容性

TS 中的兼容性，主要看结构是否兼容。（核心是考虑安全性）

一.基本数据类型的兼容性

let temp: string | number
let num!: number
temp = num

你要的我有就可以

let num: {
  toString(): string
}
let str: string = "zf"
num = str // 字符串中具备toString()方法，所以可以进行兼容
type T1 = string extends { toString(): string } ? true : false //true

• 我们可以把 string 看成一个对象 基于 toString 扩展了其他的功能

二.接口兼容性

interface IAnimal {
  name: string
  age: number
}
interface IPerson {
  name: string
  age: number
  address: string
}
let animal: IAnimal
let person: IPerson = {
  name: "zs",
  age: 11,
  address: "回龙观",
}
animal = person // 子类赋予给父类 兼容 、 你要的我都有安全
type T2 = IPerson extends IAnimal ? true : false //true

接口的兼容性，只要满足接口中所需要的类型即可！
多的赋给少的 | 子类赋予给父类

三.函数的兼容性

函数的兼容性主要是比较参数和返回值,利于 forEach 函数提供三个参数，但是我们可以只用一个

• 参数

  少的赋予给多的，多了无法判断类型是否正确，不安全

  let sum1 = (a: string, b: string) => a + b
  let sum2 = (a: string) => a
  sum1 = sum2

  赋值函数的参数要少于等于被赋值的函数，与对象相反

  type Func<T> = (item: T, index: number) => void
  function forEach<T>(arr: T[], cb: Func<T>) {
    for (let i = 0; i < arr.length; i++) {
      cb(arr[i], i)
    }
  }
  forEach([1, 2, 3], (item) => {
    console.log(item)
  })

• 返回值

  type sum1 = () => string | number
  type sum2 = () => string
  
  let fn1: sum1
  let fn2!: sum2
  fn1 = fn2

四.标称类型

class AddType<S> {
  private _type!: S
}
type NewType<T, S extends string> = T & AddType<S>

type BTC = NewType<number, "btc"> // number + BTC
type USDT = NewType<number, "usdt"> // number + USDT
let btc = 100 as BTC
let usdt = 100 as USDT

function getCount(count: USDT) {
  return count
}
getCount(usdt) // 标称类型

五.类的兼容性

class Perent {
  name: string = "zs"
  age: number = 11
}
class Parent1 {
  name: string = "zs"
  age: number = 11
}
let parent: Perent = new Parent1()

这里要注意的是，只要有 private 或者 protected 关键字类型就会不一致;但是继承的类可以兼容

class A {
  private name!: string
  age!: number
}

class B {
  private name!: string
  age!: number
}

let a: A = new B() // 语法错误

class Parent1 {
  protected name: string = "zs"
  age: number = 11
}
class Child extends Parent1 {}
let child: Parent1 = new Child()

六.泛型的兼容性

泛型的兼容性 泛型比较的是最终的结果 比较的不是泛型传递的参数

interface II<T> {
  a: T
}
let a1!: II<string>
let a2!: II<number>

type xx = II<string> extends II<number> ? true : false //false
a1 = a2 // 语法错误

七.枚举的兼容性

enum USER1 {
  role = 1,
}
enum USER2 {
  role = 1,
}
let user1!: USER1
let user2!: USER2
user1 = user2 // 错误语法

不同的枚举类型不兼容