it-swarm.com.ru

Удалить дубликаты из массива объектов в JavaScript

У меня есть объект, который содержит массив объектов.

things = new Object();

things.thing = new Array();

things.thing.Push({place:"here",name:"stuff"});
things.thing.Push({place:"there",name:"morestuff"});
things.thing.Push({place:"there",name:"morestuff"});

Мне интересно, каков наилучший способ удалить дубликаты объектов из массива. Так, например, вещи. Все станет ...

{place:"here",name:"stuff"},
{place:"there",name:"morestuff"}
220
Travis

Давайте посмотрим ... примитивным будет:

var obj = {};

for ( var i=0, len=things.thing.length; i < len; i++ )
    obj[things.thing[i]['place']] = things.thing[i];

things.thing = new Array();
for ( var key in obj )
    things.thing.Push(obj[key]);

Хорошо, я думаю, что это должно сработать. Проверьте это, Трэвис.

ПРАВКА
Отредактировал код для правильной ссылки на свойство place (прежнее id).

122
aefxx

Как насчет магии es6?

things.thing = things.thing.filter((thing, index, self) =>
  index === self.findIndex((t) => (
    t.place === thing.place && t.name === thing.name
  ))
)

Ссылочный URL

Для интерфейсов это может быть немного рано для реализации, так как многие используемые браузеры все еще не поддерживают функции es6

249
Eydrian

Если вы можете использовать библиотеки Javascript, такие как underscore или lodash, я рекомендую взглянуть на функцию _.uniq в их библиотеках. От lodash:

_.uniq(array, [isSorted=false], [callback=_.identity], [thisArg])

По сути, вы передаете массив, который здесь является литералом объекта, и передаете атрибут, с которым вы хотите удалить дубликаты, в исходном массиве данных, например так:

var data = [{'name': 'Amir', 'surname': 'Rahnama'}, {'name': 'Amir', 'surname': 'Stevens'}];
var non_duplidated_data = _.uniq(data, 'name'); 

UPDATE: Lodash теперь также ввел .uniqBy

73
ambodi

У меня было точно такое же требование, чтобы удалить дубликаты объектов в массиве на основе дубликатов в одном поле. Я нашел код здесь: Javascript: удаление дубликатов из массива объектов

Так что в моем примере я удаляю любой объект из массива, который имеет повторяющееся строковое значение licenseNum.

var arrayWithDuplicates = [
    {"type":"LICENSE", "licenseNum": "12345", state:"NV"},
    {"type":"LICENSE", "licenseNum": "A7846", state:"CA"},
    {"type":"LICENSE", "licenseNum": "12345", state:"OR"},
    {"type":"LICENSE", "licenseNum": "10849", state:"CA"},
    {"type":"LICENSE", "licenseNum": "B7037", state:"WA"},
    {"type":"LICENSE", "licenseNum": "12345", state:"NM"}
];

function removeDuplicates(originalArray, prop) {
     var newArray = [];
     var lookupObject  = {};

     for(var i in originalArray) {
        lookupObject[originalArray[i][prop]] = originalArray[i];
     }

     for(i in lookupObject) {
         newArray.Push(lookupObject[i]);
     }
      return newArray;
 }

var uniqueArray = removeDuplicates(arrayWithDuplicates, "licenseNum");
console.log("uniqueArray is: " + JSON.stringify(uniqueArray));

Результаты, достижения:

uniqueArray - это: 

[{"type":"LICENSE","licenseNum":"10849","state":"CA"},
{"type":"LICENSE","licenseNum":"12345","state":"NM"},
{"type":"LICENSE","licenseNum":"A7846","state":"CA"},
{"type":"LICENSE","licenseNum":"B7037","state":"WA"}]
54
James Drinkard

Если вы можете ждать устранения дубликатов до тех пор, пока не завершатся все добавления, типичным подходом будет сначала отсортировать массив, а затем удалить дубликаты. Сортировка избегает подхода N * N сканирования массива для каждого элемента, когда вы проходите через них.

