In TypeScript kun je type guards en custom type predicates gebruiken om tijdens runtime te verifiëren of een waarde aan een specifiek type voldoet. Dit helpt bij het schrijven van veiligere code doordat je expliciet controleert of een object het verwachte type heeft voordat je het gebruikt. **1. Definieer een gebruikersobject type:** ```typescript interface Gebruiker { naam: string; leeftijd: number; } ``` **2. Schrijf een type guard functie met een custom type predicate:** Een type guard is een functie die `boolean` teruggeeft en een type voorstelt met de `is` syntax. ```typescript function isGebruiker(obj: any): obj is Gebruiker { return ( obj !== null && typeof obj === 'object' && typeof obj.naam === 'string' && typeof obj.leeftijd === 'number' ); } ``` **3. Gebruik de type guard in je code:** ```typescript function verwerkGebruiker(input: any) { if (isGebruiker(input)) { // Hier weet TypeScript dat input een Gebruiker is console.log(`Gebruiker: ${input.naam}, Leeftijd: ${input.leeftijd}`); } else { console.log('Ongeldig gebruikersobject'); } } ``` **4. Voorbeeldgebruik:** ```typescript const persoon1 = { naam: 'Jan', leeftijd: 30 }; const persoon2 = { naam: 'Piet', leeftijd: 'oud' }; verwerkGebruiker(persoon1); // Geldig, wordt geprint verwerkGebruiker(persoon2); // Ongeldig, wordt aangegeven ``` **Samenvatting:** - Je definieert een type guard functie die controleert of een object voldoet aan de verwachte structuur. - De functie gebruikt de `obj is Gebruiker` syntax voor een custom type predicate. - Bij gebruik van de type guard wordt TypeScript geïnformeerd over het type, wat typefouten voorkomt en de code veiliger maakt. Zo kun je met behulp van type guards en custom predicates effectief runtime type verificaties uitvoeren en je code type-safe houden.

In TypeScript kun je type guards en custom type predicates als volgt schrijven voor gebruikersobjecten: ## Basis Type Definition ```typescript interface User { name: string; age: number; } ``` ## Type Guard Functies ### 1. Basis Type Guard ```typescript function isUser(value: unknown): value is User { return ( typeof value === 'object' && value !== null && 'name' in value && 'age' in value && typeof (value as any).name === 'string' && typeof (value as any).age === 'number' ); } ``` ### 2. Uitgebreide Type Guard met extra validatie ```typescript function isValidUser(value: unknown): value is User { if (!isUser(value)) return false; return ( value.name.trim().length > 0 && value.age >= 0 && value.age <= 150 ); } ``` ### 3. Type Guard voor arrays van gebruikers ```typescript function isUserArray(value: unknown): value is User[] { return ( Array.isArray(value) && value.every(isUser) ); } ``` ## Gebruik in Code ### Voorbeeld 1: Enkele gebruiker controleren ```typescript function processUser(input: unknown): void { if (isUser(input)) { // TypeScript weet nu dat 'input' van type User is console.log(`Gebruiker: ${input.name}, Leeftijd: ${input.age}`); } else { console.log('Ongeldige gebruiker data'); } } ``` ### Voorbeeld 2: Data valideren van externe bron ```typescript async function fetchUserData(): Promise<User | null> { try { const response = await fetch('/api/user'); const data = await response.json(); if (isValidUser(data)) { return data; // Veilig type } return null; } catch (error) { return null; } } ``` ### Voorbeeld 3: Array van gebruikers verwerken ```typescript function processUsers(users: unknown): void { if (isUserArray(users)) { users.forEach(user => { console.log(user.name); // Veilige toegang }); } } ``` ### Voorbeeld 4: Inline type narrowing ```typescript function handleUserInput(input: unknown): string { if ( typeof input === 'object' && input !== null && 'name' in input && typeof (input as any).name === 'string' ) { return `Hallo, ${(input as any).name}!`; } return 'Onbekende gebruiker'; } ``` ## Best Practices 1. **Wees specifiek**: Controleer alle vereiste properties 2. **Valideer datatypes**: Gebruik `typeof` checks 3. **Handel edge cases af**: Check op `null` en `undefined` 4. **Hergebruik guards**: Maak composable guard functies 5. **Geef duidelijke foutmeldingen**: Voor debugging Deze pattern zorgt voor runtime type safety terwijl je profiteert van TypeScript's compile-time type checking.