TypeScript Academy · Lektion

Valfria parametrar och standardparametrar

Hantera saknade argument med ? och standardvärden

Lektion 2 av 413 steg

Valfria parametrar och standardparametrar är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 2 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

TypeScript låter dig markera funktionsparametrar som valfria med `?` eller ge dem standardvärden. Det gör API:er flexibla samtidigt som de förblir typsäkra.

Valfria parametrar med ?

Lägg till `?` efter ett parameternamn för att göra parametern valfri. Parametertypen blir T | undefined inuti funktionen.

function greet(name: string, greeting?: string): string {
  return (greeting ?? 'Hello') + ', ' + name;
}

Standardvärden för parametrar

Tilldela ett standardvärde med `=`. TypeScript infererar typen från standardvärdet och parametern blir valfri vid anrop.

function greet(name: string, greeting: string = 'Hello'): string {
  return greeting + ', ' + name;
}
greet('Alice');         // 'Hello, Alice'
greet('Bob', 'Hi');    // 'Hi, Bob'

Valfri jämfört med standardvärde

En valfri parameter med `?` ger undefined när den utelämnas. Standardvärden ersätter undefined med ett reservvärde. Båda gör parametern icke-obligatorisk vid anrop.

function opt(x?: number) { return x; }     // x: number | undefined
function def(x: number = 0) { return x; }  // x: number

Placeringsregler

Valfria parametrar och parametrar med standardvärden måste komma efter obligatoriska parametrar i funktionssignaturen.

// Correct order
function create(name: string, role: string = 'user', active?: boolean) {}

// Error: required after optional
// function bad(x?: string, y: string) {}

Anropa uttryckligen med undefined

Du kan skicka `undefined` till en parameter med ett standardvärde för att utlösa standardvärdet.

function log(msg: string, level: string = 'info') { console.log(level, msg); }
log('test', undefined); // level is 'info'

Valfria parametrar och överlagringar

Ibland är det tydligare att använda överlagringar i stället för valfria parametrar, särskilt när funktionens beteende förändras betydligt beroende på om parametern finns eller inte.

Standardvärden för objektparametrar

Du kan destrukturera en objektparameter och ange standardvärden för varje egenskap.

function connect({ host = 'localhost', port = 5432 } = {}) {
  return `${host}:${port}`;
}

Standardvärden för arrayparametrar

Standardvärden för arrayparametrar fungerar på samma sätt. Ange en tom array som standard för att slippa kontroller av undefined.

function joinAll(parts: string[], sep: string = ', '): string {
  return parts.join(sep);
}

Optional chaining vid anrop

Om själva funktionsreferensen är valfri använder du optional chaining `?.()` för att anropa den endast när den finns.

interface Config { onReady?: () => void; }
function init(config: Config) {
  config.onReady?.();
}

Typen för valfria parametrar inuti funktionen

Inuti funktionen har en valfri parameter `x?: T` typen `T | undefined`. Du måste begränsa typen innan du använder den som T.

function process(id?: number) {
  if (id === undefined) return;
  console.log(id * 2); // id is number here
}

Snabbkontroll

Vilken typ har en parameter som deklareras som `count?: number` inuti funktionskroppen?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Använd `?` för valfria parametrar och `= value` för standardvärden. Valfria parametrar har typen T | undefined inuti funktionen. Standardvärden ersätter undefined automatiskt. Båda måste komma efter obligatoriska parametrar.

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 ”Valfria parametrar och standardparametrar” gratis?

Ja – hela texten till ”Valfria parametrar och standardparametrar” 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 ”Valfria parametrar och standardparametrar”?

Hantera saknade argument med ? och standardvärden 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 2 av 4.

Hur lång tid tar lektionen ”Valfria parametrar och standardparametrar”?

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