Функция «устранить дубликаты» обычно называется unique или uniq. Некоторые существующие реализации могут объединять два этапа, например, uniq прототипа

В этом посте есть несколько идей, которые можно попробовать (и некоторые, которых следует избегать :-)) если в вашей библиотеке их еще нет! Лично я нахожу это самым прямым:

    function unique(a){
        a.sort();
        for(var i = 1; i < a.length; ){
            if(a[i-1] == a[i]){
                a.splice(i, 1);
            } else {
                i++;
            }
        }
        return a;
    }  

    // Provide your own comparison
    function unique(a, compareFunc){
        a.sort( compareFunc );
        for(var i = 1; i < a.length; ){
            if( compareFunc(a[i-1], a[i]) === 0){
                a.splice(i, 1);
            } else {
                i++;
            }
        }
        return a;
    }
21
maccullt

Вот еще один вариант сделать это с помощью итерационных методов Array, если вам нужно сравнение только по одному полю объекта:

    function uniq(a, param){
        return a.filter(function(item, pos, array){
            return array.map(function(mapItem){ return mapItem[param]; }).indexOf(item[param]) === pos;
        })
    }

    uniq(things.thing, 'place');
18
Alex Kobylinski

Один лайнер, используя Set

var things = new Object();

things.thing = new Array();

things.thing.Push({place:"here",name:"stuff"});
things.thing.Push({place:"there",name:"morestuff"});
things.thing.Push({place:"there",name:"morestuff"});

// assign things.thing to myData for brevity
var myData = things.thing;

things.thing = Array.from(new Set(myData.map(JSON.stringify))).map(JSON.parse);

console.log(things.thing)

Объяснение:

  1. new Set(myData.map(JSON.stringify)) создает объект Set , используя строковые элементы myData. 
  2. Установка объекта гарантирует, что каждый элемент уникален. 
  3. Затем я создаю массив на основе элементов созданного набора, используя Array.from. 
  4. Наконец, я использую JSON.parse, чтобы преобразовать строковый элемент обратно в объект.
18
Mμ.

ОБНОВЛЕНО

Я сейчас правильно прочитал вопрос. Это общий способ сделать это: вы передаете функцию, которая проверяет, считаются ли два элемента массива равными. В этом случае сравниваются значения свойств name и place двух сравниваемых объектов.

function arrayContains(arr, val, equals) {
    var i = arr.length;
    while (i--) {
        if ( equals(arr[i], val) ) {
            return true;
        }
    }
    return false;
}

function removeDuplicates(arr, equals) {
    var originalArr = arr.slice(0);
    var i, len, j, val;
    arr.length = 0;

    for (i = 0, len = originalArr.length; i < len; ++i) {
        val = originalArr[i];
        if (!arrayContains(arr, val, equals)) {
            arr.Push(val);
        }
    }
}

function thingsEqual(thing1, thing2) {
    return thing1.place === thing2.place
        && thing1.name === thing2.name;
}

removeDuplicates(things.thing, thingsEqual);
14
Tim Down

один лайнер здесь

let arr = [
  {id:1,name:"sravan ganji"},
  {id:2,name:"anu"},
  {id:4,name:"mammu"},
  {id:3,name:"sanju"},
  {id:3,name:"ram"},
];

console.log(Object.values(arr.reduce((acc,cur)=>Object.assign(acc,{[cur.id]:cur}),{})))

13
sravan kumar ganji

Добавить еще один в список. Использование ES6 и Array.reduce с Array.find.
В этом примере выполняется фильтрация объектов на основе свойства guid

let filtered = array.reduce((accumulator, current) => {
  if (! accumulator.find(({guid}) => guid === current.guid)) {
    accumulator.Push(current);
  }
  return accumulator;
}, []);

Расширение этого, чтобы позволить выбор свойства и сжать его в один лайнер:

const uniqify = (array, key) => array.reduce((prev, curr) => prev.find(a => a[key] === curr[key]) ? prev : prev.Push(curr) && prev, []);

