TypeScript Academy · Lektion

Rekursiva typedefinitioner

Skriv typer som säkert refererar till sig själva.

Lektion 1 av 413 steg

Rekursiva typedefinitioner ä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 rekursiv typ?

En rekursiv typ är en typ som hänvisar till sig själv i sin egen definition. Det gör det möjligt att beskriva datastrukturer med obegränsat djup.

type LinkedList<T> = {
  value: T;
  next: LinkedList<T> | null;
};
// next is the same type again, ending at null.

En länkad listtyp

Det klassiska exemplet: varje nod innehåller ett value och en next-pekare till en annan nod, eller null för att avsluta kedjan.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const list: LinkedList<number> = {
  value: 1,
  next: { value: 2, next: null }
};
console.log(list.value, list.next?.value);

Basfallet är viktigt

Varje rekursiv typ behöver en terminator, här null, så att rekursionen kan avslutas. Utan den skulle typen ha ett oändligt djup.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const single: LinkedList<string> = { value: "only", next: null };
console.log(single.next);

Bygga längre kedjor

Strukturen kan nästlas hur djupt som helst; typen tillåter valfri längd eftersom next själv är en lista eller null.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const chain: LinkedList<number> = {
  value: 10,
  next: { value: 20, next: { value: 30, next: null } }
};
console.log(chain.next?.next?.value);

Traversera en länkad lista

En funktion kan gå igenom kedjan genom att följa next tills den når null. Den rekursiva typen gör detta helt typsäkert.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function toArray<T>(list: LinkedList<T> | null): T[] {
  const out: T[] = [];
  let cur = list;
  while (cur) { out.push(cur.value); cur = cur.next; }
  return out;
}
const l: LinkedList<number> = { value: 1, next: { value: 2, next: null } };
console.log(toArray(l));

Rekursiva funktioner över rekursiva typer

Rekursiva typer passar naturligt ihop med rekursiva funktioner. Här beräknas längden genom att rekursivt följa next.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function length<T>(list: LinkedList<T> | null): number {
  return list === null ? 0 : 1 + length(list.next);
}
const l: LinkedList<string> = { value: "a", next: { value: "b", next: null } };
console.log(length(l));

Lägga till först i en lista

Eftersom typen är enhetlig är det enkelt att skapa nya listor: bädda in en befintlig lista som next i en ny första nod.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function prepend<T>(value: T, list: LinkedList<T> | null): LinkedList<T> {
  return { value, next: list };
}
const l = prepend(1, prepend(2, null));
console.log(l.value, l.next?.value);

Valfria och nullbara terminatorer

Kedjan kan avslutas med null, eller så kan next göras valfri. Båda avslutar rekursionen; välj utifrån hur slutet ska representeras.

type ListA<T> = { value: T; next: ListA<T> | null };
type ListB<T> = { value: T; next?: ListB<T> };
const a: ListA<number> = { value: 1, next: null };
const b: ListB<number> = { value: 1 };
console.log(a.value, b.value);

Rekursiva typer expanderas vid behov

TypeScript expanderar endast en rekursiv typ så långt som den faktiskt används. Definitionen kan hänvisa till sig själv utan att orsaka oändligt arbete.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
// Using two levels only expands two levels.
const l: LinkedList<number> = { value: 1, next: { value: 2, next: null } };
console.log(l.next?.value);

Mappa över en lista

En rekursiv map-funktion omvandlar varje värde samtidigt som strukturen bevaras och returnerar en ny lista med samma form.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function mapList<T, U>(list: LinkedList<T> | null, fn: (v: T) => U): LinkedList<U> | null {
  if (list === null) return null;
  return { value: fn(list.value), next: mapList(list.next, fn) };
}
const l: LinkedList<number> = { value: 1, next: { value: 2, next: null } };
console.log(mapList(l, x => x * 10)?.value);

Varför rekursiva typer är kraftfulla

Självrefererande typer gör det möjligt att modellera godtyckligt nästlade data, listor, träd och JSON med fullständig typsäkerhet och utan någon fast djupgräns i designen.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const l: LinkedList<boolean> = { value: true, next: { value: false, next: null } };
console.log(l.value, l.next?.value);

Snabb kontroll: rekursiva typer

Testa förståelsen av rekursiva typdefinitioner.

Besvara frågan i den interaktiva lektionen

Sammanfattning: rekursiva typdefinitioner

Ni har lärt er att en rekursiv typ hänvisar till sig själv, behöver ett basfall som null för att avslutas och passar naturligt ihop med rekursiva funktioner för att traversera, mappa och bygga länkade listor.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const l: LinkedList<number> = { value: 1, next: null };
console.log(l.value);

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 ”Rekursiva typedefinitioner” gratis?

Ja – hela texten till ”Rekursiva typedefinitioner” 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 ”Rekursiva typedefinitioner”?

Skriv typer som säkert refererar till sig själva. 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 ”Rekursiva typedefinitioner”?

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