我正在寻找一种有效的方法来确定两个数组是否以任何顺序包含相同数量的相等元素(在 == 意义上):

foo = {/*some object*/}
bar = {/*some other object*/}

a = [1,2,foo,2,bar,2]
b = [bar,2,2,2,foo,1]

sameElements(a, b) --> true

附言。请注意，几乎线程中的每个解决方案都使用 === 而不是 == 进行比较。不过这对我的需求来说很好。

最佳答案

更新 5 我发布了一个新的 answer用不同的方法。

更新

我扩展了 code可以通过 reference 或 equality

只需将 true 作为第二个参数传递即可进行引用检查。

我还把例子添加到 Brunos JSPerf

• 它以大约 11 ops/s 的速度执行引用检查

我会尽快(!)评论代码，因为我有空闲时间来解释更多，但目前没有时间，sry 。完成

更新 2.

就像 Bruno 在评论中指出的那样 sameElements([NaN],[NaN]) 产生 false

在我看来，这是正确的行为，因为 NaN 是模棱两可的，应该总是导致 false 结果，至少在比较 NaN.equals(NaN )。但他有一个很好的观点。

是否

[1,2,foo,bar,NaN,3] 应等于或不等于 [1,3,foo,NaN,bar,2]。

好吧..老实说我有点纠结是否应该，所以我添加了两个标志。

• Number.prototype.equal.NaN
  • 如果为真
    • NaN.equals(NaN)//真
• Array.prototype.equal.NaN
  • 如果为真
    • [NaN].equals([NaN],true)//true
    • 请注意，这仅用于引用检查。因为深度检查无论如何都会调用 Number.prototype.equals

更新 3:

我在排序函数中完全漏掉了 2 行。

已添加

 r[0] = a._srt; //DANG i totally missed this line
 r[1] = b._srt; //And this.

Fiddle 中的第 105 行

这很重要，因为它决定了元素的一致顺序。

更新 4
我尝试稍微优化排序功能，并设法将其提高到大约 20 ops/s。

下面是更新后的代码，以及更新后的 fiddle =)

我还选择了标记排序函数之外的对象，它似乎不再对性能产生影响，并且更具可读性

这是一种使用 Object.defineProperty 来添加 equals 函数的方法

Array,Object,Number,String,Boolean's prototype 避免在一个函数中进行类型检查 性能原因。因为我们可以在任何元素上递归调用 .equals。

当然，检查对象是否相等可能会导致大对象出现性能问题。

因此，如果有人对操纵 native 原型(prototype)感到不愉快，只需进行类型检查并将其放入一个函数

Object.defineProperty(Boolean.prototype, "equals", {
        enumerable: false,
        configurable: true,
        value: function (c) {
            return this == c; //For booleans simply return the equality
        }
    });

Object.defineProperty(Number.prototype, "equals", {
        enumerable: false,
        configurable: true,
        value: function (c) {
            if (Number.prototype.equals.NaN == true && isNaN(this) && c != c) return true; //let NaN equals NaN if flag set
            return this == c; // else do a normal compare
        }
    });

Number.prototype.equals.NaN = false; //Set to true to return true for NaN == NaN

Object.defineProperty(String.prototype, "equals", {
        enumerable: false,
        configurable: true,
        value: Boolean.prototype.equals //the same (now we covered the primitives)
    });

Object.defineProperty(Object.prototype, "equals", {
        enumerable: false,
        configurable: true,
        value: function (c, reference) {
            if (true === reference) //If its a check by reference
                return this === c; //return the result of comparing the reference
            if (typeof this != typeof c) { 
                return false; //if the types don't match (Object equals primitive) immediately return
            }
            var d = [Object.keys(this), Object.keys(c)],//create an array with the keys of the objects, which get compared
                f = d[0].length; //store length of keys of the first obj (we need it later)
            if (f !== d[1].length) {//If the Objects differ in the length of their keys
                return false; //immediately return
            }
            for (var e = 0; e < f; e++) { //iterate over the keys of the first object
                if (d[0][e] != d[1][e] || !this[d[0][e]].equals(c[d[1][e]])) {
                    return false; //if either the key name does not match or the value does not match, return false. a call of .equal on 2 primitives simply compares them as e.g Number.prototype.equal gets called
                }
            }
            return true; //everything is equal, return true
        }
    });
