In TypeScript kun je mapped types gebruiken om dynamisch types te transformeren door eigenschappen van een bestaand type te herstructureren. Hiermee kun je bijvoorbeeld readonly eigenschappen veranderen naar mutable, of eigenschappen aanpassen door een prefix of suffix toe te voegen. **Voorbeeld 1: Readonly naar mutable** Stel je hebt de interface: ```typescript interface User { readonly id: number; readonly name: string; } ``` Wil je een versie maken zonder readonly, dan kun je een mapped type gebruiken: ```typescript type MutableUser = { -readonly [K in keyof User]: User[K]; }; ``` Hierbij betekent `-readonly` dat de readonly modifier wordt verwijderd uit elke eigenschap. **Voorbeeld 2: Eigenschappen voorzien van een prefix** Stel je wilt een nieuw type maken waarbij alle eigenschap-namen een prefix krijgen, bijvoorbeeld 'user_': ```typescript type PrefixedUser = { [K in keyof User as `user_${string & K}`]: User[K]; }; ``` Resultaat: ```typescript // { // user_id: number; // user_name: string; //} ``` **Voorbeeld 3: Eigenschappen voorzien van een suffix** Vergelijkbaar met het prefix, maar nu met suffix: ```typescript type SuffixedUser = { [K in keyof User as `${string & K}_info`]: User[K]; }; ``` Resultaat: ```typescript // { // id_info: number; // name_info: string; // } ``` **Samenvatting:** - Gebruik `[K in keyof T]` om eigenschappen te herhalen. - Gebruik `as` om de eigenschapnaam aan te passen. - Combineer met modifiers zoals `-readonly` of `+readonly` (voor het toevoegen van readonly). Deze aanpak maakt het mogelijk om zeer flexibele en dynamische types te creëren op basis van bestaande types.

In TypeScript gebruik je mapped types om bestaande types dynamisch te transformeren. Hier zijn voorbeelden voor je `User` interface: ```typescript interface User { readonly id: number; readonly name: string; } ``` ### 1. Readonly naar Mutable transformatie: ```typescript type MutableUser = { -readonly [P in keyof User]: User[P]; }; // Resultaat: { id: number; name: string; } (zonder readonly) ``` ### 2. Properties optioneel maken: ```typescript type OptionalUser = { [P in keyof User]?: User[P]; }; // Resultaat: { id?: number; name?: string; } ``` ### 3. Properties required maken (verwijder optioneel): ```typescript type RequiredUser = { [P in keyof User]-?: User[P]; }; // Resultaat: { id: number; name: string; } (alle properties verplicht) ``` ### 4. Prefix toevoegen aan property names: ```typescript type PrefixedUser = { [P in keyof User as `user_${P}`]: User[P]; }; // Resultaat: { user_id: number; user_name: string; } ``` ### 5. Suffix toevoegen aan property names: ```typescript type SuffixedUser = { [P in keyof User as `${P}_value`]: User[P]; }; // Resultaat: { id_value: number; name_value: string; } ``` ### 6. Type van properties veranderen: ```typescript type StringifiedUser = { [P in keyof User]: string; }; // Resultaat: { id: string; name: string; } ``` ### 7. Geavanceerde transformatie met voorwaarden: ```typescript type ConditionalUser = { [P in keyof User]: P extends 'id' ? string : User[P]; }; // Resultaat: { id: string; name: string; } (alleen id type gewijzigd) ``` ### 8. Combinatie van meerdere transformaties: ```typescript type TransformedUser = { [P in keyof User as `api_${P}`]-?: User[P]; }; // Resultaat: { api_id: number; api_name: string; } (prefix + required) ``` De syntax gebruikt: - `[P in keyof T]` - itereren over alle properties - `as` clause - property names hernoemen - `-readonly` en `-?` - modifiers verwijderen - Template literal types - strings manipuleren Deze mapped types zijn volledig type-safe en behouden alle type-informatie tijdens de transformatie!