Conseil rapide: comment fonctionnent les références JavaScript

Comprendre les références JavaScript: une plongée profonde

Concepts clés:

• JavaScript utilise la valeur pass-par-valeur pour les types primitifs (numéro, chaîne, booléen, undefined, null, symbole) et pas-by-référence pour les types de composés (objets et tableaux). L'opérateur typeof détermine la méthode d'attribution.
• Les références en JavaScript pointent directement vers les données, et non sur d'autres variables. Les valeurs primitives sont immuables; Les valeurs composées sont mutables. La réaffectation d'une valeur composée crée une nouvelle référence.
• Lors du passage des valeurs du composé aux fonctions, changent à l'intérieur La fonction aux données référencées se reflète en dehors de la fonction. Cependant, la réaffectation du paramètre dans la fonction crée une nouvelle référence, laissant l'original inchangé.

En bref: Le comportement de référence de JavaScript diffère considérablement des langues avec des pointeurs explicites. Seules les structures de données composées sont transmises par référence.

Terminologie:

• Scalaire: Une seule unité de données (par exemple, entier, booléen).
• Composé: plusieurs unités de données (par exemple, tableau, objet).
• primitif: une valeur directe, pas une référence.

Remarque: les types scalaires de JavaScript sont des primitives, contrairement à certaines langues (comme Ruby) avec des types de référence scalaire. Les valeurs primitives de JavaScript sont immuables, tandis que les valeurs composées sont mutables.

Cet article a été initialement publié sur Medium.

Résumé des points clés:

1. L'opérateur typeof détermine si une valeur est attribuée par valeur ou par référence.
2. Les primitives sont attribuées par valeur; Les valeurs composées sont attribuées par référence.
3. Les références pointent vers les données, et non sur d'autres variables ou références.
4. Les primitives sont immuables; Les valeurs composées sont mutables.

Exemples:

Pass-by-Value (primitives):

let batman = 7;
let superman = batman;   //assign-by-value
superman++;
console.log(batman);     //7
console.log(superman);   //8

pass-by-référence (valeurs composées):

let flash = [8, 8, 8];
let quicksilver = flash;   //assign-by-reference
quicksilver.push(0);
console.log(flash);        //[8, 8, 8, 0]
console.log(quicksilver);  //[8, 8, 8, 0]

Création de nouvelles références:

La réaffectation d'une valeur composée crée une nouvelle référence:

let firestorm = [3, 6, 3];
let atom = firestorm;   //assign-by-reference
atom = [9, 0, 9];         //value is reassigned (creates new reference)
console.log(firestorm); //[3, 6, 3]
console.log(atom);      //[9, 0, 9]

Références dans les fonctions:

let batman = 7;
let superman = batman;   //assign-by-value
superman++;
console.log(batman);     //7
console.log(superman);   //8

Modification de la valeur du composé d'origine dans une fonction:

let flash = [8, 8, 8];
let quicksilver = flash;   //assign-by-reference
quicksilver.push(0);
console.log(flash);        //[8, 8, 8, 0]
console.log(quicksilver);  //[8, 8, 8, 0]

Création d'une copie superficielle:

let firestorm = [3, 6, 3];
let atom = firestorm;   //assign-by-reference
atom = [9, 0, 9];         //value is reassigned (creates new reference)
console.log(firestorm); //[3, 6, 3]
console.log(atom);      //[9, 0, 9]

attribuer des primitives par référence (utilisant des objets):

let magneto = [8, 4, 8];
(function(x) {        //IIFE
    x.push(99);
    x = [1, 4, 1];      //reassign variable (creates new reference)
    x.push(88);
})(magneto);
console.log(magneto); //[8, 4, 8, 99]

Conclusion:

Comprendre le système de référence de JavaScript est crucial pour écrire un code efficace et sans bug.

(la section FAQS omise par la concision, mais pourrait être reconnu en fonction des besoins.)

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!