如何知道两个数组是否具有相同的值

Question

我有这两个数组:一个填充来自ajax请求的信息,另一个存储用户点击的按钮.我使用这段代码(我填写了样本号):

var array1 = [2, 4];
var array2 = [4, 2]; //It cames from the user button clicks, so it might be disordered.
array1.sort(); //Sorts both Ajax and user info.
array2.sort();
if (array1==array2) {
    doSomething();
}else{
    doAnotherThing();
}

但它始终给出false,即使两个数组相同,但名称不同.(我在Chrome的JS控制台中查看了这个).那么,有什么方法可以知道这两个数组是否包含相同的数据？它为什么要给予false？我如何知道第一个数组中的哪些值不在第二个数组中？

Answer 1

如果您的数组项不是对象 - 例如,如果它们是数字或字符串,您可以比较它们的连接字符串以查看它们是否具有任何顺序的相同成员 -

var array1= [10, 6, 19, 16, 14, 15, 2, 9, 5, 3, 4, 13, 8, 7, 1, 12, 18, 11, 20, 17];
var array2= [12, 18, 20, 11, 19, 14, 6, 7, 8, 16, 9, 3, 1, 13, 5, 4, 15, 10, 2, 17];

if(array1.sort().join(',')=== array2.sort().join(',')){
    alert('same members');
}
else alert('not a match');

Answer 2

如果只想检查两个数组是否具有相同的值(无论出现的次数和每个值的顺序),您可以使用lodash执行此操作:

_.isEmpty(_.xor(array1, array2))

简短,漂亮!

Answer 3

Array.prototype.compare = function(testArr) {
    if (this.length != testArr.length) return false;
    for (var i = 0; i < testArr.length; i++) {
        if (this[i].compare) { //To test values in nested arrays
            if (!this[i].compare(testArr[i])) return false;
        }
        else if (this[i] !== testArr[i]) return false;
    }
    return true;
}

var array1 = [2, 4];
var array2 = [4, 2];
if(array1.sort().compare(array2.sort())) {
    doSomething();
} else {
    doAnotherThing();
}

也许？

Answer 4

为什么你的代码不起作用

JavaScript具有原始数据类型和非原始数据类型.

对于原始数据类型,==并===检查条形图两侧的内容是否具有相同的值.这就是为什么1 === 1是真的.

对于非原始数据类型(如数组),==并===检查引用相等性.也就是说,他们检查是否arr1和arr2是同一个对象.在您的示例中,两个数组具有相同顺序的相同对象,但不等效.

解决方案

两个数组,arr1并arr2具有当且仅当相同的成员:

• 一切都arr2在arr1

和

• 一切都arr1在arr2

所以这将成功(ES2016):

const containsAll = (arr1, arr2) => 
                arr2.every(arr2Item => arr1.includes(arr2Item))

const sameMembers = (arr1, arr2) => 
                        containsAll(arr1, arr2) && containsAll(arr2, arr1);

sameMembers(arr1, arr2); // `true`

使用Underscore的第二个解决方案更接近您尝试执行的操作:

arr1.sort();
arr2.sort();

_.isEqual(arr1, arr2); // `true`

它的工作原理是因为isEqual检查"深度相等",这意味着它不仅仅是参考相等并且比较值.

第三个问题的解决方案

您还询问了如何找出arr1未包含的内容arr2.

这样做(ES2015):

const arr1 = [1, 2, 3, 4];
const arr2 = [3, 2, 1];

arr1.filter(arr1Item => !arr2.includes(arr1Item)); // `[4]`

你也可以使用Underscore的difference方法:

_.difference(arr1, arr2); // `[4]`

UPDATE

请参阅@Red的评论 - 我的解决方案适用于sameMembers您,但您可能想到的sameMembersInOrder也是已知的deepEquals.

更新2

如果您不关心数组成员的顺序,ES2015 + Set可能是比数据结构更好的数据结构Array.请参阅MDN有关如何实施isSuperset和difference使用危险的猴子修补的说明.

Answer 5

function arraysEqual(_arr1, _arr2) {

    if (!Array.isArray(_arr1) || ! Array.isArray(_arr2) || _arr1.length !== _arr2.length)
      return false;

    var arr1 = _arr1.concat().sort();
    var arr2 = _arr2.concat().sort();

    for (var i = 0; i < arr1.length; i++) {

        if (arr1[i] !== arr2[i])
            return false;

    }

    return true;

}

请注意,与先前的答案不同,这不会修改原始数组.

Answer 6

我们的目标基本上是检查 2 个数组是否是相等的集合。set是数学定义的set。最快的排序渐近花费O(nlog(n))时间。因此，如果对数组进行排序，则至少需要O(nlog(n))时间。但是您可以更快地完成此任务，使用字典数据结构渐近地花费O(n)时间（平均情况不是最坏的情况）。在 JS 中，字典只是一个带有键和值的对象。

/** assumes array elements are primitive types
* check whether 2 arrays are equal sets.
* @param  {} a1 is an array
* @param  {} a2 is an array
*/
function areArraysEqualSets(a1, a2) {
  const superSet = {};
  for (const i of a1) {
    const e = i + typeof i;
    superSet[e] = 1;
  }

  for (const i of a2) {
    const e = i + typeof i;
    if (!superSet[e]) {
      return false;
    }
    superSet[e] = 2;
  }

  for (let e in superSet) {
    if (superSet[e] === 1) {
      return false;
    }
  }

  return true;
}

请注意，此函数适用于原始类型的数组，并假定a1和a2是数组。

Answer 7

对于 ES6

var array1 = [2, 4];
var array2 = [4, 2];


let difference = array1.filter(x => !array2.includes(x));

console.log("equals", difference?.length != 0 ? false : true)

Answer 8

那这个呢？ES 2017 我想：

const array1 = [1, 3, 5];
const array2 = [1, 5, 3];

const isEqual = (array1.length === array2.length) && (array1.every(val => array2.includes(val)));
console.log(isEqual);

第一个条件检查两个数组是否具有相同的长度，第二个条件检查第一个数组是否是第二个数组的子集。将这 2 个条件结合起来应该会导致对 2 个数组的所有项目进行比较，而不管元素的顺序如何。

上面的代码只有在两个数组都有非重复项时才有效。

Answer 9

对象相等检查:JSON.stringify(array1.sort()) === JSON.stringify(array2.sort())

上述测试也适用于对象数组,在这种情况下使用http://www.w3schools.com/jsref/jsref_sort.asp中记录的排序函数

对于具有平坦JSON模式的小数组,可能就足够了.