Использование lodash для сравнения массивов (наличие элементов без порядка)

Я знаю, что могу делать это с помощью циклов, но я пытаюсь найти элегантный способ сделать это:

У меня есть два массива:

var array1 = [['a', 'b'], ['b', 'c']];
var array2 = [['b', 'c'], ['a', 'b']];

Я хочу использовать, lodashчтобы подтвердить, что два вышеуказанных массива одинаковы. Под «таким же» я подразумеваю, что в нем нет элемента, array1который не содержится в array2.

Что касается проверки равенства между этими элементами:

['a', 'b'] == ['b', 'a'] 

или

['a', 'b'] == ['a', 'b'] 

Оба работают, так как буквы всегда будут в порядке.

Если вы отсортируете внешний массив, вы можете использовать, _.isEqual()поскольку внутренний массив уже отсортирован.

var array1 = [['a', 'b'], ['b', 'c']];
var array2 = [['b', 'c'], ['a', 'b']];
_.isEqual(array1.sort(), array2.sort()); //true

Обратите внимание, что это .sort()приведет к изменению массивов. Если для вас это проблема, сначала сделайте копию, используя (например) .slice()или оператор распространения ( ...).

Или сделайте так, как рекомендует Дэниел Будик в комментарии ниже:

_.isEqual(_.sortBy(array1), _.sortBy(array2))

Lodash не sortBy()будет изменять массив.

Вы можете использовать xorдля этого lodashs

doArraysContainSameElements = _.xor(arr1, arr2).length === 0

Если вы считаете, что array [1, 1] отличается от array [1], вы можете улучшить производительность примерно так:

doArraysContainSameElements = arr1.length === arr2.length === 0 && _.xor(arr1, arr2).length === 0

Под «тем же» я подразумеваю, что в массиве array1 нет элементов, не содержащихся в array2.

Вы можете использовать Flatten () и разности () для этого, который хорошо работает , если вы не волнует , если есть элементы , в array2которые не являются в array1. Похоже, вы спрашиваете, является ли array1 подмножеством array2 ?

var array1 = [['a', 'b'], ['b', 'c']];
var array2 = [['b', 'c'], ['a', 'b']];

function isSubset(source, target) {
    return !_.difference(_.flatten(source), _.flatten(target)).length;
}

isSubset(array1, array2); // → true
array1.push('d');
isSubset(array1, array2); // → false
isSubset(array2, array1); // → true

Здесь уже есть ответы, но вот моя чистая реализация JS. Я не уверен, что это оптимально, но он уверен, что он прозрачен, удобочитаем и прост.

// Does array a contain elements of array b?
const contains = (a, b) => new Set([...a, ...b]).size === a.length
const isEqualSet = (a, b) => contains(a, b) && contains(b, a)

Обоснование в contains()том, что, если aон содержит все элементы b, то помещение их в один и тот же набор не изменит размер.

Например, если const a = [1,2,3,4]и const b = [1,2], то new Set([...a, ...b]) === {1,2,3,4}. Как видите, получившийся набор содержит те же элементы, что и a.

Оттуда, чтобы сделать его более кратким, мы можем свести его к следующему:

const isEqualSet = (a, b) => {
  const unionSize = new Set([...a, ...b])
  return unionSize === a.length && unionSize === b.length
}

PURE JS (работает также, когда массивы и подмассивы содержат более 2 элементов в произвольном порядке). Если строки содержат символ ,use как join('-')параметр (может быть utf), который не используется в строках

array1.map(x=>x.sort()).sort().join() === array2.map(x=>x.sort()).sort().join()

var array1 = [['a', 'b'], ['b', 'c']];
var array2 = [['b', 'c'], ['b', 'a']];

var r = array1.map(x=>x.sort()).sort().join() === array2.map(x=>x.sort()).sort().join();

console.log(r);

Мы можем использовать _.differenceфункцию, чтобы увидеть, есть ли разница или нет.

function isSame(arrayOne, arrayTwo) {
   var a = _.unique(arrayOne),
       b = _.unique(arrayTwo);

   if (a.length <= b.length) {
      a = arrayTwo;
      b = arrayOne;
      return _.isEmpty(_.difference(a.sort(), b.sort()));
   } else {
      return false;
   }

}

// examples
console.log(isSame([1, 2, 3], [1, 2, 3])); // true
console.log(isSame([1, 2, 4], [1, 2, 3])); // false
console.log(isSame([1, 2], [2, 3, 1])); // false
console.log(isSame([2, 3, 1], [1, 2])); // false

// Test cases pointed by Mariano Desanze, Thanks.
console.log(isSame([1, 2, 3], [1, 2, 2])); // false
console.log(isSame([1, 2, 2], [1, 2, 2])); // true
console.log(isSame([1, 2, 2], [1, 2, 3])); // false

Я надеюсь, что это поможет вам.

Изменить: я пропустил многомерный аспект этого вопроса, поэтому оставляю его здесь на случай, если он поможет людям сравнивать одномерные массивы

Это старый вопрос, но у меня были проблемы со скоростью использования .sort()или sortBy(), поэтому я использовал его вместо:

function arraysContainSameStrings(array1: string[], array2: string[]): boolean {
  return (
    array1.length === array2.length &&
    array1.every((str) => array2.includes(str)) &&
    array2.every((str) => array1.includes(str))
  )
}

Он должен был быстро выйти из строя, и для моих целей работает нормально.