Generiska typer

Generics

Välkommen till nästa lektion! I den här lektionen får du lära dig om generics, en kraftfull funktion i TypeScript som låter dig skapa återanvändbara och typsäkra komponenter. Nu sätter vi igång!

Med generics kan du skriva återanvändbar kod som fungerar med alla typer. De fungerar som platshållare för typer som du kan ange när du använder dem.

Exempel: En generisk funktion:

Uppgift: Skriv en generisk funktion som tar ett argument och returnerar det oförändrat.

function identity<T>(value: T): T {
  return value;
}

console.log(identity<string>("Hello")); 
// Output: Hello
console.log(identity<number>(42)); 
// Output: 42

Generics hjälper dig att:

• Skriva återanvändbar kod: Funktioner och klasser kan fungera med olika typer.
• Säkerställa typsäkerhet: Du kan kräva specifika typer utan att göra avkall på flexibiliteten.
• Minska upprepning: Undvik att skriva separata versioner av samma funktion eller klass för olika typer.

Tips: Använd generics för att skriva mer flexibel och lättunderhållen kod.

Du kan använda generics för att skapa flexibla funktioner. Exempel:

Uppgift: Skriv en generisk funktion som sammanfogar två objekt och returnerar resultatet.

function merge<T, U>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 };
}

let merged = merge({ name: "Alice" }, { age: 25 });
console.log(merged); 
// Output: { name: "Alice", age: 25 }

Generics kan användas i klasser för att göra dem återanvändbara med olika typer. Exempel:

class Box<T> {
  private contents: T;

  constructor(contents: T) {
    this.contents = contents;
  }

  getContents(): T {
    return this.contents;
  }
}

let stringBox = new Box<string>("Hello");
console.log(stringBox.getContents()); 
// Output: Hello

let numberBox = new Box<number>(42);
console.log(numberBox.getContents()); 
// Output: 42

Gränssnitt kan också använda generics för att säkerställa strukturen för olika typer. Exempel:

Uppgift: Definiera ett generiskt gränssnitt och skapa ett objekt som implementerar det.

interface Pair<T, U> {
  first: T;
  second: U;
}

let coordinates: Pair<number, number> = { first: 10, second: 20 };
console.log(coordinates); 
// Output: { first: 10, second: 20 }

Du kan lägga till begränsningar för generics för att säkerställa att de endast fungerar med specifika typer. Exempel:

function printLength<T extends { length: number }>(item: T): void {
  console.log(`Length: ${item.length}`);
}

printLength("Hello"); 
// Output: Length: 5
printLength([1, 2, 3]); 
// Output: Length: 3
// printLength(42); 
// Error: Argument of type 'number' is not assignable to parameter of type '{ length: number }'.

Du kan ange standardtyper för generics om ingen typ anges. Exempel:

Uppgift: Skapa en generisk funktion med en standardtyp och testa den med olika typer.

function wrap<T = string>(value: T): T[] {
  return [value];
}

console.log(wrap("Hello")); // Output: ["Hello"]
console.log(wrap(42)); // Output: [42]

Grattis! Du har lärt dig att använda generics i TypeScript för att skapa återanvändbara och typsäkra funktioner, klasser och gränssnitt. Generics är ett kraftfullt verktyg för att skriva flexibel och skalbar kod. I nästa lektion utforskar vi avancerade typer, till exempel mappade och villkorliga typer. Låt oss fortsätta koda!