Les types utilitaires

En TypeScript, en plus des types primitifs et des types personnalisés que vous pouvez créer, il existe plusieurs types utilitaires avancés qui permettent de transformer des types existants de manière sophistiquée. Omit, ainsi que d'autres types utilitaires similaires, jouent un rôle important dans ces transformations de type. Voici quelques-uns des types utilitaires les plus couramment utilisés :

Omit

Omit<T, K> crée un type en excluant certaines propriétés (K) d'un type donné (T). C'est utile pour créer des types basés sur d'autres types, mais sans certaines propriétés.

interface Personne {
    nom: string;
    age: number;
    adresse: string;
}

type PersonneSansAdresse = Omit<Personne, 'adresse'>;

// Équivalent à:
// type PersonneSansAdresse = {
//     nom: string;
//     age: number;
// }

Pick

Pick<T, K> est l'opposé de Omit. Il vous permet de créer un type en choisissant certaines propriétés (K) d'un type existant (T).

type PersonneNomEtAge = Pick<Personne, 'nom' | 'age'>;

// Équivalent à:
// type PersonneNomEtAge = {
//     nom: string;
//     age: number;
// }

Partial

Partial<T> rend toutes les propriétés d'un type T optionnelles. C'est utile lors de la modification ou de la construction partielle d'objets.

type PersonnePartielle = Partial<Personne>;

// Équivalent à:
// type PersonnePartielle = {
//     nom?: string;
//     age?: number;
//     adresse?: string;
// }

Required

Required<T> est l'opposé de Partial. Il rend toutes les propriétés d'un type T requises.

type PersonneComplete = Required<Personne>;

Readonly

Readonly<T> rend toutes les propriétés d'un type T en lecture seule. Cela signifie que les propriétés ne peuvent pas être réassignées après leur création.

type PersonneReadonly = Readonly<Personne>;

Record

Record<K, T> crée un type d'objet avec des clés de type K et des valeurs de type T. C'est utile pour définir des objets dont les clés sont connues à l'avance.

type DictionnaireDeNombres = Record<string, number>;
// Un objet avec des clés de type string et des valeurs de type number.

Exclude

Exclude<T, U> crée un type en excluant de T tous les types qui sont assignables à U. C'est utile pour retirer certains types d'une union.

type T1 = string | number | boolean;
type T2 = Exclude<T1, number>;

// T2 est maintenant string | boolean

Extract

Extract<T, U> fait le contraire de Exclude. Il crée un type en extrayant de T tous les types qui sont assignables à U.

type T3 = Extract<T1, number | boolean>;

// T3 est maintenant number | boolean

NonNullable

NonNullable<T> crée un type en excluant null et undefined de T.

type T4 = string | null | undefined;
type T5 = NonNullable<T4>;

// T5 est maintenant string

ReturnType

ReturnType<T> extrait le type de retour d'un type de fonction T.

function exemple() {
    return { nom: "Alice", age: 25 };
}

type T6 = ReturnType<typeof exemple>;

// T6 est maintenant { nom: string; age: number; }

Parameters

Parameters<T> extrait les types de paramètres d'une fonction sous forme d'un tuple.

function exemple2(nom: string, age: number) {
    // ...
}

type T7 = Parameters<typeof exemple2>;

// T7 est maintenant [string, number]

ConstructorParameters

Semblable à Parameters, mais pour les constructeurs de classes.

class ExempleClasse {
    constructor(nom: string, age: number) {}
}

type T8 = ConstructorParameters<typeof ExempleClasse>;

// T8 est maintenant [string, number]

InstanceType

InstanceType<T> extrait le type d'instance d'une classe ou d'un type de constructeur.

type T9 = InstanceType<typeof ExempleClasse>;

// T9 est maintenant ExempleClasse