Skip to content

Aller plus loin sur les types

TypeScript propose plusieurs types avancés qui permettent de gérer des cas de programmation plus complexes et d'assurer une plus grande rigueur dans la vérification des types. Voici quelques-uns des types avancés les plus utilisés en TypeScript :

Union Types

Un type union est utilisé pour définir une variable qui peut contenir plusieurs types différents.

typescript
let id: number | string;
id = 101; // valide
id = "202"; // valide

Intersection Types

Les types intersection sont utilisés pour combiner plusieurs types en un seul. Cela permet de mélanger plusieurs types pour en créer un nouveau qui possède toutes les propriétés de ces types.

typescript
interface Employe {
    nom: string;
}

interface Manager {
    equipe: number;
}

type ChefEquipe = Employe & Manager;
let chef: ChefEquipe = { nom: "Alice", equipe: 4 };

Type Guards

Les Type Guards permettent de vérifier le type d'une variable au sein d'un bloc de code.

typescript
function estChaine(texte: string | number): texte is string {
    return typeof texte === "string";
}

if (estChaine(id)) {
    console.log(id.toUpperCase());
} else {
    console.log(id);
}

Type Assertions

Les assertions de type sont utilisées pour indiquer explicitement au compilateur le type d'une variable. Elles n'altèrent pas le comportement du code au moment de l'exécution, mais fournissent des informations au compilateur.

typescript
let maVariable: any = "Ceci est une chaîne de caractères";
let longueur: number = (maVariable as string).length;

Enums avec Types Discriminés (Discriminated Unions)

Il s'agit d'une technique pour travailler avec des unions de types où chaque type a un champ commun, qui est utilisé pour discriminer entre les autres types.

typescript
interface Carre {
    type: "carre";
    cote: number;
}

interface Cercle {
    type: "cercle";
    rayon: number;
}

type Forme = Carre | Cercle;

function aire(forme: Forme) {
    if (forme.type === "carre") {
        return forme.cote * forme.cote;
    } else {
        return forme.rayon * Math.PI * 2;
    }
}

Generic Types

Les types génériques permettent de créer des composants qui peuvent travailler avec plusieurs types plutôt qu'un seul. Cela ajoute une couche de flexibilité et de réutilisabilité.

typescript
function identite<T>(arg: T): T {
    return arg;
}

let sortie = identite<string>("monTexte");

Mapped Types

Les types mappés permettent de créer des types basés sur un autre type en transformant chaque propriété. Ils sont souvent utilisés pour rendre toutes les propriétés d'un type optionnelles ou en lecture seule.

typescript
type Optionnel<T> = {
    [P in keyof T]?: T[P];
};

type EmployeOptionnel = Optionnel<Employe>;

Abonnez-vous à la newsletter

En juillet, recevez en avant-première notre newsletter avec les dernières actualités, tutoriels, astuces et ressources Angular directement par email !