Types spéciaux en JavaScript

2.1 Les variables sont des références

En JavaScript, les variables représentent des références aux objets, et non pas la variable elle-même. Cela signifie que lorsque tu crées une variable en JavaScript, tu crées simplement une référence à un objet en mémoire.

Cette particularité du langage a des conséquences importantes pour le travail avec les variables, surtout lors du passage d'objets aux fonctions ou de leur assignation à d'autres variables.

Lorsque tu crées une variable et lui attribues une valeur, JavaScript alloue un objet en mémoire pour cette valeur et rend la variable une référence à cet objet. Si tu assignes une variable à une autre, la nouvelle variable référencera le même objet que la variable initiale. Cela signifie que les modifications apportées via une variable seront également reflétées sur l'autre si l'objet est mutable.

Exemple :

    
      let a = [1, 2, 3];
      let b = a;

      b.push(4);
      console.log(a);  // Affichera : [1, 2, 3, 4]
    
  

Nous avons ajouté le nombre 4 à la variable b, mais il s'est ajouté également à la liste dans la variable a, car en réalité, les deux variables ne sont que des références à l'objet liste [1, 2, 3]

2.2 Type undefined

En JavaScript, il existe deux types de données spéciaux : null et undefined. Ces types posent souvent des questions aux développeurs en raison de leur similitude, mais ils ont des finalités différentes et sont utilisés dans différentes situations. Examinons-les de plus près.

Type undefined

Le type undefined représente la valeur d'une variable qui a été déclarée mais non initialisée. Cette valeur est également retournée lors de l'accès à une propriété d'objet inexistante ou à un élément de tableau qui n'existe pas.

Exemples

1. Variable non initialisée :

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

2. Propriété d'objet inexistante :

    
      let obj = {};
      console.log(obj.property); // undefined
    
  

3. Élément de tableau inexistant :

    
      let array = [1, 2, 3];
      console.log(array[5]); // undefined
    
  

4. Argument de fonction manquant :

    
      function myFunction(a, b) {
        console.log(b); // undefined, si appelé comme myFunction(1)
      }
      myFunction(1);
    
  

Propriétés de undefined :

• undefined est un type de données et une valeur
• typeof undefined retourne undefined

2.3 Type null

Le type null représente l'absence intentionnelle de valeur. Cette valeur est souvent utilisée pour initialiser des variables qui seront ultérieurement assignées à un objet, ou pour nettoyer la valeur d'une variable.

Exemples

1. Initialisation d'une variable :

    
      let obj = null;
      console.log(obj); // null
    
  

2. Nettoyage de la valeur d'une variable :

    
      let user = { name: "Alice" };
      user = null; // user ne pointe plus sur un objet
    
  

Propriétés de null :

• null est une valeur représentant l'absence intentionnelle de valeur
• typeof null retourne object, ce qui est une erreur reconnue dans le langage JavaScript (en réalité null n'est pas un objet)

2.4 Comparaison entre null et undefined

Bien que null et undefined puissent être utilisés pour désigner l'absence de valeur, ils diffèrent par leur intention et leur contexte d'utilisation.

Exemples d'utilisation

1. Initialisation d'une variable objet ou tableau :

    
      let myObject = null;
      let myArray = null;
    
  

2. Vérification des valeurs :

    
      let value;

      if (value === undefined) {
        console.log("La variable n'est pas initialisée.");
      }

      let result = null;

      if (result === null) {
        console.log("Absence de valeur.");
      }
    
  

3. Nettoyage des valeurs :

    
      let person = { name: "Alice" };
      person = null; // Maintenant person ne pointe plus sur un objet
    
  

4. Vérification de l'existence d'une propriété :

    
      let obj = {};

      if (obj.property === undefined) {
        console.log("La propriété n'existe pas.");
      }
    
  

Comprendre les différences entre null et undefined en JavaScript est important pour gérer correctement les valeurs et éviter les erreurs dans le code.

undefined indique généralement des variables non initialisées ou des propriétés manquantes, tandis que null est utilisé pour indiquer explicitement l'absence de valeur.

Une utilisation appropriée de ces types de données spéciaux rend le code plus compréhensible et prévisible.