Використання 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))

Лодаш не sortBy()буде мутувати масив.

Ви можете використовувати lodashs xorдля цього

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

Якщо ви вважаєте, що масив [1, 1] відрізняється від масиву [1], ви можете трохи покращити продуктивність так:

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

Під "тим самим" я маю на увазі, що в масиві1 немає жодного елемента, який не міститься в масиві2.

Ви можете використовувати Flatten () і різниці () для цього, який добре працює , якщо ви не хвилює , якщо є елементи , в array2які не є в array1. Здається, ви запитуєте array1 як підмножину масиву2 ?

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 елементів у довільному порядку). Якщо рядки містять ,використання в якості 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))
  )
}

Це було призначено швидко вийти з ладу, і для моїх цілей прекрасно працює.