Używanie lodash do porównywania tablic (istnienie elementów bez kolejności)

Wiem, że mogę to zrobić za pomocą pętli, ale staram się znaleźć elegancki sposób na zrobienie tego:

Mam dwie tablice:

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

Chcę użyć, lodashaby potwierdzić, że powyższe dwie tablice są takie same. Przez „ten sam” mam na myśli, że nie ma w nim elementu, array1który nie jest zawarty w array2.

Jeśli chodzi o sprawdzanie równości między tymi elementami:

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

lub

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

Oba działają, ponieważ litery zawsze będą w porządku.

Jeśli sortujesz zewnętrzną tablicę, możesz użyć, _.isEqual()ponieważ wewnętrzna tablica jest już posortowana.

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

Zauważ, że .sort()spowoduje to mutację tablic. Jeśli to dla ciebie problem, najpierw wykonaj kopię za pomocą (na przykład) .slice()lub operatora rozłożenia ( ...).

Lub postępuj zgodnie z zaleceniami Daniela Budicka w komentarzu poniżej:

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

Lodash sortBy()nie zmieni tablicy.

Możesz xordo tego użyć lodash

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

Jeśli uważasz, że tablica [1, 1] różni się od tablicy [1], możesz nieco poprawić wydajność w następujący sposób:

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

Przez „ten sam” rozumiem, że nie ma pozycji w tablicy1, która nie jest zawarta w tablicy2.

Można użyć Spłaszczenie () i różnicę () dla tego, który działa dobrze, jeśli nie obchodzi, czy istnieją pozycje array2, które nie są w array1. Wygląda na to, że pytasz, czy tablica1 jest podzbiorem tablicy2 ?

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

Tutaj są już odpowiedzi, ale oto moja czysta implementacja JS. Nie jestem pewien, czy jest optymalny, ale na pewno jest przejrzysty, czytelny i prosty.

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

Powodem contains()jest to, że jeśli azawiera wszystkie elementy programu b, to umieszczenie ich w tym samym zestawie nie zmieniłoby rozmiaru.

Na przykład, jeśli const a = [1,2,3,4]i const b = [1,2]wtedy new Set([...a, ...b]) === {1,2,3,4}. Jak widać, wynikowy zestaw zawiera te same elementy, co a.

Stamtąd, aby uczynić go bardziej zwięzłym, możemy sprowadzić to do następujących:

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

PURE JS (działa również, gdy tablice i podtablice mają więcej niż 2 elementy o dowolnej kolejności). Jeśli łańcuchy zawierają znak ,użyj jako join('-')parametru (może to być utf), który nie jest używany w łańcuchach

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

Możemy użyć _.differencefunkcji, aby zobaczyć, czy jest jakaś różnica, czy nie.

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

Mam nadzieję, że to Ci pomoże.

Edycja: przegapiłem wielowymiarowy aspekt tego pytania, więc zostawiam to tutaj na wypadek, gdyby pomogło to ludziom porównać jednowymiarowe tablice

To stare pytanie, ale miałem problemy z szybkością używania .sort()lub sortBy(), więc zamiast tego użyłem tego:

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

Miał on szybko zawieść i do moich celów działa dobrze.