I pattern generici che usi davvero, raggruppati per attività: dichiarare un parametro di tipo, vincolarlo, dargli un default, ramificare con un condizionale, catturare con infer e mappare una forma. Ogni riga abbina il pattern a un esempio di una riga.
Un generic è un parametro di tipo: un segnaposto per un tipo scelto dal chiamante, così una funzione o un tipo funziona per molte forme senza perdere precisione. Leggi <T> come per un certo tipo T. La potenza viene dal vincolare T, dal ramificarlo e dal mapparlo. I pattern qui sotto sono il vocabolario di lavoro.
Tabella di riferimento · 28 voci
Generics di TypeScriptExplained
28 of 28 rows
Dichiarare
Un parametro di tipo scelto dal chiamante.
function first<T>(xs: T[]): T
Più parametri di tipo indipendenti.
function pair<T, U>(a: T, b: U): [T, U]
Un secondo parametro legato alle chiavi del primo.
function get<T, K extends keyof T>(o: T, k: K): T[K]
Una classe con un parametro di tipo su campi e metodi.
class Box<T> { value: T }
Una forma di oggetto con un parametro di tipo.
interface Result<T> { data: T }
Un parametro di tipo su una arrow function; la virgola finale impedisce ai file .tsx di leggerlo come JSX.
const first = <T,>(xs: T[]): T => xs[0]
Vincolare
Richiede che T sia assegnabile a Type.
function len<T extends { length: number }>(x: T)
Vincola T a una chiave di un altro tipo.
type Keys<O> = keyof O
Vincola T a una classe costruibile con new.
function make<C extends new () => C>(c: C): C
Richiede che T soddisfi più vincoli contemporaneamente.
function log<T extends Error & { code: number }>(e: T)
Vincola a qualunque cosa; mantiene il parametro generico senza restringerlo.
type Wrap<T> = T extends unknown ? { v: T } : never
Default e infer
Dà a T un default quando il chiamante lo omette.
function parse<T = string>(): T
Cattura un tipo dentro un condizionale.
type El<T> = T extends Array<infer I> ? I : never
Scarta una Promise annidata fino al suo tipo interno.
type Data = Awaited<Promise<User>>
Cattura un pezzo di un template literal type.
type Path<S> = S extends `/api/${infer R}` ? R : never
Controlla l'intera unione in una volta; un T nudo inferisce un membro alla volta.
type El<T> = [T] extends [Array<infer I>] ? I : never
Condizionali e mappati
Sceglie un tipo in base al fatto che T sia assegnabile a U.
type IsStr<T> = T extends string ? true : false
Costruisce un nuovo tipo oggetto trasformando ogni chiave di T.
type Frozen<T> = { [K in keyof T]: Readonly<T[K]> }
Un oggetto le cui chiavi sono K e i valori V.
type Scores = Record<string, number>
Generics integrati derivati dai pattern sopra.
type Preview = Pick<User, "id" | "name">
Un T nudo prima di extends viene eseguito una volta per membro dell'unione e ne unisce i risultati.
ToArray<'a' | 'b'> = 'a'[] | 'b'[]
Aggiunge o rimuove modifier sulle chiavi mappate.
type Req<T> = { [K in keyof T]-?: T[K] }
Le chiavi di un valore a runtime, come tipo.
const opts = { a: 1 }; type K = keyof typeof opts
Costruisce un tipo stringa da altri tipi stringa.
type Route = `/users/${string}`
Concatena tipi tuple uno dietro l'altro.
type Concat<T extends unknown[], U extends unknown[]> = [...T, ...U]
Un tipo la cui definizione fa riferimento a se stessa.
type Json = string | number | Json[] | { [k: string]: Json }
Controlla un valore contro un tipo e conserva il suo tipo letterale più stretto.
const c = { dark: "#000" } satisfies Record<string, string>
Conserva il tipo letterale del chiamante invece di allargarlo (TS 5.0).