Parlez-moi des types utilitaires en TypeScript…

Les types utilitaires en TypeScript sont des types auxiliaires intégrés qui simplifient les opérations courantes sur les types, telles que les transformations, extractions ou exclusions de propriétés spécifiques. Ils améliorent la flexibilité et la lisibilité du code.

Principaux types utiles:

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

// Crée un type avec les propriétés optionnelles 'name' et 'age'
type PartialUser = Partial<{ name: string; age: number }>;

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

// Crée un type avec les propriétés 'name' et 'age', accessibles en lecture seule
type ReadonlyUser = Readonly<{ name: string; age: number }>;

Pick<Type, Keys>: Crée un type en sélectionnant un ensemble de propriétés Keys de Type. Keys peut être un littéral de chaîne ou une union de littéraux de chaîne.
```
// Crée un type contenant uniquement la propriété 'name'
type UserWithName = Pick<{ name: string; age: number }, 'name'>;
```

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

// Crée un type contenant uniquement la propriété 'age'
type UserWithoutName = Omit<{ name: string; age: number }, 'name'>;

Exclude<UnionType, ExcludedMembers>: Crée un type en excluant de UnionType tous les membres assignables à ExcludedMembers.

// Crée un type excluant 'null' du union
type NonNullableString = Exclude<string | null | undefined, null | undefined>;

Extract<Type, Union>: Extrait de Type tous les membres assignables à Union.

// Extrait 'null' et 'undefined' du union
type JustNullOrUndefined = Extract<string | null | undefined, null | undefined>;

NonNull<Type>: Exclut null et undefined de Type.

// Crée un type excluant 'null' et 'undefined'
type NonNullStringOrNumber = NonNullable<string | number | null | undefined>;

Parameters<Type>: Obtient les types de paramètres de la fonction Type sous forme de tuple.

// Obtient les types de paramètres de la fonction : [string, number]
type FuncParams = Parameters<(a: string, b: number) => void>;

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

// Obtient le type de la valeur de retour de la fonction : number
type FuncReturn = ReturnType<() => number>;

ConstructorParameters<Type>: Extrait les types de paramètres du constructeur du type constructeur.

// Obtient les types de paramètres du constructeur de la classe : [string, number]
type MyClassParams = ConstructorParameters<typeof MyClass>;

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

InstanceType<Type>: Extrait le type d'instance du type constructeur.

// Extrait le type d'instance de la classe : MyClass
type MyClassInstance = InstanceType<typeof MyClass>;

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

L'utilisation des types utilitaires contribue à créer un code plus sûr en types, flexible et facile à maintenir.

Parlez-moi des types utilitaires en TypeScript.