Usando lodash para comparar matrizes (existência de itens sem ordem)

Sei que posso fazer isso usando loops, mas estou tentando encontrar uma maneira elegante de fazer isso:

Eu tenho duas matrizes:

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

Eu quero usar lodashpara confirmar se as duas matrizes acima são iguais. Por 'o mesmo' quero dizer que não há nenhum item array1que não esteja contido em array2.

Em termos de verificação da igualdade entre esses itens:

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

ou

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

Ambos funcionam porque as letras estarão sempre em ordem.

Se você classificar a matriz externa, poderá usar, _.isEqual()uma vez que a matriz interna já está classificada.

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

Observe que isso .sort()causará mutação nas matrizes. Se isso for um problema para você, primeiro faça uma cópia usando (por exemplo) .slice()ou o operador spread ( ...).

Ou faça como Daniel Budick recomenda em um comentário abaixo:

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

O de Lodash sortBy()não altera o array.

Você pode usar lodashs xorpara isso

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

Se você considerar array [1, 1] diferente de array [1], você pode melhorar o desempenho um pouco assim:

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

Por 'o mesmo' quero dizer que não há nenhum item na matriz1 que não esteja contido na matriz2.

Você poderia usar flatten () e diferença () para isso, o que funciona bem se você não se importar se há itens array2que não estão em array1. Parece que você está perguntando se array1 é um subconjunto de 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

Já existem respostas aqui, mas aqui está minha implementação JS pura. Não tenho certeza se é o ideal, mas com certeza é transparente, legível e simples.

// 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)

O raciocínio contains()é que, se acontiver todos os elementos de b, colocá-los no mesmo conjunto não alteraria o tamanho.

Por exemplo, se const a = [1,2,3,4]e const b = [1,2], então new Set([...a, ...b]) === {1,2,3,4}. Como você pode ver, o conjunto resultante possui os mesmos elementos que a.

A partir daí, para torná-lo mais conciso, podemos resumir o seguinte:

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

PURE JS (funciona também quando arrays e subarrays têm mais de 2 elementos com ordem arbitrária). Se strings contiver ,use como join('-')caractere de parâmetro (pode ser utf) que não é usado em strings

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);

Podemos usar a _.differencefunção para ver se há alguma diferença ou não.

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

Eu espero que isso te ajude.

Edit: Eu perdi o aspecto multidimensional desta questão, então estou deixando isso aqui no caso de ajudar as pessoas a comparar matrizes unidimensionais

É uma pergunta antiga, mas eu estava tendo problemas com a velocidade de uso de .sort()ou sortBy(), então usei esta:

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

Foi planejado para falhar rápido e, para meus propósitos, funciona bem.