Types en JavaScript

Découvrez les types primitifs en JavaScript, le fonctionnement de la coercition de type et une meilleure solution pour travailler avec des types en JavaScript.

Tous les langages de programmation ont des types intégrés. Ce sont les blocs de construction qui nous aident à structurer notre code et à créer de nouvelles applications, frameworks, bibliothèques, etc. De plus, ces types intégrés diffèrent d'un langage à l'autre. Nous avons différentes langues à des fins différentes; chaque langage a une manière différente de programmer et il est utilisé pour un cas d’utilisation spécifique.

L’apprentissage d’un langage de programmation n’est pas une tâche facile. Lorsque vous savez déjà programmer dans une langue et que vous voulez apprendre une autre langue, c'est également un défi difficile. Les méthodes et concepts que vous avez à l'esprit dans votre langage de programmation précédent et principal peuvent entraver votre processus d'apprentissage d'un nouveau langage.

JavaScript est devenu le langage de programmation le plus utilisé au monde pour plusieurs raisons. L'un des facteurs les plus importants que nous pouvons énumérer est que JavaScript est très facile à utiliser. Les débutants peuvent commencer à écrire du code JavaScript sans trop de soucis. Pour les développeurs qui ont déjà de l'expérience avec un autre langage de programmation, JavaScript devient plus facile et se transforme en un langage où tout est possible.

Dynamique vs statique

Il existe deux différences principales entre les langages typés dynamiquement et statiquement typés:

• Les langages à typage dynamique effectuent une vérification de type au moment de l'exécution.
• Les langages à typage statique effectuent une vérification de type au moment de la compilation.

Les langages à typage statique exigent que vous déclariez les types de données de vos variables. Si vous avez déjà utilisé Java ou tout autre langage à typage statique, vous savez que nous devons d'abord déclarer le type de notre variable, comme ceci:

 int  time  =   10 ; 
 char  name  =   'Leonardo' ; 

Si nous ne spécifions pas le type de données de la variable dans notre langage à typage statique, cela nous enverra une erreur. Dans cet exemple, nous avons simplement défini le type de données temporelles comme int et le nom comme char .

Une autre raison pour laquelle JavaScript est devenu si célèbre dans le monde entier est qu'il s'agit d'un langage faiblement typé. à la fois. Un langage faiblement typé est un langage dans lequel les variables n'ont pas besoin d'être liées à un type de données spécifique.

C'est un langage de programmation très simple, flexible, amusant et parfois délicat. Dans les langages dynamiquement typés comme JavaScript, nous n'avons pas besoin de spécifier les types de données de nos variables.

 const  time  =   10 ; 
 const  name  =   'Leonardo' ; 

Les langages typés dynamiquement peuvent compiler votre code même s'il y a des erreurs qui peuvent planter votre application et entraîner un problème de fonctionnement. Les langages typés statiquement ne permettront pas la compilation tant que toutes les erreurs de votre code n'auront pas été corrigées.

Les langages typés dynamiquement sont très flexibles et peuvent certainement nous faire gagner beaucoup de temps lors de l'écriture de nos applications. Il est plus facile de comprendre le code, nous pouvons construire plus rapidement, etc.

