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