De generics-mönster du griper efter, grupperade efter uppgift: deklarera en typparameter, begränsa den, ge den ett standardvärde, förgrena med en villkorlig typ, fånga med infer och mappa över en form. Varje rad parar ihop mönstret med ett exempel på en rad.
En generic är en typparameter: en platshållare för en typ som anroparen väljer, så att en funktion eller typ fungerar för många former utan att tappa precision. Läs <T> som «för någon typ T». Kraften ligger i att begränsa T, förgrena på den och mappa över den. Mönstren nedan är arbetsvokabulären.
Referenstabell · 28 poster
Generics i TypeScriptExplained
28 of 28 rows
Deklarera
En typparameter som anroparen väljer.
function first<T>(xs: T[]): T
Flera oberoende typparametrar.
function pair<T, U>(a: T, b: U): [T, U]
En andra parameter knuten till den förstas nycklar.
function get<T, K extends keyof T>(o: T, k: K): T[K]
En klass med en typparameter på sina fält och metoder.
class Box<T> { value: T }
En objektform med en typparameter.
interface Result<T> { data: T }
En typparameter på en arrow-funktion; det avslutande kommat hindrar .tsx-filer från att läsa den som JSX.
const first = <T,>(xs: T[]): T => xs[0]
Begränsa
Kräver att T är tilldelningsbar till Type.
function len<T extends { length: number }>(x: T)
Begränsar T till en nyckel hos en annan typ.
type Keys<O> = keyof O
Begränsar T till en klass som kan konstrueras.
function make<C extends new () => C>(c: C): C
Kräver att T uppfyller flera begränsningar samtidigt.
function log<T extends Error & { code: number }>(e: T)
Begränsar till vad som helst; håller parametern generisk utan att snäva in den.
type Wrap<T> = T extends unknown ? { v: T } : never
Standardvärde och infer
Ger T ett standardvärde när anroparen utelämnar det.
function parse<T = string>(): T
Fångar en typ inuti en villkorlig typ.
type El<T> = T extends Array<infer I> ? I : never
Packar upp en nästlad Promise till dess inre typ.
type Data = Awaited<Promise<User>>
Fångar en del av en mall-literal-typ.
type Path<S> = S extends `/api/${infer R}` ? R : never
Kontrollerar hela unionen på en gång; en naken T härleder en medlem i taget.
type El<T> = [T] extends [Array<infer I>] ? I : never
Villkorliga och mappade
Väljer en typ baserat på om T är tilldelningsbar till U.
type IsStr<T> = T extends string ? true : false
Bygger en ny objekttyp genom att transformera varje nyckel i T.
type Frozen<T> = { [K in keyof T]: Readonly<T[K]> }
Ett objekt vars nycklar är K och värden är V.
type Scores = Record<string, number>
Inbyggda generics härledda från mönstren ovan.
type Preview = Pick<User, "id" | "name">
En naken T före extends körs en gång per unionsmedlem och förenar resultaten.
ToArray<'a' | 'b'> = 'a'[] | 'b'[]
Lägger till eller tar bort modifierare på mappade nycklar.
type Req<T> = { [K in keyof T]-?: T[K] }
Nycklarna hos ett körningsvärde, som en typ.
const opts = { a: 1 }; type K = keyof typeof opts
Bygger en strängtyp från andra strängtyper.
type Route = `/users/${string}`
Sammanfogar tupeltyper ände mot ände.
type Concat<T extends unknown[], U extends unknown[]> = [...T, ...U]
En typ vars definition hänvisar till sig själv.
type Json = string | number | Json[] | { [k: string]: Json }
Kontrollerar ett värde mot en typ och behåller dess smalare literaltyp.
const c = { dark: "#000" } satisfies Record<string, string>
Behåller anroparens literaltyp i stället för att bredda den (TS 5.0).