Eliminar duplicados de una matriz de objetos en JavaScript

Tengo un objeto que contiene una matriz de objetos.

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"});

Me pregunto cuál es el mejor método para eliminar objetos duplicados de una matriz. Entonces, por ejemplo, las cosas se volverían ...

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

Un método primitivo sería:

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]);

¿Qué tal con algo de es6magia?

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

URL de referencia

Una solución más genérica sería:

const uniqueArray = things.thing.filter((thing, index) => {
  const _thing = JSON.stringify(thing);
  return index === things.thing.findIndex(obj => {
    return JSON.stringify(obj) === _thing;
  });
});

Ejemplo de Stackblitz

Si puede usar bibliotecas de Javascript, como subrayado o lodash, le recomiendo echar un vistazo a la _.uniqfunción en sus bibliotecas. De lodash:

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

Básicamente, pasa la matriz que aquí es un objeto literal y pasa el atributo con el que desea eliminar los duplicados en la matriz de datos original, de esta manera:

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

ACTUALIZACIÓN : Lodash ahora ha introducido un .uniqBytambién.

Tenía exactamente el mismo requisito, para eliminar objetos duplicados en una matriz, basados ​​en duplicados en un solo campo. Encontré el código aquí: Javascript: eliminar duplicados de la matriz de objetos

Entonces, en mi ejemplo, estoy eliminando cualquier objeto de la matriz que tenga un valor de cadena duplicado 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));

Los resultados:

uniqueArray es:

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

Los revestimientos más cortos para ES6 +

Encuentra los únicos iden una matriz.

arr.filter((v,i,a)=>a.findIndex(t=>(t.id === v.id))===i)

Único por múltiples propiedades ( placey name)

arr.filter((v,i,a)=>a.findIndex(t=>(t.place === v.place && t.name===v.name))===i)

Único por todas las propiedades (Esto será lento para matrices grandes)

arr.filter((v,i,a)=>a.findIndex(t=>(JSON.stringify(t) === JSON.stringify(v)))===i)

Mantener la última ocurrencia.

arr.slice().reverse().filter((v,i,a)=>a.findIndex(t=>(t.id === v.id))===i).reverse()

Un revestimiento usando 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)

Explicación:

1. new Set(myData.map(JSON.stringify))crea un objeto Set utilizando los elementos myData en cadena.
2. Establecer objeto asegurará que cada elemento sea único.
3. Luego creo una matriz basada en los elementos del conjunto creado usando Array.from.
4. Finalmente, uso JSON.parse para convertir el elemento stringified nuevamente en un objeto.

Usando ES6 + en una sola línea, puede obtener una lista única de objetos por clave:

const unique = [...new Map(arr.map(item => [item[key], item])).values()]

Se puede poner en una función:

function getUniqueListBy(arr, key) {
    return [...new Map(arr.map(item => [item[key], item])).values()]
}

Aquí hay un ejemplo de trabajo:

const arr = [
    {place: "here",  name: "x", other: "other stuff1" },
    {place: "there", name: "x", other: "other stuff2" },
    {place: "here",  name: "y", other: "other stuff4" },
    {place: "here",  name: "z", other: "other stuff5" }
]

function getUniqueListBy(arr, key) {
    return [...new Map(arr.map(item => [item[key], item])).values()]
}

const arr1 = getUniqueListBy(arr, 'place')

console.log("Unique by place")
console.log(JSON.stringify(arr1))

console.log("\nUnique by name")
const arr2 = getUniqueListBy(arr, 'name')

console.log(JSON.stringify(arr2))

Como funciona

Primero, la matriz se reasigna de manera que se pueda usar como entrada para un Mapa.

arr.map (item => [item [clave], item]);

lo que significa que cada elemento de la matriz se transformará en otra matriz con 2 elementos; la clave seleccionada como primer elemento y todo el elemento inicial como segundo elemento, esto se llama una entrada (por ejemplo , entradas de matriz , entradas de mapa ). Y aquí está el documento oficial con un ejemplo que muestra cómo agregar entradas de matriz en Map constructor.

Ejemplo cuando la clave es lugar :

[["here", {place: "here",  name: "x", other: "other stuff1" }], ...]

En segundo lugar, pasamos esta matriz modificada al constructor del Mapa y aquí está sucediendo la magia. Map eliminará los valores duplicados de las claves, manteniendo solo el último valor insertado de la misma clave. Nota : El mapa mantiene el orden de inserción. ( marque la diferencia entre Mapa y objeto )

