# Set operations in JavaScript

Mathematical set operations can be easily applied to JavaScript `Set` objects and arrays. This collection of snippets will introduce you to the most common set operations, such as union, intersection and difference.

## Union

The union of two sets is a set containing all elements that exist in any of the two sets at least once. In order to calculate it, you can use the spread operator (`...`) to convert the `Set` objects to array and create a new `Set` from the resulting array.

```const union = (a, b) => new Set([...a, ...b]);

union(new Set([1, 2, 3]), new Set([4, 3, 2]));
// Set(4) { 1, 2, 3, 4 }```

## Intersection

The intersection of two sets is a set containing all elements that exist in both sets. In order to calculate it, you can use `Array.prototype.filter()` and `Set.prototype.has()` to filter out all elements that don't exist in the second set.

```const intersection = (a, b) => new Set([...a].filter(x => b.has(x)));

intersection(new Set([1, 2, 3]), new Set([4, 3, 2]));
// Set(2) { 2, 3 }```

## Difference

The difference of two sets is a set containing all elements that exist in the first set but not in the second set. In order to calculate it, you can use the same approach as the intersection, but negating the result of `Set.prototype.has()`.

```const difference = (a, b) => new Set([...a].filter(x => !b.has(x)));

difference(new Set([1, 2, 3]), new Set([4, 3, 2]));
// Set(1) { 1 }```

## Symmetric Difference

The symmetric difference of two sets is a set containing all elements that exist in either of the sets but not in both. In order to calculate it, you can calculate the difference of each set with the other and then calculate the union of the two results.

```const symmetricDifference = (a, b) =>
new Set([...[...a].filter(x => !b.has(x)), ...[...b].filter(x => !a.has(x))]);

symmetricDifference(new Set([1, 2, 3]), new Set([4, 3, 2]));
// Set(2) { 1, 4 }```

## Application to arrays

All of these snippets can be easily applied to arrays or other iterables by converting them to `Set` objects and then converting the resulting `Set` objects back to the original type.

On top of that, arrays can leverage potential performance optimizations, depending on the use-case. For example, you can use `Array.prototype.some()` and `Array.prototype.includes()` to check if two arrays intersect, instead of having to calculate their intersection.

```const intersects = (a, b) => a.some(x => b.includes(x));

intersects(['a', 'b'], ['b', 'c']); // true
intersects(['a', 'b'], ['c', 'd']); // false```

## More like this

• JavaScript ·

### Get all unique values in a JavaScript array & remove duplicates

Easily remove duplicates from a JavaScript array using the built-in `Set` object, and learn a few other tricks along the way.

• JavaScript ·

### How can I group and count values in a JavaScript array?

Learn how to group and count the values of a JavaScript array using simple array methods.

• JavaScript ·

### Perform math operations on arrays of numbers in JavaScript

Learn how to work with arrays of numbers in JavaScript, performing common math operations such as sum, average, product and more.

• JavaScript ·

### Faster element removal in unordered JavaScript arrays

Are you performing a lot of array operations? Maybe element removal is a performance bottleneck you can avoid.

Start typing a keyphrase to see matching snippets.