Wprowadzenie do typów warunkowych

Typy warunkowe w TypeScript pozwalają tworzyć typy, które dynamicznie dostosowują się na podstawie warunku, dzięki czemu kod staje się bardziej elastyczny i można go ponownie wykorzystywać.

Używają składni podobnej do operatora warunkowego (ternary) w JavaScript.

Czym są typy warunkowe

Typy warunkowe pozwalają definiować typ zależny od innego typu. Podstawowa składnia wygląda następująco:

T extends U ? X : Y

Oznacza to: jeśli T rozszerza U, typem jest X, w przeciwnym razie jest nim Y.

Podstawowy przykład typów warunkowych

Oto prosty przykład:

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

// Test cases
type A = IsString<string>; // 'Yes'
type B = IsString<number>; // 'No'

Używanie typów warunkowych w przeciążeniach funkcji

Typy warunkowe mogą uprościć przeciążenia funkcji, dynamicznie określając typy zwracane:

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

function getData(): string {
  return 'Hello';
}

type DataType = ReturnType<typeof getData>; // string

Rozdzielne typy warunkowe

Gdy typy warunkowe są stosowane do typów unii, są rozdzielane na poszczególne elementy unii:

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

type A = ToArray<string | number>;
// A = string[] | number[]

Łączenie typów warunkowych z typami mapowanymi

Typy warunkowe można łączyć z typami mapowanymi, aby wykonywać zaawansowane transformacje typów:

type User = {
  id: number;
  name: string;
  isAdmin?: boolean;
};

type MakeRequired<T> = {
  [K in keyof T]-?: T[K] extends undefined ? never : T[K];
};

type RequiredUser = MakeRequired<User>;
// { id: number; name: string; isAdmin: never; }

Typowe zastosowania typów warunkowych

Typy warunkowe są często używane do:

• Wnioskowania typów zwracanych lub parametrów.
• Przekształcania unii i przecięć.
• Tworzenia typów użytkowych, takich jak Exclude, Extract i NonNullable.

Zadanie praktyczne

Utwórz typ warunkowy, który sprawdza, czy dany typ jest tablicą, i jeśli tak, zwraca typ jej elementów; w przeciwnym razie zwraca sam typ.

Gratulacje!

Nauczyli się Państwo używać typów warunkowych do tworzenia dynamicznych i wielokrotnego użytku definicji typów w TypeScript. Proszę przećwiczyć te zagadnienia, aby pisać bardziej zaawansowany i elastyczny kod TypeScript!