How to create a Copy of a Set object in JavaScript

avatar

Borislav Hadzhiev

4 min

banner

Photo from Unsplash

Table of Contents #

  1. Create a shallow Copy of a Set in JavaScript
  2. Create a shallow Copy of a Set using a for...of loop
  3. Create a deep copy of a Set in JavaScript
  4. Create a deep copy of a Set using lodash

Create a shallow Copy of a Set in JavaScript #

To create a shallow copy of a Set, pass the original Set as a parameter to the Set() constructor, e.g. const cloned = new Set(oldSet).

The Set() constructor takes an iterable, such as another Set, and adds all of the elements of the iterable to the new Set.

index.js
const set1 = new Set(['bobby', 'hadz', 'com']); const cloned = new Set(set1); console.log(cloned); // ๐Ÿ‘‰๏ธ Set(3) { 'bobby', 'hadz', 'com' }

We used the Set() constructor to create a shallow copy of a Set.

The only parameter the Set() constructor takes is an iterable, such as an array, string, or another Set.

Once the iterable is passed to the constructor, all of the unique values from the iterable are added to the new Set.

The new Set object has a completely different location in memory and adding elements to it wouldn't add elements to the original Set.

index.js
const set1 = new Set(['one', 'two', 'three']); const cloned = new Set(set1); console.log(cloned); // ๐Ÿ‘‰๏ธ {'one', 'two', 'three'} cloned.add('four'); console.log(cloned); // ๐Ÿ‘‰๏ธ {'one', 'two', 'three', 'four'} console.log(set1); // ๐Ÿ‘‰๏ธ {'one', 'two', 'three'}

The code sample demonstrates that adding elements to the copy doesn't add elements to the original Set object.

You can also use a simple for...of loop to create a shallow copy of a Set.

Create a shallow Copy of a Set using a for...of loop #

To create a shallow copy of a Set:

  1. Declare a new variable and initialize it to an empty Set.
  2. Use a for...of loop to iterate over the original Set.
  3. Use the add() method to add each element to the new Set object.
index.js
const set1 = new Set(['bobby', 'hadz', 'com']); const cloned = new Set(); for (const element of set1) { cloned.add(element); } console.log(cloned); // ๐Ÿ‘‰๏ธ Set(3) { 'bobby', 'hadz', 'com' }

We declared a new variable and initialized it to an empty set using the Set() constructor.

The for...of statement is used to loop over iterable objects like arrays, strings, Map, Set and NodeList objects and generators.

On each iteration, we use the Set.add() method to add the current element to the new Set.

The Set.add method inserts a new element with the supplied value into a Set object, if the value is not already in the Set.

The new Set object is stored at a completely different location in memory.

Create a deep copy of a Set in JavaScript #

To create a deep copy of a Set:

  1. Convert the Set to an array.
  2. Use the JSON.stringify() method to stringify the array.
  3. Use the JSON.parse() method to parse the string back into an array.
  4. Pass the result to the Set() constructor.
index.js
const existingSet = new Set([[1, 2, 3]]); const deepCopy = new Set(JSON.parse( JSON.stringify(Array.from(existingSet)) )); console.log(deepCopy); // ๐Ÿ‘‰๏ธ {[1, 2, 3]}

We used the Array.from method to convert the Set to a two-dimensional array.

index.js
const existingSet = new Set([[1, 2, 3]]); // ๐Ÿ‘‡๏ธ [ [1, 2, 3] ] console.log(Array.from(existingSet));

The next step is to use the JSON.stringify method to convert the array to a JSON string.

index.js
const existingSet = new Set([[1, 2, 3]]); // ๐Ÿ‘‡๏ธ '[[1,2,3]]' console.log(JSON.stringify(Array.from(existingSet)));
Converting the array to a JSON string makes all of the nested arrays or objects lose their reference.

Then, we used the JSON.parse method to parse the string back into an array.

index.js
const existingSet = new Set([[1, 2, 3]]); // ๐Ÿ‘‡๏ธ [ [ 1, 2, 3 ] ] console.log(JSON.parse(JSON.stringify(Array.from(existingSet))));

The last step is to pass the two-dimensional array to the Set() constructor.

The trick here is to stringify the array, using the JSON.stringify method, so that all nested objects lose their reference.

If we then try to mutate the array in the new Set, it wouldn't affect the existing Set.

index.js
const existingSet = new Set([[1, 2, 3]]); const deepCopy = new Set(JSON.parse( JSON.stringify(Array.from(existingSet)) )); // ๐Ÿ‘‡๏ธ Mutate the nested array for (const item of deepCopy) { item.pop(); } console.log(deepCopy); // ๐Ÿ‘‰๏ธ {[1, 2]} console.log(existingSet); // ๐Ÿ‘‰๏ธ {[1, 2, 3]}

We used the pop method to mutate the array in the deep copied Set. However, notice that the array in the existing Set wasn't affected.

The nested arrays in the Sets have a different reference and location in memory because we used the JSON.stringify method.

Create a deep copy of a Set using lodash #

You can also use the lodash library to create a deep copy of a Set object.

First, install the lodash module if you haven't already.

shell
# ๐Ÿ‘‡๏ธ initialize a package.json file npm init -y npm install lodash

You can now import and use the lodash.cloneDeep method.

index.js
import _ from 'lodash'; const existingSet = new Set([[1, 2, 3]]); const deepCopy = _.cloneDeep(existingSet); // ๐Ÿ‘‡๏ธ Set(1) { [ 1, 2, 3 ] } console.log(deepCopy);

The cloneDeep method takes a value and recursively clones it, returning the deep cloned value.

If we then try to mutate the array in the new Set, it wouldn't affect the existing Set.

index.js
import _ from 'lodash'; const existingSet = new Set([[1, 2, 3]]); const deepCopy = _.cloneDeep(existingSet); for (const item of deepCopy) { item.pop(); } console.log(deepCopy); // ๐Ÿ‘‰๏ธ {[1, 2]} console.log(existingSet); // ๐Ÿ‘‰๏ธ {[1, 2, 3]}

The nested arrays in the Sets have a different reference and location in memory, so mutating the array in the copy doesn't mutate the array in the original Set.

I wrote a book in which I share everything I know about how to become a better, more efficient programmer.
book cover
You can use the search field on my Home Page to filter through all of my articles.

Copyright ยฉ 2023 Borislav Hadzhiev