Set() Object in JavaScript
Tags: javascript, web, developers
Published: 2023-04-12 04:35:01

---
title: Set() Object in JavaScript
published: true
date: 2023-04-04 15:01:13 UTC
tags: javascript, web, developers
canonical_url: https://blog.adarshkumar.me/set-object-in-javascript
---

JavaScript provides several built-in objects that programmers can use to implement various functionalities. One such object is the Set() object, which allows developers to store unique values of any type. Using the Set() object, you can add, remove, and search for elements efficiently. This article will guide you on how to use the Set() object and its benefits.

## **What is the Set() Object?**

A Set() object is a collection of unique values of any type, including objects and primitive values like strings, numbers, and booleans. The values in a Set() object are stored in insertion order, and each value can only occur once. The Set() object is part of the ES6 (ECMAScript 2015) standard and is supported by modern browsers.

## **Creating a Set() Object**

To create a Set() object, you use the Set() constructor function, which takes an optional iterable object as an argument. The iterable object can be an array or any other iterable object like a string, map, or set. Here's an example of creating a Set() object:

```
const mySet = new Set([1, 2, 3]);
console.log(mySet); // Set(3) {1, 2, 3}

```

In the example above, we pass an array of numbers to the Set() constructor function, and it returns a Set() object containing the unique values in the array.

## **Adding and Removing Elements in a Set()**

To add an element to a Set() object, you use the add() method, which takes a value as its argument. Here's an example of adding an element to a Set() object:

```
const mySet = new Set();
mySet.add(1);
mySet.add("hello");
mySet.add({name: "John", age: 30});

console.log(mySet); // Set(3) {1, "hello", {name: "John", age: 30}}

```

To remove an element from a Set() object, you use the delete() method, which takes a value as its argument. Here's an example of removing an element from a Set() object:

```
const mySet = new Set([1, 2, 3]);
mySet.delete(2);

console.log(mySet); // Set(2) {1, 3}

```

In the example above, we remove the value 2 from the Set() object using the delete() method.

## **Checking the Existence of an Element in a Set()**

To check if a value exists in a Set() object, you use the has() method, which returns true if the value exists and false if it doesn't. Here's an example of checking if a value exists in a Set() object:

```
const mySet = new Set([1, 2, 3]);
console.log(mySet.has(2)); // true
console.log(mySet.has(4)); // false

```

In the example above, we check if the Set() object contains values 2 and 4 using the has() method.

## **Iterating Over a Set()**

To iterate over the values in a Set() object, you use the forEach() method, which takes a callback function as its argument. The callback function receives three arguments: the value of the current element, the index of the current element, and the Set() object being traversed. Here's an example of iterating over a Set() object:

```
const mySet = new Set([1, 2, 3]);
mySet.forEach((value, index, set) => {
  console.log(`Value: ${value}, Index: ${index}, Set: ${set}`);
});

```

In the example above, we iterate over the Set() object using the forEach() method and log the value, index, and Set() object in each iteration.

## **Using the Set() Object to Remove Duplicate Elements in an Array**

The Set() object can be used to remove duplicate elements from an array. To do this, you first create a Set() object from the array, and then convert it back to an array using the spread operator. Here's an example of using the Set() object to remove duplicate elements from an array:

```
javascriptCopy codeconst myArray = [1, 2, 3, 1, 2, 4];
const uniqueArray = [...new Set(myArray)];

console.log(uniqueArray); // [1, 2, 3, 4]

```

In the example above, we create a Set() object from the array using the spread operator, and then convert it back to an array containing only the unique elements.

## **Converting a Set() Object to an Array**

To convert a Set() object to an array, you use the Array.from() method, which takes the Set() object as its argument. Here's an example of converting a Set() object to an array:

```
javascriptCopy codeconst mySet = new Set([1, 2, 3]);
const myArray = Array.from(mySet);

console.log(myArray); // [1, 2, 3]

```

In the example above, we create a Set() object from an array and then convert it back to an array using the Array.from() method.

## **Set() Object vs. Array**

The Set() object and the array have some similarities, but they also have some differences. One of the main differences is that the Set() object can only contain unique values, while an array can contain duplicate values. The Set() object also provides methods for adding, removing, and checking for the existence of elements, which are not available in arrays.

## **Benefits of Using the Set() Object**

There are several benefits of using the Set() object in JavaScript, including:

- Storing unique values of any type efficiently

- Removing duplicate elements in an array

- Efficiently checking for the existence of an element

- Iterating over values in insertion order

- Easy conversion to an array

## **Limitations of the Set() Object**

The Set() object has some limitations that developers should be aware of, including:

- Cannot access elements by index like arrays

- No direct way to replace an element in the Set() object

- Comparing objects in the Set() object uses reference equality, not value equality

## **When to Use a Set() Object**

The Set() object can be used in many situations, including:

- Removing duplicate elements

- Checking for the existence of an element

- Storing unique values of any type

- Keeping track of the order of insertion

- Implementing efficient algorithms that require unique values

## **Conclusion**

The Set() object is helpful for developers who want to store unique values of any type efficiently. Using the Set() object, developers can add, remove, and check for the existence of elements easily and efficiently. The Set() object also provides an easy way to remove duplicate elements from an array and iterate over values in insertion order. However, developers should also be aware of the limitations of the Set() object, such as the inability to access elements by index-like arrays and the use of reference equality when comparing objects.