获取具有重复值的数组中的对象

Question

我需要从对象数组中获取元素，其中该对象的某个属性（本例中为name）被复制 - 换句话说，出现在数组中的某个其他对象中。

数据

var data = [ 
    {id:1, name:"sam", userid:"ACD"}, 
    {id:1, name:"ram", userid:"SDC"}, 
    {id:1, name:"sam", userid:"CSTR"} 
]; 

我需要检查所有的行，并得到所有地方name属性复制数组值。

预期输出：

[ 
    {id:1, name:"sam", userid:"ACD"}, 
    {id:1, name:"sam", userid:"CSTR"} 
] 

我的代码

Array.from(data).map(x => x.name) 

，但它返回所有的值。

代码不应该创建任何性能问题，因为数组将包含500多行。

Answer 1

您可以使用此一个衬垫，

let newdata = data.reduce((x, y) => x.findIndex(e=>e.name!=y.name)<0 ? [...x, y]: x, []) 

DEMO

var data = [ 
 
      {id:1,name:"sam", userid:"ACD"}, 
 
      {id:1,name:"ram", userid:"SDC"}, 
 
      {id:1,name:"sam", userid:"CSTR"} 
 
]; 
 

 
let newdata = data.reduce((x, y) => x.findIndex(e=>e.name!=y.name)<0 ? [...x, y]: x, []) 
 

 
console.log(newdata);

Answer 2

角是一个框架，而不是语言。您的问题中没有Angular。

让我明白，如果我理解的很好。你有一个对象数组，你想保留所有重复的元素并摆脱其他，好吗？你可以试试：

data.reduce((acc, value, i, arr) => { 
    if(acc.some(v => v.name === value.name)) return acc; 
    let filtered = arr.filter(v => v.name === value.name); 
    return filtered.length > 1 ? acc.concat(filtered) : acc; 
}, []); 

或者你可以排序的一审阵列，以提高性能：

const sort = (a, b) => a.name.toUpperCase() < b.name.toUpperCase() ? -1 : 1; 

let duplicates = []; 

let sortedArray = data.sort(sort); 

for(let i=0; i<sortedArray.length - 1; i++) { 
    if(sortedArray[i].name === sortedArray[i+1].name) { 
    duplicates.push(sortedArray[i], sortedArray[i+1]); 
    i++; 
    } 
} 

Answer 3

蛮力的方法是过滤阵列只保留这些元素与重复名称，如过滤器功能duplicateName所示。

// Is there more than one element in an array satisfying some predicate? 
 
const hasMultiple = (arr, pred) => arr.filter(pred).length > 1; 
 

 
// Is this element a duplicate in the context of the array? 
 
const duplicateName = (elt, idx, arr) => hasMultiple(arr, e => e.name === elt.name); 
 

 
// Test data. 
 
var data = [ 
 
    {id:1,name:"sam", userid:"ACD"}, 
 
    {id:1,name:"ram", userid:"SDC"}, 
 
    {id:1,name:"sam", userid:"CSTR"} 
 
]; 
 
    
 
console.log(data.filter(duplicateName));

然而，这将有许多元素的情况下表现不佳（O(n^2)）。为了解决这个问题，你需要预处理数组。我们将为每个名称创建一个具有属性的对象，其值是包含该名称出现的所有元素的数组。该操作通常称为groupBy。一些流行的库如下划线将为您提供这一点。我们会写我们自己的。分组后，我们将过滤组的对象以删除只有一个成员的组。

// Group an array by some predicate. 
 
const groupBy = (arr, pred) => arr.reduce((ret, elt) => { 
 
    const val = pred(elt); 
 
    (ret[val] = ret[val] || []).push(elt); 
 
    return ret; 
 
    }, {}); 
 
    
 
// Filter an object, based on a boolean callback. 
 
const filter = (obj, callback) => Object.keys(obj).reduce((res, key) => { 
 
    if (callback(obj[key], key, obj)) res[key] = obj[key]; 
 
    return res; 
 
    }, {}); 
 

 
// Remove groups with only one element. 
 
const removeNonDups = groups => filter(groups, group => group.length > 1); 
 

 
// Test data. 
 
var data = [ 
 
    {id:1,name:"sam", userid:"ACD"}, 
 
    {id:1,name:"ram", userid:"SDC"}, 
 
    {id:1,name:"sam", userid:"CSTR"} 
 
]; 
 

 
console.log(removeNonDups(groupBy(data, elt => elt.name)));