Чтобы использовать его, передайте массив объектов и имя ключа, на котором вы хотите дедуплицировать, в виде строкового значения:

const result = uniqify(myArrayOfObjects, 'guid')
10
Pete B

Черт, дети, давайте раздавим эту штуку, почему бы и нет?

let uniqIds = {}, source = [{id:'a'},{id:'b'},{id:'c'},{id:'b'},{id:'a'},{id:'d'}];
let filtered = source.filter(obj => !uniqIds[obj.id] && (uniqIds[obj.id] = true));
console.log(filtered);
// EXPECTED: [{id:'a'},{id:'b'},{id:'c'},{id:'d'}];

8
Cliff Hall

var uniq = {}
var arr  = [{"id":"1"},{"id":"1"},{"id":"2"}]
var arrFiltered = arr.filter(obj => !uniq[obj.id] && (uniq[obj.id] = true));
console.log('arrFiltered', arrFiltered)

7
аlex dykyі

Учитывая lodash.uniqWith

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];

_.uniqWith(objects, _.isEqual);
// => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
7
Justin

Другой вариант - создать пользовательскую функцию indexOf, которая сравнивает значения выбранного вами свойства для каждого объекта и заключает его в функцию сокращения. 

var uniq = redundant_array.reduce(function(a,b){
      function indexOfProperty (a, b){
          for (var i=0;i<a.length;i++){
              if(a[i].property == b.property){
                   return i;
               }
          }
         return -1;
      }

      if (indexOfProperty(a,b) < 0 ) a.Push(b);
        return a;
    },[]);
7
ZeroSum

Вы также можете использовать Map:

const dedupThings = Array.from(things.thing.reduce((m, t) => m.set(t.place, t), new Map()).values());

Полный образец:

const things = new Object();

things.thing = new Array();

things.thing.Push({place:"here",name:"stuff"});
things.thing.Push({place:"there",name:"morestuff"});
things.thing.Push({place:"there",name:"morestuff"});

const dedupThings = Array.from(things.thing.reduce((m, t) => m.set(t.place, t), new Map()).values());

console.log(JSON.stringify(dedupThings, null, 4));

Результат:

[
    {
        "place": "here",
        "name": "stuff"
    },
    {
        "place": "there",
        "name": "morestuff"
    }
]
7
Pragmateek
let data = [
  {
    'name': 'Amir',
    'surname': 'Rahnama'
  }, 
  {
    'name': 'Amir',
    'surname': 'Stevens'
  }
];
let non_duplicated_data = _.uniqBy(data, 'name');
5
qzttt

Вот решение для es6, где вы хотите сохранить только последний элемент. Это решение является функциональным и соответствует стилю Airbnb.

const things = {
  thing: [
    { place: 'here', name: 'stuff' },
    { place: 'there', name: 'morestuff1' },
    { place: 'there', name: 'morestuff2' }, 
  ],
};

const removeDuplicates = (array, key) => {
  return array.reduce((arr, item) => {
    const removed = arr.filter(i => i[key] !== item[key]);
    return [...removed, item];
  }, []);
};

console.log(removeDuplicates(things.thing, 'place'));
// > [{ place: 'here', name: 'stuff' }, { place: 'there', name: 'morestuff2' }]
4
Micah

метод removeDuplicates () принимает массив объектов и возвращает новый массив без дубликатов объектов (на основе свойства id).

const allTests = [
  {name: 'Test1', id: '1'}, 
  {name: 'Test3', id: '3'},
  {name: 'Test2', id: '2'},
  {name: 'Test2', id: '2'},
  {name: 'Test3', id: '3'}
];

function removeDuplicates(array) {
  let uniq = {};
  return array.filter(obj => !uniq[obj.id] && (uniq[obj.id] = true))
}

removeDuplicates(allTests);

Ожидаемый результат:

[
  {name: 'Test1', id: '1'}, 
  {name: 'Test3', id: '3'},
  {name: 'Test2', id: '2'}
];

Сначала мы устанавливаем значение переменной uniq для пустого объекта.

