Javascript 如何检查数组中除0以外的重复项

我有一个变量

数据

一个对象数组。现在，我想检查是否存在除0以外的重复值。到目前为止，我所做的是下面的代码片段：

此警报显示为true，但应为false，因为未包含0以进行检查。请帮忙。谢谢

var data=[{id:0}，{id:1}，{id:3}，{id:0}，]；
var checkdata=data.map（函数（项）{
return item.id}）；
var isDuplicatedata=checkdata.some（函数（项，idx）{
返回checkdata.indexOf（项目）！=idx
});
警报（isDuplicatedata）

对象无法与其他原语类型进行比较

我编写了一个函数来解决您提出的问题，它与您实现的完全不同，它在性能和实用性方面可能不太好

var data = [{id: 0},  {id: 1}, {id: 2}, {id: 0},{id: 3}];

function isDuplicatedata() {            
  for(var i = 0; i < data.length; i++) {
    if(data[i].id === 0)
      continue;
    for(var j = i+1; j < data.length; j++) {
      if(data[j].id === data[i].id)
        return true;
    }
  }
  return false;
}

alert(isDuplicatedata())

var data=[{id:0}，{id:1}，{id:2}，{id:0}，{id:3}]；
函数isDuplicatedata（）{
对于（变量i=0；i

我建议对数组进行排序，并检查当前的

id

是否与前一个id相同。此方法仅遍历数组2次

var data=[{id:0}，{id:1}，{id:3}，{id:0}]；
//对数组进行排序，使其成为[0,0,1,3]
数据排序（函数（a，b）{
如果（a.idb.id）
返回1；
其他的
返回0；
});
//现在检查所有对象，并将它们与上一个数组元素进行比较
var isDuplicatedata=false；
对于（变量i=1，l=data.length；i您可以使用

some（）
方法测试数组中的某个元素是否通过了所提供函数实现的测试

和一个临时对象。
var data=[{id:0}，{id:1}，{id:3}，{id:0}]，
对象={}，
重复=数据。部分（函数（a）{
如果（a.id==0）{
返回false；
}
if（对象中的a.id）{
返回true；
}
对象[a.id]=真；
});
文件。书写（副本）如果数据只是对象，则可以编写一个函数来检查两个对象是否相等

Object.prototype.equals = function(x)
{
    for(p in this)
    {
        switch(typeof(this[p]))
        {
            case 'object':
                if (!this[p].equals(x[p])) { return false }; break;
            case 'function':
                if (typeof(x[p])=='undefined' || (p != 'equals' && this[p].toString() != x[p].toString())) { return false; }; break;
            default:
                if (this[p] != x[p]) { return false; }
        }
    }

    for(p in x)
    {
        if(typeof(this[p])=='undefined') {return false;}
    }

    return true;
}

然后使用for循环

    function isDuplicatedata( data ) {
    for( var i = 0; i < data.length - 1; i ++ ) {
        for( var j = i + 1; j < data.length; j ++ ) {
            if( data[i].equals(data[j])) {
                return true;
            }
        }
    }

    return false;
}

函数isDuplicatedata（数据）{
对于（var i=0；i

使用此方法，您可以检查任何类型的数据。请注意，此方法的复杂性为O（n^2）。
当您使用
lodash
时，您可以这样做：

var data = [{id: 0},  {id: 1}, {id: 3}, {id: 0}];

// group by id
var result = _.groupBy(data, function (item) {
     return item.id;
});

// remove the 0
delete result[0]

// check if there are duplicates
var isDuplicatedData = _.some(Object.keys(result), function (k) {
     return result[k].length > 1;
});

如果您没有lodash，以下是纯javascript中使用的函数：

var groupBy = function(arr, grouper) {
    var map = {};
    (arr || []).forEach(function(element) {
        var key = grouper(element);
        map[key] = map[key] || [];
        map[key].push(element);
    });
    return map;
 };
var some = function (arr, predicate) {
    return (arr || []).reduce(function (a, b) {
        return a || predicate(b);
    }, false);
};

下面是一个带有
lodash
-one:
的jsfiddle:
null
，您实际上是指0吗？因为它产生了巨大的差异。答案应该是错误的，因为0不包括在检查中非常干净、简洁和高效。这段代码很好用，但是为什么要比较字符串化数组和数组呢？右边的数组隐式转换为字符串，请看啊，因此您的代码依赖于等式运算符执行的类型强制。是的，没错，为了增强简洁性，以在最短答案中领先此线程的高分排名，请努力提高质量并理解问题，而不是担心字节数减少：）
var data = [{id: 0}, {id: 1}, {id: 3}, {id: 0},];         
var checkdata= data.map(function(item){ return item.id })
    .filter(function(item){ return item !== 0 });
var isDuplicatedata = checkdata.sort() + "" != checkdata.sort().reduce(function(p, c){
    if (c != p[0]) p.unshift(c);
    return p;
}, []).sort();

alert(isDuplicatedata)