Alias de types et interfaces

Alias de types et interfaces

Bienvenue dans la prochaine leçon ! Vous allez découvrir les alias de types et les interfaces dans TypeScript, notamment leurs différences, leurs similitudes et les situations dans lesquelles utiliser chacun. Commençons !

Un alias de type vous permet de définir un nom personnalisé pour un type. Il peut représenter des types primitifs, des objets ou même des signatures de fonctions.

Exemple :

Tâche : Créez un alias de type pour un objet représentant un livre et utilisez-le pour définir une variable.

type Point = {
  x: number;
  y: number;
};

let point: Point = { x: 10, y: 20 };
console.log(point); 
// Output: { x: 10, y: 20 }

Une interface définit la structure d’un objet, notamment ses propriétés et ses méthodes. Elle est souvent utilisée pour garantir la cohérence et la sécurité du typage des objets.

Exemple :

Tâche : Créez une interface pour le profil d’un utilisateur et utilisez-la pour définir une variable.

interface Point {
  x: number;
  y: number;
}

let point: Point = { x: 5, y: 15 };
console.log(point); 
// Output: { x: 5, y: 15 }

Les alias de types et les interfaces partagent certaines fonctionnalités :

• Ils peuvent tous deux décrire la forme d’un objet.
• Ils peuvent tous deux être utilisés pour définir des types de fonctions.
• Ils prennent tous deux en charge l’extension d’autres types.

Exemple : un type de fonction :

Tâche : Définissez à la fois un alias de type et une interface pour une fonction, puis utilisez-les.

type Add = (a: number, b: number) => number;
interface Subtract {
  (a: number, b: number): number;
}

let add: Add = (x, y) => x + y;
let subtract: Subtract = (x, y) => x - y;

console.log(add(5, 3)); 
// Output: 8
console.log(subtract(5, 3)); 
// Output: 2

Voici les principales différences :

• Interfaces : elles peuvent être fusionnées (fusion de déclarations).
• Alias de types : ils ne peuvent pas être fusionnés.
• Alias de types : ils peuvent définir des types union et intersection.
• Interfaces : elles sont principalement conçues pour décrire la forme des objets.

Exemple : des types union avec des alias de types :

Tâche : Utilisez un alias de type pour définir un type union et affectez différentes valeurs à une variable.

type StringOrNumber = string | number;

let value: StringOrNumber = "Hello";
value = 42;
// value = true; 
// Error: Type 'true' is not assignable to type 'StringOrNumber'.

Les alias de types et les interfaces peuvent tous deux étendre d’autres types :

• Interfaces : utilisez le mot-clé extends.
• Alias de types : utilisez des intersections (&).

Exemple :

Tâche : Étendez un alias de type et une interface pour créer de nouveaux types.

interface Animal {
  name: string;
}

interface Dog extends Animal {
  breed: string;
}

type Bird = Animal & { canFly: boolean };

let myDog: Dog = { name: "Buddy", breed: "Golden Retriever" };
let myBird: Bird = { name: "Parrot", canFly: true };

console.log(myDog, myBird);

Les interfaces prennent en charge la fusion de déclarations : plusieurs déclarations d’interface portant le même nom sont fusionnées en une seule. Les alias de types ne prennent pas en charge cette fonctionnalité.

Exemple :

Tâche : Créez deux déclarations d’interface portant le même nom et testez la fusion de déclarations.

interface Person {
  name: string;
}

interface Person {
  age: number;
}

let person: Person = { name: "Alice", age: 30 };
console.log(person); 
// Output: { name: "Alice", age: 30 }

Voici quelques recommandations :

• Utilisez les interfaces pour définir la forme des objets et lorsque la fusion de déclarations est nécessaire.
• Utilisez les alias de types pour les unions, les intersections ou lorsque vous définissez des types de fonctions.

Conseil : Utilisez l’option qui correspond le mieux à votre cas d’utilisation afin de garantir la clarté et la cohérence !

Félicitations ! Vous avez appris les similitudes et les différences entre les alias de types et les interfaces dans TypeScript, ainsi que les situations dans lesquelles utiliser chacun. Dans la prochaine leçon, vous découvrirez des fonctionnalités avancées de TypeScript, comme les types conditionnels. Continuons à coder !