Далее мы фильтруем массив объектов. Фильтр создает новый массив со всеми элементами, которые проходят тест, реализованный предоставленной функцией.

return array.filter(obj => !uniq[obj.id] && (uniq[obj.id] = true));

Выше мы используем функцию короткого замыкания &&. Если левая часть && имеет значение true, тогда она возвращает значение справа от &&. Если левая сторона ложна, она возвращает то, что находится слева от &&.

Для каждого объекта (obj) мы проверяем uniq для свойства, называемого значением obj.id (в этом случае на первой итерации оно проверяет свойство '1'.) Мы хотим противоположность того, что возвращает (либо true или ложь) именно поэтому мы используем! в! uniq [obj.id]. Если uniq уже имеет свойство id, он возвращает true, что означает ложь (!), Указывающую функции фильтра НЕ добавлять этот объект. Однако, если он не находит свойство obj.id, он возвращает значение false, которое затем оценивается как true (!) И возвращает все справа от && или (uniq [obj.id] = true). Это истинное значение, говорящее методу фильтра добавить obj к возвращаемому массиву, а также добавляет свойство {1: true} в uniq. Это гарантирует, что любой другой экземпляр obj с тем же идентификатором не будет добавлен снова.

3
MarkN
let myData = [{place:"here",name:"stuff"}, 
 {place:"there",name:"morestuff"},
 {place:"there",name:"morestuff"}];


let q = [...new Map(myData.map(obj => [JSON.stringify(obj), obj])).values()];

console.log(q)

Однострочное использование ES6 и new Map().

// assign things.thing to myData
let myData = things.thing;

[...new Map(myData.map(obj => [JSON.stringify(obj), obj])).values()];

Подробности:-

  1. Выполнение функции .map() в списке данных и преобразование каждого отдельного объекта в массив пар [key, value] (длина = 2), первый элемент (ключ) будет версия объекта stringified, а второй (значение) будет сам object.
  2. Добавление списка созданных выше массивов к new Map() будет иметь ключ как объект stringified, и любое добавление того же ключа приведет к переопределению уже существующего ключа.
  3. Использование .values() даст MapIterator со всеми значениями на карте (obj в нашем случае)
  4. Наконец, оператор spread ... для выдачи нового массива со значениями из предыдущего шага.
2
Savan Akbari

Продолжая исследовать способы удаления дубликатов из массива объектов ES6: установка аргумента thisArg для Array.prototype.filter в new Set предоставляет достойную альтернативу:

const things = [
  {place:"here",name:"stuff"},
  {place:"there",name:"morestuff"},
  {place:"there",name:"morestuff"}
];

const filtered = things.filter(function({place, name}) {

  const key =`${place}${name}`;

  return !this.has(key) && this.add(key);

}, new Set);

console.log(filtered);

Однако он не будет работать с функциями стрелок () =>, так как this связан с их лексической областью действия.

2
Leonid Pyrlia

Если вы не хотите указывать список свойств:

function removeDuplicates(myArr) {
  var props = Object.keys(myArr[0])
  return myArr.filter((item, index, self) =>
    index === self.findIndex((t) => (
      props.every(prop => {
        return t[prop] === item[prop]
      })
    ))
  )
}

OBS! Не совместим с IE11.

2
stoatoffear

Вы слышали о библиотеке Лодаш? Я рекомендую вам эту утилиту, когда вы действительно не хотите применять свою логику к коду и использовать уже существующий код, который оптимизирован и надежен. 

Подумайте о создании такого массива

things.thing.Push({place:"utopia",name:"Unicorn"});
things.thing.Push({place:"jade_palace",name:"po"});
things.thing.Push({place:"jade_palace",name:"tigress"});
things.thing.Push({place:"utopia",name:"flying_reindeer"});
things.thing.Push({place:"panda_village",name:"po"});

Обратите внимание, что если вы хотите сохранить один атрибут уникальным, вы можете сделать это с помощью библиотеки lodash. Здесь вы можете использовать _.uniqBy

