TypeScript笔记

类型检查

1. instanceof

class Pet {
  eat(): void {
    console.log('eat');
  }
  sleep(): void {
    console.log('sleep');
  }
}

const p1 = new Pet();

console.log(p1 instanceof Pet);

// true

2. in

interface IHuman {
  name: string;
  age: number;
  gender: string;
}
const human: IHuman = {
  name: 'Tom',
  age: 18,
  gender: 'male'
};

console.log('name' in human);

// true

3. typeof

function doSth(params: number | string) {
  typeof params === 'string'
    ? console.log(`string: ${params}`)
    : console.log(`number: ${params}`);
}

doSth('typescript');

// string: typescript

交叉类型

interface IEat {
  eat(): void;
}

interface IDrink {
  drink(): void;
}

const pet: IEat & IDrink = {
  eat() {},
  drink() {}
};

联合类型

interface IEat {
  eat(): void;
}

interface IDrink {
  drink(): void;
}

const pet: IEat | IDrink = {
  eat() {}
};

索引类型

interface IHuman {
  name: string;
  age: number;
  gender: string;
}

const human: IHuman = {
  name: 'Tom',
  age: 18,
  gender: 'male'
};

function getHumanDetail<T, K extends keyof T>(
  obj: T,
  keys: Array<K>
): Array<T[K]> {
  return keys.map(key => obj[key]);
}

getHumanDetail(human, ['name', 'age', 'gender']);

// [ 'Tom', 18, 'male' ]

映射类型

1.readonly（只读）

type Readonly<T> = {
    readonly [P in keyof T]: T[P]
}


interface IHuman {
  name: string;
  age: number;
  gender: string;
}

type ReadonlyHuman = Readonly<IHuman>;

2.partial（可选）

type Partial<T> = {
    [P in keyof T]?: T[P]
}


interface IHuman {
  name: string;
  age: number;
  gender: string;
}

type PartialHuman = Partial<IHuman>;

3.pick（子集）

type Pick<T, K extends keyof T> = {
    [P in K]: T[P];
};

interface IHuman {
  name: string;
  age: number;
  gender: string;
}

type PickHuman = Pick<IHuman, 'name'>;

4.record（新属性）

type Record<K extends keyof any, T> = {
    [P in K]: T;
};

interface IHuman {
  name: string;
  age: number;
  gender: string;
}

type PickHuman = Record<'key', IHuman>;