Types de données JavaScript: référence primitive vs

Les types de données de JavaScript sont divisés en types primitifs et types de référence. Les types primitifs incluent la chaîne, le nombre, le booléen, le nul, un non défini et le symbole. Les valeurs sont immuables et copies des copies lorsqu'elles sont attribuées, de sorte qu'elles ne se affectent pas; Les types de référence tels que les objets, les tableaux et les fonctions stockent les adresses de mémoire, et les variables pointant vers le même objet s'afferchent mutuellement. Le typeof et l'instance de OFF peuvent être utilisés pour déterminer les types, mais prêtez attention au problème historique du type de null. Comprendre ces deux types de différences peut aider à écrire un code plus stable et fiable.

Les types de données JavaScript sont divisés en deux catégories: primitive et référence. Comprendre la différence entre eux est essentiel pour écrire un code plus stable et prévisible.

Les types primitifs sont des valeurs immuables

Il existe six types de données primitifs dans JavaScript: string , number , boolean , null , undefined et symbol (nouveau dans ES6). Ces types de valeurs sont immuables, ce qui signifie que vous ne pouvez pas modifier une valeur d'origine elle-même, vous ne pouvez le remplacer que par une nouvelle valeur.

Par exemple:

 Soit name = "Tom";
name.touppercase (); // retourne "Tom", mais le nom lui-même est toujours "Tom"

Cela signifie que le fonctionnement du type d'origine ne modifiera pas la valeur d'origine, mais renverra une nouvelle valeur. Lorsque vous attribuez un type primitif à une autre variable, vous copiez réellement la copie de cette valeur:

 Soit a = 10;
Soit b = a;
b = 20;
console.log (a); // toujours 10

Par conséquent, l'affectation et le fonctionnement du type d'origine sont indépendants et ne se affectent pas mutuellement.

Le type de référence pointe vers l'adresse mémoire

Les types de référence incluent principalement les objets (objet), les tableaux (tableau) et les fonctions (fonction). Ils stockent des "références" à un emplacement en mémoire, pas aux données réelles elle-même.

Voir un exemple:

 Soit obj1 = {nom: "Alice"};
Soit obj2 = obj1;
obj2.name = "bob";
console.log (obj1.name); // Bob de sortie

Ici, obj2 ne copie pas le contenu d' obj1 , mais pointe vers la même adresse mémoire. Par conséquent, la modification des attributs de obj2 affectera également obj1 .

La même situation se produira également lorsque la fonction transmet les arguments:

 function changeName (user) {
  user.name = "changé";
}

Soit Person = {Name: "Original"};
Changename (personne);
console.log (personne.Name); // Sortie modifiée

Parce que ce qui est passé est une référence à l'objet, les modifications de l'objet à l'intérieur de la fonction affecteront l'extérieur.

Conseils pour juger les types

Pour déterminer si une variable est un type primitif ou un type de référence, vous pouvez utiliser typeof et instanceof :

• typeof reconnaît la plupart des types primitifs (sauf que null renverra "object" )
• instanceof est utilisée pour déterminer le constructeur spécifique du type de référence

Par exemple:

 typeof 42; // "nombre"
type de "bonjour"; // "chaîne"
typeof true; // "booléen"
typeof null; // "Objet" (c'est un problème historique avec JS)
typeof {}; // "objet"
typeof function () {}; // "fonction" (type de référence spécial)

Si vous souhaitez juger avec précision null , vous pouvez utiliser === null pour le gérer séparément.

Fondamentalement, c'est tout. Comprendre la différence entre les types primitifs et les types de référence peut vous aider à éviter de nombreux problèmes inattendus, en particulier lorsque vous traitez des structures complexes ou du passage des paramètres de fonction.

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!