Question

我有一个数组如下

arr1 = [{
    'Name': 'Ken',
    'ProjectId': '123'
}, {
    'Name': 'Kris',
    'ProjectId': '223'
}, {
    'Name': 'Ken',
    'ProjectId': '223'
}, {
    'Name': 'Ben',
    'ProjectId': '229'
}, {
    'Name': 'Alex',
    'ProjectId': '222'
}, {
    'Name': 'Kris',
    'ProjectId': '786'
}]

我想要生成的数组，其中删除了基于名称的数组重复项，但是如果ProjectId = 123将其保留在数组中并删除其他重复

即在上面的示例中有2个重复名称为Ken但一个记录具有ProjectId = 123，在这种情况下考虑此记录并删除其他类似名称重复

此外，如果副本不包含ProjectId，则删除任何一个副本。例如：在上面的示例中，有2个重复项，名称为Kris，但没有ProjectId为123，在这种情况下考虑任何一个记录。

，即我得到的数组应该是这样的

[{
    'Name': 'Ken',
    'ProjectId': '123'
}, {
    'Name': 'Kris',
    'ProjectId': '223'
}, {
    'Name': 'Ben',
    'ProjectId': '229'
}, {
    'Name': 'Alex',
    'ProjectId': '222'
}]

或

[{
    'Name': 'Ken',
    'ProjectId': '123'
}, {
    'Name': 'Ben',
    'ProjectId': '229'
}, {
    'Name': 'Alex',
    'ProjectId': '222'
}, {
    'Name': 'Kris',
    'ProjectId': '786'
}]

Answer 1

function removeDuplicatesByName(arr) { 
    var obj = {};
    for(var i = 0; i < arr.length; i++) {
         obj[arr[i].Name] = arr[i];
    }
    var out = [];
    for(var key in obj)
        out.push(obj[key]);
    out.sort(function(a, b){ return a.ProjectId - b.ProjectId; });
    return out;
}

这使用了一个事实，即对象不能有重复键来按名称删除数组中的所有重复项。它返回它们按ProjectId排序，因为当它进入对象时排序将丢失。

Answer 2

JSFIDDLE DEMO

这应该有效。：）

var arr1 = [{
    'Name': 'Ken',
    'ProjectId': '123'
}, {
    'Name': 'Kris',
    'ProjectId': '223'
}, {
    'Name': 'Ken',
    'ProjectId': '223'
}, {
    'Name': 'Ben',
    'ProjectId': '229'
}, {
    'Name': 'Alex',
    'ProjectId': '222'
}, {
    'Name': 'Kris',
    'ProjectId': '786'
}];

var removeDups = function (array) {
    for (var i=0; i < array.length; i++) {
        var obj1 = array[i];
        for (var j=0; j < array.length; j++) {
            if (j==i)
                continue;
            var obj2 = array[j];

            if (obj1.Name == obj2.Name) {
                var indexToDelete = checkProject123(i, j);
                array.splice(indexToDelete-1, indexToDelete);
            }
        }
    }

    return array;
}

var checkProject123 = function (i, j) { 
    if (arr1[i].ProjectId == '123')
        return j; // Index i has projectId 123 so return j to be deleted.
    else if (arr1[j].ProjectId == '123')
        return i; // Index j has projectId 123 so return i to be deleted.
    else
        return i; // Neither of them have projectId 123 so delete the first one, idk
}

console.log(removeDups(arr1));

Answer 3

这是一个解决方案。您可以过滤输入数组并搜索当前元素位置是否与输入数组中的第一个结果相同，以消除重复项。

var arr1 = [{
    'Name': 'Ken',
    'ProjectId': '123'
}, {
    'Name': 'Kris',
    'ProjectId': '223'
}, {
    'Name': 'Ken',
    'ProjectId': '223'
}, {
    'Name': 'Ben',
    'ProjectId': '229'
}, {
    'Name': 'Alex',
    'ProjectId': '222'
}, {
    'Name': 'Kris',
    'ProjectId': '786'
}];

var result=arr1.filter(function(e,i,a){
  if (a.map(function(d) { return d['Name']; }).indexOf(e.Name) == i) {
    return e;
  }
})

console.log(result);

Answer 4

工作解决方案：

var arr1 = [{
    'Name': 'Ken',
    'ProjectId': '123'
}, {
    'Name': 'Kris',
    'ProjectId': '223'
}, {
    'Name': 'Ken',
    'ProjectId': '223'
}, {
    'Name': 'Ben',
    'ProjectId': '229'
}, {
    'Name': 'Alex',
    'ProjectId': '222'
}, {
    'Name': 'Kris',
    'ProjectId': '786'
}];

function filter(arr) {

    var i, j;

    for (i = 0; i < arr.length; i++) {
        for (j = i; j < arr.length; j++) {
            if (i === j) { continue; }
            if (arr[j].Name === arr[i].Name) {
                var spliceIndex = (arr[j].ProjectId === '123') ? i : j;

                arr.splice(spliceIndex, 1);
                j--;

                if (spliceIndex === i) {
                    i--;
                    break;
                }
            }
        }
    }

    return arr;
}

console.log(filter(arr1));

Answer 5

使用lodash的uniq功能。传入自定义比较器。他们的文档中的示例代码：

// using an iteratee function
_.uniq([1, 2.5, 1.5, 2], function(n) {
  return this.floor(n);
}, Math);
// → [1, 2.5]

或者采摘速记：

// using the `_.property` callback shorthand
_.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');

我相信underscore.js具有相同的功能。

在javascript中将数组与条件组合

5 个答案: