Wprowadzenie do typów mapowanych

Typy mapowane umożliwiają przekształcanie istniejących typów w nowe przez zastosowanie operacji do każdej właściwości typu.

Są przydatne do tworzenia elastycznych struktur typów, które można wielokrotnie wykorzystywać w TypeScript.

Czym są typy mapowane?

Typy mapowane wykorzystują składnię taką jak { [P in keyof T]: T[P] }, aby iterować po właściwościach typu T.

Podstawowy przykład typów mapowanych

Oto prosty przykład użycia typu mapowanego do utworzenia wersji typu przeznaczonej tylko do odczytu:

type User = {
  name: string;
  age: number;
};

type ReadonlyUser = {
  readonly [P in keyof User]: User[P];
};

Korzystanie z wbudowanych typów mapowanych

TypeScript udostępnia kilka wbudowanych typów mapowanych, takich jak:

• Readonly<T>: sprawia, że wszystkie właściwości typu T są tylko do odczytu.
• Partial<T>: sprawia, że wszystkie właściwości typu T są opcjonalne.
• Required<T>: sprawia, że wszystkie właściwości typu T są wymagane.

type User = {
  name: string;
  age: number;
};

// Example of Partial
const user: Partial<User> = {
  name: 'John',
};

Mapowanie typów unii

Typów mapowanych można również używać z typami unii, aby tworzyć nowe, połączone typy:

type Status = 'active' | 'inactive';

type StatusFlags = {
  [K in Status]: boolean;
};

const flags: StatusFlags = {
  active: true,
  inactive: false,
};

Warunkowe typy mapowane

Typów warunkowych można używać razem z typami mapowanymi do tworzenia bardziej złożonych przekształceń typów.

type User = {
  name: string;
  age?: number;
};

type NonOptional<T> = {
  [K in keyof T]-?: T[K];
};

type RequiredUser = NonOptional<User>;

Zaawansowany przykład: wykluczanie właściwości

Oto sposób tworzenia typu mapowanego wykluczającego określone właściwości:

type User = {
  id: number;
  name: string;
  password: string;
};

type PublicUser = {
  [K in keyof User as Exclude<K, 'password'>]: User[K];
};

Zadanie praktyczne

Należy utworzyć typ mapowany, który doda modyfikator readonly do wszystkich właściwości typu Product. Następnie należy go przetestować, deklarując zmienną nowego typu.

Gratulacje!

Nauczyli się Państwo używać typów mapowanych do dynamicznego przekształcania istniejących typów w nowe. Proszę ćwiczyć te techniki, aby jeszcze zwiększyć możliwości kodu TypeScript!