TypeScript Academy · Lektion

Restparametrar och spread med typer

Typannotera restparametrar och spread-operationer

Lektion 3 av 413 steg

Restparametrar och spread med typer är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 3 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.

Välkommen

Rest-parametrar samlar flera argument i en array. TypeScript typbestämmer rest-parametern som en array av elementtypen.

Typbestämma rest-parametrar

Använd syntaxen `...name: T[]` för en rest-parameter. Den fångar alla återstående argument som en array.

function sum(...nums: number[]): number {
  return nums.reduce((a, b) => a + b, 0);
}
console.log(sum(1, 2, 3, 4)); // 10

Rest efter obligatoriska parametrar

Rest-parametrar måste stå sist. Övriga obligatoriska parametrar placeras före dem.

function log(level: string, ...messages: string[]): void {
  console.log(level, messages.join(' '));
}
log('INFO', 'Server', 'started', 'on', 'port', '3000');

Sprida arrayer till funktioner

Använd spread `...` för att skicka arrayelement som enskilda argument. TypeScript kontrollerar att spread-typen överensstämmer med parametrarna.

function add(a: number, b: number): number { return a + b; }
const args: [number, number] = [1, 2];
add(...args); // OK — tuple spread is type-safe

Sprida vanliga arrayer

Att sprida en vanlig array till en funktion med ett fast antal parametrar kan orsaka ett fel eftersom TypeScript inte kan verifiera att antalet stämmer.

const nums = [1, 2]; // number[] — length unknown
// add(...nums); // Error: spread must match parameters
const pair: [number, number] = [1, 2];
add(...pair); // OK — tuple has known length

Rest-parametrar jämfört med arguments-objektet

Rest-parametrar ersätter det gamla `arguments`-objektet. De är riktiga arrayer med fullständigt TypeScript-stöd, till skillnad från `arguments`.

Sprida objekt (inte rest-parametrar)

Att sprida ett objekt skapar en ytlig kopia. TypeScript infererar den kombinerade typen för resultatet av spridningen.

const a = { x: 1, y: 2 };
const b = { z: 3 };
const c = { ...a, ...b }; // { x: number; y: number; z: number }

Åsidosätta egenskaper med spread

När du sprider egenskaper åsidosätter senare egenskaper tidigare egenskaper med samma namn.

const base = { color: 'red', size: 5 };
const updated = { ...base, color: 'blue' };
// { color: 'blue', size: 5 }

Typad spread i arrayer

Array-spread skapar en ny array. TypeScript infererar den kombinerade elementtypen.

const a: number[] = [1, 2];
const b: number[] = [3, 4];
const c: number[] = [...a, ...b]; // [1, 2, 3, 4]

Variadisk rest i tupler

TypeScript stöder rest-element i tuppeltyper för avancerade variadiska mönster.

type Strings = string[];
type StringsAndNumber = [...Strings, number];
const t: StringsAndNumber = ['a', 'b', 42];

Rest vid destrukturering

Använd rest-syntax vid destrukturering för att samla återstående element i en typad array.

const [first, ...rest]: number[] = [1, 2, 3, 4];
// first: number, rest: number[]

Snabbkontroll

Vilken typ infererar TypeScript för rest-parametern `...items` i `function collect(...items: string[])`?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Rest-parametrar (`...args: T[]`) samlar återstående argument i en typad array. Sprid arrayer till funktioner med hjälp av tupler för typsäkerhet. Sprid objekt för att skapa ytliga kopior med infererade kombinerade typer.

Gratis att börja

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

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Restparametrar och spread med typer” gratis?

Ja – hela texten till ”Restparametrar och spread med typer” 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 ”Restparametrar och spread med typer”?

Typannotera restparametrar och spread-operationer 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 3 av 4.

Hur lång tid tar lektionen ”Restparametrar och spread med typer”?

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

Parameter- och returtypsannoteringar
Valfria parametrar och standardparametrar
Restparametrar och spread med typer
void, never och funktionssignaturer

← Tillbaka till TypeScript Academy