ES6 - how to Clone an Array By Nilesh
Tags: javascript
Published: 2023-10-01 10:15:53

---
title: ES6 - how to Clone an Array By Nilesh
published: true
date: 2023-10-01 09:34:00 UTC
tags: javascript
canonical_url: https://www.technilesh.com/2023/10/es6-way-to-clone-array.html
---
# **[How to Clone an Array](https://www.technilesh.com/2023/10/es6-way-to-clone-array.html)**

## **Understanding the Basics of Array Cloning**

So, you've got an array, and you want to make a copy of it. Whether you're a seasoned developer or just starting your coding journey, you've probably heard the term "array cloning." But what exactly is it, and how can you do it? Let's dive into the basics of array cloning and learn how it can be a handy tool in your coding arsenal.

Imagine your array as a tray of cookies. You have a delicious assortment of cookies on your tray, and you want to make an identical tray with the same cookies. Array cloning is essentially the process of duplicating your array, so you have two identical trays of cookies. Why might you need this? Well, there are situations where you want to preserve the original array while working with a modified version of it. Let's see how we can do that.

## **The Old Way: Shallow Copy**

In the early days of array cloning, developers often used what is called a "shallow copy." This method creates a new array and copies the references to the objects from the original array into the new one. In simpler terms, it's like creating a new tray and placing the same cookies on it. However, if one of the cookies gets a bite taken out of it, both trays will reflect this change since they point to the same cookies.

```javascript
const originalArray = [1, 2, 3];
const shallowCopy = originalArray.slice(); // Shallow copy

shallowCopy[0] = 42; // Modifying the copy
console.log(originalArray); // [1, 2, 3] - Original array remains unchanged
console.log(shallowCopy); // [42, 2, 3] - Copy reflects the change
```

Shallow copying is a quick and simple way to clone an array, but it has limitations when dealing with nested arrays or objects.

## **The Modern Solution: Deep Copy**

Now, let's introduce the concept of a "deep copy." A deep copy creates an entirely new array and clones all the elements within it. Going back to our cookie analogy, it's like baking a completely new batch of cookies from scratch – they have no connection to the original batch.

In JavaScript, we can use methods like `JSON.parse()` and `JSON.stringify()` to achieve deep copying:

```javascript
const originalArray = [1, 2, [3, 4]];
const deepCopy = JSON.parse(JSON.stringify(originalArray)); // Deep copy

deepCopy[2][0] = 42; // Modifying the copy
console.log(originalArray); // [1, 2, [3, 4]] - Original array remains unchanged
console.log(deepCopy); // [1, 2, [42, 4]] - Copy reflects the change
```

Deep copying is a more robust method and is suitable for complex data structures. However, keep in mind that it has its limitations, too, such as not being able to clone functions, regular expressions, or non-JSON data.

## **Choosing the Right Method**

Now that we've explored both shallow and deep copying, the question remains: which one should you use? It depends on your specific needs. If you're dealing with a simple array and want a quick copy, a shallow copy might suffice. On the other hand, for complex data structures or when you want to avoid unexpected side effects, a deep copy is the way to go.

In conclusion, array cloning is an essential concept for developers, and understanding the difference between shallow and deep copies is crucial. Like our cookie trays, array cloning methods allow us to duplicate data for various purposes while preserving the integrity of the original array.

So, next time you need to clone an array, remember the choice between shallow and deep copying – and bake your cookies accordingly! Happy coding!