Value type vs Reference type in JavaScript
Tags: javascript, webdev, beginners
Published: 2023-03-30 23:20:23



## Introduction
JavaScript is a dynamic, loosely typed language that allows developers to create and manipulate variables with ease. One of the fundamental concepts in JavaScript is the difference between **reference** and **value** types. Understanding the difference between these two types is crucial for writing efficient, bug-free code.

## Primitives vs Objects
In JavaScript, variables can be assigned values that are either primitives or objects(non-primitives). Understanding the difference between primitive and object(non-primitive) values is essential to understanding **value** and **reference** in JavaScript.

Primitive values are simple, immutable values that are not objects. There are six primitive data types in JavaScript: **string**, **number**, **boolean**, **null**, **undefined**, and **symbol**. When a primitive value is assigned to a variable, the variable holds a copy of that value.

On the other hand, **objects** are values that can hold a collection of key-value pairs, methods, and other **objects**, (in JavaScript arrays and functions are also objects). When an **object** is assigned to a variable, the variable holds a reference to the memory location where the object is stored.

![Data types in JavaScript](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hisqjxt9n50lqlv1aqs0.png)

## Value vs Reference examples
1- When a variable is assigned a **value** type, the variable holds a copy of the value.
**Example 1**

```
let a = 5;
let b = a;
a = 10;

console.log(a); // Output: 10
console.log(b); // Output: 5
```
In this example, the variable a is assigned the value 5. The variable b is then assigned the value of a, which means that b also has the value of 5. When a is then assigned the value 10, the value of b remains unchanged because b has a copy of the value of a, not a reference to a.

**Example 2**

```
let str1 = "hello";
let str2 = str1;
str2 = "world";

console.log(str1); // Output: "hello"
console.log(str2); // Output: "world"
```
In this example, str1 holds the string value “hello”, and when we assign str1 to str2, str2 holds a copy of the value of str1. When we then assign str2 the value “world”, str1 is not affected, because str2 holds a separate copy of the value.

2- When a variable is assigned a **reference** type, changes to the object will affect all variables that reference that object. For example:

**Example 1**

```
let arr1 = [1, 2, 3];
let arr2 = arr1;
arr1.push(4);

console.log(arr1); // Output: [1, 2, 3, 4]
console.log(arr2); // Output: [1, 2, 3, 4]
```
In this example, arr1 is assigned a reference to an array containing the values [1, 2, 3]. arr2 is then assigned the same reference as arr1. When arr1 is then modified by pushing the value 4 onto the end of the array, the change is reflected in arr2 because both variables hold a reference to the same object in memory.

**Example 2**

```
let obj1 = { name: "Alice", age: 30 };
let obj2 = obj1;
obj2.age = 31;

console.log(obj1); // Output: { name: "Alice", age: 31 }
console.log(obj2); // Output: { name: "Alice", age: 31 }
```
In this example, obj1 holds a reference to an object with properties name and age. When we assign obj1 to obj2, obj2 holds a copy of the reference to the same object in memory. When we then change the value of the age property of obj2, obj1 is also affected, because both variables hold a reference to the same object in memory.

## When to Use Value Types vs Reference Types
Now that we understand the difference between **value** and **reference** types in JavaScript, let’s explore how to use them effectively in our code.

**Value** types are useful when you want to create a copy of a variable without affecting the original value. This is especially important when you are working with primitive data types such as numbers, strings, and Booleans.

**Reference** types are useful when you want to create a variable that refers to the same object or array in memory. This is especially important when you are working with complex data types such as objects and arrays.

However, it is important to be careful when working with **reference** types. If you make changes to a **reference** type variable, it will affect all other variables that reference the same object or array in memory. This can lead to unexpected behavior and bugs in your code.

## conclusion
knowing the difference between **value** and **reference** types in JavaScript is crucial for writing effective and efficient code. By understanding when to use each type, you can avoid bugs and ensure that your code behaves as intended. By keeping these concepts in mind, you can write cleaner and more maintainable code.