Vertel over de utility types in TypeScript.

TypeScript's utility types zijn ingebouwde types die het mogelijk maken om bestaande datatypes om te zetten in nieuwe types door verschillende nuttige operaties uit te voeren. Ze helpen de flexibiliteit en herbruikbaarheid van types te vergroten, waardoor redundantie in de code wordt verminderd.

Belangrijke utility types:

• Partial<Type>: Maakt een nieuw type waarbij alle eigenschappen van Type optioneel worden.

  interface User {
    id: number;
    name: string;
    age: number;
  }
  
  type PartialUser = Partial<User>;
  // PartialUser zal { id?: number; name?: string; age?: number; }
  

• Readonly<Type>: Maakt een nieuw type waarbij alle eigenschappen van Type alleen-lezen zijn.

  interface Point {
    x: number;
    y: number;
  }
  
  type ReadonlyPoint = Readonly<Point>;
  // ReadonlyPoint zal { readonly x: number; readonly y: number; }
  

• Pick<Type, Keys>: Creëert een type door een geselecteerde set eigenschappen Keys uit Type te kiezen.

  interface Product {
    id: number;
    name: string;
    price: number;
    description: string;
  }
  
  type ProductSummary = Pick<Product, 'id' | 'name' | 'price'>;
  // ProductSummary zal { id: number; name: string; price: number; }
  

• Omit<Type, Keys>: Creëert een type door een geselecteerde set eigenschappen Keys uit Type uit te sluiten.

  interface Order {
    id: number;
    productId: number;
    quantity: number;
    timestamp: string;
  }
  
  type OrderDetails = Omit<Order, 'timestamp'>;
  // OrderDetails zal { id: number; productId: number; quantity: number; }
  

• Exclude<Type, ExcludedUnion>: Creëert een type door uit Type die elementen uit te sluiten die kunnen worden toegewezen aan ExcludedUnion. Wordt gebruikt voor unie types.

  type Colors = 'red' | 'green' | 'blue' | 'yellow';
  type PrimaryColors = Exclude<Colors, 'yellow'>;
  // PrimaryColors zal 'red' | 'green' | 'blue'
  

• Extract<Type, Union>: Creëert een type door uit Type die elementen te kiezen die kunnen worden toegewezen aan Union. Wordt gebruikt voor unie types.

  type AllAnimals = 'dog' | 'cat' | 'fish' | 'bird';
  type PetAnimals = Extract<AllAnimals, 'dog' | 'cat'>;
  // PetAnimals zal 'dog' | 'cat'
  

• NonNullable<Type>: Creëert een type dat de waarden null en undefined uit Type uitsluit.

  type MaybeString = string | null | undefined;
  type NotNullableString = NonNullable<MaybeString>;
  // NotNullableString zal string
  

• Record<Keys, Type>: Creëert een objecttype waarvan de eigenschappen sleutels uit Keys hebben en waarden van type Type.

  type CityPopulation = Record<string, number>;
  // CityPopulation zal { [key: string]: number }
  
  const population: CityPopulation = {
    "Moscow": 12635466,
    "Saint Petersburg": 5381033,
  };
  

• Parameters<Type>: Geeft een tuple van de types van de parameters van de functie Type.

  function greet(name: string, age: number): string {
    return `Hello, ${name}! You are ${age}.`;
  }
  
  type GreetParams = Parameters<typeof greet>;
  // GreetParams zal [name: string, age: number]
  

• ReturnType<Type>: Geeft het type van de returnwaarde van de functie Type.

  function calculateSum(a: number, b: number): number {
    return a + b;
  }
  
  type SumResult = ReturnType<typeof calculateSum>;
  // SumResult zal number
  

• ConstructorParameters<Type>: Geeft een tuple of array van de types van de constructorparameters van de klasse Type.

  class MyClass {
    constructor(name: string, id: number) {}
  }
  
  type MyClassParams = ConstructorParameters<typeof MyClass>;
  // MyClassParams zal [name: string, id: number]
  

• InstanceType<Type>: Geeft het type van een instantie van de klasse Type.

  class AnotherClass {
    value: string;
    constructor(v: string) {
      this.value = v;
    }
  }
  
  type AnotherClassInstance = InstanceType<typeof AnotherClass>;
  // AnotherClassInstance zal AnotherClass
  

Het gebruik van utility types maakt de code veiliger, onderhoudbaarder en expressiever, doordat het effectief beheer van complexe datatypes mogelijk wordt.