De generics-patronen waar je steeds naar grijpt, gegroepeerd per taak: declareer een typeparameter, begrens hem, geef hem een standaardwaarde, vertak met een conditioneel type, leg vast met infer en map over een vorm. Elke rij koppelt het patroon aan een voorbeeld van één regel.
Een generic is een typeparameter: een placeholder voor een type dat de aanroeper kiest, zodat één functie of type voor veel vormen werkt zonder precisie te verliezen. Lees <T> als 'voor een of ander type T'. De kracht zit in het begrenzen van T, erop vertakken en erover mappen. De patronen hieronder zijn het vocabulaire voor het dagelijkse werk.
Referentietabel · 28 items
Generics in TypeScriptExplained
28 of 28 rows
Declareren
Een typeparameter die de aanroeper kiest.
function first<T>(xs: T[]): T
Meerdere onafhankelijke typeparameters.
function pair<T, U>(a: T, b: U): [T, U]
Een tweede parameter gekoppeld aan de sleutels van de eerste.
function get<T, K extends keyof T>(o: T, k: K): T[K]
Een klasse met een typeparameter op zijn velden en methoden.
class Box<T> { value: T }
Een objectvorm met een typeparameter.
interface Result<T> { data: T }
Een typeparameter op een arrowfunctie; de komma op het einde voorkomt dat .tsx-bestanden hem als JSX lezen.
const first = <T,>(xs: T[]): T => xs[0]
Begrenzen
Vereis dat T aan Type toewijsbaar is.
function len<T extends { length: number }>(x: T)
Begrens T tot een sleutel van een ander type.
type Keys<O> = keyof O
Begrens T tot een klasse die met new geconstrueerd kan worden.
function make<C extends new () => C>(c: C): C
Vereis dat T aan meerdere constraints tegelijk voldoet.
function log<T extends Error & { code: number }>(e: T)
Begrens tot alles; houdt de parameter generiek zonder hem te vernauwen.
type Wrap<T> = T extends unknown ? { v: T } : never
Standaardwaarde en infer
Geef T een standaardwaarde als de aanroeper hem weglaat.
function parse<T = string>(): T
Leg een type vast binnen een conditioneel type.
type El<T> = T extends Array<infer I> ? I : never
Pak een geneste Promise uit naar zijn binnenliggende type.
type Data = Awaited<Promise<User>>
Leg één deel van een template-literal-type vast.
type Path<S> = S extends `/api/${infer R}` ? R : never
Controleer de hele unie in één keer; een kale T leidt telkens één lid af.
type El<T> = [T] extends [Array<infer I>] ? I : never
Conditioneel en mapped
Kies een type op basis van of T aan U toewijsbaar is.
type IsStr<T> = T extends string ? true : false
Bouw een nieuw objecttype door elke sleutel van T te transformeren.
type Frozen<T> = { [K in keyof T]: Readonly<T[K]> }
Een object waarvan de sleutels K zijn en de waarden V.
type Scores = Record<string, number>
Ingebouwde generics, afgeleid van de patronen hierboven.
type Preview = Pick<User, "id" | "name">
Een kale T vóór extends draait één keer per unielid en verenigt de resultaten.
ToArray<'a' | 'b'> = 'a'[] | 'b'[]
Modificatoren op gemapte sleutels toevoegen of verwijderen.
type Req<T> = { [K in keyof T]-?: T[K] }
De sleutels van een runtime-waarde, als type.
const opts = { a: 1 }; type K = keyof typeof opts
Bouw een stringtype uit andere stringtypes.
type Route = `/users/${string}`
Verbind tuple-types achter elkaar.
type Concat<T extends unknown[], U extends unknown[]> = [...T, ...U]
Een type waarvan de definitie naar zichzelf verwijst.
type Json = string | number | Json[] | { [k: string]: Json }
Controleer een waarde tegen een type en behoud zijn smallere letterlijke type.
const c = { dark: "#000" } satisfies Record<string, string>
Behoud het letterlijke type van de aanroeper in plaats van het te verbreden (TS 5.0).