Javascript's assignment operation is to copy references?

Question

The basic example:

var b = 10;
var c = b;
b++;
console.log(b,c);

>> 11 10

c looks like a copy of b.

But in another case:

var x = {};
var y = x;
x.abc = 10;
console.log(x.abc, y.abc);

>> 10 10

Why is the y not a copy of x, but a reference which points to the same instance x points to?

Also, I guessed b++ creates another instance, so b points to the new instance but c points to the old one. However...

var u = 10;
setTimeout(function() {
  console.log(u);
}, 10000)
u++;

>> 11

If u++ creates a new instance, then the u inside the anonymous function should point to the old u, shouldn't it?

Answer 1

When primitives are assigned, they are assigned by value; references types (like your object) are assigned by reference (or, as Jon Skeet corrects me, they're assigned a copy of the reference).

In your second example x and y both point to the same object in memory. That's why adding an abc property to one, also adds it to the other

You'd also observe the same behavior passing x or y into a function

function addABC(foo) {
   foo.abc = 10;
}

var x = {};
var y = x;
addABC(x);
console.log(x.abc, y.abc);

Just note that, though x and y point to the same object in memory, they're separate copies of the reference, so this

    var x = { a: 1 };
    var y = x;
    y = {};
    alert(x.a);

and this

    var x = { a: 1 };
    var y = x;
    x = {};
    alert(y.a);

will still alert 1.

Answer 2

the c looks like a copy of b.

Both are references to the same immutable value.

Why the y is not copy of x but a reference which points to the instance x points to?

x was a reference to an object in the first place, so y is a copy of it (a copy of the reference, not a copy of the object).

If u++ creates a new instance,

It doesn't.

the u in anonymous function should points to the old u, shouldn't it?

u++ assigns a reference to 11 to u. The anonymous function is looking at u and not "the value of u at the time the function was created".