Introducere în Tipurile mapate TypeScript

Tipurile mapate în TypeScript oferă o modalitate de a crea noi tipuri prin transformarea celor existente. Sunt un instrument puternic pentru gestionarea operațiunilor de tip complex și pentru asigurarea siguranței tipului în aplicațiile TypeScript. Acest articol prezintă tipurile mapate, explică sintaxa acestora și oferă exemple pentru a demonstra utilizarea lor.

Ce sunt tipurile mapate?

Tipurile mapate permit crearea de noi tipuri prin aplicarea unei transformări fiecărei proprietăți a unui tip existent. Ele sunt adesea folosite pentru a modifica sau extinde tipurile într-un mod flexibil. Sintaxa de bază a unui tip mapat este:

type MappedType = {
  [K in keyof T]: NewType;
};

În această sintaxă:

• T este tipul original.
• K reprezintă fiecare cheie din T.
• NewType este noul tip atribuit fiecărei proprietăți.

Exemplu de bază de tipuri mapate

Iată un exemplu simplu de tip mapat care convertește toate proprietățile unui anumit tip în numai citire:

type ReadOnly = {
  readonly [K in keyof T]: T[K];
};

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

type ReadOnlyUser = ReadOnly;

În acest exemplu, tipul mapat ReadOnly transformă toate proprietățile tipului User în doar citire, rezultând un nou tip ReadOnlyUser în care toate proprietățile sunt imuabile.

Tipuri mapate cu transformări de tip

Tipurile mapate pot fi, de asemenea, folosite pentru a transforma tipuri în moduri mai complexe. De exemplu, un tip mapat care face ca toate proprietățile să fie opționale:

type Partial = {
  [K in keyof T]?: T[K];
};

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

type PartialUser = Partial;

În acest exemplu, tipul mapat Partial face ca toate proprietățile tipului User să fie opționale, rezultând un nou tip PartialUser unde fiecare proprietate este opțională.

Utilizarea tipurilor mapate cu tipuri condiționale

Tipurile mapate pot fi combinate cu tipuri condiționale pentru operații de tip mai sofisticate. De exemplu, crearea unui tip care include numai proprietăți ale unui anumit tip:

type OnlyStrings = {
  [K in keyof T]: T[K] extends string ? T[K] : never;
};

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

type StringProperties = OnlyStrings;

În acest exemplu, tipul mapat OnlyStrings filtrează proprietățile care nu sunt de tipul string, rezultând un nou tip StringProperties care include numai proprietăți șir din Utilizator tip.

Tipuri mapate avansate

Cazurile de utilizare avansate pentru tipurile mapate includ crearea de tipuri care modifică tipurile existente în funcție de diferite condiții. De exemplu, un tip mapat care adaugă un sufix la fiecare nume de proprietate:

type WithSuffix<T, S extends string> = {
  [K in keyof T as `${string & K}${S}`]: T[K];
};

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

type UserWithSuffix = WithSuffix<User, "Prop">;

În acest exemplu, tipul mapat WithSuffix adaugă un sufix la fiecare nume de proprietate de tipul User, rezultând un nou tip UserWithSuffix unde numele proprietăților au valoarea specificată. sufix.

Concluzie

Tipurile mapate în TypeScript sunt o caracteristică versatilă care permite dezvoltatorilor să creeze noi tipuri prin transformarea celor existente. Prin înțelegerea și utilizarea tipurilor mapate, dezvoltatorii pot gestiona transformări complexe de tip și pot asigura o mai mare siguranță a tipurilor în codul lor TypeScript. Tipurile mapate oferă capabilități puternice pentru îmbunătățirea și personalizarea definițiilor de tip în aplicațiile TypeScript.