ชนิดข้อมูลแบบแมปและชนิดข้อมูลแบบมีเงื่อนไข

ชนิดข้อมูลแบบแมป — แปลงทุกคุณสมบัติ

// Partial implemented as a mapped type:
type MyPartial<T> = {
  [K in keyof T]?: T[K];
};

// Readonly:
type MyReadonly<T> = {
  readonly [K in keyof T]: T[K];
};

การแมปคีย์ใหม่ด้วย as

type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

type UserGetters = Getters<{ name: string; age: number }>;
// { getName: () => string; getAge: () => number }

การกรองคุณสมบัติด้วย never

// Keep only function-valued properties:
type FunctionProperties<T> = {
  [K in keyof T as T[K] extends Function ? K : never]: T[K];
};

ชนิดข้อมูลแบบมีเงื่อนไข — if/else สำหรับชนิดข้อมูล

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

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

type Flatten<T> = T extends Array<infer E> ? E : T;
type StrArr = Flatten<string[]>; // string
type Num = Flatten<number>;       // number

ชนิดข้อมูลแบบมีเงื่อนไขชนิดกระจาย

type ToArray<T> = T extends any ? T[] : never;

type StringOrNumberArray = ToArray<string | number>;
// string[] | number[]  (not (string | number)[])

การใช้ infer เพื่อดึงชนิดข้อมูล

type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;

type Resolved = UnwrapPromise<Promise<string>>; // string
type Direct = UnwrapPromise<number>;             // number

ชนิดลิเทอรัลของแม่แบบ

type Side = 'top' | 'right' | 'bottom' | 'left';
type PaddingKey = `padding-${Side}`;
// 'padding-top' | 'padding-right' | 'padding-bottom' | 'padding-left'

type EventName<T extends string> = `on${Capitalize<T>}`;
type ClickEvent = EventName<'click'>; // 'onClick'

การรวมชนิดข้อมูลแบบแมปและแบบมีเงื่อนไข

// Make all functions in an object async:
type Asyncify<T> = {
  [K in keyof T]: T[K] extends (...args: infer A) => infer R
    ? (...args: A) => Promise<R>
    : T[K];
};

ชนิดอรรถประโยชน์แบบเรียกซ้ำ DeepPartial

type DeepPartial<T> = {
  [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
};

การใช้งานจริง: ชนิดข้อมูลการตอบกลับของ API

หลีกเลี่ยงการออกแบบที่ซับซ้อนเกินจำเป็น

ตรวจสอบอย่างรวดเร็ว

สรุป: ชนิดข้อมูลแบบแมปและมีเงื่อนไข