我想比较两个数组。。。理想地、有效地。没有什么稀奇古怪的，如果它们是相同的，那就是真的，如果不是，那就是假的。毫不奇怪，比较运算符似乎不起作用。
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对每个数组进行编码，但是否有一种更快或“更好”的方法来简单地比较数组而不必遍历每个值？
当前回答
我喜欢将Undercore库用于数组/对象密集型编码项目。。。在Undercore和Lodash中，无论您是比较数组还是对象，它看起来都是这样的：
_.isEqual(array1, array2) // returns a boolean
_.isEqual(object1, object2) // returns a boolean
Undercore is Equal文档Lodash isEqual文档
其他回答
我们可以用功能性的方式(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
这里有很多好答案。我通常是这样做的-
if ( arr1.length === arr2.length && arr1.every((a1) => arr2.includes(a1)) ) {
// logic
}
every（）只在所有元素都通过给定的camparison时返回true思维方式如果在任何迭代中遇到错误，它将终止并返回false。时间复杂度为O（n*m）。
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)
使用数字/字符串/数组/对象的Ré草书cmp函数
<脚本>var cmp=函数（元素，目标）{if（元素类型！==目标类型）{return false；}否则if（typeof element==“object”&&（！target||！element））{返回目标==元素；}else if（元素类型==“对象”）{var keys_element=对象.keys（元素）；var keys_target=对象.keys（目标）；如果（keys_element.length！==keys_target.length）{return false；}其他的{对于（var i=0；i<keys_element.length；i++）{如果（keys_element[i]！==keys_target[i]）return false；if（！cmp（元素[keys_element[i]]，目标[keys_target[i]]））return false；}返回true；}}其他的{返回元素==目标；}};console.log（cmp({键1：3，key2:“字符串”，key3:[4，“45”，｛key4:[5，“6”，false，null，｛v:1｝]｝]}, {键1：3，key2:“字符串”，key3:[4，“45”，｛key4:[5，“6”，false，null，｛v:1｝]｝]})); // 真的console.log（cmp({键1：3，key2:“字符串”，key3:[4，“45”，｛key4:[5，“6”，false，null，｛v:1｝]｝]}, {键1：3，key2:“字符串”，键3:[4，“45”，｛键4:[5，“6”，未定义，null，｛v:1｝]｝]})); // 假的</script>
我的解决方案比较对象，而不是数组。这将以与Tomáš相同的方式工作，因为数组是对象，但没有警告：
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;
}
