This Banner is For Sale !!
Get your ad here for a week in 20$ only and get upto 15k traffic Daily!!!

Interface et type quand les utiliser ?


La différence entre interface et kind dans TypeScript est assez difficile à cerner et c’est regular ! Ils sont tellement similaires, qu’il est potential de les interchanger sans que ça ne soit problématique.




Alors quand utiliser l’un et quand utiliser l’autre ?

Cela dépend de vous, il n’y a pas de règle bien définie.

Le seul conseil valable serait de bien définir les conventions d’utilization que vous souhaitez mettre en place dans vos projets et de les respecter.


🤜 Une petite observe en passant, on parle de kind mais ça n’est pas tout à fait correcte, ce que nous créons est un alias de kind.

Un exemple easy qui permettrait de mieux comprendre serait de définir un alias de kind qui correspondrait à un kind primitif (string, boolean, quantity, …)

kind MonAliasDeType = string;

kind MonAutreAliasDeType = {
   maPropriete: MonAliasDeType,
   ...
}
Enter fullscreen mode

Exit fullscreen mode

Nous faisons référence à un kind.




Mon level de vue

Personnellement j’ai beaucoup utilisé les interfaces, tellement, qu’il était très uncommon que j’en vienne à utiliser les sorts.

Mais après avoir feuilleté la documentation TypeScript, lu quelques articles et révisé mes cours, j’ai maintenant une idée plus claire et surtout une raison pour utiliser soit une interface soit un kind.

J’utilise kind parce qu’il permet de définir plus de cas, de manière plus parlante et est plus strict donc, selon moi, plus adapté pour décrire notre code. En effet, les sorts ne sont pas ouverts, c’est à dire qu’ils ne peuvent pas être modifiés après avoir été définis.

Contrairement aux interfaces qui, quant à elles, permettent la fusion, c’est à dire que si l’on déclare deux fois, ou plus, une interface avec le même nom, ça ne sera pas considéré comme une erreur et aura pour effet de fusionner les interfaces.

interface MonInterface {
  a: string;
}

interface MonInterface {
  b: string;
}

let maVariable: MonInterface;

maVariable.a
maVariable.b
Enter fullscreen mode

Exit fullscreen mode

A utiliser les interfaces on prendrait donc le risque de fusionner celles qui ont le même nom. Même si ça ne semble pas être un problème courant, il serait potential de fusionner des interfaces sans s’en rendre compte.

kind, quant à lui, retournera une erreur.

kind a aussi l’avantage de proposer plus possibilités pour décrire le format des données, voir les Discriminated Sorts (|) et les Intersection sorts (&).



A quoi servent les interfaces ? me diriez-vous.

J’utilise interface quand j’ai besoin d’ajouter des propriétés à une interface globale, comme celle de Window ou dans les librairies que je crée, je définie des interfaces pour qu’elles puissent être surchargées.

Un autre cas d’utilisation serait pour les interfaces de classe.

class MaClass implements MonInterface {}
Enter fullscreen mode

Exit fullscreen mode



Pour récapituler

J’utilise kind par défaut parce qu’il :

  • Permet de définir plus de cas
  • N’est pas ouvert, donc plus strict (on ne peut pas le modifier après sa déclaration)

J’utilise interface dans le cas où :

  • Je veux étendre une interface globale comme Window
  • Je veux étendre ou pouvoir étendre une interface venant d’une librairie
  • Je dois utiliser implements

Sur ce, bon dev 😉

The Article was Inspired from tech community site.
Contact us if this is inspired from your article and we will give you credit for it for serving the community.

This Banner is For Sale !!
Get your ad here for a week in 20$ only and get upto 10k Tech related traffic daily !!!

Leave a Reply

Your email address will not be published. Required fields are marked *

Want to Contribute to us or want to have 15k+ Audience read your Article ? Or Just want to make a strong Backlink?