我想比较两个阵列......理想情况下，有效率。没有什么花哨的，如果它们相同则只有true，如果没有，则为false。毫不奇怪，比较运算符似乎不起作用。
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编码都有，但是有没有更快或更好的方法来简单地比较数组而不必遍历每个值？
答案 0 :(得分：798)
要比较数组，循环遍历它们并比较每个值：
// Warn if overriding existing method
if(Array.prototype.equals)
console.warn("Overriding existing Array.prototype.equals. Possible causes: New API defines the method, there's a framework conflict or you've got double inclusions in your code.");
// attach the .equals method to Array's prototype to call it on any array
Array.prototype.equals = 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;
for (var i = 0, l=this.length; i < l; i++) {
// Check if we have nested arrays
if (this[i] instanceof Array && array[i] instanceof Array) {
// recurse into the nested arrays
if (!this[i].equals(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;
}
// Hide method from for-in loops
Object.defineProperty(Array.prototype, "equals", {enumerable: false});
[1, 2, [3, 4]].equals([1, 2, [3, 2]]) === false;
[1, "2,3"].equals([1, 2, 3]) === false;
[1, 2, [3, 4]].equals([1, 2, [3, 4]]) === true;
[1, 2, 1, 2].equals([1, 2, 1, 2]) === true;
你可能会说“但比较字符串要快得多 - 没有循环...... ”那么你应该注意到ARE循环。第一个将Array转换为字符串的递归循环，第二个是比较两个字符串的递归循环。因此，此方法比使用字符串更快。
我相信大量的数据应该总是存储在数组中，而不是存储在对象中。但是，如果您使用对象，也可以对它们进行部分比较 以下是：
我已经说过，两个对象实例永远不会相等，即使它们目前包含相同的数据：
({a:1, foo:"bar", numberOfTheBeast: 666}) == ({a:1, foo:"bar", numberOfTheBeast: 666}) //false
这有一个原因，因为可能有例如private variables within objects.
但是，如果您只是使用对象结构来包含数据，那么仍然可以进行比较：
Object.prototype.equals = function(object2) {
//For the first loop, we only check for types
for (propName in this) {
//Check for inherited methods and properties - like .equals itself
//https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty
//Return false if the return value is different
if (this.hasOwnProperty(propName) != object2.hasOwnProperty(propName)) {
return false;
}
//Check instance type
else if (typeof this[propName] != typeof object2[propName]) {
//Different types => not equal
return false;
}
}
//Now a deeper check using other objects property names
for(propName in object2) {
//We must check instances anyway, there may be a property that only exists in object2
//I wonder, if remembering the checked values from the first loop would be faster or not
if (this.hasOwnProperty(propName) != object2.hasOwnProperty(propName)) {
return false;
}
else if (typeof this[propName] != typeof object2[propName]) {
return false;
}
//If the property is inherited, do not check any more (it must be equa if both objects inherit it)
if(!this.hasOwnProperty(propName))
continue;
//Now the detail check and recursion
//This returns the script back to the array comparing
/**REQUIRES Array.equals**/
if (this[propName] instanceof Array && object2[propName] instanceof Array) {
// recurse into the nested arrays
if (!this[propName].equals(object2[propName]))
return false;
}
else if (this[propName] instanceof Object && object2[propName] instanceof Object) {
// recurse into another objects
//console.log("Recursing to compare ", this[propName],"with",object2[propName], " both named \""+propName+"\"");
if (!this[propName].equals(object2[propName]))
return false;
}
//Normal value comparison for strings and numbers
else if(this[propName] != object2[propName]) {
return false;
}
}
//If everything passed, let's say YES
return true;
}
但是，请记住，这个用于比较JSON之类的数据，而不是类实例和其他东西。如果您想比较复杂的物体，请查看this answer and it's superlong function
要使这项工作与Array.equals一致，您必须稍微编辑原始函数：
...
// Check if we have nested arrays
if (this[i] instanceof Array && array[i] instanceof Array) {
// recurse into the nested arrays
if (!this[i].equals(array[i]))
return false;
}
/**REQUIRES OBJECT COMPARE**/
else if (this[i] instanceof Object && array[i] instanceof Object) {
// recurse into another objects
//console.log("Recursing to compare ", this[propName],"with",object2[propName], " both named \""+propName+"\"");
if (!this[i].equals(array[i]))
return false;
}
else if (this[i] != array[i]) {
...
我做了little test tool for both of the functions。
indexOf和contains Samy Bencherif has prepared对于您在嵌套数组中搜索特定对象的情况的有用函数，可在此处获取：https://jsfiddle.net/SamyBencherif/8352y6yw/
答案 1 :(得分：309)
虽然这只适用于标量数组（见下面的注释），但它很简短：
array1.length === array2.length && array1.every(function(value, index) { return value === array2[index]})
Rr，在带有箭头功能的ECMAScript 6 / CoffeeScript / TypeScript中：
array1.length === array2.length && array1.every((value, index) => value === array2[index])
（注意：'标量'在这里表示可以使用===直接比较的值。所以：数字，字符串，引用对象，参考函数。有关比较的更多信息，请参阅the MDN reference运算符）。
<强>更新
根据我从评论中读到的内容，对数组进行排序和比较可能会给出准确的结果：
array1.length === array2.length && array1.sort().every(function(value, index) { return value === array2.sort()[index]});
例如：
array1 = [2,3,1,4];
array2 = [1,2,3,4];
然后上面的代码会给出true
答案 2 :(得分：178)
我喜欢将Underscore库用于数组/对象繁重的编码项目......在Underscore和Lodash中，无论你是在比较它看起来像这样的数组还是对象：
_.isEqual(array1, array2) // returns a boolean
_.isEqual(object1, object2) // returns a boolean
答案 3 :(得分：87)
我认为这是使用JSON stringify执行此操作的最简单方法，在某些情况下它可能是最佳解决方案：
JSON.stringify(a1) === JSON.stringify(a2);
这会将对象a1和a2转换为字符串，以便对其进行比较。在大多数情况下，顺序很重要，因为它可以使用上述答案之一中显示的排序算法对对象进行排序。
请注意，您不再比较对象，而是比较对象的字符串表示形式。它可能不是你想要的。
答案 4 :(得分：60)
目前还不清楚“相同”是什么意思。例如，下面的数组a和b是否相同（注意嵌套数组）？
var a = ["foo", ["bar"]], b = ["foo", ["bar"]];
这是一个优化的数组比较函数，它使用严格相等来依次比较每个数组的相应元素，并且不对数据元素本身是数组进行递归比较，这意味着对于上面的示例，arraysIdentical(a, b)将返回{ {1}}。它适用于一般情况，基于JSON和false的解决方案不会：
join()答案 5 :(得分：36)
本着原始问题的精神：
我想比较两个阵列......理想情况下，有效。的没有 花哨，如果它们相同则为真，如果不相同则为假。
我一直在使用以下results（快到慢）提出的一些更简单的建议进行性能测试：
Tim Downwhile（67％）
var i = a1.length;
while (i--) {
if (a1[i] !== a2[i]) return false;
}
return true
a1.every((v,i)=> v === a2[i]);
reduce（74％）
a1.reduce((a, b) => a && a2.includes(b), true);
join＆amp; toString（78％）由Gaizka Allende＆amp;的Vivek
a1.join('') === a2.join('');
a1.toString() === a2.toString();
half toString（90％）
a1 == a2.toString();
stringify（100％）
JSON.stringify(a1) === JSON.stringify(a2);
注意以下示例假设数组是排序的，一维数组。
.length已针对常见基准测试进行了比较（将a1.length === a2.length添加到任何建议中，您将获得约10％的性能提升）。了解最适合您的解决方案，了解每种解决方案的速度和限制。无关的说明：有趣的是，人们可以通过向下投票按钮获得所有触发快乐的John Waynes对这个问题的完美合法答案。
答案 6 :(得分：28)
建立TomášZato的答案，我同意只是迭代数组是最快的。另外（就像其他人已经说过的那样），该函数应该被称为equals / equal，而不是比较。鉴于此，我修改了函数以处理比较数组的相似性 - 即它们具有相同的元素，但是无序 - 供个人使用，并且我认为我会把它扔在这里供所有人看。
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;
}
此函数采用另一个strict参数，默认为true。这个严格的参数定义了数组在内容和内容的顺序上是否完全相同，或者只是包含相同的内容。
示例：
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/
答案 7 :(得分：10)
虽然这有很多答案，但我认为这有帮助：
const newArray = [ ...new Set( [...arr1, ...arr2] ) ]
在问题中没有说明阵列的结构如何，所以如果您确定在阵列中没有嵌套数组或对象 （它发生在我身上，这就是我回答这个问题的原因）上面的代码会起作用。
我们使用扩展运算符（...）来连接两个数组，然后我们使用Set来消除任何重复。一旦你有了它，你可以比较它们的大小，如果所有三个阵列具有相同的大小，你就可以去。
这个答案也忽略了元素的顺序，正如我所说，确切的情况发生在我身上，所以也许处于相同情况的人可能会在这里结束（就像我一样）。
EDIT1。
回答德米特里·格林科的问题：＆＃34;你为什么在这里使用传播运营商（...） - ......新的集合？它没有工作＆＃34;
考虑以下代码：
const arr1 = [ 'a', 'b' ]
const arr2 = [ 'a', 'b', 'c' ]
const newArray = [ new Set( [...arr1, ...arr2] ) ]
console.log(newArray)
你会得到
[ Set { 'a', 'b', 'c' } ]
为了使用该值，您需要使用一些Set属性（请参阅https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set）。 另一方面，当您使用此代码时：
const arr1 = [ 'a', 'b' ]
const arr2 = [ 'a', 'b', 'c' ]
const newArray = [ ...new Set( [...arr1, ...arr2] ) ]
console.log(newArray)
你会得到
[ 'a', 'b', 'c' ]
不同之处在于，前者会给我一个Set，它会起作用，因为我可以得到那个Set的大小，但是后者给了我需要的阵列，更直接的是什么决议。
答案 8 :(得分：7)
与JSON.encode在同一行是使用join（）。
function checkArrays( arrA, arrB ){
//check if lengths are different
if(arrA.length !== arrB.length) return false;
//slice so we do not effect the original
//sort makes sure they are in order
//join makes it a string so we can do a string compare
var cA = arrA.slice().sort().join(",");
var cB = arrB.slice().sort().join(",");
return cA===cB;
}
var a = [1,2,3,4,5];
var b = [5,4,3,2,1];
var c = [1,2,3,4];
var d = [1,2,3,4,6];
var e = ["1","2","3","4","5"]; //will return true
console.log( checkArrays(a,b) ); //true
console.log( checkArrays(a,c) ); //false
console.log( checkArrays(a,d) ); //false
console.log( checkArrays(a,e) ); //true
唯一的问题是，如果您关心上次比较测试的类型。 如果你关心类型，你将不得不循环。
function checkArrays( arrA, arrB ){
//check if lengths are different
if(arrA.length !== arrB.length) return false;
//slice so we do not effect the orginal
//sort makes sure they are in order
var cA = arrA.slice().sort();
var cB = arrB.slice().sort();
for(var i=0;i<cA.length;i++){
if(cA[i]!==cB[i]) return false;
}
return true;
}
var a = [1,2,3,4,5];
var b = [5,4,3,2,1];
var c = [1,2,3,4];
var d = [1,2,3,4,6];
var e = ["1","2","3","4","5"];
console.log( checkArrays(a,b) ); //true
console.log( checkArrays(a,c) ); //false
console.log( checkArrays(a,d) ); //false
console.log( checkArrays(a,e) ); //false
如果订单应该保持不变，那么它只是一个循环，不需要排序。
function checkArrays( arrA, arrB ){
//check if lengths are different
if(arrA.length !== arrB.length) return false;
for(var i=0;i<arrA.length;i++){
if(arrA[i]!==arrB[i]) return false;
}
return true;
}
var a = [1,2,3,4,5];
var b = [5,4,3,2,1];
var c = [1,2,3,4];
var d = [1,2,3,4,6];
var e = ["1","2","3","4","5"];
console.log( checkArrays(a,a) ); //true
console.log( checkArrays(a,b) ); //false
console.log( checkArrays(a,c) ); //false
console.log( checkArrays(a,d) ); //false
console.log( checkArrays(a,e) ); //false
答案 9 :(得分：6)
如果它们只是两个数字或字符串数组，那么这是一个快速的单行数据
const array1 = [1, 2, 3];
const array2 = [1, 3, 4];
console.log(array1.join(',') === array2.join(',')) //false
const array3 = [1, 2, 3];
const array4 = [1, 2, 3];
console.log(array3.join(',') === array4.join(',')) //true
答案 10 :(得分：5)
这是打字稿版本：
//https://stackoverflow.com/a/16436975/2589276
export function arraysEqual<T>(a: Array<T>, b: Array<T>): boolean {
if (a === b) return true
if (a == null || b == null) return false
if (a.length != b.length) return false
for (var i = 0; i < a.length; ++i) {
if (a[i] !== b[i]) return false
}
return true
}
//https://stackoverflow.com/a/16436975/2589276
export function arraysDeepEqual<T>(a: Array<T>, b: Array<T>): boolean {
return JSON.stringify(a) === JSON.stringify(b)
}
一些摩卡测试用例：
it('arraysEqual', function () {
let a = [1,2]
let b = [1,2]
let c = [2,3]
let d = [2, 3]
let e = ['car','apple','banana']
let f = ['car','apple','banana']
let g = ['car','apple','banan8']
expect(arraysEqual(a, b)).to.equal(true)
expect(arraysEqual(c, d)).to.equal(true)
expect(arraysEqual(a, d)).to.equal(false)
expect(arraysEqual(e, f)).to.equal(true)
expect(arraysEqual(f, g)).to.equal(false)
})
it('arraysDeepEqual', function () {
let a = [1,2]
let b = [1,2]
let c = [2,3]
let d = [2, 3]
let e = ['car','apple','banana']
let f = ['car','apple','banana']
let g = ['car','apple','banan8']
let h = [[1,2],'apple','banan8']
let i = [[1,2],'apple','banan8']
let j = [[1,3],'apple','banan8']
expect(arraysDeepEqual(a, b)).to.equal(true)
expect(arraysDeepEqual(c, d)).to.equal(true)
expect(arraysDeepEqual(a, d)).to.equal(false)
expect(arraysDeepEqual(e, f)).to.equal(true)
expect(arraysDeepEqual(f, g)).to.equal(false)
expect(arraysDeepEqual(h, i)).to.equal(true)
expect(arraysDeepEqual(h, j)).to.equal(false)
})
答案 11 :(得分：5)
如果您使用Mocha之类的测试框架和Chai断言库，则可以使用deep相等来比较数组。
expect(a1).to.deep.equal(a2)
只有当数组在相应的索引处具有相同的元素时，才会返回true。
答案 12 :(得分：5)
有一个Stage 1 proposal（在2020年推出），可以通过在语言中添加Array.prototype.equals来轻松比较数组。无需任何库，monkeypatching或任何其他代码，这就是它的工作方式：
[1, 2, 3].equals([1, 2, 3]) // evaluates to true
[1, 2, undefined].equals([1, 2, 3]) // evaluates to false
[1, [2, [3, 4]]].equals([1, [2, [3, 4]]]) // evaluates to true
到目前为止，这只是一个暂定提议-TC39 will now“花时间研究问题空间，解决方案和跨领域问题”。如果进入第二阶段，它很有可能最终被整合到适当的语言中。
答案 13 :(得分：4)
[更新23-05-2019]
请勿使用下述方法。上面提供了非常好的答案，使用其中一个。
对于单维数组，您只需使用：
arr1.sort().toString() == arr2.sort().toString()
这也将处理索引不匹配的数组。
答案 14 :(得分：4)
我们可以使用every（https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/every）
function compareArrays(array1, array2) {
if (array1.length === array2.length)
return array1.every((a, index) => a === array2[index])
else
return false
}
// test
var a1 = [1,2,3];
var a2 = [1,2,3];
var a3 = ['a', 'r', 'r', 'a', 'y', '1']
var a4 = ['a', 'r', 'r', 'a', 'y', '2']
console.log(compareArrays(a1,a2)) // true
console.log(compareArrays(a1,a3)) // false
console.log(compareArrays(a3,a4)) // false
答案 15 :(得分：4)
您可以简单地从lodash库中使用isEqual。这是非常高效和干净的。
import {isEqual} from "lodash";
const isTwoArraysEqual = isEqual(array1, array2);
答案 16 :(得分：4)
有很多答案展示了如何有效地比较数组。
以下是比较两个字符串或 int 数组的最短方法，以代码字节为单位。
const a = [1, 2, 3]
const b = [1, 2, 3]
console.log("1. ", a.join() === b.join())
console.log("2. ", a.join() === [].join())
console.log("3. ", 1 + a === 1 + b)
console.log("4. ", 1 + [] === 1 + b)这是有效的，因为在使用 + 运算符时，类型会自动转换为允许连接。在这种情况下，1 和 [1, 2, 3] 都被转换为字符串。
在内部，JavaScript 使用 [1, 2, 3].join() 将数组转换为字符串，然后将它们相加得到 11,2,3。对两个数组执行此操作时，只需使用 === 或 == 来比较两个字符串。
使用这种技术，比较不关心要比较的数组中的元素是否属于不同类型。由于数组连接，[1, 2] 将等于 ["1", "2"]。
注意：虽然这对代码打高尔夫球很有用，但它可能不应该用于生产代码
答案 17 :(得分：3)
Herer是我的解决方案：
/**
* Tests two data structures for equality
* @param {object} x
* @param {object} y
* @returns {boolean}
*/
var equal = function(x, y) {
if (typeof x !== typeof y) return false;
if (x instanceof Array && y instanceof Array && x.length !== y.length) return false;
if (typeof x === 'object') {
for (var p in x) if (x.hasOwnProperty(p)) {
if (typeof x[p] === 'function' && typeof y[p] === 'function') continue;
if (x[p] instanceof Array && y[p] instanceof Array && x[p].length !== y[p].length) return false;
if (typeof x[p] !== typeof y[p]) return false;
if (typeof x[p] === 'object' && typeof y[p] === 'object') { if (!equal(x[p], y[p])) return false; } else
if (x[p] !== y[p]) return false;
}
} else return x === y;
return true;
};
适用于任何嵌套数据结构，显然忽略了对象的方法。甚至不想用这个方法扩展Object.prototype，当我试一次，jQuery破坏了;）
对于大多数阵列而言，它仍然比大多数序列化解决方案更快。它可能是对象记录数组最快的比较方法。
答案 18 :(得分：3)
这是一个棘手的隐式数组相等性检查，但可以在将数组连贯到字符串后立即处理工作。
var a1 = [1, 2, 3];
var a2 = [1, 2, 3];
var isEqual = a1 <= a2 && a1 >= a2; // true
答案 19 :(得分：3)
这比较了2个未排序的数组：
# Function returns a rotation matrix transforming x into y
rotation = function(x,y){
u=x/sqrt(sum(x^2))
v=y-sum(u*y)*u
v=v/sqrt(sum(v^2))
cost=sum(x*y)/sqrt(sum(x^2))/sqrt(sum(y^2))
sint=sqrt(1-cost^2);
diag(length(x)) - u %*% t(u) - v %*% t(v) +
cbind(u,v) %*% matrix(c(cost,-sint,sint,cost), 2) %*% t(cbind(u,v))
}
x=c(2,4,5,3,6)
y=c(6,2,0,1,7)
# Same norm
sqrt(sum(x^2))
sqrt(sum(y^2))
Rx2y = rotation(x,y)
x %*% Rx2y
#> [,1] [,2] [,3] [,4] [,5]
#> [1,] 6 2 -8.881784e-16 1 7
答案 20 :(得分：2)
这里有可能进行未排序的数组和自定义比较：
const array1 = [1,3,2,4,5];
const array2 = [1,3,2,4,5];
const isInArray1 = array1.every(item => array2.find(item2 => item===item2))
const isInArray2 = array2.every(item => array1.find(item2 => item===item2))
const isSameArray = array1.length === array2.length && isInArray1 && isInArray2
console.log(isSameArray); //true
答案 21 :(得分：2)
JSON.stringify(collectionNames).includes(JSON.stringify(sourceNames)) ? array.push(collection[i]) : null
这就是我做到的。
答案 22 :(得分：2)
比较2个数组：
var arr1 = [1,2,3];
var arr2 = [1,2,3];
function compare(arr1,arr2)
{
if((arr1 == arr2) && (arr1.length == arr2.length))
return true;
else
return false;
}
调用函数
var isBool = compare(arr1.sort().join(),arr2.sort().join());
答案 23 :(得分：2)
递归，并且可用于 NESTED 数组：
class="col-md-6 p-0"答案 24 :(得分：2)
var a1 = [1,2,3,6];
var a2 = [1,2,3,5];
function check(a, b) {
return (a.length != b.length) ? false :
a.every(function(row, index) {
return a[index] == b[index];
});
}
check(a1, a2);
//////或///////
var a1 = [1,2,3,6];
var a2 = [1,2,3,6];
function check(a, b) {
return (a.length != b.length) ? false :
!(a.some(function(row, index) {
return a[index] != b[index];
}));
}
check(a1, a2)
答案 25 :(得分：2)
另一种代码非常少的方法（使用Array reduce和Array includes）：
arr1.length == arr2.length && arr1.reduce((a, b) => a && arr2.includes(b), true)
如果你想比较顺序的相等性：
arr1.length == arr2.length && arr1.reduce((a, b, i) => a && arr2[i], true)
length检查确保一个数组中的元素集不仅仅是另一个数组中的元素集。
reducer用于遍历一个数组并搜索其他数组中的每个项目。如果未找到一个项目，则reduce函数返回false。
答案 26 :(得分：2)
扩展TomášZato的想法。 Tomas的Array.prototype.compare应该被称为Array.prototype.compareIdentical。
传递：
[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;
}
答案 27 :(得分：2)
在我的情况下，比较数组只包含数字和字符串。此函数将显示数组是否包含相同的元素。
function are_arrs_match(arr1, arr2){
return arr1.sort().toString() === arr2.sort().toString()
}
我们来试试吧！
arr1 = [1, 2, 3, 'nik']
arr2 = ['nik', 3, 1, 2]
arr3 = [1, 2, 5]
console.log (are_arrs_match(arr1, arr2)) //true
console.log (are_arrs_match(arr1, arr3)) //false
答案 28 :(得分：1)
所有其他解决方案看起来都很复杂。这可能不是最有效或处理所有边缘情况的方法，但对我来说效果很好。
Array.prototype.includesArray = function(arr) {
return this.map(i => JSON.stringify(i)).includes(JSON.stringify(arr))
}
用法
[[1,1]].includesArray([1,1])
// true
[[1,1]].includesArray([1,1,2])
// false
答案 29 :(得分：1)
一种简单的方法：
function equals(a, b) {
if ((a && !b) || (!a && b) || (!a && !b) || (a.length !== b.length)) {
return false;
}
var isDifferent = a.some(function (element, index) {
return element !== b[index];
});
return !isDifferent;
}
答案 30 :(得分：1)
可以选择是否比较订单：
function arraysEqual(a1, a2, compareOrder) {
if (a1.length !== a2.length) {
return false;
}
return a1.every(function(value, index) {
if (compareOrder) {
return value === a2[index];
} else {
return a2.indexOf(value) > -1;
}
});
}
答案 31 :(得分：1)
已经有了一些很好的答案。但我想分享另一个已经证明在比较阵列时可靠的想法。我们可以使用JSON.stringify ( )比较两个数组。它将在数组中创建一个字符串，从而比较两个数组中两个获得的字符串的相等性
JSON.stringify([1,{a:1},2]) == JSON.stringify([1,{a:1},2]) //true
JSON.stringify([1,{a:1},2]) == JSON.stringify([1,{a:2},2]) //false
JSON.stringify([1,{a:1},2]) == JSON.stringify([1,{a:2},[3,4],2]) //false
JSON.stringify([1,{a:1},[3,4],2]) == JSON.stringify([1,{a:2},[3,4],2]) //false
JSON.stringify([1,{a:2},[3,4],2]) == JSON.stringify([1,{a:2},[3,4],2]) //true
JSON.stringify([1,{a:2},[3,4],2]) == JSON.stringify([1,{a:2},[3,4,[5]],2]) //false
JSON.stringify([1,{a:2},[3,4,[4]],2]) == JSON.stringify([1,{a:2},[3,4,[5]],2]) //false
JSON.stringify([1,{a:2},[3,4,[5]],2]) == JSON.stringify([1,{a:2},[3,4,[5]],2]) //true
答案 32 :(得分：1)
使用带有 NESTED 数组的 MULTIPLE 参数：
//:Return true if all of the arrays equal.
//:Works with nested arrays.
function AllArrEQ(...arrays){
for(var i = 0; i < (arrays.length-1); i++ ){
var a1 = arrays[i+0];
var a2 = arrays[i+1];
var res =(
//:Are both elements arrays?
Array.isArray(a1)&&Array.isArray(a2)
?
//:Yes: Compare Each Sub-Array:
//:v==a1[i]
a1.every((v,i)=>(AllArrEQ(v,a2[i])))
:
//:No: Simple Comparison:
(a1===a2)
);;
if(!res){return false;}
};;
return( true );
};;
console.log( AllArrEQ(
[1,2,3,[4,5,[6,"ALL_EQUAL" ]]],
[1,2,3,[4,5,[6,"ALL_EQUAL" ]]],
[1,2,3,[4,5,[6,"ALL_EQUAL" ]]],
[1,2,3,[4,5,[6,"ALL_EQUAL" ]]],
));;
答案 33 :(得分：1)
当两个数组具有相同的元素但顺序不同时，您的代码将无法正确处理这种情况。
在您的示例中查看我的代码，该示例比较了两个元素为数字的数组，您可以针对其他元素类型进行修改或扩展（通过使用.join（）而不是.toString（））。
var a1 = [1,2,3];
var a2 = [1,2,3];
const arraysAreEqual = a1.sort().toString()==a2.sort().toString();
// true if both arrays have same elements else false
console.log(arraysAreEqual);
答案 34 :(得分：1)
我知道在处理大型数据集时JSON.stringfy速度很慢，但是如果您使用模板文字呢？
示例：
const a = [1, 2, 3];
const b = [1, 2, 'test'];
const a_string = `${a}`;
const b_string = `${b}`;
const result = (a === b);
console.log(result);
当然要考虑使用ES6。
=）
答案 35 :(得分：1)
对于数字数组，请尝试
a1==''+a2
var a1 = [1,2,3];
var a2 = [1,2,3];
console.log( a1==''+a2 )
答案 36 :(得分：1)
我用过：连接数组并创建一个字符串进行比较。 对于比此示例复杂的方案，您可以使用其他一些分隔符。
var a1 = [1,2,3];
var a2 = [1,2,3];
if (a1.length !== a2.length) {
console.log('a1 and a2 are not equal')
}else if(a1.join(':') === a2.join(':')){
console.log('a1 and a2 are equal')
}else{
console.log('a1 and a2 are not equal')
}
答案 37 :(得分：1)
从[a]中选择每个并从[b]循环遍历所有： 结果：1,5
var a = [1,4,5,9];
var b = [1,6,7,5];
for (i = 0; i < a.length; i++) {
for (z = 0; z < a.length; z++) {
if (a[i] === b[z]) {
console.log(b[z]); // if match > console.log it
}
}
}
答案 38 :(得分：1)
此脚本比较对象，数组和多维数组
function compare(a,b){
var primitive=['string','number','boolean'];
if(primitive.indexOf(typeof a)!==-1 && primitive.indexOf(typeof a)===primitive.indexOf(typeof b))return a===b;
if(typeof a!==typeof b || a.length!==b.length)return false;
for(i in a){
if(!compare(a[i],b[i]))return false;
}
return true;
}
第一行检查它是否是原始类型。如果是这样，它会比较两个参数。
如果他们是对象。它遍历Object并以递归方式检查每个元素。
用法：
var a=[1,2,[1,2]];
var b=[1,2,[1,2]];
var isEqual=compare(a,b); //true
答案 39 :(得分：1)
此函数比较两个任意形状和尺寸的数组：
function equals(a1, a2) {
if (!Array.isArray(a1) || !Array.isArray(a2)) {
throw new Error("Arguments to function equals(a1, a2) must be arrays.");
}
if (a1.length !== a2.length) {
return false;
}
for (var i=0; i<a1.length; i++) {
if (Array.isArray(a1[i]) && Array.isArray(a2[i])) {
if (equals(a1[i], a2[i])) {
continue;
} else {
return false;
}
} else {
if (a1[i] !== a2[i]) {
return false;
}
}
}
return true;
}
答案 40 :(得分：0)
我的解决方案是比较对象，而不是阵列。这可以像Tomáš的Arrays是Objects一样工作，但没有警告：
Object.prototype.compare_to = function(comparable){
// Is the value being compared an object
if(comparable instanceof Object){
// Count the amount of properties in @comparable
var count_of_comparable = 0;
for(p in comparable) count_of_comparable++;
// Loop through all the properties in @this
for(property in this){
// Decrements once for every property in @this
count_of_comparable--;
// Prevents an infinite loop
if(property != "compare_to"){
// Is the property in @comparable
if(property in comparable){
// Is the property also an Object
if(this[property] instanceof Object){
// Compare the properties if yes
if(!(this[property].compare_to(comparable[property]))){
// Return false if the Object properties don't match
return false;
}
// Are the values unequal
} else if(this[property] !== comparable[property]){
// Return false if they are unequal
return false;
}
} else {
// Return false if the property is not in the object being compared
return false;
}
}
}
} else {
// Return false if the value is anything other than an object
return false;
}
// Return true if their are as many properties in the comparable object as @this
return count_of_comparable == 0;
}
希望这有助于您或其他任何人寻找答案。
答案 41 :(得分：0)
function compareArrays(arrayA, arrayB) {
if (arrayA.length != arrayB.length) return true;
for (i = 0; i < arrayA.length; i++)
if (arrayB.indexOf(arrayA[i]) == -1) {
return true;
}
}
for (i = 0; i < arrayB.length; i++) {
if (arrayA.indexOf(arrayB[i]) == -1) {
return true;
}
}
return false;
}
答案 42 :(得分：0)
简单
type Values = number | string;
/** Not sorted array */
function compare<Values>(a1: Array<Values>, a2: Array<Values>): boolean {
if (a1.length !== a2.length) {
return false;
}
/** Unique values */
const set1 = new Set<Values>(a1);
const set2 = new Set<Values>(a2);
if (set1.size !== set2.size) {
return false;
}
return [...set1].every((value) => [...set2].includes(value));
}
compare([1, 2, 3], [1, 2, 3]); // true
compare([1, 2, 3], [1, 3, 2]); // true
compare([1, 1, 1], [1, 2, 3]); // false
compare([1, 1, 2, 3], [1, 2, 3]); // false
/** Sorted arrays, faster method */
function compareSorted<Values>(a1: Array<Values>, a2: Array<Values>): boolean {
if (a1.length !== a2.length) {
return false;
}
/** Unique values */
const set1 = new Set<Values>(a1);
const set2 = new Set<Values>(a2);
if (set1.size !== set2.size) {
return false;
}
return [...set1].every((value, index) => value === [...set2][index]);
}
compareSorted([1, 2, 3], [1, 2, 3]); // true
compareSorted([1, 2, 3], [1, 3, 2]); // false
compareSorted([1, 1, 1], [1, 2, 3]); // false
compareSorted([1, 1, 2, 3], [1, 2, 3]); // false
答案 43 :(得分：0)
使用 functional Programming approach，我们可以使用以下代码实现。
const a1 = [1, 2, 22, 4];
const a2 = [4, 2, 22, 1];
const checkValue = (firstValues: number[]) => {
return (value: number) => {
const isEqual = firstValues.includes(value);
return isEqual
}
}
const notUniq = a1.map(checkValue(a2)).some((x) => !x) // false
答案 44 :(得分：0)
我在 https://stackoverflow.com/a/10316616/711085 回答了这个问题（此后已被标记为与此答案重复）。 您会在那里找到一个 Deep Equals 实现，它可以处理多种情况，例如 Map 和 Set 以及数组和对象的任意嵌套。其中关于 == 的非传递性和记录 == 与 === 的讨论尤为重要。
对于 OP 的特殊问题，如果数组只包含数字、字符串和布尔值，而没有 NaN，那么对于足够大的数组来说，最有效的方法是预编译函数：
function areSimpleArraysEqual(a,b) {
// requires inputs be arrays of only Number, String, Boolean, and no NaN.
// will propagate error if either array is undefined.
if (a.length!=b.length)
return false;
for(let i=0; i<a.length; i++)
if (a[i]!==b[i]) // using === equality
return false;
return true;
}
如果一个人的业务逻辑不断附加到数组的末尾，则可以在一些罕见的情况下实现平均情况 O(1) 和最坏情况 O(N)，同时检查 if (a.length>0 && a[a.length-1]!==b[b.length-1]) return false; 。
答案 45 :(得分：0)
这是一个CoffeeScript版本，适合那些喜欢的人：
Array.prototype.equals = (array) ->
return false if not array # if the other array is a falsy value, return
return false if @length isnt array.length # compare lengths - can save a lot of time
for item, index in @
if item instanceof Array and array[index] instanceof Array # Check if we have nested arrays
if not item.equals(array[index]) # recurse into the nested arrays
return false
else if this[index] != array[index]
return false # Warning - two different object instances will never be equal: {x:20} != {x:20}
true
所有学分都归@ tomas-zato。
答案 46 :(得分：0)
我认为最简单的方法是像尝试过的那样将每个数组转换成字符串，并比较字符串。
要将数组转换为字符串，只需将此方法字符串放入数组。 这些是数组：
var arr1 = [1, 2, "foo", 3, "bar", 3.14]
var arr2 = [1, 2, "foo", 3, "bar", 3.14]
现在，您必须将它们转换为字符串。方法列表为：
arr1.toString().replace(/,/gi, "")
arr2.toString().replace(/,/gi, "")
方法可以：
**.toString()**-
将数组转换为字符串，并连接数组中的元素。
例如
["tree", "black hole"]-> "tree,black hole"
可悲的是，它包含逗号。这就是为什么我们必须这样做：
***.replace(a, b)***
它会在您要处理的字符串中找到并用第二个参数（b）替换第一个参数（a）。
例如。
"0000010000010000000".replace("1", "2")
将返回："0000020000010000000"
它仅替换参数1的第一个实例，因此我们可以执行正则表达式。
例如。
"0000010000010000000".replace(/1/gi, "2")
将返回："0000020000020000000"
用/包裹要替换的内容。 假设您要替换的是1.您将其替换为：/ 1 /。 但是然后您必须在最后添加gi，以便它选择每个实例。 因此，您必须在/ 1 / gi末尾加一个逗号，然后才能放入要替换的内容。
现在，您的两个数组是：
arr1："12foo3bar3.14"
arr2："12foo3bar3.14"
现在你这样说：
if(arr1 === arr2) {
// Now the code you put inside of this if statement will only run if arr1 and arr2 have the same contents.
} else {
// This code will run if arr1 and arr2 have any differences.
}
如果要检查arr1是否包含arr2而不是内容完全相同，请执行此操作。
if(arr1.indexOf(arr2) !== -1) {
//This code will happen if arr2 is inside of arr1. If there is one extra array
//item in arr1, it doesn't matter. But, if arr2 has an extra array item, nothing in
//this if will run. If you want arr2 to contain arr1, just make arr1 in the
//condition of this if arr2, and make arr2 arr1.
}
基本上，如果要使数组完全相同，请执行以下操作：
if(arr1.toString().replace(/,/gi, "") === arr2.toString().replace(/,/gi, "")) {
//arrays are the same
} else {
//arrays are different
}
如果您想知道一个数组是否包含另一个数组，请执行以下操作：
arrayThatWillHoldAnotherArray = arrayThatWillHoldAnotherArray.toString().replace(/,/gi)
arrayThatWillBeInsideAnotherArray = arrayThatWillBeInsideAnotherArray.toString().replace(/,/gi)
if(arrayThatWillHoldAnotherArray.indexOf(arrayThatWillBeInsideAnotherArray) !== -1) {
//arrayThatWillHoldAnotherArray has arrayThatWillBeInsideAnotherArray inside of it
} else {
//it doesn't
}
console.log("Read the code to understand this.")
var arr1 = [1,2,"foo",3,"bar",3.14]
var arr2 = [1,2,"foo",3,"bar",3.14]
function checkIfArraysAreTheSame(a,b) {
if(a.toString().replace(/,/gi,"") === b.toString().replace(/,/gi,"")) {
console.log("A and B are the same!")
return true;
}
console.log("A and B are NOT the same!")
return false
}
checkIfArraysAreTheSame(arr1,arr2)
//expected output: A and B are the same!
//Now, let's add another item to arr2.
arr2.push("Lorem")
checkIfArraysAreTheSame(arr1,arr2)
//expected output: A and B are NOT the same!
function checkIfArrayIsNestedInsideAnother(a,b) {
//If this returns true, b is nested inside a.
if (a.toString().replace(/,/gi,"").indexOf(b.toString().replace(/,/gi,"")) > -1) {
console.log("B is nested inside of A!")
} else if(b.toString().replace(/,/gi,"").indexOf(a.toString().replace(/,/gi,"")) > -1) {
console.log("A is nested inside of B!")
}
}
checkIfArrayIsNestedInsideAnother(arr1, arr2)
//expected output: A is nested inside of B! because:
//arr1 (a): [1,2,"foo",3,"bar",3.14]
//arr2 (b): [1,2,"foo",3,"bar",3.14, "Lorem"]
//We added Lorem at line 15.
//Now, let's check if arr2 is nested inside arr1, which it is not.
checkIfArrayIsNestedInsideAnother(arr2, arr1)
//expected output: B is nested inside of A!
答案 47 :(得分：0)
该方法仅适用于标量数组，例如该问题的第二个投票答案。
var arrs = [
[[1, 2, 3], [1, 2, 3]], // true
[[1, 2, 3, 4], [1, 2, 3]], // false
[[1, 2, 3], [1, 2, 3, 4]], // false
]
const arraysEqual = (one, two) => (one.filter((i, n) => two[n] === i).length === one.length) && (two.filter((i, n) => one[n] === i).length === two.length)
arrs.forEach(arr => {
console.log(arraysEqual(arr[0], arr[1]))
})
没有ES6语法：
var arrs = [
[[1, 2, 3], [1, 2, 3]], // true
[[1, 2, 3, 4], [1, 2, 3]], // false
[[1, 2, 3], [1, 2, 3, 4]], // false
]
function arraysEqual(one, two) {
return (one.filter((i, n) => two[n] === i).length === one.length) && (two.filter((i, n) => one[n] === i).length === two.length)
}
arrs.forEach(arr => {
console.log(arraysEqual(arr[0], arr[1]))
})
答案 48 :(得分：0)
如果数组是普通的并且顺序很重要，那么这两行可能有帮助
//Assume
var a = ['a','b', 'c']; var b = ['a','e', 'c'];
if(a.length !== b.length) return false;
return !a.reduce(
function(prev,next,idx, arr){ return prev || next != b[idx] },false
);
减少遍历其中一个数组并返回＆＃39; false＆＃39;如果至少有一个元素是＆＃39; a＆＃39;并不等同于＆＃39; b＆＃39; 只需将其包装成功能
即可答案 49 :(得分：0)
function areEqual(a, b){
let x = 0;
for (n in a){
if (a[n] == b[n]){x = 1;}
else {x = 0};
}
return x;
}
a = [1,2,3];
b = [1,2,3];
> console.log（areEqual（a，b））
true
我在这个简单的真实代码应用程序中使用了它
<script>
let corrette = [1];
let risposte = [];
function areEqual(a, b){
let x = 0;
for (n in a){
if (a[n] == b[n]){x = 1;}
else {x = 0};
}
if (x){console.log("The 2 arrays are equal")}
return x;
}
</script>
Apporto di attrezzatura per cucina da parte del proprietario
<button onclick="risposte[0]=1">Capitale proprio</button>
<button onclick="risposte[0]=0">Capitale di debito</button>
<button onclick="risposte[0]=0">Debito commerciale</button>
<br><hr>
<button onclick="if(areEqual(corrette,risposte)){controlla.innerHTML='Esatto'}else{controlla.innerHTML='No'}">Controlla le risposte</button>
<div id="controlla"></div>
答案 50 :(得分：0)
我们可以使用every（）和includes（）方法比较两个数组。
function check(a1,a2){
let result = a1.every((x)=>{
return a2.includes(x);
});
return result;
}
答案 51 :(得分：0)
使用过滤器和箭头功能的另一种方法
arrOne.length === arrTwo.length && arrOne.filter((currVal, idx) => currVal !== arrTwo[idx]).length === 0
答案 52 :(得分：0)
我相信简单的JS和ECMAScript 2015，这很容易理解。
var is_arrays_compare_similar = function (array1, array2) {
let flag = true;
if (array1.length == array2.length) {
// check first array1 object is available in array2 index
array1.every( array_obj => {
if (flag) {
if (!array2.includes(array_obj)) {
flag = false;
}
}
});
// then vice versa check array2 object is available in array1 index
array2.every( array_obj => {
if (flag) {
if (!array1.includes(array_obj)) {
flag = false;
}
}
});
return flag;
} else {
return false;
}
}
希望它将对某人有所帮助。
答案 53 :(得分：0)
In a simple way uning stringify but at same time thinking in complex arrays:
**Simple arrays**:
var a = [1,2,3,4];
var b = [4,2,1,4];
JSON.stringify(a.sort()) === JSON.stringify(b.sort()) // true
**Complex arrays**:
var a = [{id:5,name:'as'},{id:2,name:'bes'}];
var b = [{id:2,name:'bes'},{id:5,name:'as'}];
JSON.stringify(a.sort(function(a,b) {return a.id - b.id})) === JSON.stringify(b.sort(function(a,b) {return a.id - b.id})) // true
**Or we can create a sort function**
function sortX(a,b) {
return a.id -b.id; //change for the necessary rules
}
JSON.stringify(a.sort(sortX)) === JSON.stringify(b.sort(sortX)) // true
答案 54 :(得分：0)
实际上，在Lodash documentation中，他们提供了两个非常好的示例，用于比较和返回具有差异和相似性的新数组（分别在以下示例中）：
import { differenceWith, intersectionWith, isEqual } from 'lodash'
differenceWith(
[{ a: 1 }, { b: 1 }],
[{ a: 1 }, { b: 1 }, { c: 1 }],
isEqual
) // []... the bigger array needs to go first!
differenceWith(
[{ a: 1 }, { b: 1 }, { c: 1 }],
[{ a: 1 }, { b: 1 }],
isEqual,
) // [{ c: 1 }]
intersectionWith(
[{ a: 1 }, { b: 1 }],
[{ a: 1 }, { b: 1 }, { c: 1 }],
isEqual,
) // [{ a: 1 }, { b: 1 }] this one doesn't care about which is bigger
如果您不总是知道哪个数组更大，可以像这样编写一个辅助函数：
const biggerFirst = (arr1, arr2) => {
return arr1.length > arr2.length ? [arr1, arr2] : [arr2, arr1]
}
const [big, small] = biggerFirst(
[{ a: 1 }, { b: 1 }],
[{ a: 1 }, { b: 1 }, { c: 1 }],
)
differenceWith(big, small, isEqual) // even though we have no idea which is bigger when they are fed to biggerFirst()
据我所知，它们之间的匹配程度也很高，因此非常好。
我知道不应该为所有事情而依赖库，但这是我发现的一个最常见/最简洁的解决方案。希望它能对某人有所帮助！
答案 55 :(得分：0)
{
"error": {
"code": 403,
"message": "Permission denied. Could not perform this operation"
}
}
答案 56 :(得分：0)
递归cmp函数可用于数字/字符串/数组/对象
<script>
var cmp = function(element, target){
if(typeof element !== typeof target)
{
return false;
}
else if(typeof element === "object" && (!target || !element))
{
return target === element;
}
else if(typeof element === "object")
{
var keys_element = Object.keys(element);
var keys_target = Object.keys(target);
if(keys_element.length !== keys_target.length)
{
return false;
}
else
{
for(var i = 0; i < keys_element.length; i++)
{
if(keys_element[i] !== keys_target[i])
return false;
if(!cmp(element[keys_element[i]], target[keys_target[i]]))
return false;
}
return true;
}
}
else
{
return element === target;
}
};
console.log(cmp({
key1: 3,
key2: "string",
key3: [4, "45", {key4: [5, "6", false, null, {v:1}]}]
}, {
key1: 3,
key2: "string",
key3: [4, "45", {key4: [5, "6", false, null, {v:1}]}]
})); // true
console.log(cmp({
key1: 3,
key2: "string",
key3: [4, "45", {key4: [5, "6", false, null, {v:1}]}]
}, {
key1: 3,
key2: "string",
key3: [4, "45", {key4: [5, "6", undefined, null, {v:1}]}]
})); // false
</script>
答案 57 :(得分：0)
这是很短的方法
function arrEquals(arr1, arr2){
return arr1.length == arr2.length &&
arr1.filter(elt=>arr1.filter(e=>e===elt).length == arr2.filter(e=>e===elt).length).length == arr1.length
}
答案 58 :(得分：0)
原因是identity或strict运算符（===），它与没有类型转换进行比较，这意味着如果两个值没有相同的值和相同的类型，它们将被视为不相等。 / p> 看看这个链接，它让你毫无疑问 easy way to understand how identity operator works
答案 59 :(得分：-1)
此外，我已经将托马斯的解决方案转换为我需要的订单免费比较。
Array.prototype.equalsFreeOrder = function (array) {
var isThisElemExist;
if (!array)
return false;
if (this.length != array.length)
return false;
for (var i = 0; i < this.length; i++) {
isThisElemExist = false;
for (var k = 0; k < this.length; k++) {
if (this[i] instanceof Array && array[k] instanceof Array) {
if (this[i].equalsFreeOrder(array[k]))
isThisElemExist = true;
}
else if (this[i] == array[k]) {
isThisElemExist = true;
}
}
if (!isThisElemExist)
return false;
}
return true;
}
答案 60 :(得分：-1)
function palindrome(text)
{
var Res1 = new Array();
var Res2 = new Array();
for (i = 0; i < text.length; i++)
{
Res1[i] = text.substr(i, 1);
}
j=0;
for (k = (text.length-1); k>=0; k--)
{
Res2[j] = text.substr(k, 1);
j=j+1;
}
if(JSON.stringify(Res1)==JSON.stringify(Res2)){
return true;
}else{
return false;
}
}
document.write(palindrome("katak"));
答案 61 :(得分：-1)
虽然这个问题的最佳答案是正确和良好的，但所提供的代码可以使用一些改进。
下面是我自己的比较数组和对象的代码。代码简短而简单：
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});
此代码支持嵌套在数组中嵌套的对象和对象的数组。
您可以在此代表处看到一整套测试并自行测试代码：https://repl.it/Esfz/3
答案 62 :(得分：-1)
我想出了另一种方法。使用join('')将它们更改为字符串，然后比较2个字符串：
var a1_str = a1.join(''),
a2_str = a2.join('');
if (a2_str === a1_str) {}
答案 63 :(得分：-1)
如果您正在编写测试代码，那么
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.
答案 64 :(得分：-1)
我非常喜欢这种方法，因为它比其他方法简洁得多。它将所有项目与一个保持相同值的累加器进行对比，如果累加器达到了一个不同的值，则将其替换为NaN。由于NaN不能等于任何值，包括NaN本身，因此该值将转换为布尔值（!!）并且为false。否则，该值应为true。为了防止零数组返回false，该表达式将转换为其绝对值并添加到1，因此!!(Math.abs(0) + 1)将是true。为案例-1添加了绝对值，当将其添加到1时，它等于0，因此等于false。
function areArrayItemsEqual(arr) {
return !!(Math.abs(arr.reduce((a, b) => a === b ? b : NaN)) + 1);
}
答案 65 :(得分：-1)
仅适用于一级数组，字符串或数字类型
function isArrayEqual(ar1, ar2) {
return !ar1.some(item => ar2.indexOf(item) === -1) && ar1.length === ar2.length;
}
答案 66 :(得分：-1)
我需要类似的东西，比较两个包含标识符但随机顺序的数组。 在我的情况下：“此数组是否至少包含另一个列表中的一个标识符？” 使用reduce函数，代码非常简单。
function hasFullOverlap(listA, listB){
return listA.reduce((allIdsAreFound, _id) => {
// We return true until an ID has not been found in the other list
return listB.includes(_id) && allIdsAreFound;
}, true);
}
if(hasFullOverlap(listA, listB) && hasFullOverlap(listB, listA)){
// Both lists contain all the values
}
答案 67 :(得分：-1)
let equals = (LHS, RHS) => {
if (!(LHS instanceof Array)) return "false > L.H.S is't an array";
if (!(RHS instanceof Array)) return "false > R.H.S is't an array";
if (LHS.length != RHS.length) return false;
let to_string = x => JSON.stringify(x.sort((a, b) => a - b));
return to_string(LHS) == to_string(RHS);
};
let l = console.log
l(equals([5,3,2],[3,2,5])) // true
l(equals([3,2,5,3],[3,2,5])) // false
答案 68 :(得分：-1)
如果元素数量不匹配或者其中一个元素不在另一个数组中，则可以取消“相同”的资格。这是一个对我有用的简单功能。
var start = function(){
this.cx = this.attr("cx"),
this.cy = this.attr("cy");
}, move = function (dx, dy,x,y) {
var X = this.cx + dx * scale.x,
Y = this.cy + dy * scale.y;
this.attr({cx: X, cy: Y});
}
raphael_element.drag(move,start);
答案 69 :(得分：-2)
在“ forEach”中使用“ includes”怎么样？
var array1 = [1,2,3];
var array2 = [1,2,4];
var array_diff = 0;
// loop through each element in first array
array1.forEach(function(elem){
// check if second array contains it, return false if not
if(!array2.includes(elem)){
array_diff = 1;
return false;
}else{
array_diff = 0;
}
});
// loop through each element in second array
array2.forEach(function(elem){
// check if first array contains it, return false if not
if(!array1.includes(elem)){
array_diff = 1;
return false;
}else{
array_diff = 0;
}
});
// variable array_diff determines the result
if(array_diff == 1){
alert('Arrays are different');
}else{
alert('Arrays are same');
}
注意：这对排序数组和未排序数组均适用
答案 70 :(得分：-2)
我会这样做：
[2,3,4,5] == [2,3,4,5].toString()
当你使用“==”运算符时，javascript检查值（左和右）是否是相同的类型，如果它是不同的javascript尝试转换同一类型的双方。
Array == String
数组有toString方法，所以javascript使用它将它们转换为相同的类型，工作方式与此类似：
[2,3,4,5].toString() == [2,3,4,5].toString()
答案 71 :(得分：-2)
如果要比较两个数组并检查两个数组中是否有相同的对象，它将起作用。例子：
Array1 = [a，b，c，d] Array2 = [d，e，f，g]
这里，“ d”在两个数组中都很常见，因此此函数将返回真值。
cehckArray(array1, array2) {
for (let i = 0; i < array1.length; i++) {
for (let j = 0; j < array2.length; j++) {
if (array1[i] === array2[j]) {
return true;
}
}
}
// Return if no common element exist
return false;
}
答案 72 :(得分：-3)
var er = [{id:"23",name:"23222"}, {id:"222",name:"23222222"}];
var er2 = [{id:"23",name:"23222"}, {id:"222",name:"23222222"}];
var result = (JSON.stringify(er) == JSON.stringify(er2)); // true
如果每个条目的属性顺序没有改变，它就可以很好地处理json对象。
var er = [{name:"23222",id:"23"}, {id:"222",name:"23222222"}];
var er2 = [{id:"23",name:"23222"}, {id:"222",name:"23222222"}];
var result = (JSON.stringify(er) == JSON.stringify(er2)); // false
但是数组的每个条目只有一个属性或值，这样可以正常工作。
答案 73 :(得分：-6)
到目前为止，我使用此代码没有任何问题：
if(a.join() == b.join())
...
即使项目中有逗号，它仍然有效。