TypeScript 学习 -类型 - 8

交叉类型 与 联合类型

交叉类型

interface DogInterface {
  run(): void;
}

interface CatInterface {
  jump(): void;
}

let pet: DogInterface & CatInterface = {
  run() {},
  jump() {},
};

联合类型

• 只能访问公共的方法
• 约束不可以漏处理某个类型

type Shape = Square | Rectangle | Circle;

// 约束不可以漏处理某个类型
// 如果 case 有遗漏, 会报错
function area(s: Shape) {
  switch (s.kind) {
    case "square":
      return s.size * s.size;
    case "rectangle":
      return s.height * s.width;
    case "circle":
      return Math.PI * s.r ** 2;
    default:
      // 如果可以走到 default , 则会判断传入的参数是不是 never 类型, 如果 case 有遗漏, 会报错
      return ((e: never) => {
        throw new Error(e);
      })(s);
  }
}

索引类型

• Readonly 只读
• Partial 可选
• Pick 抽取部分属性
• Record 创建一些新的属性

// 约束 keys 的类型
interface Obj {
  a: string;
  b: number;
  c: boolean;
}
// 把所有的属性变成只读
type ReadonlyObj = Readonly<Obj>;

var a: ReadonlyObj = {
  a: 'a',
  b: 1,
  c: true,
};

// 把所有的属性变成可选
type PartialObj = Partial<Obj>;

var b: PartialObj = {
  a: 'a',
};

// 抽取部分属性
type PickObj = Pick<Obj, 'a' | 'b'>;
var c: PickObj = {
  a: 'a',
  b: 1,
};

// 创建一些新的属性
type RecordObj = Record<'x' | 'y', Obj>;
var d: RecordObj = {
  x: {
    a: 'a',
    b: 1,
    c: true,
  },
  y: {
    a: 'b',
    b: 2,
    c: false,
  },
};

条件类型

• extends
  • T extends U ? X : Y
• Exclude<T, U> - 从类型 T 中排除掉那些可以赋值给类型 U 的类型
• NonNullable<T> - 从类型 T 中移除 null 和 undefined
• Extract<T, U> - 从类型 T 中提取所有可以赋值给类型 U 的类型
• ReturnType<T> - 获取函数类型 T 的返回类型

type IsString<T> = T extends string ? "Yes" : "No";

type Result1 = IsString<string>;  // "Yes"
type Result2 = IsString<number>;  // "No"

type ExcludeExample = Exclude<"a" | "b" | "c", "a" | "b">;  // "c"

type NonNullableExample = NonNullable<string | null | undefined>;  // string

type ExtractExample = Extract<"a" | "b" | "c", "b" | "c" | "d">;  // "b" | "c"

type MyFunction = (x: number, y: number) => string;

type ReturnTypeExample = ReturnType<MyFunction>;  // string