.uniqBy (массив, [iteratee = .identity])

Этот метод похож на _.uniq (который возвращает версию массива без дубликатов, в которой сохраняется только первое вхождение каждого элемента), за исключением того, что он принимает iteratee, который вызывается для каждого элемента в массиве для генерации критерий, по которому вычисляется уникальность.

Так, например, если вы хотите вернуть массив, имеющий уникальный атрибут 'place'

_.uniqBy (things.thing, 'place')

Точно так же, если вы хотите уникальный атрибут как «имя»

_.uniqBy (things.thing, 'name')

Надеюсь это поможет.

Ура!

2
Mayank Gangwal

Если вы не возражаете против сортировки вашего уникального массива впоследствии, это будет эффективным решением:

things.thing
  .sort(((a, b) => a.place < b.place)
  .filter((current, index, array) =>
    index === 0 || current.place !== array[index - 1].place)

Таким образом, вам нужно только сравнить текущий элемент с предыдущим элементом в массиве. Сортировка один раз перед фильтрацией (O(n*log(n))) дешевле, чем поиск дубликата во всем массиве для каждого элемента массива (O(n²)).

2
Clemens Helm

Другим способом было бы использовать функцию Reduce и иметь новый массив, чтобы быть аккумулятором. Если в массиве аккумуляторов уже есть thing с таким именем, не добавляйте его туда.

let list = things.thing;
list = list.reduce((accumulator, thing) => {
    if (!accumulator.filter((duplicate) => thing.name === duplicate.name)[0]) {
        accumulator.Push(thing);
    }
    return accumulator;
}, []);
thing.things = list;

Я добавляю этот ответ, потому что я не смог найти хорошее, удобочитаемое решение es6 (я использую babel для обработки функций стрелок), которое совместимо с Internet Explorer 11. Проблема в том, что IE11 не имеет Map.values() или Set.values() без полизаполнения. По той же причине я использовал filter()[0], чтобы получить первый элемент вместо find().

1
Keammoort

Источник

JSFiddle

Это удалит дубликат объекта без передачи ключа.

uniqueArray = a => [...new Set(a.map(o => JSON.stringify(o)))].map(s => JSON.parse(s));

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];

var unique = uniqueArray(objects);
console.log('Original Object',objects);
console.log('Unique',unique);
uniqueArray = a => [...new Set(a.map(o => JSON.stringify(o)))].map(s => JSON.parse(s));

    var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];

    var unique = uniqueArray(objects);
    console.log(objects);
    console.log(unique);
1
Suhail AKhtar
 var testArray= ['a','b','c','d','e','b','c','d'];

 function removeDuplicatesFromArray(arr){

 var obj={};
 var uniqueArr=[];
 for(var i=0;i<arr.length;i++){ 
    if(!obj.hasOwnProperty(arr[i])){
        obj[arr[i]] = arr[i];
        uniqueArr.Push(arr[i]);
    }
 }

return uniqueArr;

}
var newArr = removeDuplicatesFromArray(testArray);
console.log(newArr);

Output:- [ 'a', 'b', 'c', 'd', 'e' ]
1
shubham verma

Если вам часто приходится удалять дубликаты объектов из массивов, основанных на определенных полях, возможно, стоит создать функцию distinct(array, predicate), которую можно импортировать из любого места в вашем проекте. Это будет выглядеть как

const things = [{place:"here",name:"stuff"}, ...];
const distinctThings = distinct(things, thing => thing.place);

Отличная функция может использовать любую из реализаций, приведенных во многих хороших ответах выше. Самый простой из них использует findIndex:

const distinct = (items, predicate) => items.filter((uniqueItem, index) =>
    items.findIndex(item =>
        predicate(item) === predicate(uniqueItem)) === index);
0
Elphas Tori

Вы можете использовать Object.values ​​() в сочетании с Array.prototype.reduce () :

const things = new Object();

things.thing = new Array();

things.thing.Push({place:"here",name:"stuff"});
things.thing.Push({place:"there",name:"morestuff"});
things.thing.Push({place:"there",name:"morestuff"});

