Skip to content
op-array

Logical

import {
  intersection,
  except,
  union,
  exists,
  existsAll,
  existsAny,
  equals,
  symmetricDifference,
  isSubset,
  isSuperset,
  isDisjoint,
} from 'op-array/logical';

intersection(left, right)

Elements present in both arrays. Order follows left. O(n + m).

intersection([1, 2, 3], [2, 3, 4]); // [2, 3]

except(source, excluded)

Elements of source not in excluded. O(n + m).

except([1, 2, 3, 4], [2, 4]); // [1, 3]

union(left, right)

Combined elements without duplicates, in first-seen order.

union([1, 2, 3], [3, 4, 5]); // [1, 2, 3, 4, 5]

exists(source, item)

exists([1, 2, 3], 2); // true
exists([], 2);        // false

existsAll(source, items)

True when every element of items is in source. False if source is empty.

existsAll([1, 2, 3], [1, 3]); // true
existsAll([1, 2, 3], [1, 9]); // false
existsAll([], [1]);           // false

existsAny(source, items)

True when any element of items is in source. False if either side is empty.

existsAny([1, 2, 3], [4, 2]); // true
existsAny([1, 2, 3], [4, 5]); // false
existsAny([], [1]);           // false
existsAny([1], []);           // false

equals(left, right)

Set-equality. true when both arrays contain exactly the same distinct elements regardless of order or duplicates. Not a deep equality check. Element comparison uses Set (SameValueZero) semantics.

equals([1, 2, 3], [3, 2, 1]); // true
equals([1, 2], [1, 2, 2]);    // true  (set semantics)
equals([1, 2], [1, 3]);       // false
equals([], []);               // true

symmetricDifference(left, right)

Items present in exactly one of left or right (xor). Left-first then right ordering; duplicates collapsed via Set. O(n + m).

symmetricDifference([1, 2, 3], [2, 3, 4]); // [1, 4]
symmetricDifference([1, 1, 2], [2, 3, 3]); // [1, 3]
symmetricDifference([1, 2], [2, 1]);       // []
symmetricDifference([], []);               // []

isSubset(left, right)

true when every distinct element of left is in right. Empty left is vacuously a subset of any array (including []). Element comparison uses Set (SameValueZero) semantics. O(n + m).

isSubset([1, 2], [1, 2, 3]); // true
isSubset([1, 4], [1, 2, 3]); // false
isSubset([1, 2, 3], [3, 2, 1]); // true (set-equal)
isSubset([], [1, 2]);        // true
isSubset([1], []);           // false

isSuperset(left, right)

true when every distinct element of right is in left, i.e. left is a (non-strict) superset of right. Any left is vacuously a superset of [] (including [] itself). Element comparison uses Set (SameValueZero) semantics. O(n + m).

isSuperset([1, 2, 3], [1, 2]);    // true
isSuperset([1, 2, 3], [1, 4]);    // false
isSuperset([1, 2, 3], [3, 2, 1]); // true (set-equal)
isSuperset([1, 2], []);           // true
isSuperset([], [1]);              // false

isDisjoint(left, right)

true when left and right share no elements. Either side empty is vacuously disjoint. Element comparison uses Set (SameValueZero) semantics. O(n + m).

isDisjoint([1, 2], [3, 4]); // true
isDisjoint([1, 2], [2, 3]); // false
isDisjoint([], [1, 2]);     // true
isDisjoint([1, 2], []);     // true
isDisjoint([], []);         // true