Why number are immutable in Javascript?

Question

I have read the question and answer here:

javascript numbers- immutable

But it's not enough clear for me why the number (primitive type) are immutable? Just because they create a new reference but not overwrite the value?

If on each assignemt is created a new reference

var x = 5;
x = 1;

Would we have 100 times a new reference in the following loop?

while (x < 101)
{
    x++;
}

Is that efficient? I think I am not seeing correctly.

Answer 1

I'm honestly not quite sure what kind of answer you expect since I don't quite understand what you are confused about. But here we go:

Would we have 100 times a new reference in the following loop?

Variables are just containers for values. At a low level a variable is basically just a label for a memory address or a register. E.g. variable x might point to register R1.

x++ would simply increment the number that is stored in that register by 1. Lets assume our register looked like this:

R1: 5

After incrementing it, which can be a single operation, such as ADD R1 1, we would get

R1: 6

I.e. we simple overwrote the previous value with a new one. And we do that multiple times.

---

Is that efficient? I think I am not seeing correctly.

Incrementing a number by one is as simple of an operation as it can get.

Sure, you could implement mutable numbers on a higher level, but it certainly wouldn't make things more efficient or simpler.

Mutability doesn't make much sense for "single value" values, because mutating such a value basically means replacing it with a different value "in place".

Mutability makes more sense for values that are composed of other values such as lists and dictionaries, where one part changes and the other stays the same.

Additionally, mutability only seems relevant when a language has reference type data types. With that I mean that multiple variables can hold a reference to the very same value of a data type. Objects are reference-type in JavaScript, which allows you to do this:

var a = {foo: 42};
var b = a;
b.foo = 21;
console.log(a);

If data types are not of a reference-type, called value-type, (which primitive values are in JavaScript), then mutability doesn't matter because it would be indistinguishable from immutability. Consider the following hypothetical scenario with a mutable, value-type number:

var a = MutableNumber(42);
var b = a; // creates a copy of MutableNumber(42) because it's a value type
a.add(1);
console.log(a, b); // would log 43, 42

In this scenario it is not possible for two variables to refer to the same mutable number value, a.add(1) is indistinguishable from assigning a new value to a (i.e. a = a + 1).

Answer 2

Primitive values vs. references:

In JavaScript values of type boolean, undefined, null, number, symbol, string are primitive. When you assign them to a variable or pass them as an argument to a function, they always get copied. In contrast objects have two parts to them: Object (it's data) is stored in one chunk of memory and what you assign to a variable is a reference pointing to that object. Object itself is not copied on assignment.

Because numbers are always copied when you assign them to a variable it is impossible to change a number and see that change through some other variable without actually assigning a new value to that variable. In contrast when you change a field on an object, all variables pointing to that object will see that change.

Let's see some examples:

var a = 1;
var b = a; //This creates a new copy of value 1
console.log(a, b); // 1 1
a = 2;
console.log(a, b); // 2 1


var obj_a = {attr: 1};
var obj_b = obj_a; //This makes a new reference to the same object.
console.log(obj_a, obj_b); // {'attr': 1} {'attr': 1}
obj_b.attr = 2;
console.log(obj_a, obj_b); // {'attr': 2} {'attr': 2}

Immutable objects: immutable.js

Libraries like immutable.js provide types that combine properties of primitive types and objects: Types from immutable.js behave as ordinary objects as long as you don't change them. When you change a property of an immutable object, a new object is created and the change is only visible through that new object. The benefit is that you save space in memory and you can quickly check equality of objects by just comparing their references. You get a set of types that behave like integers but you can store more complex structures in them.

Answer 3

i dont understand entirely this,

var a=12;
a=45;

we can infer from ;

1.firstly interpreter allocate a chunk of memory and locate 12 to this area. actually (a) is label of this memory area. 2.than, interpreter allocate a new memory cell and locate 45 to this area. lastly (a) is associated with this new memory cell. The memory cell that contain 12 is destroyed by garbage collector.

Answer 4

Mutation is a change of state while numbers (the primitive type) are pure state objects. Any mutation to such a "object" state is actually a new number. Number itself is like an identifier of a mutation of bits in a cell of computer memory.

Therefore numbers are not mutable. Same as colors or characters.

It is also worth claryfining that a new number will ocupy the same memory cell as the old one for any given variable. Actually replacing the old one. Therefore there is no performance hit of any kind.