Dizileri karşılaştırmak için lodash kullanma (sırasız öğeler varlığı)

Bunu döngüler kullanarak yapabileceğimi biliyorum, ancak bunu yapmanın zarif bir yolunu bulmaya çalışıyorum:

İki dizim var:

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

lodashYukarıdaki iki dizinin aynı olduğunu doğrulamak için kullanmak istiyorum . 'Aynı' derken hiçbir öğe olduğu anlamına array1içerdiği olmadığını array2.

Bu öğeler arasındaki eşitliği kontrol etmek açısından:

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

veya

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

Harfler her zaman sırayla olacağından ikisi de çalışır.

Dış diziyi sıralarsanız, _.isEqual()iç dizi zaten sıralandığı için kullanabilirsiniz.

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

.sort()Bunun dizileri değiştireceğini unutmayın . Bu sizin için bir sorunsa, önce (örneğin) .slice()veya yayma operatörünü ( ...) kullanarak bir kopya oluşturun .

Veya aşağıdaki yorumda Daniel Budick'in önerdiği şekilde yapın:

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

Lodash sortBy()diziyi değiştirmeyecek.

Sen lodashs kullanabilirsiniz xorbunun için

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

[1, 1] dizisinin [1] dizisinden farklı olduğunu düşünürseniz, performansı şu şekilde biraz artırabilirsiniz:

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

'Aynı' derken, dizi1'de dizi2'de yer almayan hiçbir öğe olmadığını kastediyorum.

Öğeler varsa umursamıyorsun eğer iyi çalışır bunun için () ve farkı (), düzleştirmek kullanabilirsiniz değildir de . Diye soruyorsan gibi geliyor dizi2 bir alt kümesi dizi1 olduğunu ?array2array1

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

Burada zaten cevaplar var, ancak işte benim saf JS uygulamam. En uygun olup olmadığından emin değilim, ama kesinlikle şeffaf, okunabilir ve basit.

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

Buradaki mantık, contains()öğesinin atüm öğelerini içeriyorsa b, onları aynı sete koymanın boyutu değiştirmeyeceğidir.

Örneğin, eğer const a = [1,2,3,4]ve const b = [1,2]sonra new Set([...a, ...b]) === {1,2,3,4}. Gördüğünüz gibi, ortaya çıkan küme ile aynı unsurlara sahip a.

Oradan, daha özlü hale getirmek için, onu şu şekilde özetleyebiliriz:

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

PURE JS (diziler ve alt diziler rastgele sırayla 2'den fazla öğe içerdiğinde de çalışır). Dizeler, dizelerde ,kullanılmayan join('-')parametre karakteri olarak kullanım içeriyorsa (utf olabilir)

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

Bir _.differencefark olup olmadığını görmek için fonksiyonu kullanabiliriz .

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

Umarım bu sana yardımcı olmuştur.

Düzenleme: Bu sorunun çok boyutlu yönünü kaçırdım, bu yüzden insanların tek boyutlu dizileri karşılaştırmasına yardımcı olma ihtimaline karşı bunu burada bırakıyorum

Bu eski bir soru, ancak .sort()veya kullanma hızıyla ilgili sorunlar yaşıyordum sortBy(), bu yüzden bunun yerine şunu kullandım:

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

Hızlı başarısız olması amaçlanmıştı ve benim amaçlarım için iyi çalışıyor.