Pour être flexibles, les langages parfois typés dynamiquement, comme JavaScript, peuvent nous conduire à des erreurs lors de l'exécution que nous ne détectons pas au début.

 3   -   1  
 3   +   1  
 '3'   -   1  
 '3'   +   1 [19659040] Nous avons littéralement un grand référentiel GitHub appelé  wtfjs  avec de nombreuses erreurs étranges et délicates dans JavaScript. 

 Savoir exactement comment tous les types primitifs de JavaScript fonctionnent est essentiel pour éviter ces erreurs délicates dans vos applications. 
 Types primitifs 
 JavaScript est essentiellement un langage typé dynamiquement. Parfois, il peut sembler que JavaScript n'a pas de types, ce qui est fondamentalement incorrect. 
 Lorsque nous parlons de types en JavaScript, cela peut signifier quelque chose de très différent de ce que nous parlons de types dans des langages à typage statique. 
 Un type fournit un ensemble de valeurs à partir desquelles une expression peut prendre ses valeurs, et en JavaScript, nous avons quelques types primitifs: 
 string 
    
 number 
    
 undefined 
    
 null 
    
 boolean 
    
 symbol [19659009] Ces types primitifs sont les blocs de construction de JavaScript - ce sont les types derrière toutes nos applications. 

 Tout ce qui n'est pas un type primitif en JavaScript est un objet. Malgré ce que beaucoup de gens pourraient penser, les objets ne sont pas des types primitifs en JavaScript. Nous pouvons énumérer de nombreuses différences entre les types primitifs et les objets, mais l'une des plus importantes est que les types primitifs sont immuables et qu'un objet ne peut avoir qu'une référence immuable et que leurs valeurs peuvent changer avec le temps. 
 Chaque développeur JavaScript devrait savoir, au moins un peu, comment fonctionne chaque type primitif et son comportement intrinsèque. Cela vous aidera à vous familiariser avec tous les différents types que nous avons dans le langage et quand utiliser correctement chaque type primitif. 



  


               




 L'une des raisons pour lesquelles nous pouvons avoir de nombreuses erreurs dans JavaScript est que le langage est un langage dynamique et faible. langue typée en même temps, il est difficile de prévoir et de garantir le type de la variable. Chaque fois que nous essayons d'obtenir la valeur de quelque chose, cela peut avoir changé, ainsi que le type de données. 
 Coercition de type 
 La coercition de type est un processus en JavaScript de conversion d'une valeur d'un type à un autre. Tout type de JavaScript, primitif ou objet, peut être converti en un autre type. 
 C'est l'une des raisons pour lesquelles JavaScript peut parfois être si délicat. Nous utilisons une variable, et par erreur, nous pourrions changer le type de données de cette variable en un autre sans le remarquer. 
 Il existe deux types de coercition de type:  implicite  et  explicite  ]. 
 Imaginons que vous ayez une chaîne   de valeur  10  et que vous vouliez la traiter comme un nombre  . Pour ce faire, vous devez d'abord convertir (forcer) la valeur d'une chaîne   en un nombre  . Le type explicite de coercition se produit lorsque vous voulez convertir un type en un autre. 
 let  myNumber  =   1 ; 
 let  finalStr  =  myNumber .  toString  () 
 La contrainte de type implicite se produit généralement lorsque vous appliquez des opérateurs à des valeurs de types différents. La plupart du temps, la coercition implicite est déclenchée par erreur.
 null   +   {} 
 Vous êtes-vous déjà demandé pourquoi il existe deux opérations différentes pour les comparaisons en JavaScript? Nous avons le  ==  et le  ===  pour faire des comparaisons, et la plupart des développeurs qui commencent à apprendre JavaScript ont du mal à comprendre les différences entre eux.
 Le  L'opérateur ==  dans certains cas peut déclencher une contrainte de type dans JavaScript. Imaginons que vous ayez l'expression  20 == "20"  et que vous vouliez renvoyer le résultat. JavaScript les convertira dans le même type de données afin que la comparaison puisse être effectuée.
 Le  ===  ne déclenche pas de coercition de type en JavaScript, et la plupart du temps, c'est l'opérateur que vous souhaitez utiliser pour comparer les types. En utilisant cet opérateur, aucun type de coercition n’aura lieu et vous pouvez mieux travailler avec les types en JavaScript.
 Une meilleure solution
  TypeScript  est un sur-ensemble de JavaScript qui ajoute le typage statique à la langue. Cela aide à mieux structurer votre code, à mettre en évidence les comportements inattendus dans votre code et à réduire les risques de bogues inattendus.
 Certaines personnes pourraient penser que TypeScript est un langage totalement différent de JavaScript et l'apprendre demandera du temps, et c'est totalement faux . Lorsque vous exécutez du code TypeScript, ce qui se passe, c'est que vous exécutez JavaScript et toutes les fonctionnalités dont il dispose, TypeScript garantit simplement que les types que vous utilisez sont affectés de manière cohérente.
 Imaginez que vous vouliez créer une variable appelée nom et que vous voulez vous assurer que cette variable sera une chaîne quoi qu'il arrive. Vous pouvez définir le type de votre variable en faisant simplement cela:
 let  name :   string   =   "Rose" ; 
 Si vous essayez de assignez une nouvelle valeur à la variable de nom qui est différente d'une chaîne, TypeScript vous montrera une erreur.
 TypeScript fonctionne également avec l'inférence de type - vous n'avez pas besoin d'attribuer le type de la variable dans les cas où vous ne le souhaitez pas à. Il utilisera automatiquement la valeur comme type.
 let  name  =   "Rose" ; 

 Lorsque vous avez quelque chose de plus complexe dans votre application, comme une variable qui peut avoir des valeurs différentes, vous créez des types complexes. Vous pouvez utiliser des types d'union pour cela, par exemple:
 type  Modal  =   'open'   |   'close' ; 
 Ce n'est que l'un des les bases de TypeScript, pour montrer comment ce sur-ensemble de JavaScript peut vous aider à créer un code plus robuste et structuré. Vous ne remarquerez la différence et les avantages de TypeScript que lorsque vous l'utiliserez pour la première fois.
 Selon le  Stack Overflow Survey 2020 TypeScript est un langage plus apprécié que JavaScript. De nos jours, TypeScript est très largement utilisé dans de nombreux projets et applications. Cela aide définitivement les développeurs à repérer les erreurs avant d'exécuter le code, ce qui leur permet de créer un code JavaScript plus fortement typé et plus sûr et d'améliorer l'expérience des développeurs.
 Conclusion
 Tout dans JavaScript est soit un type primitif, soit un objet. Savoir travailler avec des types en JavaScript peut être une tâche très délicate. Parfois, cela peut nous conduire à faire des erreurs inattendues et à créer des effets secondaires dans nos applications.
 Nous avons appris les différences entre les langages typés dynamiquement et statiquement et la coercition de type, un processus en JavaScript de conversion d'un type en un autre type qui fonctionne sous le capot. Une bonne solution pour résoudre les erreurs inattendues de types dans JavaScript pourrait être d'utiliser TypeScript, un sur-ensemble de JavaScript qui ajoute un typage statique au langage.
 Continuez à lire
 Consultez ces articles pour en savoir plus sur certains principes fondamentaux de JavaScript.