我想比较两个数组。。。理想地、有效地。没有什么稀奇古怪的,如果它们是相同的,那就是真的,如果不是,那就是假的。毫不奇怪,比较运算符似乎不起作用。

var a1 = [1,2,3];
var a2 = [1,2,3];
console.log(a1==a2);    // Returns false
console.log(JSON.stringify(a1)==JSON.stringify(a2));    // Returns true

JSON对每个数组进行编码,但是否有一种更快或“更好”的方法来简单地比较数组而不必遍历每个值?


当前回答

不清楚你所说的“相同”是什么意思。例如,下面的数组a和b是否相同(请注意嵌套数组)?

var a = ["foo", ["bar"]], b = ["foo", ["bar"]];

这里有一个优化的数组比较函数,它使用严格的相等性依次比较每个数组的对应元素,并且不递归比较本身为数组的数组元素,这意味着对于上面的示例,arraysIncore(a,b)将返回false。它适用于一般情况,而基于JSON和join()的解决方案不会:

function arraysIdentical(a, b) {
    var i = a.length;
    if (i != b.length) return false;
    while (i--) {
        if (a[i] !== b[i]) return false;
    }
    return true;
};

其他回答

将TomášZa的想法扩展到。Tomas的Array.prototype.compare实际上应该被称为Array.prototy.compare。

它传递:

[1, 2, [3, 4]].compareIdentical ([1, 2, [3, 2]]) === false;
[1, "2,3"].compareIdentical ([1, 2, 3]) === false;
[1, 2, [3, 4]].compareIdentical ([1, 2, [3, 4]]) === true;
[1, 2, 1, 2].compareIdentical ([1, 2, 1, 2]) === true;

但在以下情况下失败:

[[1, 2, [3, 2]],1, 2, [3, 2]].compareIdentical([1, 2, [3, 2],[1, 2, [3, 2]]])

以下是更好的(我认为)版本:

Array.prototype.compare = function (array) {
    // if the other array is a falsy value, return
    if (!array)
        return false;

    // compare lengths - can save a lot of time
    if (this.length != array.length)
        return false;

    this.sort();
    array.sort();
    for (var i = 0; i < this.length; i++) {
        // Check if we have nested arrays
        if (this[i] instanceof Array && array[i] instanceof Array) {
            // recurse into the nested arrays
            if (!this[i].compare(array[i]))
                return false;
        }
        else if (this[i] != array[i]) {
            // Warning - two different object instances will never be equal: {x:20} != {x:20}
            return false;
        }
    }
    return true;
}

http://jsfiddle.net/igos/bcfCY/

这个方法只适用于标量数组,就像这个问题的第二个投票答案一样。

变量arrs=[[[1,2,3],[1,2,3]],//真[[1,2,3,4],[1,2,3],//错误[[1,2,3],[1,2,3,4]],//错误]常量数组相等=(一,二)=>(一个滤波器((i,n)=>两个[n]==i)。长度==一个长度)&&(两个滤波器(i,n)=>一个[n]==i)。长==两个长度)arrs.forEach(arr=>{console.log(arraysEqual(arr[0],arr[1]))})

没有ES6语法:

变量arrs=[[[1,2,3],[1,2,3]],//真[[1,2,3,4],[1,2,3],//错误[[1,2,3],[1,2,3,4]],//错误]函数arraysEqual(一,二){return(one.filter((i,n)=>two[n]==i).length==one.length)&&(two.filter}arrs.forEach(arr=>{console.log(arraysEqual(arr[0],arr[1]))})

尝试了深度平等,并且成功了

var eq = require('deep-equal');
eq({a: 1, b: 2, c: [3, 4]}, {c: [3, 4], a: 1, b: 2});

我想出了另一种方法。使用join(“”)将它们更改为字符串,然后比较两个字符串:

var a1_str = a1.join(''),
    a2_str = a2.join('');

if (a2_str === a1_str) {}

当两个数组具有相同的元素但顺序不同时,代码将无法正确处理这种情况。

看看我的代码,看看你的示例,它比较了两个元素为数字的数组,你可以修改或扩展它以用于其他元素类型(通过使用.jjoin()而不是.toString())。

变量a1=[1,2,3];变量a2=[1,2,3];const arrayAreEqual=a1.sort().toString()==a2.sort(().toString();//如果两个数组具有相同的元素,则为true,否则为falseconsole.log(arrayAreEqual);