const result = Object.values(things.thing.reduce((a, c) => (a[`${c.place}${c.name}`] = c, a), {})); 

console.log(result);
.as-console-wrapper { max-height: 100% !important; top: 0; }
0
Yosvel Quintero
str =[
{"item_id":1},
{"item_id":2},
{"item_id":2}
]

obj =[]
for (x in str){
    if(check(str[x].item_id)){
        obj.Push(str[x])
    }   
}
function check(id){
    flag=0
    for (y in obj){
        if(obj[y].item_id === id){
            flag =1
        }
    }
    if(flag ==0) return true
    else return false

}
console.log(obj)

str - массив объектов. Существуют объекты, имеющие одинаковое значение (здесь небольшой пример, есть два объекта с одинаковым item_id, равным 2). check (id) - это функция, которая проверяет, существует ли какой-либо объект с таким же item_id или нет. если он существует, вернуть false, иначе вернуть true. В соответствии с этим результатом поместите объект в новый массив obj Вывод приведенного выше кода: [{"item_id":1},{"item_id":2}]

0
Bibin Jaimon

Общий для любого массива объектов:

/**
* Remove duplicated values without losing information
*/
const removeValues = (items, key) => {
  let tmp = {};

  items.forEach(item => {
    tmp[item[key]] = (!tmp[item[key]]) ? item : Object.assign(tmp[item[key]], item);
  });
  items = [];
  Object.keys(tmp).forEach(key => items.Push(tmp[key]));

  return items;
}

Надеюсь, это может кому-нибудь помочь.

0
aSoler

Решение TypeScript

Это удалит дубликаты объектов, а также сохранит типы объектов.

function removeDuplicateObjects(array: any[]) {
  return [...new Set(array.map(s => JSON.stringify(s)))]
    .map(s => JSON.parse(s));
}
0
K48

Простое решение с ES6 вспомогательными методами «уменьшить» и «найти» массива

Работает качественно и отлично отлично!

"use strict";

var things = new Object();
things.thing = new Array();
things.thing.Push({
    place: "here",
    name: "stuff"
});
things.thing.Push({
    place: "there",
    name: "morestuff"
});
things.thing.Push({
    place: "there",
    name: "morestuff"
});

// the logic is here

function removeDup(something) {
    return something.thing.reduce(function (prev, ele) {
        var found = prev.find(function (fele) {
            return ele.place === fele.place && ele.name === fele.name;
        });
        if (!found) {
            prev.Push(ele);
        }
        return prev;
    }, []);
}
console.log(removeDup(things));
0
KJ Sudarshan

Вы можете преобразовать объекты массива в строки, чтобы их можно было сравнивать, добавить строки в набор, чтобы сопоставимые дубликаты были автоматически удалены, а затем преобразовать каждую строку обратно в объекты.

Это может быть не так эффективно, как другие ответы, но это читабельно.

const things = {};

things.thing = [];
things.thing.Push({place:"here",name:"stuff"});
things.thing.Push({place:"there",name:"morestuff"});
things.thing.Push({place:"there",name:"morestuff"});

const uniqueArray = (arr) => {

  const stringifiedArray = arr.map((item) => JSON.stringify(item));
  const set = new Set(stringifiedArray);

  return Array.from(set).map((item) => JSON.parse(item));
}

const uniqueThings = uniqueArray(things.thing);

console.log(uniqueThings);
0
TheDarkIn1978

вот мое решение, оно ищет дубликаты на основе object.prop и когда находит дублирующий объект, оно replaces its value в массиве 1 with array2 value

