Ce sunt tipurile condiționale și mapate?

Question

Accepted Answer

Acestea sunt instrumente de **programare la nivel de tip** din TypeScript — calculează tipuri noi din cele existente. ## De ce este important Tipuri mapate — transformă fiecare proprietate Un tip mapat iterează asupra cheilor unui tip și transformă fiecare: ```ts type ReadonlyAll = { readonly [K in keyof T]: T[K] }; type Optional = { [K in keyof T]?: T[K] }; interface User { id: number; name: string; } type RO = ReadonlyAll; // { readonly id: number; readonly name: string } ``` `[K in keyof T]` parcurge fiecare cheie `K`; `T[K]` este tipul valorii acelei chei. Așa sunt implementate `Partial`, `Readonly` și `Required`. Puteți, de asemenea, remapării cheile și adăuga modificatori (`-readonly`, `-?` le elimină). ## Tipuri condiționale — ramificare pe baza unei condiții ```ts type IsString = T extends string ? "yes" : "no"; type A = IsString; // "yes" type B = IsString; // "no" ``` `T extends U ? X : Y` este o instrucțiune if/else la nivel de tip. Cu `infer` puteți *extrage* tipuri din interiorul condiției: ```ts type ElementOf = T extends (infer U)[] ? U : never; type E = ElementOf; // string ``` ## Combinarea lor — un exemplu real ```ts // Make only the function-valued properties optional type PartialMethods = { [K in keyof T]: T[K] extends Function ? T[K] | undefined : T[K]; }; ``` Tipurile mapate se **distribuie**, de asemenea, peste uniuni în condiționale, permițând transformări puternice. ## De ce este important Tipurile mapate și condiționale permit bibliotecilor să exprime relații de tip precise — ele implementează tipurile utilitare, alimentează biblioteci de formular/validare, constructori de interogări ORM și clienți API care deduc forme de răspuns. Sunt avansate, dar înțelegerea lor explică *cum* sistemul de tipuri al TypeScript poate fi atât de expresiv și vă permite să construiți transformări de tip reutilizabile în loc să scrieți variante manual.