Angular

Appearance

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
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 };
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);
}
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;
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;
    }
}
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");
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>;
type Optionnel<T> = {
    [P in keyof T]?: T[P];
};

type EmployeOptionnel = Optionnel<Employe>;