function mergeSecondArrayIntoFirstArrayByProperty(array1, array2) {
    for (var i = 0; i < array2.length; i++) {
        var found = false;
        for (var j = 0; j < array1.length; j++) {
            if (array2[i].prop === array1[j].prop) { // if item exist in array1
                array1[j] = array2[i]; // replace it in array1 with array2 value
                found = true;
            }
        }
        if (!found) // if item in array2 not found in array1, add it to array1
            array1.Push(array2[i]);

    }
    return array1;
}
0
Basheer AL-MOMANI
function filterDuplicateQueries(queries){
    let uniqueQueries = [];
     queries.forEach((l, i)=>{
        let alreadyExist = false;
        if(uniqueQueries.length>0){
            uniqueQueries.forEach((k, j)=>{
                if(k.query == l.query){
                    alreadyExist = true;
                }
            });
        }
        if(!alreadyExist){
           uniqueQueries.Push(l)
        }
    });
0
ARUN ARUMUGAM
  • Это решение является общим для любого вида объектов и проверяет каждый (key, value)Object в массиве. 
  • Использование временного объекта в качестве хеш-таблицы, чтобы увидеть, присутствовал ли когда-либо весь Object в качестве ключа.
  • Если строковое представление Object найдено, то этот элемент удаляется из массива.

var arrOfDup = [{'id':123, 'name':'name', 'desc':'some desc'},
                {'id':125, 'name':'another name', 'desc':'another desc'},
                {'id':123, 'name':'name', 'desc':'some desc'},
                {'id':125, 'name':'another name', 'desc':'another desc'},
                {'id':125, 'name':'another name', 'desc':'another desc'}];

function removeDupes(dupeArray){
  let temp = {};
  let tempArray = JSON.parse(JSON.stringify(dupeArray));
  dupeArray.forEach((item, pos) => {
    if(temp[JSON.stringify(item)]){
      tempArray.pop();
    }else{
      temp[JSON.stringify(item)] = item;
    }
  });
 return tempArray;
}

arrOfDup = removeDupes(arrOfDup);

arrOfDup.forEach((item, pos) => {
  console.log(`item in array at position ${pos} is ${JSON.stringify(item)}`);
});

0
Amardeep Bhowmick
const uniqueElements = (arr, fn) => arr.reduce((acc, v) => {
    if (!acc.some(x => fn(v, x))) { acc.Push(v); }
    return acc;
}, []);

const stuff = [
    {place:"here",name:"stuff"},
    {place:"there",name:"morestuff"},
    {place:"there",name:"morestuff"},
];

const unique = uniqueElements(stuff, (a,b) => a.place === b.place && a.name === b.name );
//console.log( unique );

[{
    "place": "here",
    "name": "stuff"
  },
  {
    "place": "there",
    "name": "morestuff"
}]
0
wLc

eS6 магия в одну строку ... читается при этом!

// returns the union of two arrays where duplicate objects with the same 'prop' are removed
const removeDuplicatesWith = (a, b, prop) => a.filter(x => !b.find(y => x[prop] === y[prop]);
0
Josiah Coad

Вот решение, использующее новую функцию фильтра JavaScript, которая довольно проста. Допустим, у вас есть такой массив.

var duplicatesArray = ['AKASH','AKASH','NAVIN','HARISH','NAVIN','HARISH','AKASH','MANJULIKA','AKASH','TAPASWENI','MANJULIKA','HARISH','TAPASWENI','AKASH','MANISH','HARISH','TAPASWENI','MANJULIKA','MANISH'];

Функция фильтра позволит вам создать новый массив, используя функцию обратного вызова один раз для каждого элемента в массиве. Таким образом, вы можете настроить уникальный массив следующим образом.

var uniqueArray = duplicatesArray.filter(function(elem, pos) {return duplicatesArray.indexOf(elem) == pos;});

В этом случае ваш уникальный массив будет проходить через все значения в дублирующем массиве. Переменная elem представляет значение элемента в массиве (mike, james, james, alex), позиция - это позиция с 0 индексами в массиве (0,1,2,3 ...) и duplicatesArray. Значение indexOf (elem) - это просто индекс первого вхождения этого элемента в исходном массиве. Таким образом, поскольку элемент 'james' дублируется, когда мы перебираем все элементы в duplicatesArray и помещаем их в uniqueArray, при первом обращении к james наше значение "pos" равно 1, а наш indexOf (elem) равно 1, так что Джеймса выталкивают в uniqueArray. Во второй раз, когда мы нажимаем на Джеймса, наше значение "pos" равно 2, а наш indexOf (elem) по-прежнему равен 1 (потому что он находит только первый экземпляр элемента массива), поэтому дубликат не выдвигается. Поэтому наш uniqueArray содержит только уникальные значения.

Вот демонстрационная версия вышеупомянутой функции . Нажмите здесь, чтобы увидеть приведенный выше пример функции

0
HARISH TIWARY

Вот еще один способ найти номер дубликата и легко удалить его из объекта данных. «dupsCount» - количество дубликатов файлов. сначала отсортируйте данные, а затем удалите. это даст вам самое быстрое удаление дубликатов.

  dataArray.sort(function (a, b) {
            var textA = a.name.toUpperCase();
            var textB = b.name.toUpperCase();
            return (textA < textB) ? -1 : (textA > textB) ? 1 : 0;
        });
        for (var i = 0; i < dataArray.length - 1; ) {
            if (dataArray[i].name == dataArray[i + 1].name) {
                dupsCount++;
                dataArray.splice(i, 1);
            } else {
                i++;
            }
        }
0
HD..

Как насчет этого:

function dedupe(arr, compFn){
    let res = [];
    if (!compFn) compFn = (a, b) => { return a === b };
    arr.map(a => {if(!res.find(b => compFn(a, b))) res.Push(a)});
    return res;
}
0
zipper

Это простой способ, как убрать двуличие из массива объектов.

Я много работаю с данными, и это полезно для меня.

const data = [{name: 'AAA'}, {name: 'AAA'}, {name: 'BBB'}, {name: 'AAA'}];
function removeDuplicity(datas){
    return datas.filter((item, index,arr)=>{
    const c = arr.map(item=> item.name);
    return  index === c.indexOf(item.name)
  })
}

console.log(removeDuplicity(data))

выведет на консоль:

[[object Object] {
name: "AAA"
}, [object Object] {
name: "BBB"
}]
0
Juraj Sarissky

Если вам нужен уникальный массив, основанный на нескольких свойствах объекта, вы можете сделать это с картой и комбинировать свойства объекта.

    var hash = array.map(function(element){
        var string = ''
        for (var key in element){
            string += element[key]
        }
        return string
    })
    array = array.filter(function(element, index){
        var string = ''
        for (var key in element){
            string += element[key]
        }
        return hash.indexOf(string) == index
    })
0
ykay

Сделай что-нибудь простое. Фантазия хороша, но нечитаемый код бесполезен. Наслаждаться :-)

var a = [
        {
                executiveId: 6873702,
                largePhotoCircle: null,
                name: "John A. Cuomo",
                photoURL: null,
                primaryCompany: "VSE CORP",
                primaryTitle: "Chief Executive Officer, President and Director"
        },
        {
                executiveId: 6873702,
                largePhotoCircle: null,
                name: "John A. Cuomo",
                photoURL: null,
                primaryCompany: "VSE CORP",
                primaryTitle: "Chief Executive Officer, President and Director"
        },
        {
                executiveId: 6873703,
                largePhotoCircle: null,
                name: "John A. Cuomo",
                photoURL: null,
                primaryCompany: "VSE CORP",
                primaryTitle: "Chief Executive Officer, President and Director",
        }
];

function filterDuplicate(myArr, prop) {
      // Format - (1)

      // return myArr.filter((obj, pos, arr) => {
      //     return arr.map(mapObj => mapObj[prop]).indexOf(obj[prop]) === pos;
      // });

      // Format - (2)
      var res = {};
      var resArr = [];
      for (var elem of myArr) {
        res[elem.executiveId] = elem;
      }
      for (let [index, elem] of Object.entries(res)) {
        resArr.Push(elem);
      }
      return resArr;
  }
  
let finalRes = filterDuplicate(a,"executiveId");
console.log("finalResults : ",finalRes);
0
sg28