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 :

1. Commencer par le mot-clé interface.
2. Donner un nom à l'interface.
3. 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'.
}