Interfaces en TypeScript
Qu'est-ce qu'une interface ?
Les interfaces en TypeScript servent à définir la structure d'un objet en précisant un ensemble de membres et/ou des annotations de type. Cela permet de garantir que les objets respectent une certaine forme, ce qui aide à maintenir un code propre et prévisible.
Syntaxe des interfaces
Pour créer une interface, vous utilisez la syntaxe suivante :
- Commencer par le mot-clé
interface
. - Donner un nom à l'interface.
- Définir un objet contenant un ensemble de membres et/ou d'annotations de type.
Voici un exemple :
interface MonType {
membreUn: string;
membreDeux: number;
}
let maVariable: MonType = { membreUn: 'Mon nombre préféré est', membreDeux: 42 };
Exemple de l'interface Chien
Prenons comme exemple une interface pour un Chien. Cette interface déclare les membres pelucheux
et aboyer
. Tout objet déclaré comme étant de type Chien saura qu'il devra avoir ces membres :
interface Chien {
pelucheux: boolean;
aboyer(): string;
}
function interagirAvecChien(chien: Chien) {
chien.aboyer();
if (chien.pelucheux) {
console.log('Quelle bouffée de poils !');
}
chien.aboyer(); // Erreur : La propriété 'aboyer' n'existe pas sur le type 'Chien'.
}
Membres optionnels
Dans l'interface Animal de Compagnie, le membre nom
est indiqué comme optionnel grâce au point d'interrogation (?
). Le seul membre requis est espece
. Ainsi, il n'est pas nécessaire de spécifier un nom, mais l'espèce doit être définie :
interface AnimalDeCompagnie {
nom?: string;
espece: string;
}
let animalAnonyme: AnimalDeCompagnie = { espece: 'Chien' }; // Correct
let animalNomme: AnimalDeCompagnie = { nom: 'Émeraude', espece: 'Perroquet' }; // Correct
let animalInvalide: AnimalDeCompagnie = { nom: 'Ma Pierre' }; // Erreur : La propriété 'espece' est manquante.
Extensions d'interfaces
Les interfaces peuvent également étendre d'autres interfaces. Cela signifie que l'interface dérivée (en extension) héritera de tous les membres des interfaces parent (de base). Pour cela, on utilise le mot-clé extends
suivi du nom des interfaces à étendre.
Examinons un exemple avec l'interface Chat, qui hérite d'une interface de base Animal :
interface Animal {
marcher(): void;
}
interface Chat extends Animal {
pelucheux: boolean;
ronronner(): string;
}
function travaillerAvecAnimaux(animal: Animal, chat: Chat) {
animal.marcher(); // Ok : défini sur Animal
chat.marcher(); // Ok : Chat hérite d'Animal
if (chat.pelucheux) {
console.log('Floof !!');
chat.ronronner(); // Ok : défini sur Chat
}
animal.ronronner(); // Erreur : La propriété 'ronronner' n'existe pas sur le type 'Animal'.
}