Questi sono gli strumenti di programmazione a livello di tipo di TypeScript — calcolano nuovi tipi da quelli esistenti.
Un tipo mappato itera sulle chiavi di un tipo e trasforma ognuna:
<T> = { [K keyof T]: T[K] };
<T> = { [K keyof T]?: T[K] };
{ : ; : ; }
= <>;
[K in keyof T] scorre ogni chiave K; T[K] è il tipo di valore di quella chiave. Così Partial, Readonly e Required vengono implementati. Puoi anche rimappare le chiavi e aggiungere modificatori (-readonly, -? le rimuovono).
type IsString<T> = T extends string ? "yes" : "no";
type A = IsString<string>; // "yes"
type B = IsString<number>; // "no"
T extends U ? X : Y è un if/else a livello di tipo. Con infer puoi estrarre tipi all'interno della condizione:
type ElementOf<T> = T extends (infer U)[] ? U : never;
type E = ElementOf<string[]>; // string
// Make only the function-valued properties optional
type PartialMethods<T> = {
[K in keyof T]: T[K] extends Function ? T[K] | undefined : T[K];
};
I tipi mappati inoltre si distribuiscono su unioni nei condizionali, abilitando trasformazioni potenti.
I tipi mappati e condizionali consentono alle librerie di esprimere relazioni di tipo precise — implementano i tipi utility, alimentano librerie di form/validazione, generatori di query ORM e client API che deducono le forme di risposta.
Sono avanzati, ma comprenderli spiega come il sistema dei tipi di TypeScript può essere così espressivo, e ti consente di costruire trasformazioni di tipo riutilizzabili invece di scrivere manualmente le varianti.