Nuevo mapa (matriz de entrada recién mapeada arriba)

En tercer lugar, usamos los valores del mapa para recuperar los elementos originales, pero esta vez sin duplicados.

nuevo Map (mappedArr) .values ​​()

Y el último es agregar esos valores en una nueva matriz nueva para que pueda verse como la estructura inicial y devolver eso:

return [... new Map (mappedArr) .values ​​()]

Aquí hay otra opción para hacerlo utilizando los métodos de iteración de Array si necesita comparar solo un campo de un objeto:

    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');

un trazador de líneas está aquí

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}),{})))

Si puede esperar para eliminar los duplicados hasta después de todas las adiciones, el enfoque típico es primero ordenar la matriz y luego eliminar los duplicados. La clasificación evita el enfoque N * N de escanear la matriz para cada elemento a medida que los recorre.

La función "eliminar duplicados" generalmente se llama única o uniq . Algunas implementaciones existentes pueden combinar los dos pasos, por ejemplo, uniq de prototipo

¡Esta publicación tiene algunas ideas para probar (y algunas para evitar :-)) si su biblioteca aún no tiene una ! Personalmente, creo que este es el más sencillo:

    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;
    }

La forma más simple es usar filter:

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)

Esta es una forma genérica de hacer esto: pasa una función que prueba si dos elementos de una matriz se consideran iguales. En este caso, compara los valores de las propiedades namey placede los dos objetos que se comparan.

Respuesta ES5

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

    for (i = 0, len = originalArr.length; i < len; ++i) {
        val = originalArr[i];
        if (!arr.some(function(item) { return equals(item, val); })) {
            arr.push(val);
        }
    }
}

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

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

removeDuplicates(things, thingsEqual);
console.log(things);

Respuesta original de ES3

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);

Para agregar uno más a la lista. Usando ES6 y Array.reducecon Array.find.
En este ejemplo, filtrar objetos basados ​​en una guidpropiedad.

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

Extendiendo este para permitir la selección de una propiedad y comprimirla en un solo revestimiento:

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

Para usarlo, pase una matriz de objetos y el nombre de la clave que desea deducir como valor de cadena:

const result = uniqify(myArrayOfObjects, 'guid')

También puedes usar un Map:

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

Muestra completa:

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));

Resultado:

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

Dang, niños, aplastemos esto, ¿por qué no lo hacemos?

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'}];

Una solución TypeScript

Esto eliminará los objetos duplicados y también preservará los tipos de los objetos.

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

Considerando 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 }]

Otra opción sería crear una función indexOf personalizada, que compare los valores de su propiedad elegida para cada objeto y la ajuste en una función de reducción.

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;
    },[]);

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)

One-liner usando ES6 y new Map().

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

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

Detalles: -

1. Al hacer .map()en la lista de datos y convertir cada objeto individual en una [key, value]matriz de pares (longitud = 2), el primer elemento (clave) sería la stringifiedversión del objeto y el segundo (valor) sería unobject sí mismo.
2. Agregar la lista de matriz creada anteriormente new Map()tendría la clave como stringifiedobjeto y cualquier misma adición de clave resultaría en la anulación de la clave ya existente.
3. El uso .values()daría MapIterator con todos los valores en un Mapa (obj en nuestro caso)
4. Finalmente, spread ...operador para dar una nueva matriz con los valores del paso anterior.

Aquí hay una solución para es6 donde solo desea conservar el último elemento. Esta solución es funcional y cumple con el estilo 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' }]

removeDuplicates () toma una matriz de objetos y devuelve una nueva matriz sin ningún objeto duplicado (basado en la propiedad 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);

Gastos esperados:

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

Primero, establecemos el valor de la variable uniq en un objeto vacío.

A continuación, filtramos a través de la matriz de objetos. Filter crea una nueva matriz con todos los elementos que pasan la prueba implementada por la función proporcionada.

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

Arriba, utilizamos la funcionalidad de cortocircuito de &&. Si el lado izquierdo de && se evalúa como verdadero, entonces devuelve el valor a la derecha de &&. Si el lado izquierdo es falso, devuelve lo que está en el lado izquierdo de &&.

