虽然这个问题的最佳答案是正确和良好的，但提供的代码可能需要一些改进。

下面是我自己比较数组和对象的代码。代码简短而简单：

Array.prototype.equals = function(otherArray) {
  if (!otherArray || this.length != otherArray.length) return false;
  return this.reduce(function(equal, item, index) {
    var otherItem = otherArray[index];
    var itemType = typeof item, otherItemType = typeof otherItem;
    if (itemType !== otherItemType) return false;
    return equal && (itemType === "object" ? item.equals(otherItem) : item === otherItem);
  }, true);
};

if(!Object.prototype.keys) {
  Object.prototype.keys = function() {
    var a = [];
    for (var key in this) {
      if (this.hasOwnProperty(key)) a.push(key);
    }
    return a;
  }
  Object.defineProperty(Object.prototype, "keys", {enumerable: false});
}

Object.prototype.equals = function(otherObject) {
  if (!otherObject) return false;
  var object = this, objectKeys = object.keys();
  if (!objectKeys.equals(otherObject.keys())) return false;
  return objectKeys.reduce(function(equal, key) {
    var value = object[key], otherValue = otherObject[key];
    var valueType = typeof value, otherValueType = typeof otherValue;
    if (valueType !== otherValueType) return false;
    // this will call Array.prototype.equals for arrays and Object.prototype.equals for objects
    return equal && (valueType === "object" ? value.equals(otherValue) : value === otherValue);
  }, true);
}
Object.defineProperty(Object.prototype, "equals", {enumerable: false});

此代码支持嵌套在对象中的数组和嵌套在数组中的对象。

您可以在下面的repl中看到一整套测试并自己测试代码：https://repl.it/Esfz/3

本着原问题的精神：

我想比较两个数组。。。理想地、有效地。没有什么想象，如果它们是相同的，则为真，如果不是，则为假。

我一直在对这里提出的一些更简单的建议进行性能测试，结果如下（从快到慢）：

而Tim Down（67%）

var i = a1.length;
while (i--) {
    if (a1[i] !== a2[i]) return false;
}
return true

每（69%）用户2782196

a1.every((v,i)=> v === a2[i]);

DEI减少（74%）

a1.reduce((a, b) => a && a2.includes(b), true);

Gaizka Allende&vivek的join&toString（78%）

a1.join('') === a2.join('');

a1.toString() === a2.toString();

Victor Palomo创作的半到字符串（90%）

a1 == a2.toString();

radtek的stringify（100%）

JSON.stringify(a1) === JSON.stringify(a2);

注意，下面的示例假设数组是排序的，一维数组。对于一个常见的基准测试，长度比较已被删除（将a1.length==a2.length添加到任何建议中，您将获得约10%的性能提升）。选择最适合您的解决方案，了解每种解决方案的速度和局限性。

根据TomášZato的回答，我同意仅迭代数组是最快的。此外（就像其他人已经说过的那样），函数应该被称为equals/equal，而不是compare。考虑到这一点，我修改了该函数，以处理比较数组的相似性（即它们具有相同的元素，但没有顺序），以供个人使用，并认为我将把它放在这里让大家看到。

Array.prototype.equals = function (array, strict) {
    if (!array)
        return false;

    if (arguments.length == 1)
        strict = true;

    if (this.length != array.length)
        return false;

    for (var i = 0; i < this.length; i++) {
        if (this[i] instanceof Array && array[i] instanceof Array) {
            if (!this[i].equals(array[i], strict))
                return false;
        }
        else if (strict && this[i] != array[i]) {
            return false;
        }
        else if (!strict) {
            return this.sort().equals(array.sort(), true);
        }
    }
    return true;
}

此函数接受默认为true的strict附加参数。这个严格的参数定义数组是否需要在内容和这些内容的顺序上完全相等，或者仅仅包含相同的内容。

例子：

var arr1 = [1, 2, 3, 4];
var arr2 = [2, 1, 4, 3];  // Loosely equal to 1
var arr3 = [2, 2, 3, 4];  // Not equal to 1
var arr4 = [1, 2, 3, 4];  // Strictly equal to 1

arr1.equals(arr2);         // false
arr1.equals(arr2, false);  // true
arr1.equals(arr3);         // false
arr1.equals(arr3, false);  // false
arr1.equals(arr4);         // true
arr1.equals(arr4, false);  // true

我还编写了一个函数的快速jsfiddle，以及这个示例：http://jsfiddle.net/Roundaround/DLkxX/

如果您正在编写测试代码，那么

import chai from 'chai';
const arr1 = [2, 1];
const arr2 = [2, 1];
chai.expect(arr1).to.eql(arr2); // Will pass. `eql` is data compare instead of object compare.

我会这样做：

[2,3,4,5] == [2,3,4,5].toString()

当您使用“==”运算符时，javascript检查值（左侧和右侧）是否是相同的类型，如果是不同的，javascript尝试将两边转换为相同的类型。

Array == String

Array具有toString方法，因此javascript使用它将它们转换为相同的类型，工作方式如下：

[2,3,4,5].toString() == [2,3,4,5].toString()

这是一个棘手的隐式数组相等性检查，但可以在连贯数组到字符串之后立即处理该任务。

var a1 = [1, 2, 3];
var a2 = [1, 2, 3];
var isEqual = a1 <= a2 && a1 >= a2; // true