Typbestämning av variadiska funktioner
Bygg flexibla API:er med variadiska tupeltyper.
Typbestämning av variadiska funktioner är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för TypeScript Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i TypeScript Academy innehåller totalt 4 lektioner.
Generiska variadiska funktioner
Variadiska tupeltyper låter generiska typer fånga och bearbeta argumentlistor. Det möjliggör verktyg som sammanfogar tupler, vidarebefordrar parametrar och omformar anropssignaturer med fullständig typsäkerhet.
Fånga argument som en tupel
En generisk typ som begränsas till unknown[] kan fånga en hel argumentlista som tupeltypen T och bevara varje parameters typ och position.
function tuple<T extends unknown[]>(...args: T): T {
return args
}
const t = tuple("a", 1, true) // type [string, number, boolean]
console.log(t)Spreadning av en generisk tupel
Du kan använda spread för en fångad generisk tupel i en annan parameterlista. På så sätt vidarebefordras argumenten samtidigt som deras exakta typer bevaras.
function wrap<T extends unknown[]>(fn: (...args: T) => void) {
return (...args: T) => fn(...args)
}
const log = wrap((n: number, s: string) => console.log(n, s))
log(1, "hi")Sammanfoga två tupler
Variadiska tupeltyper är särskilt användbara när tupler kombineras. Om du använder spread för två generiska tupler i en returtyp skapas deras sammanfogning.
function concat<A extends unknown[], B extends unknown[]>(a: A, b: B): [...A, ...B] {
return [...a, ...b]
}
const r = concat([1, 2], ["a"]) // [number, number, string]
console.log(r)Varför resultattypen är exakt
Eftersom [...A, ...B] använder spread för de generiska tuplerna bevarar resultatet varje elements typ och ordning – inte bara en bredare unionsarray.
function concat<A extends unknown[], B extends unknown[]>(a: A, b: B): [...A, ...B] {
return [...a, ...b]
}
const r = concat([true], [42])
const flag: boolean = r[0]
const num: number = r[1]
console.log(flag, num)Lägga till ett inledande argument
Med variadiska tupler kan du omforma parameterlistor – till exempel skapa en funktion som lägger till ett inledande argument i en callback-funktions signatur.
function withId<T extends unknown[]>(fn: (...args: T) => void) {
return (id: number, ...rest: T) => {
console.log("id", id)
fn(...rest)
}
}
const f = withId((msg: string) => console.log(msg))
f(7, "hello")Extrahera huvudtypen
Med en tupelparameter kan du dela av typen för det första elementet och resten med hjälp av en namngiven tupel och sedan arbeta med delarna var för sig.
function head<H, T extends unknown[]>(...args: [H, ...T]): H {
return args[0]
}
const h = head("first", 2, 3) // type string
console.log(h)Hjälptypen Parameters
Den inbyggda Parameters<F> extraherar en funktions argumentlista som en tupel – själv byggd på variadiska tupeltyper. Du kan återanvända en signaturs parametrar på andra ställen.
function greet(name: string, age: number) {}
type GreetArgs = Parameters<typeof greet> // [string, number]
const args: GreetArgs = ["Ada", 36]
console.log(args)Vidarebefordra med Parameters
Kombinera Parameters med en rest-spread för att bygga en wrapper som vidarebefordrar argument till en befintlig funktion med identisk typning.
function add(a: number, b: number) { return a + b }
function traced(...args: Parameters<typeof add>): number {
console.log("calling add", args)
return add(...args)
}
console.log(traced(2, 3))Bygga en curry-liknande signatur
Variadiska tupler möjliggör hjälpfunktioner för partiell applicering: fånga vissa argument nu, förvänta dig resten senare – allt typsäkert.
function partial<A extends unknown[], B extends unknown[], R>(
fn: (...args: [...A, ...B]) => R,
...a: A
) {
return (...b: B) => fn(...a, ...b)
}
const addThree = (x: number, y: number, z: number) => x + y + z
const add5 = partial(addThree, 5)
console.log(add5(2, 3)) // 10Kraft och försiktighet
Generiska variadiska tupler ger exakta, återanvändbara verktyg för att forma funktioner – wrappers, vidarebefordrare och sammanfogare. De är avancerade, så använd dem när den förbättrade typnoggrannheten verkligen motiverar komplexiteten.
function pipe2<A extends unknown[], B, C>(
f: (...a: A) => B,
g: (b: B) => C
) {
return (...a: A) => g(f(...a))
}
const fn = pipe2((n: number) => n * 2, (n) => n + 1)
console.log(fn(5)) // 11Snabbtest
Testa din förståelse av generiska variadiska tupeltyper.
Sammanfattning
Variadiska tupeltyper låter generiska typer fånga argumentlistor som tupler och använda spread i parameter- eller returpositioner. Det möjliggör sammanfogning av tupler ([...A, ...B]), vidarebefordran av argument, uppdelning i huvud och svans samt partiell applicering – samtidigt som de exakta elementtyperna bevaras. Inbyggda typer som Parameters<F> bygger på samma mekanism. Använd dessa verktyg när exakt typning av funktionsstrukturer är värd komplexiteten.
Lär dig TypeScript med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 101
- Lektioner
- 352
Vanliga frågor
Är lektionen ”Typbestämning av variadiska funktioner” gratis?
Ja – hela texten till ”Typbestämning av variadiska funktioner” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i TypeScript Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i TypeScript Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Typbestämning av variadiska funktioner”?
Bygg flexibla API:er med variadiska tupeltyper. Ni övar på TypeScript Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig TypeScript Academy?
Du behöver inga förkunskaper. Utbildningen i TypeScript Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.
Hur lång tid tar lektionen ”Typbestämning av variadiska funktioner”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här TypeScript Academy-lektionen?
Ja. Varje TypeScript Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Rest-parametrar i funktioner
- Spread i arrayer och objekt
- Rest-element i tupler
- Typbestämning av variadiska funktioner