我想比较两个数组。。。理想地、有效地。没有什么稀奇古怪的，如果它们是相同的，那就是真的，如果不是，那就是假的。毫不奇怪，比较运算符似乎不起作用。
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对每个数组进行编码，但是否有一种更快或“更好”的方法来简单地比较数组而不必遍历每个值？
当前回答
根据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/
其他回答
易于理解的
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
我的解决方案比较对象，而不是数组。这将以与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;
}
JSON.stringify(collectionNames).includes(JSON.stringify(sourceNames)) ? array.push(collection[i]) : null
我就是这样做的。
2020年推出了第一阶段的建议，通过在语言中添加Array.prototype.equals，可以方便地比较数组。这就是它的工作方式，没有任何库、猴痘或任何其他代码：
[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现在将“花时间研究问题空间、解决方案和跨领域关注”。如果它进入了第二阶段，那么它很有可能最终融入到语言中。
使用数字/字符串/数组/对象的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>
