Utilizzo di lodash per confrontare array (esistenza di oggetti senza ordine)

So di poterlo fare usando i loop, ma sto cercando di trovare un modo elegante per farlo:

Ho due array:

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

Voglio usare lodashper confermare che i due array precedenti sono gli stessi. Con "lo stesso" intendo che non vi è alcun elemento array1che non sia contenuto array2.

In termini di controllo dell'uguaglianza tra questi elementi:

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

o

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

Entrambi funzionano poiché le lettere saranno sempre in ordine.

Se si ordina l'array esterno, è possibile utilizzarlo _.isEqual()poiché l'array interno è già ordinato.

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

Nota che .sort()muterà gli array. Se questo è un problema per te, crea prima una copia utilizzando (ad esempio) .slice()o l'operatore di diffusione ( ...).

Oppure, fai come Daniel Budick consiglia in un commento qui sotto:

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

Lodash sortBy()non muterà l'array.

Puoi usare i lodash xorper questo

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

Se consideri l'array [1, 1] diverso dall'array [1], potresti migliorare le prestazioni in questo modo:

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

Con "lo stesso" intendo che non ci sono elementi in array1 che non siano contenuti in array2.

Potresti usare flatten () e difference () per questo, che funziona bene se non ti interessa se ci sono elementi array2che non sono presenti array1. Sembra che tu stia chiedendo se array1 sia un sottoinsieme di 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

Ci sono già risposte qui, ma ecco la mia implementazione JS pura. Non sono sicuro che sia ottimale, ma sicuramente è trasparente, leggibile e semplice.

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

La logica contains()è che se acontiene tutti gli elementi di b, metterli nello stesso set non cambierebbe le dimensioni.

Ad esempio, if const a = [1,2,3,4]e const b = [1,2], then new Set([...a, ...b]) === {1,2,3,4}. Come puoi vedere, il set risultante ha gli stessi elementi dia .

Da lì, per renderlo più conciso, possiamo ridurlo a quanto segue:

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

PURE JS (funziona anche quando array e sottoarray hanno più di 2 elementi con ordine arbitrario). Se le stringhe contengono, ,usa come join('-')carattere parametr (può essere utf) che non è usato nelle stringhe

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

Possiamo usare la _.differencefunzione per vedere se c'è qualche differenza o no.

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

Spero che questo ti possa aiutare.

Modifica: ho perso l'aspetto multidimensionale di questa domanda, quindi lo lascio qui nel caso in cui aiuti le persone a confrontare array unidimensionali

È una vecchia domanda, ma avevo problemi con la velocità di utilizzo di .sort()o sortBy(), quindi ho usato questo invece:

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

Doveva fallire velocemente e per i miei scopi funziona bene.