Variables et types de données en JavaScript

2.1 Variables en JavaScript

JavaScript est un langage de programmation flexible et dynamique qui supporte différentes façons de déclarer des variables et de travailler avec des types de données. Dans cette conférence, nous allons examiner trois moyens clés de déclarer des variables (var, let, const) et les principaux types de données primitifs en JavaScript.

Variables en JavaScript

JavaScript est un langage avec typage dynamique. Les variables n'ont pas de type. Tu peux assigner n'importe quelle valeur à n'importe quelle variable à tout moment (mais il y a des nuances).

Pour créer une variable, il faut écrire une construction comme suit:

    
      var name;
    
  

Tu peux assigner immédiatement une valeur à la variable:

    
      var name = value;
    
  

Mais en fait, JavaScript propose pas moins de 3 façons de créer des variables. Voyons cela en détail maintenant.

Opérateur var

Les variables déclarées avec var ont une portée fonctionnelle ou globale. Elles sont soumises au "hoisting", ce qui signifie que leur déclaration est déplacée en haut de leur portée lors de l'exécution du code.

Exemple :

    
      console.log(x); // undefined
      var x = 10;
      console.log(x); // 10
    
  

Dans cet exemple, la variable x est élevée au début de sa portée, donc le premier console.log affiche undefined.

En d'autres termes, le "hoisting" transforme notre code en ceci :

    
      var x;
      console.log(x); // undefined
      x = 10;
      console.log(x); // 10
    
  

Opérateur let

Les développeurs voulaient vraiment changer le comportement de l'opérateur var, mais ils avaient peur de casser des millions de lignes de code existantes. Donc ils ont simplement inventé un autre opérateur qui crée aussi des variables, mais avec un comportement légèrement différent.

Les variables déclarées avec let ont une portée de bloc. Cela signifie qu'elles ne sont accessibles qu'à l'intérieur du bloc de code (généralement entre accolades {}), dans lequel elles sont déclarées. let n'est pas sujet au hoisting comme var.

Exemple :

La variable y n'existe que dans le bloc if.

    
      if (true) {
        let y = 20;
        console.log(y); // 20
      }

      console.log(y); // ReferenceError: y is not defined
    
  

Opérateur const

Les variables déclarées avec const ont également une portée de bloc et ne peuvent pas être réassignées après leur initialisation. Cependant, cela ne rend pas immuables les objets déclarés avec const — leurs propriétés peuvent être modifiées.

Donc la variable ne peut pas être changée, mais l'objet auquel elle fait référence peut l'être. Ils voulaient bien faire, mais ça a raté, comme d'habitude.

Exemple :

Dans cet exemple, la constante x ne peut pas être réassignée, mais l'objet obj peut être modifié.

    
      const x = 30;
      console.log(x); // 30
      x = 40; // TypeError: Assignment to constant variable.

      const obj = { name: 'Alice' };
      obj.name = 'Bob'; // C'est permis
      console.log(obj.name); // Bob
    
  

2.2 Types de données primitifs

JavaScript supporte plusieurs types de données primitifs qui représentent des valeurs simples, qui ne sont pas des objets complexes.

Type Number

Représente toutes les valeurs numériques, y compris les entiers et les nombres à virgule flottante.

Exemples :

    
      let num = 42;
      let pi = 3.14;
    
  

Type String

Représente des données textuelles : chaînes, caractères, emojis. Tout ce qui ressemble à des chaînes — c'est ici.

Exemples :

    
      let greeting = "Hello, world!";
      let facepalm = "🤦";
      let char = 'x';
    
  

Type Boolean

Représente des valeurs logiques true ou false.

    
      let isTrue = true;
      let isFalse = false;
    
  

Type Null

Représente l'absence intentionnelle de valeur.

    
      let empty = null;
    
  

Si un type ne consiste qu'en une seule valeur, qui signifie l'absence de valeur, peut-être est-ce plus une valeur unique qu'un type unique?

Type Undefined

Représente la valeur d'une variable qui a été déclarée mais non initialisée.

    
      let notAssigned;
      console.log(notAssigned); // undefined
    
  

2.3 Comparaison var, let, et const

Comparons une dernière fois nos trois façons de créer des variables :

JavaScript offre plusieurs façons de déclarer des variables, chacune ayant ses propres caractéristiques et son applicabilité en fonction du contexte. var est utilisé moins fréquemment en raison de ses particularités de hoisting et de portée globale. let et const sont préférés dans le JavaScript moderne en raison de leur portée de bloc et du contrôle de réassignation.

Les types de données primitifs permettent de travailler avec les structures de données de base, fournissant des fonctionnalités essentielles pour créer des applications complexes. Et c'est le langage le plus populaire au monde :)