Mutability And Immutability In JavaScript Explained In Detail

April 5th 2021 new story

5

You would often hear the most seasoned react developers suggest using the spread operator to copy an array instead of simply assigning it to a new variable. This has to do with specific data types being a reference type in JavaScript, hence being mutable. The concept of mutability and immutability in JavaScript is essential to understand to avoid errors. Let’s dive deeper into the idea of mutability vs. immutability in JavaScript.

Primitive Types vs. Reference Types in JavaScript

The data assigned to a JavaScript variable can be of two types, the primitive type and the reference type. There is a difference in how JavaScript treats these two data types. To know how they are treated differently, let’s first understand the difference between primitive and reference types.

0 reactions

Primitive Types

Primitive types are simple atomic pieces of data in JavaScript. Primitive types are always saved and accessed by the variable's value and not as a reference to another object. There are six primitive types in JavaScript:

0 reactions

• undefined
• boolean
• number
• strings
• symbol

Reference types

Reference types are not simple atomic values but are objects that are made up of multiple properties assigned to them. They are stored as a reference in memory and not as independent values assigned to variables. There are three reference types in JavaScript:

0 reactions

• objects
• arrays
• functions

How Primitive Types and Reference Types are Stored in Memory

How primitive types and reference types are stored in the memory is the basis of how they are different from each other. Let’s look at a few examples and try to understand how they utilize memory differently.

0 reactions

Memory Utilization by Primitive Types

As highlighted earlier, primitive types are stored as a single atomic value assigned to a variable in the memory. Let’s see this example:

0 reactions

let name = 'john';
let name2 = name;

Looking at the above example, I created a variable name and assigned it a value 

john

name2

name2

name2

name

0 reactions

Memory Utilization by Reference Types

Reference values are objects stored in memory and references to objects instead of dedicated places in memory, unlike primitive types. Let’s look at the following example to understand better how the reference types are saved in memory by JavaScript.

0 reactions

let person = {
    name: 'john',
    age: 22,
};

let person2 = person; 

Let’s just declared a variable called 

person

person

person2

person

person2

person

0 reactions

If you look at this image, you will realize that JavaScript here is actually pointing to the same object in the memory. Though it has created a new variable, as a value, that variable just is referring to the same 

person

0 reactions

Understanding Immutability and Mutability of Primitive and Reference Types in JavaScript

Since we are now clear with the primitive and reference types in JavaScript, we can easily understand the concept of mutability and immutability in JavaScript. Mutable can be changed or added to where immutable means something that cannot be changed or added. Primitive values in JavaScript cannot have anything added upon to them, they can only be re-assigned, and hence all primitive values in JavaScript are immutable. Let see this with an example.

0 reactions

let name = 'john';
let name2 = name;

console.log(name);
console.log(name2);

/*
 * john
 * john 
 */

let name2 = 'doe';

console.log(name);
console.log(name2);

/*
 * john
 * doe 
 */

Extending our previous example of primitive types, let’s print the values of both our variables, i.e. 

name

name2

name2

doe

name2

doe

name

name2

name

0 reactions

Let’s try to replicate the same example for reference types as well. Picking up from our previous example, let’s print the values of both 

person

person2

0 reactions

let person = {
    name: 'john',
    age: 22,
};

let person2 = person; 

console.log(person);
console.log(person2);

/*
* {
* name: 'john',
* age: 22,
* }
*
* {
* name: 'john',
* age: 22,
* }
*/

We see two objects printed on the console with the same properties. Now I will change one of the properties of the 

person2

0 reactions

let person2.name = 'doe'; 

console.log(person);
console.log(person2);

/*
* {
* name: 'doe',
* age: 22,
* }
*
* {
* name: 'doe',
* age: 22,
* }
*/

You see that JavaScript has changed 

person

person2

person2

person

0 reactions

The Spread Operator

The spread operator was introduced in ES6 (more information on ES6) and lets you copy your objects safely and create a new instance of the object instead of merely referencing the previous object. Let’s look at the same example and see how we can copy an object and save a new instance of the variable's object.

0 reactions

let person = {
    name: 'john',
    age: 22,
};

let person2 = {...person};
let person2.name = 'doe';

console.log(person);
console.log(person2);

/*
* {
* name: 'john',
* age: 22,
* }
*
* {
* name: 'doe',
* age: 22,
* }
*/

Let’s take the same person object, and instead of assigning it directly to a variable this time, let’s use the spread operator to copy it. The spread operator can be used by prefixing three dots … in front of the object that you want to copy and encapsulate it using the literal object syntax. This way, JavaScript creates a new object and stores it in the variable 

person2

person2

doe

person2

person

person2

person

0 reactions

PS: I have created an extensive JavaScript cheatsheet. It has been in a manner where it becomes easy for you to refer to each property and method for various JavaScript objects. It's absolutely free to download from the above link ☺️

0 reactions

Previously published at https://cloudaffle.com/post/mutability-vs-immutability-javascript

0 reactions

5