如何比较javascript数组的内容，而不是它们的顺序？

正如标题所说，我想比较两个js数组，其中我只关心内容是否相同，而不关心它们的顺序是否相同。因此，我所期望的是：

[1, 2, 3, 3] == [1, 2, 3, 3]     // True
[1, 2, 3, 3] == [1, 3, 2, 3]     // True
[1, 2, 3, 3] == [1, 2]           // False
[1, 2, 3, 3] == [1, 2, 3]        // False
[1, 2, 3, 3] == [1, 2, 3, 3, 3]  // False
[1, 2, 3, 3] == [1, "2, 3, 3"]      // False

显然，比较运算符不起作用。从中我得到了下面的Array.prototype方法，但不幸的是，这也检查了顺序是否相同

有人知道我如何检查两个js数组是否包含相同的元素，而不考虑元素的顺序吗？欢迎所有提示

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;
}   

Array.prototype.equals=函数（数组）{
//如果另一个数组是falsy值，则返回
if（！数组）
返回false；
//比较长度-可以节省大量时间
if（this.length！=array.length）
返回false；
for（var i=0，l=this.length；i比较前对其进行排序：

从下面的注释中，如果希望2个ARR包含不同的基元类型，请添加此排序函数

function s(x,y){
    var pre = ['string' , 'number' , 'bool']
    if(typeof x!== typeof y )return pre.indexOf(typeof y) - pre.indexOf(typeof x);

    if(x === y)return 0;
    else return (x > y)?1:-1;

}
var arr1 = [1, 2, 3, 3].sort(s);
var arr2 = [1, 3, 2, 3].sort(s);

arr1.equals(arr2);// true

下面是一个适用于基本值的解决方案。它将对象用作基本体贴图，并统计每个值的出现次数。但是，它还考虑每个值的数据类型

它首先检查数组的长度，作为快捷方式：

function equals(a, b) {
    if (a.length !== b.length) {
        return false;
    }

    var seen = {};
    a.forEach(function(v) {
        var key = (typeof v) + v;
        if (!seen[key]) {
            seen[key] = 0;
        }
        seen[key] += 1;
    });

    return b.every(function(v) {
        var key = (typeof v) + v;
        if (seen[key]) {
            seen[key] -= 1;
            return true;
        }
        // not (anymore) in the map? Wrong count, we can stop here
    });
}

你只是在处理数字数组，还是在寻找一个通用的解决方案？阵列的大致大小是多少？我相信只有使用
Map
才能获得最佳的通用解决方案。您可以始终对它们进行排序并检查它们是否相同。此外，此实现也不是很好。因为它使用松散的比较，所以会返回误报。例如，
[[1,2]]
和
['1,2']
被这个算法认为是相等的。@shmuli:你是说两个嵌套循环？或者你是什么意思？@aaronk6：这里显示的解决方案似乎忽略了重复项。排序并不总是有效的。正如我在另一个答案中解释的那样，
[1，'1'].sort（）
和
['1'，1].sort（）
都将按原始顺序保留数组。在您的示例中，这个特定示例不是问题，因为
equals
实现使用了松散的比较，但这本身就意味着其他问题（请参阅我对这个问题的评论）。事实上，只有当您只处理相同原始数据类型的值时，排序才真正起作用。（考虑到OP对问题的描述，情况可能是这样）鉴于我的数组只包含字母字符串，而没有其他内容，Felix Kling的上述评论对我来说不是问题。这个解决方案既简单又有效，我现在已经在使用它了。谢谢@Omar@FelixKling感谢您的通知。编辑中的解决方案。您的排序回调不正确，但是。。。它应始终返回负值或正值，或0。不是布尔值。@kramer65:一个更能反映您的用例的示例会更好。幸好ES 2015引入了映射！现在类型检查和字符串化已经过时了，可以使用类似的东西来代替：
const compareOutOfOrder=（arr1，arr2）=>{if（arr1.length！==arr2.length）{return false；}const counts=new Map（）；arr1.forEach（（value）=>counts.set（value，（counts.get（value）？？0）+1））；arrr2.forEach（（value）=>counts.set（value），（counts.get（值）？？0）-1）；返回数组。从（counts.values（））.every（（count）=>count==0）；}；
。我怀疑是否有可能利用一个
返回值
…
。every（
…
）；
直接在这里计数。