Javascript 代码可以使用数组，但不能使用多维数组。

在Holdem hand evaluator上工作，牦牛剃须的一部分是编写一个“从7张牌中获得5张牌的多少组合”函数（pickNofSet（））。我已经这样做了，但我这样做的方式会返回一堆副本

所以我必须写一个removeDuplicates（）。问题是。。。它适用于一个简单的数组，但不适用于我的“pickNofSet”函数生成的“数组数组”

--这是删除的复制代码--

var removeDuplicates=函数（输入）{//takes数组
var输出=[]；
对于（i=0；i

以下是我从控制台获得的信息：

> removeDuplicates(['a','b','c'],['a','b','c'],['d','e','f'],['g','h','i']);
< undefined
> removeDuplicates([1, 2, 2, 3, 3, 5, 5, 6, 6, 6]);
< [1, 2, 3, 5, 6]

>移除的副本（['a'，'b'，'c']，['a'，'b'，'c']，['d'，'e'，'f']，['g'，'h'，'i']）；
<未定义
>移除的副本（[1,2,2,3,3,5,5,6,6,6]）；
< [1, 2, 3, 5, 6]

运算符===无法比较数组

当您使用

==

检查两个元素之间的相等性时，这只适用于基本数据类型，而不适用于数组。e、 g

1===1 // true
[1]===[1] // Sorry, you can't

如果希望算法同时处理基本元素和数组元素，则可能需要将等式检查从

==

升级为自定义函数

来自此：

if(input[j] === input[i]){
   unique = false; // guilty!
};// endif

if (equals(input[j],input[i]){
   unique = false; // guilty!
};// endif

对此：

if(input[j] === input[i]){
   unique = false; // guilty!
};// endif

if (equals(input[j],input[i]){
   unique = false; // guilty!
};// endif

并实现

equals

函数，以便能够比较基本数据类型和数组：

function equals(a,b){
    if (typeof(a)!=typeof(b))
        return false;
    else if (typeof(a)=='object'){
        if (Object.keys(a).length != Object.keys(b).length)
            return false;
        else{
            for (var keyA of Object.keys(a)){
                if (!(keyA in b))
                    return false;
                else if (a[keyA]!==b[keyA])
                    return false;
                else
                    return true;
            }
        }
    }
    else
        return a===b;
}

提示：希望此解决方案也能与JSON元素一起使用

---

下面是一个通用独特过滤器的示例，它可以满足您的需要。需要符合ES5标准的环境

（函数（）{
"严格使用",；
功能$QUAL（a、b）{
返回a==b；
}
函数$isUndefined（inputArg）{
返回$STRIECTQUAL（输入的类型，'未定义'）；
}
函数$isPrimitive（inputArg）{
变量类型=输入的类型；
返回类型=='undefined'| | inputArg===null | |类型=='boolean'| |类型=='string'| |类型==='number'| |类型=='symbol'；
}
函数$isFunction（inputArg）{
返回inputArg的类型==='function'；
}
函数$isDate（inputArg）{
返回Object.prototype.toString.call（inputArg）='[Object Date]'；
}
函数$isRegExp（inputArg）{
返回Object.prototype.toString.call（inputArg）='[Object RegExp]'；
}
函数$isString（inputArg）{
返回Object.prototype.toString.call（inputArg）='[Object String]'；
}
函数$isArguments（inputArg）{
返回Object.prototype.toString.call（inputArg）='[Object Arguments]'；
}
函数$getItem（对象，索引）{
var项目；
if（$isString（对象））{
item=object.charAt（索引）；
}否则{
项目=对象[索引]；
}
退货项目；
}
var de=功能（a、b、circ）{
如果（a==b）{
返回true；
}
var aType，
B类型，
艾萨克人，
比萨格斯，
艾斯普里姆，
比斯普里姆，
aCirc，
bCirc，
灵魂，
kb，
长度，
指数
信息技术
如果（$isDate（a）和&$isDate（b））{
返回a.getTime（）==b.getTime（）；
}
如果（$isRegExp（a）和&$isRegExp（b））{
返回a.source==b.source&&
a、 全局===b.global&&
a、 多行===b.多行&&
a、 lastIndex==b.lastIndex&&
a、 ignoreCase==b.ignoreCase&&
a、 粘性===b.粘性；
}
aisprimic=$isPrimitive（a）；
bIsPrim=$isPrimitive（b）；
if（（aIsPrim | |$isFunction（a））和&（bIsPrim | |$isFunction（b）））{
/*jslint eqeq：正确*/
返回a==b；
}
if（aIsPrim | | bIsPrim）{
返回a==b；
}
如果（a.原型！==b.原型）{
返回false；
}
如果（a=1）{
约a.push（a）；
}否则{
aCirc=真；
}
if（循环b.indexOf（b）=-1）{
约b.push（b）；
}否则{
bCirc=真；
}
if（aCirc和bCirc）{
circ.cnt+=1；
}否则{
circ.cnt=0；
}
如果（circ.cnt>200）{
抛出新的RangeError（“超出循环参考限制”）；
}
aIsArgs=$isArguments（a）；
bIsArgs=$isArguments（b）；
if（（aIsArgs&&bIsArgs）| |（！aIsArgs&&bIsArgs））{
返回false；
}
if（aIsArgs）{
返回de（Array.prototype.slice.call（a），Array.prototype.slice.call（b），circ）；
}
ka=对象键（a）；
kb=对象键（b）；
长度=ka.长度；
if（长度！==kb.length）{
if（Array.isArray（a）和&Array.isArray（b））{
如果（a.长度！==b.长度）{
返回false；
}
}否则{
返回false；
}
}否则{
ka.sort（）；
kb.sort（）；
对于（索引=0；索引<长度；索引+=1）{
if（ka[index]！==kb[index]）{
返回false；
}
}
}
对于（索引=0；索引<长度；索引+=1）{
it=ka[指数]；
如果（！de（$getItem（a，it），$getItem（b，it），circ））{
返回false；
}
}
aType=a的类型；
b型=b型；