基础类型

基础类型默认是不能相互赋值。在联合类型的帮助下可以相互赋值

  1. type NumOrStr = number | string;
  2. type NumOrStrOrBool = number | string | boolean;
  3. let num: NumOrStr = 123;
  4. let str: NumOrStr = "string";
  5. let bol: NumOrStrOrBool = true;
  6. // 联合类型，可以用少的联合类型 赋值 给多的联合，
  7. // 多的相当于少的父类
  8. bol = str;
  9. bol = num;
  10. // str = bol; // 缺少boolean类型
  11. // num = bol; // 缺少boolean类型

接口

接口赋值时会有类型兼容转化；
多属性的类型可以赋值给 少的类型; 接口属性 多赋值少 可以

  1. interface IAnimal{
  2.   legs: number;
  3.   name: string;
  4. }
  6. interface IDog{
  7.   legs: number;
  8.   name: string;
  9.   wang: string
  10. }
  11. let a: IAnimal; 
  12. let d: IDog;
  13. a = d; //可以正常赋值
  14. //d = a; // 会报错，a对象身上的类型少，给类型多的对象赋值，不安全

但是 值赋值给接口时，不会进行类型转换

  1. interface IAnimal{
  2.   legs: number;
  3.   name: string;
  4. }
  5. let wangcai:IAnimal= {
  6.   legs:4,
  7.   name: "旺财",
  8.   wang: "汪汪汪" //此处会报错，不存在的属性
  9. }

可以通过定义成变量，然后进行赋值

  1. interface IAnimal{
  2.   legs: number;
  3.   name: string;
  4. }
  5. let a: IAnimal; 
  6. // 定义成变量
  7. let wangcai= {
  8.   legs:4,
  9.   name: "旺财",
  10.   wang: "汪汪汪"
  11. }
  12. a = wangcai;

函数

函数参数赋值，少可赋多

少参数函数，可以赋值给多参数的函数。少传参数可以控制参数的安全性。

  1. let sum1 = (a:number, b:number): number => a+b;
  2. let sum2 = (a:number): number => a *10;
  3. sum1 = sum2;
  4. // sum2 = sum1; //报错，原因是无法限制b参数的类型
  1. function forEach<T>(arr: T[], cb: (item: T, index: number, arr: T[]) => void) {
  2.   for(let i = 0; i < arr.length; i++){
  3.     cb(arr[i], i, arr);  //这里cb必须是3个参数
  4.   }
  5. }
  6. forEach([1,2,3], (item)=>{ //这里面可以传0-3个参数
  7.   console.log(item);
  8. })

返回值，分基本值还是对象

  • 返回值是联合类型sum1函数可以赋值给返回值是小范围的函数sum2

    1. type sum1 = (a:number, b:number) => string | number;
    2. type sum2 = (a:number) => number;
    3. let s1:sum1;
    4. let s2:sum2;
    5. s1 = s2; // 返回值是单一类型可赋值给返回值是联合类型

  • 返回值是对象，可以把多参数的类型赋值给少参数的类型

    1. // 返回值是对象时，遵循的是接口的类型赋值转换
    2. type sum1 = (a:number, b:number) => {name: string};
    3. type sum2 = (a:number) => {name: string, age:number};
    4. let s1:sum1;
    5. let s2:sum2;
    6. s1 = s2; // 可以把多参数的类型，赋值给少参数的类型

    针对参数类型和返回值类型做兼容

    参逆父，返协子

函数参数：逆变

  1. class Parent {
  2.   money: number;
  3. }
  4. class Son extends Parent {
  5.   house: string;
  6. }
  7. class Grandson extends Son {
  8.   play: string;
  9. }
  10. function FN(cb: (person: Son) => Son) {}
  11. // 使用FN函数是，内部的cb调用，person参数的类型可以是Son，也可以是父类Parent，这是参数的逆变，使用父类型
  12. FN((person: Parent) => new Son)

函数返回值：协变

  1. class Parent {
  2.   money: number;
  3. }
  4. class Son extends Parent {
  5.   house: string;
  6. }
  7. class Grandson extends Son {
  8.   play: string;
  9. }
  10. function FN(cb: (person: Son) => Son) {}
  11. // FN的返回值，可以是Son类型，也可以是Son的子类型，这是返回值的协变
  12. FN((person: Son) => new Grandson)