Generics

Generieke typen

Welkom bij de volgende les! In deze les leer je over generieke typen, een krachtige functie in TypeScript waarmee je herbruikbare en typeveilige componenten kunt maken. Laten we beginnen!

Met generieke typen kun je herbruikbare code schrijven die met elk type werkt. Ze fungeren als plaatshouders voor typen die je kunt opgeven wanneer je ze gebruikt.

Voorbeeld: Een generieke functie:

Taak: Schrijf een generieke functie die een argument accepteert en het ongewijzigd teruggeeft.

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

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

Generieke typen helpen je om:

• Herbruikbare code te schrijven: Functies en klassen kunnen met verschillende typen werken.
• Typeveiligheid te waarborgen: Je kunt specifieke typen afdwingen zonder flexibiliteit op te offeren.
• Redundantie te verminderen: Voorkom dat je afzonderlijke versies van dezelfde functie of klasse voor verschillende typen schrijft.

Tip: Gebruik generieke typen om flexibelere en beter onderhoudbare code te schrijven.

Je kunt generieke typen gebruiken om flexibele functies te maken. Voorbeeld:

Taak: Schrijf een generieke functie die twee objecten samenvoegt en het resultaat teruggeeft.

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 }

Generieke typen kunnen in klassen worden gebruikt om deze herbruikbaar te maken voor verschillende typen. Voorbeeld:

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

Interfaces kunnen ook generieke typen gebruiken om structuur voor verschillende typen af te dwingen. Voorbeeld:

Taak: Definieer een generieke interface en maak een object dat deze implementeert.

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 }

Je kunt beperkingen toevoegen aan generieke typen om ervoor te zorgen dat ze alleen met specifieke typen werken. Voorbeeld:

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 }'.

Je kunt standaardtypen voor generieke typen opgeven als er geen type wordt opgegeven. Voorbeeld:

Taak: Maak een generieke functie met een standaardtype en test deze met verschillende typen.

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

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

Gefeliciteerd! Je hebt geleerd hoe je generieke typen in TypeScript gebruikt om herbruikbare, typeveilige functies, klassen en interfaces te maken. Generieke typen zijn een krachtig hulpmiddel voor het schrijven van flexibele en schaalbare code. In de volgende les verkennen we geavanceerde typen, zoals gemapte en conditionele typen. Laten we blijven programmeren!