Javascript's Immutable Array Transformation: Exploring the Power of the New Methods
Tags: javascript, immutable, array, tutorial
Published: 2023-07-29 01:58:07

## Introduction


JavaScript, being one of the most popular programming languages in the world, continuously evolves to meet the demands of modern web development. In recent times, a powerful feature has been introduced that allows developers to change elements, sort, reverse, and splice arrays without altering the original array, thereby giving it immutability. In this article, we will dive into this new feature and explore the four new array methods that enable developers to perform transformations effortlessly.



## 1. The with() Method


The `with()` method is a game-changer when it comes to array manipulations. This method creates a copy of the original array and allows developers to change the value at a specific index without affecting the original array. Let's look at an example:



```
const arr = ["I", "B", "R", "A", "H", "I", "M"];

const modifiedArr = arr.with(2, "b");



console.log(modifiedArr); // ["I", "B", "b", "A", "H", "I", "M"]

console.log(arr); // ["I", "B", "R", "A", "H", "I", "M"];

```


As you can see, the `with()` method produced a new array with the element at index 2 replaced by the provided value "b," while leaving the original array `arr` unchanged.



## 2. The toSorted() Method


Sorting arrays has always been a common task in programming. With the introduction of the `toSorted()` method, developers can now create a new array that is sorted in ascending order without modifying the original array:



```
const arr = ["I", "B", "R", "A", "H", "I", "M"];

const sortedArr = arr.toSorted();



console.log(sortedArr); // ['A', 'B', 'H', 'I', 'I', 'M', 'R']

console.log(arr); // ["I", "B", "R", "A", "H", "I", "M"];
```



In this example, `sortedArr` contains the elements of `arr` arranged in ascending order, while the original array remains unchanged.



The `toSorted()` method also allows developers to provide a custom sorting function for more complex sorting scenarios:



```
const numbers = [1, 10, 21, 2];

const customSortedNumbers = numbers.toSorted((a, b) => a - b);



console.log(customSortedNumbers); // [1, 2, 10, 21]

```


## 3. The toReversed() Method


Reversing the order of elements in an array is another common operation in JavaScript. The `toReversed()` method makes this task a breeze by creating a new array with the elements in reversed order:



```
const arr = ["I", "B", "R", "A", "H", "I", "M"];

const reversedArr = arr.toReversed();



console.log(reversedArr); // ['M', 'I', 'H', 'A', 'R', 'B', 'I']

console.log(arr); // ["I", "B", "R", "A", "H", "I", "M"];
```



As evident from the example, `reversedArr` contains the elements of `arr` in reverse order, while the original array `arr` remains unchanged.



The `toReversed()` method is particularly useful when you need to display data in the reverse order without altering the original dataset.



## 4. The toSpliced() Method


The `toSpliced()` method takes array manipulation a step further by allowing developers to create a new array with some elements removed and/or replaced at a given index, all without changing the original array:



```
const arr = ["I", "B", "R", "A", "H", "I", "M"];

const splicedArr = arr.toSpliced(3, 3, "BAG");



console.log(splicedArr); // ['I', 'B', 'R', 'BAG', 'M']

console.log(arr); // ["I", "B", "R", "A", "H", "I", "M"];
```



In this example, the `toSpliced()` method creates a new array `splicedArr`, where three elements starting from index 3 are removed, and the value "BAG" is inserted at that index.



Additionally, the `toSpliced()` method can be used to insert elements without removing any:



```
const months = ["Jan", "Mar", "Apr", "May"];

const updatedMonths = months.toSpliced(1, 0, "Feb");



console.log(updatedMonths); // ["Jan", "Feb", "Mar", "Apr", "May"]


```

## Conclusion


The introduction of these four new array methods in JavaScript has undoubtedly transformed the way developers handle array manipulations. With the ability to create copies and apply various transformations without altering the original array, JavaScript gains immutability, enhancing code predictability and maintainability. However, it's essential to be mindful of browser compatibility, as some methods may not be supported in certain browsers like Firefox. As these methods gain broader support, developers can confidently embrace them to write cleaner, more efficient, and bug-resistant code for a seamless user experience on the web.