CODEWITHSUNDEEP
javascript
Seeliang
Seeliang

Reputation: 2949

How does a.x = a = {n: b} work in JavaScript?

This is related to Javascript a=b=c statements.

I do understand that

foo = foo.x = {n: b}; // console.log(foo) => {n: b}

but 

foo.x = foo = {n: b}; // console.log(foo) => {n: b}

It should equal to :

foo = {n: b};
foo.x = foo; // console.log(foo) => {n: b, x:object}

Am I missing something here?

Upvotes: 15

Views: 2118

Answers (4)

gurvinder372
gurvinder372

Reputation: 68413

This is because when you write

var foo = {};
foo.x = foo = {n: b} //a=b=c

while the line is being executed, foo is pointing to {} but when this statement is broken down to

foo.x = (foo = {n: b}) /a=(b=c)

foo's reference has changed from {} to {n:b} but foo in foo.x (a) is still pointing to old reference of foo since left hand expression was evaluated before assignment had begun.

As per the spec

  1. If LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral,

    a. then Let lref be the result of evaluating LeftHandSideExpression.

Which means before the assignment foo.x was still having reference to old foo.

So, if you tweak your example a little bit by doing

var foo = {z:2};
foo.x = foo.n = {n: 1};

In this example, you didn't change the reference to foo, only assigned new property, so the output now is

Object {z: 2, n: Object, x: Object}

Now, it has retained the reference to old foo since a new reference was not assigned hence all properties z, n and x are being retained.

Upvotes: 11

Jonathan Lonowski
Jonathan Lonowski

Reputation: 123513

With:

foo.x = foo = {n: b};

The leading foo.x is partially evaluated first, enough to determine the exact target for the assignment, before proceeding to actually assign it.

It behaves more along the lines of:

var oldFoo = foo;
foo = {n: b};
oldFoo.x = foo;

This is mentioned in the standard. The left side of the = is evaluated (1.a) before the value is placed there (1.f):

AssignmentExpression : LeftHandSideExpression = AssignmentExpression

1) If LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral, then
a) Let lref be the result of evaluating LeftHandSideExpression.
...
f) Perform ? PutValue(lref, rval).

Upvotes: 18

Flying Fisher
Flying Fisher

Reputation: 1952

I got it.

var foo = {}; // now foo is a reference point to object {}
foo.x = foo = {n:1}; // first foo is refer to a new object {n:1}, then old foo referred object {} set a prop x

// try this to get what you want
var foo = foo1 = {};
foo.x = foo = {n:1};
console.log(foo, foo1) // here foo1 is what you want

Upvotes: 1

Alexey Ten
Alexey Ten

Reputation: 14374

It equals

let tmp = foo;
foo = {n: b};
tmp.x = foo;

You could see, that old foo (stored in z in this example) was modified:

> z=foo={};
{}
> foo.x = foo = {n: b};
{ n: 10 }
> foo
{ n: 10 }
> z
{ x: { n: 10 } }

Upvotes: 6

Related Questions