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

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

sameElements(a,b) --> true

解决方法

更新

我扩大了code,有可能通过参考或平等检查

只是作为第二个参数传递给做参考检查.

另外我把例子添加到了Brunos JSPerf

>运行在大约11个操作/ s做参考检查

我会尽快评论这个代码(！),因为我有空余的时间来解释一下,但是现在没有时间去思考.完成

更新2.

像布鲁诺一样,在评论中指出,同样的数据([NaN],[NaN])产生错误

在我看来,这是正确的行为,因为NaN是含糊不清的,应该总是导致一个错误的结果,至少在比较NaN.equals(NaN)时.但他有一个很好的点.

是否

[1,NaN,3]应该等于[1,3,2].

好的,诚实地,我有点被撕裂,不管是否应该,所以我添加了两个标志.

> Number.prototype.equal.NaN

>如果为真

> NaN.equals(NaN)// true

> 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.

第105行在Fiddle

哪种是重要的,因为它决定了元素的一致顺序.

更新4
我试图优化排序功能,并设法达到约20个操作/秒.

以下是更新的代码,以及更新的fiddle =)

此外,我选择标记排序函数之外的对象,它似乎不再具有性能差异,并且它更易读

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

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

但是当然,检查对象是否相同可能会导致大对象中的性能问题.

所以如果任何人感觉到不愉快的操纵原生的原型,只需做一个类型检查并把它放在一个功能

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,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,value: Boolean.prototype.equals //the same (now we covered the primitives)
    });

Object.defineProperty(Object.prototype,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,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;
        }

    }

});

这样我们可以减少相同的元素功能

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

注意.当然,您可以将所有相同的函数放在同一个元素函数中,用于类型检查的成本.

现在这里有3个例子：1,深入检查,2个参考检查.

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

var bar = {
    a: 1,3]
};

var foobar = {
    a: 1,4]
};

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

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

>检查a和b只有参考.

console.log(sameElements(a,b,true))// true它们包含相同的元素
>检查b和c只有参考

console.log(sameElements(b,c,true))// false,因为c包含两次.
>深入检查b和c

console.log(sameElements(b,false))// true,因为bar和foo是相等但不一样的
>检查包含NaN的2个数组

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

演示JSFiddle