Comprendre les types de données JavaScript : primitifs et non primitifs

En JavaScript, les types de données sont divisés en deux catégories principales : les types Primitifs et Non primitifs (Référence). Cette distinction est essentielle pour comprendre comment les données sont stockées et accessibles en mémoire. Décomposons chaque type et voyons comment ils fonctionnent.

Types de données primitifs

JavaScript a 7 types de données primitifs :

1. Chaîne
   
   Représente des données textuelles, par exemple « Hello World ».

2. Numéro
   
   Représente à la fois des nombres entiers et des nombres à virgule flottante, par exemple 100, 100,3. Contrairement à d'autres langages, JavaScript ne fait pas de distinction entre les nombres entiers et les nombres flottants : ce ne sont que des nombres.
   

   const score = 100;
   const scoreValue = 100.3;
   console.log(typeof scoreValue); // Output: number
   

3. Booléen
   
   Représente des valeurs logiques : vrai ou faux.
   

   const isLoggedIn = true;
   console.log(typeof isLoggedIn); // Output: boolean
   

4. Symbole
   
   Représente un identifiant unique. Même si deux symboles sont créés avec la même description, ils sont distincts.
   

   const id = Symbol('123');
   const anotherId = Symbol('123');
   console.log(id === anotherId); // Output: false
   

5. Nul
   
   Représente une absence intentionnelle de toute valeur d'objet.
   

   const outsideTemp = null;
   console.log(typeof outsideTemp); // Output: object
   

6. Indéfini
   
   Représente une variable qui a été déclarée mais qui n'a pas encore reçu de valeur.
   

   let weather;
   console.log(typeof weather); // Output: undefined
   

7. BigInt
   
   Représente des entiers avec une précision arbitraire, vous permettant de travailler avec de grands nombres au-delà de la limite entière sûre de Number.
   

   const bigNumber = 23873847283748289483n;
   console.log(typeof bigNumber); // Output: bigint
   

Types de données primitifs : appel par valeur

Les types primitifs sont stockés directement dans l'emplacement mémoire associé à une variable. Lorsque vous attribuez une valeur primitive à une autre variable, une nouvelle copie de la valeur est créée.

let myName = "Aman";
let myOtherName = myName;
myOtherName = "Dawn";
console.log(myName);       // Output: Aman
console.log(myOtherName);  // Output: Dawn

Dans l'exemple ci-dessus, la modification de myAutreNom n'affecte pas monNom, car une nouvelle copie de la valeur a été créée.

Types de données non primitifs

Les types non primitifs, également appelés types de référence, incluent :

1. Tableaux
   
   Collections d'éléments pouvant être de n'importe quel type, stockés sous forme de liste.
   

   const heros = ["ironman", "spiderman", "batman"];
   console.log(typeof heros); // Output: object
   

2. Objets
   
   Collections de paires clé-valeur, où les clés sont des chaînes ou des symboles, et les valeurs peuvent être de n'importe quel type.
   

   let myObj = {
       name: "Ayush",
       age: 21,
   };
   console.log(typeof myObj); // Output: object
   

3. Fonctions
   
   Blocs de code conçus pour effectuer une tâche particulière, qui peuvent être stockés dans des variables.
   

   const myFunction = function() {
       console.log("Hello World");
   };
   console.log(typeof myFunction); // Output: function
   

Types de données non primitifs : appel par référence

Les types non primitifs sont stockés dans le tas et la variable contient une référence (adresse mémoire) aux données réelles. Lorsque vous attribuez un type non primitif à une autre variable, les deux variables pointent vers le même emplacement mémoire.

let userOne = {
    email: "user1@google.com",
    upi: "user@ybl"
};
let userTwo = userOne;
userTwo.email = "aman@google.com";
console.log(userOne.email);  // Output: aman@google.com
console.log(userTwo.email);  // Output: aman@google.com

Dans l'exemple ci-dessus, la modification de userTwo.email modifie également userOne.email car les deux variables font référence au même objet en mémoire.

Points clés à retenir

• Les Types primitifs sont des types de données simples qui stockent directement les valeurs. Ils sont immuables et chaque variable contient sa propre copie des données.
• Les Les types non primitifs sont plus complexes et les variables stockent des références aux données. Les modifications apportées à une variable peuvent affecter d’autres qui font référence aux mêmes données.
• Comprendre ces différences est crucial pour écrire du code efficace et sans bug en JavaScript.

Bon codage et à bientôt pour le prochain !!!

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!