Interface vs classe dans TypeScript
- Différences entre les classes et les interfaces dans TypeScript
- Quand utiliser les classes par rapport aux interfaces dans TypeScript
TypeScript est un langage fortement typé et prend en charge les types complexes et primitifs. Il s’agit d’un sur-ensemble du langage de programmation JavaScript et, par conséquent, il possède également les différentes fonctionnalités présentes dans JavaScript, telles que les concepts de programmation orientée objet (POO) et les concepts de programmation fonctionnelle.
TypeScript devient extrêmement utile pour les organisations ayant de grandes bases de code. TypeScript permet d’éviter les erreurs d’exécution qui seraient inévitables dans le cas de JavaScript pour les types déduits à tort.
Les outils appropriés et l’IDE prenant en charge TypeScript peuvent suggérer des complétions de code, détecter des erreurs dans les types, corriger automatiquement les erreurs, etc. via diverses interfaces définies par l’utilisateur ou par des types déduits par le compilateur TypeScript.
Ce didacticiel se concentrera sur les différences entre les classes et les interfaces et montrera quand utiliser lesquelles modéliser certaines données.
Différences entre les classes et les interfaces dans TypeScript
Les classes sont essentiellement nécessaires pour contenir l’implémentation de différents objets avec différentes propriétés et méthodes qui leur sont associées. Les classes peuvent avoir des propriétés initialisées et avoir des implémentations de diverses méthodes à l’intérieur et peuvent être utilisées pour initialiser ou créer différents objets.
Les interfaces ne sont utilisées que pour contenir les informations de type de divers attributs correspondant à un objet. Il est généralement utilisé pour la vérification de type et évite ainsi les erreurs d’exécution et ne peut pas être utilisé pour l’instanciation d’objet.
class Animal {
name : string;
eyes : number;
constructor( name : string, eyes : number) {
this.name = name;
this.eyes = eyes;
}
getName() : string {
return this.name;
}
getEyes() : number {
return this.eyes;
}
}
Le bloc de code ci-dessus montre l’implémentation d’une classe TypeScript qui contient le plan des différents attributs associés à la classe Animal et possède quelques méthodes. Les mêmes données peuvent être modélisées à l’aide d’une interface.
interface Animal {
name : string;
eyes : number;
getName : () => string;
getEyes : () => number;
}
Ainsi selon l’interface, il a toutes les possibilités de vérification de type sur tout objet implémentant l’interface, mais contrairement aux classes, il n’a aucun moyen d’initialiser les propriétés d’une classe et ne peut avoir aucune implémentation pour les fonctions d’une classe.
Quand utiliser les classes par rapport aux interfaces dans TypeScript
Les classes sont utilisées comme un modèle d’objet contenant des valeurs par défaut, différentes implémentations de méthodes ou en utilisant le mot-clé new pour créer différentes instances de la même classe. De plus, avec les classes, le code prendra de la place à l’exécution, contrairement aux interfaces supprimées par le compilateur TypeScript.
Les classes ont des constructeurs pour ajouter du code d’initialisation et initialiser des variables de données dans la classe, contrairement aux interfaces.
Ainsi, les classes sont utilisées pour représenter certains modèles de données complexes dont les objets peuvent avoir besoin d’être créés et doivent souvent être étendus et peuvent nécessiter une logique d’initialisation qui leur est attachée.
Pendant ce temps, les interfaces sont utilisées pour avoir une modélisation simple des données, constituée uniquement des types des attributs associés à un objet.
Ils peuvent également servir d’interface de données pour certaines classes, par exemple la classe Tiger implante Animal - la classe Tiger aura tout le support de vérification de type avec les mêmes attributs que ceux présents dans l’interface Animal.
