在JavaScript中查找嵌套的重复数组。（以lodash/下划线表示的嵌套数组uniq）

我试图确定JavaScript数组数组是否包含重复项。这可能吗？我首先试着看看我是否能去掉重复的部分，然后做一个平等性检查，但我无法通过第一部分。下面是下划线返回的内容：

var arr1 = [[1,2], [2,3], [1,2]];
var arr2 = _.uniq(arr1);

var arraysAreEqual = _.isEqual(arr1, arr2);

console.log(arraysAreEqual, arr1, arr2);
// true

Jsbin：

有人知道一种确定数组是否包含重复数组的方法吗？

这有点草率，但是（可能）

将从以下列表中为您提供正确的结果

：

uniq

\uq（数组，[isSorted]，[iteratee]）

别名：唯一的
产生 复制数组的免费版本，使用===测试对象 平等。如果事先知道数组已排序，则传递 对于

isSorted，为true将运行更快的算法。如果你想
基于转换计算唯一项，传递迭代对象
功能

但在JavaScript中不能严格比较数组

因此，您可以使用转换函数启用与
uniq
的比较。例如：

console.log([1,2] === [1,2]) // false, can't strict compare arrays
console.log([1,2].toString()) // "1,2" - string representation
console.log([1,2].toString() === [1,2].toString()) // true, strings can be compared

var valueToString = function(v) {return v.toString()}; // transform array to string
var arr1 = [[1,2], [2,3], [1,2]];
var arr2 = _.uniq(arr1, false, valueToString); // compare based on transformation
var arraysAreEqual = _.isEqual(arr1, arr2);

console.log("arraysAreEqual:", arraysAreEqual, arr1, arr2); 
// false
// [[1, 2], [2, 3], [1, 2]]
// [[1, 2], [2, 3]]

请注意转换为字符串是“有难度的”：您最好比较数组的每个值，如中所述

通过在该问题中使用建议的
equals
实现，您需要实现自己版本的
uniq
，它使用
equals
而不是
=

非常简单-它创建一个新的
结果
数组并在给定数组中循环。如果当前值尚未出现在结果中，请将其插入

console.log("Using array comparison:");
arrayEquals = function (array1, array2) {
    // if any array is a falsy value, return
    if (!array1 || !array2)
        return false;

    // compare lengths - can save a lot of time 
    if (array1.length != array2.length)
        return false;

    for (var i = 0, l=array1.length; i < l; i++) {
        // Check if we have nested arrays
        if (array1[i] instanceof Array && array2[i] instanceof Array) {
            // recurse into the nested arrays
            if (!arrayEquals(array1[i],array2[i]))
                return false;       
        }           
        else if (array1[i] !== array2[i]) { 
            return false;   
        }        
    }       
    return true;
};

_.uniqArrays = function(array) {
  if (array == null) return [];
  var result = [];
  for (var i = 0, length = array.length; i < length; i++) {
    var value = array[i];
    var arrayEqualsToValue = arrayEquals.bind(this, value); // arrayEquals with first argument set to value
    var existing = _.find(result, arrayEqualsToValue); // did we already find this?
    if (!existing) {
      result.push(value);
    }
  }
  return result;
};

var arr3 = _.uniqArrays(arr1);
arraysAreEqual = _.isEqual(arr1, arr3);
console.log("arraysAreEqual:", arraysAreEqual, arr1, arr3); // false

console.log（“使用数组比较：”）；
arrayEquals=函数（array1，array2）{
//如果任何数组是falsy值，则返回
如果（！array1 | |！array2）
返回false；
//比较长度-可以节省大量时间
if（array1.length！=array2.length）
返回false；
对于（变量i=0，l=array1.length；i

如果你想玩的话，我做了一个测试。
在最新的lodash（4.6.1）中，你可以这样做：

if (_.uniqWith(arr, _.isEqual).length < arr.length) {
  // then there were duplicates
}

if（q.uniqWith（arr，q.isEqual）.length
试试这个：

var numArray = [1, 7, 3, 0, 9, 7, 8, 6, 2, 3];
var duplicates = [];
var sortednumArray = numArray.sort();


for (var i = 0; i < sortednumArray.length; i++) {
    //console.log(sortednumArray[i]);
    if (sortednumArray[i] == sortednumArray[i + 1]) {
        duplicates.push(sortednumArray[i]);
    }
}

if (duplicates.length == 0) {
    console.log("Soted Array:");
    for(var i = 0; i < sortednumArray.length; i++) {
        console.log(sortednumArray[i]);
    }
} else {
    console.log("Duplicates:");
    for(var i = 0; i < duplicates.length; i++){
        console.log(duplicates[i]);
    }
}

var numArray=[1,7,3,0,9,7,8,6,2,3]；
重复变量=[]；
var sortednumArray=numArray.sort（）；
对于（变量i=0；i

程序将所有重复项推送到一个名为“duplicates”的数组中，然后显示它，但如果不存在，则会显示numArray的排序版本。当您说“duplicate”时，是指数组是相同的对象，还是指数组具有相同的长度和项目顺序，或者具有相同的长度但没有项目顺序？可以严格比较数组，
var a=[1,2]，b=[1,2]
现在
a===a
是
true
，它们是相同的数组。但是
a===b
是
false
，它们不是相同的数组，但它们都是长度相同、项目值顺序相同的数组。要测试它们的项值是否相等，您应该检查它们的长度，然后逐项检查，顺序是否相同。@Xotic750，当您比较
a===a
时，您不是将数组与自身进行比较，而是将对数组的引用与自身进行比较，这显然必须是真的。实际上，
a===a
将始终为真（）。你是对的，检查平等性的最好方法是检查每个项目，不过，我将链接到一个讨论这个问题的答案。然后，他们被严格地比较，因为这是同一个对象，我确实继续解释，但可能仅仅作为一个评论不够清楚。我还质疑OP的意思。而且
a===a
并不总是
true
，请尝试
var a=NaN，b=NaN
。也许你的语句应该读过类似于<代码>的内容，你不能严格地比较（即=＝=或偶数＝）2个不同的数组对象的内容< /代码>，甚至比我问的OP简单的问题，你甚至可能需要考虑以下是否相等：代码> var a= [1,2]，b= {0:1,1:2，长度：2 } <代码>作为另一个例子，我改进了我的问题，以反映转换为字符串并不是进行转换的理想方式。无论如何，我们必须同意，它的方式更简单：）在这个非常简单的例子中，然后也许，并取决于OP的定义。
var numArray = [1, 7, 3, 0, 9, 7, 8, 6, 2, 3];
var duplicates = [];
var sortednumArray = numArray.sort();


for (var i = 0; i < sortednumArray.length; i++) {
    //console.log(sortednumArray[i]);
    if (sortednumArray[i] == sortednumArray[i + 1]) {
        duplicates.push(sortednumArray[i]);
    }
}

if (duplicates.length == 0) {
    console.log("Soted Array:");
    for(var i = 0; i < sortednumArray.length; i++) {
        console.log(sortednumArray[i]);
    }
} else {
    console.log("Duplicates:");
    for(var i = 0; i < duplicates.length; i++){
        console.log(duplicates[i]);
    }
}