In TypeScript kun je generieke types gebruiken door parameters te definiëren met `<T>`, waarbij `T` staat voor het type dat je flexibel wilt maken. Dit stelt je in staat om functies, klassen of interfaces te maken die werken met verschillende datatypes zonder dat je voor elk datatype aparte implementaties hoeft te schrijven. Hier is een voorbeeld van een generieke functie die een lijst van elementen sorteert, ongeacht het datatype: ```typescript function sorteerLijst<T>(lijst: T[], vergelijker: (a: T, b: T) => number): T[] { return lijst.slice().sort(vergelijker); } ``` In dit voorbeeld: - `<T>` maakt de functie generiek voor elk datatype. - `lijst: T[]` is een array van elementen van type `T`. - `vergelijker` is een functie die twee elementen van type `T` vergelijkt en een nummer teruggeeft (zoals de standaard `sort`-functie in JavaScript). Gebruik van de functie met verschillende datatypes: ```typescript // Voor numbers const getallen = [3, 1, 4, 1, 5]; const gesorteerdeGetallen = sorteerLijst(getallen, (a, b) => a - b); console.log(gesorteerdeGetallen); // [1, 1, 3, 4, 5] // Voor strings const woorden = ["appel", "banaan", "kers"]; const gesorteerdeWoorden = sorteerLijst(woorden, (a, b) => a.localeCompare(b)); console.log(gesorteerdeWoorden); // ["appel", "banaan", "kers"] ``` Deze aanpak is zeer flexibel doordat je de vergelijkingsfunctie zelf kunt aanpassen aan het datatype dat je wilt sorteren. **Samenvatting:** - Gebruik `<T>` om een generieke parameter te definiëren. - Maak je functie of klasse afhankelijk van deze parameter. - Bied een manier om het datatype te vergelijken (bijvoorbeeld een vergelijkerfunctie) zodat je de sortering kunt aanpassen aan het datatype. Wil je nog een voorbeeld van een generieke klasse of een meer complexe toepassing?

Zeker! Hier is een uitleg over generieke types in TypeScript met een voorbeeld van een sorteermethode: ## Wat zijn generieke types? Generieke types (ook wel "generics" genoemd) stellen je in staat om herbruikbare componenten te maken die met verschillende datatypes kunnen werken, terwijl je toch typeveiligheid behoudt. ## Basis syntax ```typescript function functieNaam<T>(parameter: T): T { // implementatie } ``` ## Voorbeeld: Generieke sorteermethode ```typescript // Generieke functie om een array te sorteren function sorteerLijst<T>(lijst: T[], vergelijkFunctie: (a: T, b: T) => number): T[] { return [...lijst].sort(vergelijkFunctie); } // Gebruik met verschillende datatypes: // 1. Sorteren van getallen const getallen = [3, 1, 4, 1, 5, 9, 2]; const gesorteerdeGetallen = sorteerLijst(getallen, (a, b) => a - b); console.log(gesorteerdeGetallen); // [1, 1, 2, 3, 4, 5, 9] // 2. Sorteren van strings const woorden = ["banaan", "appel", "kers", "druif"]; const gesorteerdeWoorden = sorteerLijst(woorden, (a, b) => a.localeCompare(b)); console.log(gesorteerdeWoorden); // ["appel", "banaan", "druif", "kers"] // 3. Sorteren van objecten interface Persoon { naam: string; leeftijd: number; } const personen: Persoon[] = [ { naam: "Jan", leeftijd: 30 }, { naam: "Piet", leeftijd: 25 }, { naam: "Klaas", leeftijd: 35 } ]; const opLeeftijdGesorteerd = sorteerLijst(personen, (a, b) => a.leeftijd - b.leeftijd); console.log(opLeeftijdGesorteerd); // [{ naam: "Piet", leeftijd: 25 }, { naam: "Jan", leeftijd: 30 }, { naam: "Klaas", leeftijd: 35 }] ``` ## Generieke klasse voor een verzameling ```typescript class Verzameling<T> { private items: T[] = []; toevoegen(item: T): void { this.items.push(item); } sorteren(vergelijkFunctie: (a: T, b: T) => number): T[] { return [...this.items].sort(vergelijkFunctie); } getAll(): T[] { return this.items; } } // Gebruik: const nummerVerzameling = new Verzameling<number>(); nummerVerzameling.toevoegen(5); nummerVerzameling.toevoegen(2); nummerVerzameling.toevoegen(8); const gesorteerd = nummerVerzameling.sorteren((a, b) => a - b); console.log(gesorteerd); // [2, 5, 8] ``` ## Meerdere generieke parameters ```typescript function combineer<T, U>(eerste: T, tweede: U): [T, U] { return [eerste, tweede]; } const resultaat = combineer("hello", 42); // Type: [string, number] ``` ## Voordelen van generieke types: - **Typeveiligheid**: Compile-time type checking - **Herbruikbaarheid**: Werkt met verschillende datatypes - **Flexibiliteit**: Behoudt type-informatie - **Onderhoudbaarheid**: Minder duplicate code De generieke parameter `T` fungeert als een placeholder voor het daadwerkelijke type dat wordt doorgegeven wanneer de functie of klasse wordt gebruikt.