Azok a generikus minták, amelyekért a gyakorlatban nyúlsz, feladat szerint csoportosítva: típusparaméter deklarálása, megszorítása, alapértelmezett érték adása neki, elágaztatás feltételes típussal, típus befogása infer-rel és leképezés egy struktúrára. Minden sor a mintát egy egy soros példával párosítja.
A generikum egy típusparaméter: helyőrző egy olyan típusnak, amelyet a hívó választ meg, így egyetlen függvény vagy típus sokféle alakra működik pontosságvesztés nélkül. A <T>-t olvasd úgy: valamely T típus. Az erő abból jön, hogy a T-t megszorítod, elágaztatsz rajta, és leképezed. Az alábbi minták a mindennapi munkaszókincs.
Referenciatáblázat · 28 bejegyzés
TypeScript generikumokExplained
28 of 28 rows
Deklarálás
A hívó által kiválasztott típusparaméter.
function first<T>(xs: T[]): T
Több egymástól független típusparaméter.
function pair<T, U>(a: T, b: U): [T, U]
Egy második paraméter, amely az első kulcsaihoz kötődik.
function get<T, K extends keyof T>(o: T, k: K): T[K]
Osztály típusparaméterrel a mezőin és a metódusain.
class Box<T> { value: T }
Objektumforma típusparaméterrel.
interface Result<T> { data: T }
Típusparaméter nyílfüggvényen; a záró vessző megakadályozza, hogy a .tsx fájlok JSX-ként értelmezzék.
const first = <T,>(xs: T[]): T => xs[0]
Megszorítás
Megköveteli, hogy a T hozzárendelhető legyen a Type típusra.
function len<T extends { length: number }>(x: T)
A T-t egy másik típus valamelyik kulcsára korlátozza.
type Keys<O> = keyof O
A T-t egy példányosítható osztályra korlátozza.
function make<C extends new () => C>(c: C): C
Megköveteli, hogy a T egyszerre több megszorítást is kielégítsen.
function log<T extends Error & { code: number }>(e: T)
Bármire korlátoz; a paraméter generikus marad, szűkítés nélkül.
type Wrap<T> = T extends unknown ? { v: T } : never
Alapérték és infer
Alapértelmezett értéket ad a T-nek, amikor a hívó kihagyja.
function parse<T = string>(): T
Egy típus befogása egy feltételes típuson belül.
type El<T> = T extends Array<infer I> ? I : never
Kibontja a beágyazott Promise-ot a belső típusára.
type Data = Awaited<Promise<User>>
Egy template literal típus egy darabjának befogása.
type Path<S> = S extends `/api/${infer R}` ? R : never
A teljes uniót egyszerre ellenőrzi; a mezítelen T egyszerre egy tagot inferál.
type El<T> = [T] extends [Array<infer I>] ? I : never
Feltételes és leképzett típusok
Aszerint választ típust, hogy a T hozzárendelhető-e az U-ra.
type IsStr<T> = T extends string ? true : false
Új objektumtípust épít a T minden kulcsának átalakításával.
type Frozen<T> = { [K in keyof T]: Readonly<T[K]> }
Objektum, amelynek kulcsai K és értékei V.
type Scores = Record<string, number>
Beépített generikumok, amelyek a fenti mintákból származnak.
type Preview = Pick<User, "id" | "name">
A mezítelen T az extends előtt uniótagonként egyszer fut le, és egyesíti az eredményeket.
ToArray<'a' | 'b'> = 'a'[] | 'b'[]
Módosítók hozzáadása vagy eltávolítása a leképzett kulcsokon.
type Req<T> = { [K in keyof T]-?: T[K] }
Egy futásidejű érték kulcsai, típusként.
const opts = { a: 1 }; type K = keyof typeof opts
Sztring típust épít más sztring típusokból.
type Route = `/users/${string}`
Tuple-típusok összefűzése végtől végig.
type Concat<T extends unknown[], U extends unknown[]> = [...T, ...U]
Olyan típus, amelynek definíciója önmagára hivatkozik.
type Json = string | number | Json[] | { [k: string]: Json }
Ellenőrzi az értéket egy típussal szemben, és megtartja annak szűkebb literális típusát.
const c = { dark: "#000" } satisfies Record<string, string>
A hívó literális típusát tartja meg a kiszélesítés helyett (TS 5.0).