Set.prototype.isDisjointFrom()
==============================

Limited availability
--------------------

This feature is not Baseline because it does not work in some of the most widely-used browsers.

* Learn more
* See full compatibility
* Report feedback
**Experimental:** **This is an experimental technology**  
Check the Browser compatibility table carefully before using this in production.

The **`isDisjointFrom()`** method of `Set` instances takes a set and returns a boolean indicating if this set has no elements in common with the given set.

Syntax
------


```js
isDisjointFrom(other)
```

### Parameters

`other`

A `Set` object, or set-like object.

### Return value

`true` if this set has no elements in common with the `other` set, and `false` otherwise.

Description
-----------

Two sets are *disjoint* if they have no elements in common. In mathematical notation:



A
 is disjoint from 
B
⇔
A
∩
B
=
∅

A\text{ is disjoint from }B \Leftrightarrow A\cap B = \empty


And using Venn diagram:

![A Venn diagram with two circles. A and B are disjoint because the circles have no region of overlap.](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/isDisjointFrom/diagram.svg)

`isDisjointFrom()` accepts set-like objects as the `other` parameter. It requires `this` to be an actual `Set` instance, because it directly retrieves the underlying data stored in `this` without invoking any user code. Then, its behavior depends on the sizes of `this` and `other`:

* If there are more elements in `this` than `other.size`, then it iterates over `other` by calling its `keys()` method, and if any element in `other` is present in `this`, it returns `false` (and closes the `keys()` iterator by calling its `return()` method). Otherwise, it returns `true`.
* Otherwise, it iterates over the elements in `this`, and returns `false` if any element `e` in `this` causes `other.has(e)` to return a truthy value. Otherwise, it returns `true`.

Because of this implementation, the efficiency of `isDisjointFrom()` mostly depends on the size of the smaller set between `this` and `other` (assuming sets can be accessed in sublinear time).

Examples
--------

### Using isDisjointFrom()

The set of perfect squares (<20) is disjoint from the set of prime numbers (<20), because a perfect square is by definition decomposable into the product of two integers, while 1 is also not considered a prime number:


```js
const primes = new Set([2, 3, 5, 7, 11, 13, 17, 19]);
const squares = new Set([1, 4, 9, 16]);
console.log(primes.isDisjointFrom(squares)); // true
```


The set of perfect squares (<20) is not disjoint from the set of composite numbers (<20), because all non-1 perfect squares are by definition composite numbers:


```js
const composites = new Set([4, 6, 8, 9, 10, 12, 14, 15, 16, 18]);
const squares = new Set([1, 4, 9, 16]);
console.log(composites.isDisjointFrom(squares)); // false
```

Specifications
--------------

| Specification |
| --- |
| Set methods # sec-set.prototype.isDisjointFrom |

Browser compatibility
---------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

See also
--------

* Polyfill of `Set.prototype.isDisjointFrom` in `core-js`
* `Set.prototype.difference()`
* `Set.prototype.intersection()`
* `Set.prototype.isSubsetOf()`
* `Set.prototype.isSupersetOf()`
* `Set.prototype.symmetricDifference()`
* `Set.prototype.union()`