Types d’union et d’intersection

Bienvenue dans la prochaine leçon ! Dans cette leçon, vous apprendrez à utiliser les types d’union pour permettre plusieurs types possibles pour une variable et les types d’intersection pour combiner plusieurs types en un seul. Ce sont des outils puissants pour créer un code flexible et robuste. Commençons !

Que sont les types d’union ?

Les types d’union permettent à une variable de contenir plusieurs types. Vous pouvez utiliser le symbole | pour définir un type d’union.

Exemple : Une variable qui peut être une chaîne ou un nombre :

Tâche : Déclarez une variable avec un type d’union et affectez-lui différentes valeurs.

let value: string | number;
value = "Hello";
console.log(value); // Output: "Hello"

value = 42;
console.log(value); // Output: 42

Utiliser les types d’union dans les fonctions

Vous pouvez utiliser les types d’union dans les paramètres des fonctions pour autoriser plusieurs types d’entrée. Exemple :

Tâche : Écrivez une fonction qui accepte un paramètre de type d’union et le journalise dans la console.

function printValue(value: string | number): void {
  console.log(`The value is ${value}`);
}

printValue("Hello"); // Output: The value is Hello
printValue(100); // Output: The value is 100

Que sont les types d’intersection ?

Les types d’intersection combinent plusieurs types en un seul. Vous pouvez utiliser le symbole & pour définir un type d’intersection.

Exemple : Combiner deux types d’objet :

Tâche : Créez un type d’intersection pour combiner deux objets et utilisez-le.

type Person = { name: string };
type Employee = { employeeId: number };

type Staff = Person & Employee;

let staffMember: Staff = {
  name: "Alice",
  employeeId: 123,
};

console.log(staffMember);

Utiliser les gardes de type avec les unions

TypeScript ne sait pas quel type vous utilisez dans un type d’union. Vous pouvez utiliser des gardes de type pour affiner le type. Exemple :

Tâche : Utilisez des gardes de type pour traiter différents types dans une union.

function display(value: string | number): void {
  if (typeof value === "string") {
    console.log(`String value: ${value.toUpperCase()}`);
  } else {
    console.log(`Number value: ${value * 2}`);
  }
}

display("Hello"); // Output: String value: HELLO
display(5); // Output: Number value: 10

Les types d’intersection en pratique

Les types d’intersection sont utiles lorsque vous travaillez avec des objets qui partagent des propriétés. Exemple :

Tâche : Créez un type d’intersection pour combiner les rôles admin et utilisateur.

type Admin = { adminLevel: string };
type User = { username: string };

type AdminUser = Admin & User;

let admin: AdminUser = {
  adminLevel: "super",
  username: "admin123",
};

console.log(`Admin ${admin.username} has level ${admin.adminLevel}`);

Erreurs courantes avec les types d’union et d’intersection

Voici quelques erreurs courantes :

• Utiliser un type d’union sans traiter tous les cas possibles (par exemple, oublier une garde de type).
• Rendre les types inutilement complexes avec des intersections superflues.
• Affecter des valeurs incompatibles à un type d’union ou d’intersection.

Conseil : Testez toujours votre code pour vous assurer que les types fonctionnent comme prévu !

Quand utiliser les unions et les intersections

Utilisez les types d’union lorsque :

• Une variable peut avoir l’un de plusieurs types possibles.
• Vous avez besoin de flexibilité dans les paramètres de fonction.

Utilisez les types d’intersection lorsque :

• Vous combinez plusieurs objets ou types en un seul.
• Vous créez des types plus complexes pour des cas d’utilisation spécifiques.

Bravo !

Félicitations ! Vous avez appris à utiliser les types d’union et d’intersection pour gérer des situations complexes en TypeScript. Ces outils rendent votre code plus flexible et plus expressif. Dans la prochaine leçon, nous explorerons les énumérations et la manière dont elles aident à gérer les valeurs constantes. Continuons à coder !