Para cada objeto (obj) verificamos uniq para una propiedad llamada valor de obj.id (en este caso, en la primera iteración verificaría la propiedad '1'). Queremos lo contrario de lo que devuelve (ya sea verdadero o falso) por eso usamos el! in! uniq [obj.id]. Si uniq ya tiene la propiedad id, devuelve verdadero que se evalúa como falso (!) Indicando a la función de filtro que NO agregue ese obj. Sin embargo, si no encuentra la propiedad obj.id, devuelve falso, que luego se evalúa como verdadero (!) Y devuelve todo a la derecha de &&, o (uniq [obj.id] = verdadero). Este es un valor verdadero, que le dice al método de filtro que agregue ese obj a la matriz devuelta, y también agrega la propiedad {1: true} a uniq. Esto asegura que cualquier otra instancia de obj con esa misma identificación no se agregará nuevamente.

let data = [
  {
    'name': 'Amir',
    'surname': 'Rahnama'
  }, 
  {
    'name': 'Amir',
    'surname': 'Stevens'
  }
];
let non_duplicated_data = _.uniqBy(data, 'name');

Creo que una combinación de reducecon JSON.stringifya la perfección comparar objetos y selectivamente la adición de los que no están ya en el acumulador es una manera elegante.

Tenga en cuenta que JSON.stringifypodría convertirse en un problema de rendimiento en casos extremos donde la matriz tiene muchos Objetos y son complejos, PERO para la mayoría de las veces , esta es la forma más corta de ir en mi humilde opinión.

var collection= [{a:1},{a:2},{a:1},{a:3}]

var filtered = collection.reduce((filtered, item) => {
  if( !filtered.some(filteredItem => JSON.stringify(filteredItem) == JSON.stringify(item)) )
    filtered.push(item)
  return filtered
}, [])

console.log(filtered)

Otra forma de escribir lo mismo (pero menos eficiente):

collection.reduce((filtered, item) => 
  filtered.some(filteredItem => 
    JSON.stringify(filteredItem ) == JSON.stringify(item)) 
      ? filtered
      : [...filtered, item]
, [])

Continuar explorando formas de ES6 de eliminar duplicados de una matriz de objetos: establecer el thisArgargumento de Array.prototype.filterto new Setproporciona una alternativa decente:

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);

Sin embargo, no funcionará con funciones de flecha () =>, ya que thisestá vinculado a su alcance léxico.

es6 magia en una línea ... ¡legible en eso!

// 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]);

Solución simple con los métodos auxiliares de matriz 'reduce' y 'find' de ES6

Funciona de manera eficiente y perfectamente bien!

"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));

Si no le importa que su matriz única se ordene después, esta sería una solución eficiente:

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

De esta manera, solo tiene que comparar el elemento actual con el elemento anterior en la matriz. Ordenar una vez antes de filtrar ( O(n*log(n))) es más barato que buscar un duplicado en toda la matriz para cada elemento de la matriz ( O(n²)).

Esta es una manera simple de cómo eliminar la duplicidad de la matriz de objetos.

Trabajo mucho con datos y esto es útil para mí.

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))

se imprimirá en la consola:

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

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 es una matriz de objetos. Existen objetos que tienen el mismo valor (aquí un pequeño ejemplo, hay dos objetos que tienen el mismo item_id que 2). check (id) es una función que verifica si existe o no algún objeto que tenga el mismo item_id. si existe, devuelve falso; de lo contrario, devuelve verdadero. De acuerdo con ese resultado, inserte el objeto en una nueva matriz obj La salida del código anterior es [{"item_id":1},{"item_id":2}]

¿Has oído hablar de la biblioteca Lodash? Le recomiendo esta utilidad, cuando realmente no desea aplicar su lógica al código, y usar el código ya presente que es optimizado y confiable.

Considere hacer una matriz como esta

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"});

Tenga en cuenta que si desea mantener un atributo único, puede hacerlo utilizando la biblioteca lodash. Aquí, puedes usar _.uniqBy

.uniqBy (matriz, [iteratee = .identity])

Este método es como _.uniq (que devuelve una versión libre de duplicados de una matriz, en la que solo se mantiene la primera aparición de cada elemento), excepto que acepta iteratee que se invoca para cada elemento de la matriz para generar el criterio por el cual Se calcula la unicidad.

Entonces, por ejemplo, si desea devolver una matriz que tenga un atributo único de 'lugar'

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

Del mismo modo, si desea un atributo único como 'nombre'

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

Espero que esto ayude.

¡Salud!