Understanding Javascript immutable variable

Question

I am trying to understand what a Javascript immutable variable means. If I can do:

var x = "astring";
x = "str";
console.log(x); //logs str` , then why it is immutable?

The only answer I can think (from the little bit of C I know) is that var x is a pointer to a memory block with the value "astring", and after the 2nd statement it points to another block with the value "str". Is that the case?

And a bonus question: I was confused by the value types of Javascript. Are all variables objects under the hood? Even number and strings?

Answer 1

Values are immutable; variables are not; they hold a reference to their (primitive) values.

The three primitive types string, number and boolean have corresponding types whose instances are objects: String, Number, Boolean.
They are sometimes called wrapper types.

The following values are primitive:

• Strings: "hello"
• Numbers: 6, 3.14 (all numbers in JavaScript are floating point)
• Booleans: true, false
• null: usually explicitly assigned
• undefined: usually the default (automatically assigned) value

All other values are objects, including wrappers for primitives.

So:

• Objects are mutable by default
• Objects have unique identities and are compared by reference
• Variables hold references to objects
• Primitives are immutable
• Primitives are compared by value, they don’t have individual identities

You might find The Secret Life of JavaScript Primitives a good explanation.

Also, in ES6 there is a new const keyword, that creates a read-only named constant that cannot change value through assignment or be re-declared while the script is running.

Hope this helps!

Answer 2

First, in C "A string is an array of characters with last elem = '\0' ". They are mutable.
If you declare and initialize a string in C like this:

char str[] = "Foo";

What you are basically doing is reserving 4 bytes ( probably 8bit-byte, don't mind this probably if it hurts you ). The word str serves as a pointer to the first elem of this array. So, if you do like this:

str[0] or *(str) = 'G'

then it will mutate the value at that address instead of creating new array. You can verify it by printing out the address of str. In both cases it will be same.

Now in case of JavaScript string is a primitive type. All operations on string are done by value instead of by reference. So, doing this will produce true.

var str1 = "foo";
var str2 = "foo";
str1 === str2; => true

The initialization of string asks for a buffer to fit "foo" and binds the name str1 to it. What makes them immutable is that you can't change that buffer. So, you can't do this:

str1[0] = 'G'

Executing this command will produce no warning or error in non-strict mode but, it will not change the str1. You can verify it by

console.log(str1) => "foo"

But if you do like this:

str1 = "goo"

what you are actually doing is that you are asking for a new buffer to fit "goo" and bind identifier str1 to it. No change in that old buffer containing "foo".

So, what happens to "foo"?

Java Script has an automatic garbage collector. When it sees some chunk of memory that no longer can be referenced by any identifier or ... then it consider that memory free.

Same happens to number,booleans. Now, about wrapper objects! Whenever you try to access a property on string like this:

str1.length;

What JavaScript does it creates a new object using String class and invoke the methods on string. As soon as the function call returns, the object is destroyed. The below code explains it further:

var str = "nature"; 
str.does = "nurtures"; //defining a new property; 
console.log(str.does) => undefined

because the object has been destroyed. Try this!

var str = new String("Nature");
str.does = "nurtures";
console.log(str) =>  ??

this str is really an object...

Conclusion: In C , in a single scope the variable name serves as a pointer. So, int, float, string all are mutable. But in Java Script a primitive type variable name serves as value not as reference

References: C++ primer plus, Java Script The Definitive Guide, C by Stephen Kochan