使用lodash比较数组（项目存在而无顺序）

我知道我可以使用循环来做到这一点，但是我试图找到一种优雅的方式来做到这一点：

我有两个数组：

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

我想用来lodash确认以上两个数组是相同的。通过“相同的”我的意思是，有没有在项目array1中没有包含在array2。

在检查这些项目之间的相等性方面：

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

要么

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

两者都可以工作，因为字母始终是有序的。

如果对外部数组进行排序，则可以使用，_.isEqual()因为内部数组已被排序。

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

请注意，这.sort()将使数组变异。如果您遇到问题，请首先使用（例如）.slice()或散布运算符（...）进行复制。

或者，按照Daniel Budick在以下评论中建议的方式进行操作：

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

Lodash sortBy()不会改变数组。

您可以xor为此使用破折号

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

如果您认为数组[1，1]与数组[1]不同，则可以像下面这样改善性能：

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

“相同”是指array1中没有未包含在array2中的项目。

您可以为此使用flatten（）和Difference（），如果您不在乎是否存在不在其中的项目，则array2它们会很好地工作array1。听起来您在问array1是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

此处已经有答案，但这是我的纯JS实现。我不确定它是否是最佳选择，但它肯定是透明的，可读的和简单的。

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

其基本原理contains()是，如果a包含以下内容的所有元素，b，则将它们放入同一集合不会改变大小。

例如，如果const a = [1,2,3,4]和const b = [1,2]，则new Set([...a, ...b]) === {1,2,3,4}。如您所见，结果集具有与元素相同的元素a。

从那里开始，为了使其更简洁，我们可以将其简化为以下内容：

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

PURE JS（当数组和子数组具有两个以上任意顺序的元素时，也可以使用）。如果字符串包含,用作字符串中未使用的join('-')参数字符（可以是utf）

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

我们可以使用_.difference函数来查看是否存在任何差异。

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

我希望这能帮到您。

编辑：我错过了这个问题的多维方面，所以我留在这里，以防它帮助人们比较一维数组

这是一个老问题，但是我在使用.sort()or 的速度方面遇到问题sortBy()，所以我改用了这个：

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

它原本打算很快失败，但出于我的目的，它工作正常。