Verwenden von lodash zum Vergleichen von Arrays (Elemente existieren ohne Reihenfolge)

Ich weiß, dass ich es mit Schleifen machen kann, aber ich versuche einen eleganten Weg zu finden, dies zu tun:

Ich habe zwei Arrays:

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

Ich möchte damit lodashbestätigen, dass die beiden oben genannten Arrays identisch sind. Mit "das Gleiche" meine ich, dass es keinen Gegenstand array1gibt, der nicht in enthalten ist array2.

In Bezug auf die Überprüfung der Gleichheit zwischen diesen Elementen:

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

oder

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

Beide funktionieren, da die Buchstaben immer in Ordnung sind.

Wenn Sie das äußere Array sortieren, können Sie es verwenden, _.isEqual()da das innere Array bereits sortiert ist.

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

Beachten Sie, dass .sort()die Arrays mutiert werden. Wenn dies ein Problem für Sie ist, erstellen Sie zuerst eine Kopie mit (zum Beispiel) .slice()oder dem Spread-Operator ( ...).

Oder tun Sie, was Daniel Budick in einem Kommentar unten empfiehlt:

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

Lodashs sortBy()mutieren das Array nicht.

Sie können lodashs verwenden xorfür diese

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

Wenn Sie Array [1, 1] als anders als Array [1] betrachten, können Sie die Leistung ein wenig verbessern:

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

Mit "dasselbe" meine ich, dass es in Array1 kein Element gibt, das nicht in Array2 enthalten ist.

Sie könnten () und Differenz () für diesen Einsatz Flatten, die gut funktioniert , wenn Sie es egal, ob es Elemente in array2die nicht sind in array1. Es hört sich so an, als würden Sie fragen, ob Array1 eine Teilmenge von Array2 ist .

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

Hier gibt es bereits Antworten, aber hier ist meine reine JS-Implementierung. Ich bin mir nicht sicher, ob es optimal ist, aber es ist sicher transparent, lesbar und einfach.

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

Das Grundprinzip in contains()ist, dass, wenn aalle Elemente von enthalten sind b, das Einfügen in dieselbe Menge die Größe nicht ändern würde.

Zum Beispiel, wenn const a = [1,2,3,4]und const b = [1,2]dann new Set([...a, ...b]) === {1,2,3,4}. Wie Sie sehen können, enthält die resultierende Menge dieselben Elemente wie a.

Um es übersichtlicher zu gestalten, können wir es von dort aus auf Folgendes reduzieren:

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

PURE JS (funktioniert auch, wenn Arrays und Subarrays mehr als 2 Elemente mit beliebiger Reihenfolge haben). Wenn Zeichenfolgen die ,Verwendung als join('-')Parameterzeichen enthalten (kann utf sein), das in Zeichenfolgen nicht verwendet wird

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

Wir können die _.differenceFunktion verwenden, um festzustellen, ob es einen Unterschied gibt oder nicht.

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

Ich hoffe, dies wird dir helfen.

Bearbeiten: Ich habe den mehrdimensionalen Aspekt dieser Frage übersehen, daher lasse ich dies hier, falls es den Leuten hilft, eindimensionale Arrays zu vergleichen

Es ist eine alte Frage, aber ich hatte Probleme mit der Geschwindigkeit der Verwendung von .sort()oder sortBy(), also habe ich diese stattdessen verwendet:

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

Es sollte schnell scheitern und funktioniert für meine Zwecke einwandfrei.