这种方法很糟糕，但我把它留在这里作为参考，所以其他人会避免这种方法:

使用@ninjagecko的选项1最适合我:

Array.prototype.equals = function(array) {
    return array instanceof Array && JSON.stringify(this) === JSON.stringify(array) ;
}

a = [1, [2, 3]]
a.equals([[1, 2], 3]) // false
a.equals([1, [2, 3]]) // true

它还将处理null和未定义的情况，因为我们将它添加到数组的原型中，并检查另一个参数是否也是一个数组。

使用map()和reduce():

function arraysEqual (a1, a2) {
    return a1 === a2 || (
        a1 !== null && a2 !== null &&
        a1.length === a2.length &&
        a1
            .map(function (val, idx) { return val === a2[idx]; })
            .reduce(function (prev, cur) { return prev && cur; }, true)
    );
}

如果您正在使用lodash，并且不想修改任何一个数组，则可以使用_.xor()函数。它将两个数组作为集合进行比较，并返回包含它们之差的集合。如果此差值的长度为零，则两个数组本质上相等:

var a = [1, 2, 3];
var b = [3, 2, 1];
var c = new Array(1, 2, 3);
_.xor(a, b).length === 0
true
_.xor(b, c).length === 0
true

jQuery没有比较数组的方法。然而，下划线库(或类似的Lodash库)确实有这样一个方法:isEqual，它也可以处理各种其他情况(如对象字面量)。坚持提供的例子:

var a=[1,2,3];
var b=[3,2,1];
var c=new Array(1,2,3);

alert(_.isEqual(a, b) + "|" + _.isEqual(b, c));

顺便说一句:下划线还有很多jQuery没有的方法，所以它是jQuery的一个很好的补充。

编辑:正如评论中所指出的，现在只有当两个数组的元素顺序相同时，上述方法才有效，即:

_.isEqual([1,2,3], [1,2,3]); // true
_.isEqual([1,2,3], [3,2,1]); // false

幸运的是，Javascript有一个内置的方法来解决这个问题，sort:

_.isEqual([1,2,3].sort(), [3,2,1].sort()); // true

在JavaScript 1.6版中，这很简单:

Array.prototype.equals = function( array ) {
  return this.length == array.length && 
         this.every( function(this_i,i) { return this_i == array[i] } )  
  }

例如，[].equals([])给出true，而[1,2,3]。Equals([1,3,2])产生false。

要做到这一点并不容易。我也需要这个，但我想要一个函数，可以接受任何两个变量，并测试是否相等。这包括非对象值、对象、数组和任何级别的嵌套。

在您的问题中，您提到希望忽略数组中值的顺序。我的解决方案本身并没有这样做，但您可以通过在比较是否相等之前对数组进行排序来实现

我还想将非对象转换为字符串，这样[1,2]===["1"，2]

由于我的项目使用了UnderscoreJs，所以我决定将其作为一个mixin，而不是一个独立的函数。

您可以在http://jsfiddle.net/nemesarial/T44W4/上进行测试

这是我的mxin:

_.mixin({
  /**
  Tests for the equality of two variables
    valA: first variable
    valB: second variable
    stringifyStatics: cast non-objects to string so that "1"===1
  **/
  equal:function(valA,valB,stringifyStatics){
    stringifyStatics=!!stringifyStatics;

    //check for same type
    if(typeof(valA)!==typeof(valB)){
      if((_.isObject(valA) || _.isObject(valB))){
        return false;
      }
    }

    //test non-objects for equality
    if(!_.isObject(valA)){
      if(stringifyStatics){
        var valAs=''+valA;
        var valBs=''+valB;
        ret=(''+valA)===(''+valB);
      }else{
        ret=valA===valB;
      }
      return ret;
    }

    //test for length
    if(_.size(valA)!=_.size(valB)){
      return false;
    }

    //test for arrays first
    var isArr=_.isArray(valA);

    //test whether both are array or both object
    if(isArr!==_.isArray(valB)){
      return false;
    }

    var ret=true;
    if(isArr){
      //do test for arrays
      _.each(valA,function(val,idx,lst){
        if(!ret){return;}
        ret=ret && _.equal(val,valB[idx],stringifyStatics);
      });
    }else{
      //do test for objects
      _.each(valA,function(val,idx,lst){
        if(!ret){return;}

        //test for object member exists
        if(!_.has(valB,idx)){
          ret=false;
          return;
        }

        // test for member equality
        ret=ret && _.equal(val,valB[idx],stringifyStatics);
      });

    }
    return ret;
  }
});

下面是它的用法:

_.equal([1,2,3],[1,2,"3"],true)

要演示嵌套，你可以这样做:

_.equal(
    ['a',{b:'b',c:[{'someId':1},2]},[1,2,3]],
    ['a',{b:'b',c:[{'someId':"1"},2]},["1",'2',3]]
,true);