TypeScript Academy · Lektion

Generiska begränsningar med extends

Begränsa typparametrar till specifika strukturer

Lektion 3 av 413 steg

Generiska begränsningar med extends ä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

Generiska begränsningar begränsar vilka typer som kan anges som typargument. Använd `extends` för att kräva att T har vissa egenskaper eller motsvarar en viss form.

Problemet utan begränsningar

Utan begränsningar vet TypeScript inte vilka operationer som är giltiga för T, så endast operationer som är gemensamma för alla typer tillåts.

function getLength<T>(val: T): number {
  // return val.length; // Error — T might not have .length
}

Lägga till en begränsning

Använd `T extends Shape` för att kräva att T har minst de egenskaper som finns i Shape.

function getLength<T extends { length: number }>(val: T): number {
  return val.length;
}
getLength('hello');  // OK — string has .length
getLength([1, 2]);   // OK — array has .length
// getLength(42);   // Error — number has no .length

Begränsa till ett gränssnitt

Begränsa T så att det implementerar ett specifikt gränssnitt.

interface Named { name: string; }
function greet<T extends Named>(person: T): string {
  return 'Hello, ' + person.name;
}

Begränsning med keyof

Använd `K extends keyof T` för att begränsa K till nycklarna i T. Det möjliggör säker åtkomst till egenskaper.

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}
const age = getProperty({ name: 'Alice', age: 30 }, 'age'); // number

Utöka en union

T kan begränsas till en uniontyp, vilket begränsar typargumentet till specifika värden.

type Status = 'active' | 'inactive' | 'banned';
function setStatus<T extends Status>(status: T): void {
  console.log('Setting status:', status);
}

Begränsa till en konstruktor

Begränsa T så att det är en klass med en konstruktor, så att du kan skapa instanser inuti funktionen.

function create<T>(ctor: new () => T): T {
  return new ctor();
}

Flera begränsningar med intersektion

Begränsa T så att det uppfyller flera gränssnitt med hjälp av en intersektion.

interface Serializable { serialize(): string; }
interface Loggable { log(): void; }
function process<T extends Serializable & Loggable>(item: T): void {
  item.log();
  console.log(item.serialize());
}

Begränsningar och arv

Begränsningar fungerar med arv. Om T utökar en basklass kan du anropa alla basklassens metoder.

class Animal { breathe() { return 'breathing'; } }
function care<T extends Animal>(a: T): string { return a.breathe(); }

T extends sig själv (rekursivt)

Begränsningar kan referera till sig själva för rekursiva datastrukturer.

interface Comparable<T> { compareTo(other: T): number; }
function max<T extends Comparable<T>>(a: T, b: T): T {
  return a.compareTo(b) >= 0 ? a : b;
}

Felmeddelanden för begränsningar

När ett typargument inte uppfyller en begränsning rapporterar TypeScript ett tydligt fel som anger både argumentet och begränsningen.

Snabbkontroll

Vad begränsar `K extends keyof T` K till?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Använd `T extends SomeType` för att begränsa generiska typparametrar. Då kan du anropa specifika metoder på T, använda keyof för säker åtkomst till egenskaper och bygga typsäkra verktygsfunktioner.

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 ”Generiska begränsningar med extends” gratis?

Ja – hela texten till ”Generiska begränsningar med extends” 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 ”Generiska begränsningar med extends”?

Begränsa typparametrar till specifika strukturer 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 ”Generiska begränsningar med extends”?

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