Typy warunkowe: T extends U ? X : Y

Witamy

Podstawowa składnia

type IsString<T> = T extends string ? true : false;
type A = IsString<string>; // true
type B = IsString<number>; // false

Wbudowany typ NonNullable

type NonNullable<T> = T extends null | undefined ? never : T;
type C = NonNullable<string | null>; // string

Typ warunkowy z generykami

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

Zagnieżdżone typy warunkowe

type TypeName<T> =
  T extends string ? 'string' :
  T extends number ? 'number' :
  T extends boolean ? 'boolean' :
  'object';

Rozdzielanie sum typów

type ToArray<T> = T extends any ? T[] : never;
type R = ToArray<string | number>; // string[] | number[]

Zapobieganie rozdzielaniu

type NoDistribute<T> = [T] extends [any] ? T[] : never;
type R2 = NoDistribute<string | number>; // (string | number)[]

Używanie never do filtrowania

type OnlyStrings<T> = T extends string ? T : never;
type S = OnlyStrings<'a' | 'b' | 1 | 2>; // 'a' | 'b'

Typy warunkowe w typach mapowanych

type NullableValues<T> = { [K in keyof T]: T[K] extends string ? null : T[K] };

Wnioskowanie z parametrów funkcji

type FirstParam<T> = T extends (first: infer P, ...rest: any[]) => any ? P : never;
type FP = FirstParam<(a: string, b: number) => void>; // string

Wbudowane narzędzia warunkowe

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

Szybki sprawdzian

Podsumowanie