Object.defineProperty(Array.prototype, "equals", {
        enumerable: false,
        configurable: true,
        value: function (c,reference) {

            var d = this.length;
            if (d != c.length) {
                return false;
            }
            var f = Array.prototype.equals.sort(this.concat());
            c = Array.prototype.equals.sort(c.concat(),f)

            if (reference){
                for (var e = 0; e < d; e++) {
                    if (f[e] != c[e] && !(Array.prototype.equals.NaN && f[e] != f[e] && c[e] != c[e])) {
                        return false;
                    }
                }                
            } else {
                for (var e = 0; e < d; e++) {
                    if (!f[e].equals(c[e])) {
                        return false;
                    }
                }
            }
            return true;

        }
    });

Array.prototype.equals.NaN = false; //Set to true to allow [NaN].equals([NaN]) //true

Object.defineProperty(Array.prototype.equals,"sort",{
  enumerable:false,
  value:function sort (curr,prev) {
         var weight = {
            "[object Undefined]":6,         
            "[object Object]":5,
            "[object Null]":4,
            "[object String]":3,
            "[object Number]":2,
            "[object Boolean]":1
        }
        if (prev) { //mark the objects
            for (var i = prev.length,j,t;i>0;i--) {
                t = typeof (j = prev[i]);
                if (j != null && t === "object") {
                     j._pos = i;   
                } else if (t !== "object" && t != "undefined" ) break;
            }
        }

        curr.sort (sorter);

        if (prev) {
            for (var k = prev.length,l,t;k>0;k--) {
                t = typeof (l = prev[k]);
                if (t === "object" && l != null) {
                    delete l._pos;
                } else if (t !== "object" && t != "undefined" ) break;
            }
        }
        return curr;

        function sorter (a,b) {

             var tStr = Object.prototype.toString
             var types = [tStr.call(a),tStr.call(b)]
             var ret = [0,0];
             if (types[0] === types[1] && types[0] === "[object Object]") {
                 if (prev) return a._pos - b._pos
                 else {
                     return a === b ? 0 : 1;
                 }
             } else if (types [0] !== types [1]){
                     return weight[types[0]] - weight[types[1]]
             }



            return a>b?1:a<b?-1:0;
        }

    }

});

这样我们就可以将 sameElements 函数简化为

function sameElements(c, d,referenceCheck) {
     return c.equals(d,referenceCheck);  //call .equals of Array.prototype.
}

注意。当然，您可以将所有相同的函数放入 sameElements 函数中，以进行类型检查。

现在这里有 3 个示例:1 个使用深度检查，2 个使用引用检查。

var foo = {
    a: 1,
    obj: {
        number: 2,
        bool: true,
        string: "asd"
    },
    arr: [1, 2, 3]
};

var bar = {
    a: 1,
    obj: {
        number: 2,
        bool: true,
        string: "asd"
    },
    arr: [1, 2, 3]
};

var foobar = {
    a: 1,
    obj: {
        number: 2,
        bool: true,
        string: "asd"
    },
    arr: [1, 2, 3, 4]
};

var a = [1, 2, foo, 2, bar, 2];
var b = [foo, 2, 2, 2, bar, 1];
var c = [bar, 2, 2, 2, bar, 1];

所以这些是我们比较的数组。输出是

1. 检查 a 和 b 仅引用。

   console.log (sameElements ( a,b,true))//true 因为它们包含相同的元素

2. 检查 b 和 c 仅引用

   console.log (sameElements (b,c,true))//false 因为 c 包含 bar 两次。

3. 深入检查b和c

   console.log (sameElements (b,c,false))//true，因为 bar 和 foo 相等但不相同

4. 检查 2 个包含 NaN 的数组

   Array.prototype.equals.NaN = true;
console.log(sameElements([NaN],[NaN],true));//真。
Array.prototype.equals.NaN = false;

演示 JSFiddle

关于javascript - 将数组作为(多)集合进行比较，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/16913668/