TypeScript Academy · Lektion

Sträng- och numeriska literaltyper

Begränsa värden till exakta strängar och tal med literaltyper.

Lektion 1 av 413 steg

Sträng- och numeriska literaltyper är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 1 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.

Vad är en literaltyp?

De flesta typer beskriver en mängd värden. string betyder vilken sträng som helst och number betyder vilket tal som helst. En literaltyp begränsar detta till ett enda exakt värde.

Typen 'north' tillåter bara strängen 'north' — inget annat. Med literaltyper kan du modellera exakta, ändliga mängder tillåtna värden direkt i typsystemet.

let dir: 'north' = 'north';
console.log(dir);
// dir = 'south'; // Error: not assignable to type 'north'

Strängliteralunioner

En enda literal är inte särskilt användbar på egen hand. Kombinera flera med | för att skapa en literalunion. Det är det vedertagna sättet att modellera en fast uppsättning alternativ.

Direction nedan kan bara vara en av fyra exakta strängar.

type Direction = 'north' | 'south' | 'east' | 'west';

let heading: Direction = 'east';
console.log('Heading:', heading);

heading = 'west';
console.log('Now:', heading);

Avvisa ogiltiga värden

Styrkan hos literalunioner är att kompilatorn avvisar allt som ligger utanför den tillåtna mängden. Stavfel och ogiltiga alternativ blir kompileringsfel i stället för fel som uppstår under körning.

type Direction = 'north' | 'south' | 'east' | 'west';

let heading: Direction = 'north';
console.log(heading);
// heading = 'up'; // Error: '"up"' is not assignable to 'Direction'

Literaler som funktionsparametrar

Använd literalunioner för funktionsparametrar som bara accepterar specifika värden. Den som anropar funktionen får autokomplettering och hindras från att skicka ogiltiga värden.

type Direction = 'north' | 'south' | 'east' | 'west';

function move(dir: Direction): string {
  return 'Moving ' + dir;
}

console.log(move('south'));
// console.log(move('left')); // Error

Numeriska literaltyper

Literaltyper är inte bara till för strängar. Du kan även använda exakta tal. Ett klassiskt exempel är en sexsidig tärning, vars sidovärde måste vara ett av talen 1 till 6.

type Dice = 1 | 2 | 3 | 4 | 5 | 6;

function roll(): Dice {
  return (Math.floor(Math.random() * 6) + 1) as Dice;
}

console.log('Rolled:', roll());

Numeriska literaler i parametrar

Numeriska literalunioner begränsar indata till en exakt uppsättning tal — perfekt för exempelvis kvalitetsnivåer, HTTP-liknande koder eller rutnätsstorlekar.

type Quality = 1 | 2 | 3;

function setQuality(level: Quality): void {
  console.log('Quality set to', level);
}

setQuality(2);
// setQuality(5); // Error: 5 is not 1 | 2 | 3

Blanda sträng- och numeriska literaler

En union kan kombinera olika literaltyper. Det är praktiskt för API:er som accepterar antingen en namngiven förinställning eller ett råvärde.

type Size = 'small' | 'large' | 0 | 100;

function resize(s: Size): void {
  console.log('Resizing to', s);
}

resize('small');
resize(100);

Booleska literaltyper

Även booleska värden har literaltyper: true och false är både typer och värden. Den fullständiga typen boolean är egentligen bara true | false.

type AlwaysOn = true;

let enabled: AlwaysOn = true;
console.log('Enabled:', enabled);
// enabled = false; // Error: false not assignable to true

Literaler förbättrar dokumentationen

En literalunion fungerar även som dokumentation. Den som läser type Status = 'idle' | 'loading' | 'done' ser direkt alla möjliga tillstånd — inga gissningar och inga magiska strängar utspridda i koden.

type Status = 'idle' | 'loading' | 'done';

function render(s: Status): string {
  return 'State is: ' + s;
}

console.log(render('loading'));

Kombinera literaler med andra typer

Du kan blanda literaltyper med bredare typer i en union. Ett vanligt mönster är 'auto' | number, vilket betyder antingen det särskilda nyckelordet 'auto' eller vilket tal som helst.

type Width = 'auto' | number;

function setWidth(w: Width): void {
  console.log('Width:', w);
}

setWidth('auto');
setWidth(320);

Literaler som namngivna konstanter

Literaltyper passar utmärkt ihop med namngivna konstanter. Definiera typen en gång, återanvänd den överallt och refaktorera säkert. Kompilatorn ser till att all användning förblir konsekvent.

type Theme = 'light' | 'dark';

const DEFAULT_THEME: Theme = 'dark';

function applyTheme(t: Theme): void {
  console.log('Applying', t, 'theme');
}

applyTheme(DEFAULT_THEME);

Snabbtest

Testa dina kunskaper om literaltyper.

Besvara frågan i den interaktiva lektionen

Sammanfattning: literaltyper

Du har lärt dig att:

Literaltyper representerar ett enda exakt värde, till exempel 'north' eller 6.
Genom att kombinera literaler med | skapar du en ändlig union av tillåtna värden.
De fungerar för strängar, tal och booleska värden och kan kombineras med bredare typer, som 'auto' | number.
När de används som funktionsparametrar ger de autokomplettering och avvisar ogiltiga indata vid kompilering.

Härnäst undersöker vi hur TypeScript väljer mellan literaltyper och breddade typer.

type Direction = 'north' | 'south' | 'east' | 'west';
type Dice = 1 | 2 | 3 | 4 | 5 | 6;

function describe(d: Direction, n: Dice): string {
  return 'Go ' + d + ' ' + n + ' steps';
}

console.log(describe('north', 3));

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 ”Sträng- och numeriska literaltyper” gratis?

Ja – hela texten till ”Sträng- och numeriska literaltyper” 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 ”Sträng- och numeriska literaltyper”?

Begränsa värden till exakta strängar och tal med literaltyper. 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 1 av 4.

Hur lång tid tar lektionen ”Sträng- och numeriska literaltyper”?

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

← Tillbaka till TypeScript Academy