Comment fonctionne l'attribution de variable en JavaScript?

Je jouais donc l'autre jour pour voir exactement comment les affectations de masse fonctionnent en JavaScript.

J'ai d'abord essayé cet exemple dans la console:

a = b = {};
a.foo = 'bar';
console.log(b.foo);

Le résultat était une "barre" affichée dans une alerte. C'est assez juste, aet ce ne bsont en réalité que des alias du même objet. Puis j'ai pensé, comment pourrais-je rendre cet exemple plus simple.

a = b = 'foo';
a = 'bar';
console.log(b);

C'est à peu près la même chose, n'est-ce pas? Eh bien cette fois, il foone revient pas barcomme je l'attendrais du comportement du premier exemple.

Pourquoi cela arrive-t-il?

NB Cet exemple pourrait être encore plus simplifié avec le code suivant:

a = {};
b = a;
a.foo = 'bar';
console.log(b.foo);

a = 'foo';
b = a;
a = 'bar';
console.log(b);

(Je soupçonne que JavaScript traite les primitives telles que les chaînes et les entiers différemment des hachages. Les hachages renvoient un pointeur tandis que les primitives "principales" renvoient une copie d'elles-mêmes)

Dans le premier exemple, vous définissez une propriété d'un objet existant. Dans le deuxième exemple, vous attribuez un tout nouvel objet.

a = b = {};

aet bsont maintenant des pointeurs vers le même objet. Alors quand vous faites:

a.foo = 'bar';

Il fixe b.fooaussi depuis aet bpointe vers le même objet.

Toutefois!

Si vous faites cela à la place:

a = 'bar';

vous dites que cela apointe vers un objet différent maintenant. Cela n'a aucun effet sur ce qui a été asignalé précédemment.

En JavaScript, l'affectation d'une variable et l'affectation d'une propriété sont 2 opérations différentes. Il est préférable de considérer les variables comme des pointeurs vers des objets, et lorsque vous affectez directement à une variable, vous ne modifiez aucun objet, vous rejoignez simplement votre variable vers un objet différent.

Mais attribuer une propriété, comme a.foo, modifiera l'objet vers lequel apointe. Ceci, bien sûr, modifie également toutes les autres références qui pointent vers cet objet simplement parce qu'elles pointent toutes vers le même objet.

Votre question a déjà reçu une réponse satisfaisante de Squeegy - cela n'a rien à voir avec les objets vs les primitives, mais avec la réaffectation des variables vs la définition des propriétés dans le même objet référencé.

Il semble y avoir beaucoup de confusion sur les types JavaScript dans les réponses et les commentaires, alors voici une petite introduction au système de type de JavaScript:

En JavaScript, il existe deux types de valeurs fondamentalement différents: les primitives et les objets (et il n'y a rien de tel qu'un «hachage»).

Chaînes, nombres et booléens ainsi que nullet undefinedsont des primitifs, les objets sont tout ce qui peut avoir des propriétés. Même les tableaux et les fonctions sont des objets réguliers et peuvent donc contenir des propriétés arbitraires. Ils diffèrent simplement par la propriété interne [[Class]] (les fonctions ont en plus une propriété appelée [[Call]] et [[Construct]], mais bon, ce sont des détails).

La raison pour laquelle les valeurs primitives peuvent se comporter comme des objets est due à l'autoboxing, mais les primitives elles-mêmes ne peuvent contenir aucune propriété.

Voici un exemple:

var a = 'quux';
a.foo = 'bar';
document.writeln(a.foo);

Cela produira undefined: acontient une valeur primitive, qui est promue en objet lors de l'attribution de la propriété foo. Mais ce nouvel objet est immédiatement rejeté, donc la valeur de fooest perdue.

Pensez-y comme ceci:

var a = 'quux';
new String(a).foo = 'bar'; // we never save this new object anywhere!
document.writeln(new String(a).foo); // a completly new object gets created

Vous avez plus ou moins raison, sauf que ce que vous appelez un "hachage" n'est en fait qu'une syntaxe abrégée pour un objet.

Dans le premier exemple, a et b font tous deux référence au même objet. Dans le deuxième exemple, vous modifiez a pour faire référence à autre chose.

voici ma version de la réponse:

obj = {a:"hello",b:"goodbye"}
x = obj
x.a = "bonjour"

// now obj.a is equal to "bonjour"
// because x has the same reference in memory as obj
// but if I write:
x = {}
x.a = obj.a
x.b = obj.b
x.a = "bonjour"

// now x = {a:"bonjour", b:"goodbye"} and obj = {a:"hello", b:"goodbye"}
// because x points to another place in the memory

Vous définissez a pour qu'il pointe vers un nouvel objet chaîne, tandis que b continue de pointer vers l'ancien objet chaîne.

Dans le premier cas, vous modifiez une propriété de l'objet contenu dans la variable, dans le second cas vous affectez une nouvelle valeur à la variable. Ce sont des choses fondamentalement différentes. Les variables aet bne sont pas en quelque sorte liées par magie par la première affectation, elles contiennent juste le même objet. C'est également le cas dans le deuxième exemple, jusqu'à ce que vous affectiez une nouvelle valeur à la bvariable.

La différence se situe entre les types simples et les objets.

Tout ce qui est un objet (comme un tableau ou une fonction) est passé par référence.

Tout ce qui est de type simple (comme une chaîne ou un nombre) est copié.

J'ai toujours une fonction copyArray à portée de main pour être sûr de ne pas créer un tas d'alias vers le même tableau.