Parlez-moi des types utilitaires en TypeScript…

Les types utilitaires en TypeScript sont des types intégrés qui permettent de transformer des types de données existants en nouveaux types, en effectuant diverses opérations utiles. Ils aident à augmenter la flexibilité et la réutilisabilité des types, en réduisant la redondance du code.

Types utilitaires principaux :

Partial<Type> : Crée un nouveau type où toutes les propriétés de Type sont optionnelles.

interface User {
  id: number;
  name: string;
  age: number;
}

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

Readonly<Type> : Crée un nouveau type où toutes les propriétés de Type sont en lecture seule.

interface Point {
  x: number;
  y: number;
}

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

Pick<Type, Keys> : Crée un type en sélectionnant un ensemble spécifique de propriétés Keys de Type.

interface Product {
  id: number;
  name: string;
  price: number;
  description: string;
}

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

Omit<Type, Keys> : Crée un type en excluant un ensemble spécifique de propriétés Keys de Type.

interface Order {
  id: number;
  productId: number;
  quantity: number;
  timestamp: string;
}

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

Exclude<Type, ExcludedUnion> : Crée un type en excluant de Type ceux éléments qui peuvent être assignés à ExcludedUnion. Utilisé pour les unions (types union).

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

Extract<Type, Union> : Crée un type en sélectionnant de Type ceux éléments qui peuvent être assignés à Union. Utilisé pour les unions.

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

NonNullable<Type> : Crée un type en excluant de Type les valeurs null et undefined.

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

Record<Keys, Type> : Crée un type d'objet dont les propriétés ont des clés de Keys et des valeurs du type Type.

type CityPopulation = Record<string, number>;
// CityPopulation sera { [key: string]: number }

const population: CityPopulation = {
  "Moscow": 12635466,
  "Saint Petersburg": 5381033,
};

Parameters<Type> : Retourne un tuple (tuple) des types des paramètres de la fonction Type.

function greet(name: string, age: number): string {
  return `Hello, ${name}! You are ${age}.`;
}

type GreetParams = Parameters<typeof greet>;
// GreetParams sera [name: string, age: number]

ReturnType<Type> : Retourne le type de la valeur de retour de la fonction Type.

function calculateSum(a: number, b: number): number {
  return a + b;
}

type SumResult = ReturnType<typeof calculateSum>;
// SumResult sera number

ConstructorParameters<Type> : Retourne un tuple ou un tableau des types des paramètres du constructeur de la classe Type.

class MyClass {
  constructor(name: string, id: number) {}
}

type MyClassParams = ConstructorParameters<typeof MyClass>;
// MyClassParams sera [name: string, id: number]

InstanceType<Type> : Retourne le type de l'instance de la classe Type.

class AnotherClass {
  value: string;
  constructor(v: string) {
    this.value = v;
  }
}

type AnotherClassInstance = InstanceType<typeof AnotherClass>;
// AnotherClassInstance sera AnotherClass

L'utilisation des types utilitaires rend le code plus sûr, maintenable et expressif, permettant de gérer efficacement des types de données complexes.

Parlez-moi des types utilitaires en TypeScript.