Typescript Set

A Set in TypeScript is a bunch of unique values. It is part of the ECMAScript 2015 (ES6) standard and is implemented as a native object in JavaScript.

Unlike arrays, sets do not allow duplicate elements, making them useful for storing collections of unique items. TypeScript provides strong typing for sets, ensuring type safety and autocompletion in the development environment.

Creating a New Set

You can create a new set by using the Set constructor.

Syntax

let mySet = new Set<Type>();

Example: Creating new set using the numbers

let numberSet = new Set<number>();
numberSet.add(1);
numberSet.add(2);
numberSet.add(3);
console.log(numberSet); 

Output

Set { 1, 2, 3 }

Adding Elements to a Set

Elements can be added to a set using the add method.

Syntax

mySet.add(value);

Example: Adding new fruits to the set.

let stringSet = new Set<string>();
stringSet.add("apple");
stringSet.add("banana");
stringSet.add("orange");

console.log(stringSet); 

Output

Set { 'apple', 'banana', 'orange' }

Checking if an Element Exists in a Set

It has method checks if an element exists in the set.

Syntax

mySet.has(value);

Example: Checking if the element exist or not.

let fruitSet = new Set<string>(["apple", "banana", "orange"]);
console.log(fruitSet.has("apple")); 
console.log(fruitSet.has("grape")); 

Output

true
false

Removing Elements from a Set

Elements can be removed from a set using the delete method.

Syntax

mySet.delete(value);

Example: Removing an element from the set.

let colorSet = new Set<string>(["red", "green", "blue"]);
colorSet.delete("green");

console.log(colorSet); 

Output

Set { 'red', 'blue' }

Iterating Over a Set

You can iterate over a set using for...of or forEach.

Syntax

for (let item of mySet) {
    console.log(item);
}

mySet.forEach((item) => {
    console.log(item);
});

Example: Iterating over set and printing each element.

let numSet = new Set<number>([1, 2, 3, 4, 5]);

for (let num of numSet) {
    console.log(num);
}

numSet.forEach((num) => {
    console.log(num);
});

Output

 1
 2
 3
 4
 5
 1
 2
 3
 4
 5

Converting a Set to an Array

A set can be converted to an array using the spread operator or the Array.from method.

Syntax

let myArray = [...mySet];
let myArray2 = Array.from(mySet);

Example: In this example we are converting a set to array.

let mySet = new Set<number>([1, 2, 3]);
let myArray = [...mySet];

console.log(myArray); 

let myArray2 = Array.from(mySet);
console.log(myArray2); 

Output

[1, 2, 3]
[1, 2, 3]

Performing Set Operations

Sets can be used to perform mathematical operations like union, intersection, and difference.

Syntax

let union = new Set([...set1, ...set2]);
let intersection = new Set([...set1].filter(x => set2.has(x)));
let difference = new Set([...set1].filter(x => !set2.has(x)));

Example: Performing set operation union, intersection and difference.

let set1 = new Set<number>([1, 2, 3, 4]);
let set2 = new Set<number>([3, 4, 5, 6]);

let union = new Set<number>([...set1, ...set2]);
console.log(union); 

let intersection = new Set<number>([...set1].filter(x => set2.has(x)));
console.log(intersection); 

let difference = new Set<number>([...set1].filter(x => !set2.has(x)));
console.log(difference); 

Output

Set { 1, 2, 3, 4, 5, 6 }
Set { 3, 4 }
Set { 1, 2 }

Benefits of Using Set

• Uniqueness: A Set automatically ensures that all elements are unique. This is particularly useful when you need to enforce uniqueness in your data, such as in user identifiers, tags, or any collection where duplicates are not allowed.
• Efficient Lookups: The has method of a Set provides an efficient way to check if an element is present in the collection. This can be much faster than using an array, especially for large datasets.
• Simplified Operations: With methods like add, delete, and clear, a Set offers a simple and readable way to manage collections. Operations that would require complex logic with arrays can often be done more easily with a Set.
• Improved Performance: For certain operations, such as checking for the presence of an element or removing duplicates, Set can offer better performance compared to arrays. This is because Set uses a more efficient data structure internally.