Skip to main content

TypeScript 运算符

类型运算符​

typeof​

let s = "hello";
let n: typeof s; // string类型

keyof​

interface Person {
    name: string;
    age: number;
}

type PersonKeys = keyof Person; // "name" | "age"

in​

type Keys = "a" | "b" | "c"
type Obj = {
  [K in Keys]: string
} // { a: string, b: string, c: string }

条件类型​

基础条件类型​

type IsString<T> = T extends string ? true : false;

type A = IsString<string>;  // true
type B = IsString<number>;  // false

infer​

type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any;

function foo() { return 123; }
type FooReturn = ReturnType<typeof foo>; // number

映射类型​

Partial​

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

Required​

type Required<T> = {
    [P in keyof T]-?: T[P];
};

Readonly​

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

Pick​

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

Record​

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

联合类型和交叉类型​

联合类型 (|)​

type StringOrNumber = string | number;
let value: StringOrNumber = "hello"; // OK
value = 42; // OK

交叉类型 (&)​

interface A { a: string }
interface B { b: number }
type C = A & B;

let obj: C = { a: "hello", b: 42 };