numeros - eliminar elementos repetidos de un array de objetos javascript

JavaScript: eliminar duplicados de objetos que comparten el mismo valor de propiedad

Question

Tengo una matriz de objetos que me gustaría recortar en función de una key:value específica key:value par de key:value . Quiero crear una matriz que incluya solo un objeto por esta key:value específica key:value par de key:value . No importa necesariamente qué objeto de los duplicados se copia a la nueva matriz.

Por ejemplo, quiero recortar según la propiedad price de arrayWithDuplicates , creando una nueva matriz que solo incluye uno de cada valor:

var arrayWithDuplicates = [
  {"color":"red", 
    "size": "small",
    "custom": {
      "inStock": true,
      "price": 10
    }
  },
  {"color":"green", 
    "size": "small",
    "custom": {
      "inStock": true,
      "price": 30
    }
  },
  {"color":"blue", 
    "size": "medium",
    "custom": {
      "inStock": true,
      "price": 30
    }
  },
  {"color":"red", 
    "size": "large",
    "custom": {
      "inStock": true,
      "price": 20
    }
  }
];

Se convertiría:

var trimmedArray = [
  {"color":"red", 
    "size": "small",
    "custom": {
      "inStock": true,
      "price": 10
    }
  },
  {"color":"green", 
    "size": "small",
    "custom": {
      "inStock": true,
      "price": 30
    }
  },
  {"color":"red", 
    "size": "large",
    "custom": {
      "inStock": true,
      "price": 20
    }
  }
];

¿Hay una función de JavaScript o angular que pueda recorrer y hacer esto?

EDITAR: la propiedad para filtrar está anidada dentro de otra propiedad.

Answer 1

En la parte superior de mi cabeza no hay una sola función que haga esto por ti, ya que estás tratando con una matriz de objetos y tampoco hay una regla para la que el duplicado sea eliminado como duplicado.

En el ejemplo, elimine el que tiene el size: small pero si lo implementa con un bucle, probablemente incluya el primero y excluya el último mientras recorre el conjunto.

Puede valer la pena echar un vistazo a una biblioteca como lodash y crear una función que utiliza una combinación de sus métodos API para obtener el comportamiento deseado que desee.

Aquí hay una posible solución que podría usar haciendo uso de Arrays básicos y una expresión de filtro para verificar si un nuevo elemento se consideraría un duplicado antes de adjuntarlo a un resultado de devolución.

var arrayWithDuplicates = [
    {"color":"red", "size": "small"},
    {"color":"green", "size": "small"},
    {"color":"blue", "size": "medium"},
    {"color":"red", "size": "large"}
];

var reduce = function(arr, prop) {
  var result = [],
      filterVal,
      filters,
      filterByVal = function(n) {
          if (n[prop] === filterVal) return true;
      };
  for (var i = 0; i < arr.length; i++) {
      filterVal = arr[i][prop];
      filters   = result.filter(filterByVal);
      if (filters.length === 0) result.push(arr[i]);
  }
  return result;
};

console.info(reduce(arrayWithDuplicates, ''color''));

Puede consultar algo de literatura sobre Filtrado de matrices aquí. Si necesita proporcionar una preferencia sobre qué elemento eliminar, puede definir parámetros adicionales y una lógica que haga comprobaciones de propiedades adicionales antes de agregar un valor de retorno.

¡Espero que ayude!

Answer 2

No creo que haya una función incorporada en Angular, pero no es difícil crear una:

function removeDuplicates(originalArray, objKey) {
  var trimmedArray = [];
  var values = [];
  var value;

  for(var i = 0; i < originalArray.length; i++) {
    value = originalArray[i][objKey];

    if(values.indexOf(value) === -1) {
      trimmedArray.push(originalArray[i]);
      values.push(value);
    }
  }

  return trimmedArray;

}

Uso:

removeDuplicates(arrayWithDuplicates, ''size'');

Devoluciones:

[
    {
        "color": "red",
        "size": "small"
    },
    {
        "color": "blue",
        "size": "medium"
    },
    {
        "color": "red",
        "size": "large"
    }
]

Y

removeDuplicates(arrayWithDuplicates, ''color'');

Devoluciones:

[
    {
        "color": "red",
        "size": "small"
    },
    {
        "color": "green",
        "size": "small"
    },
    {
        "color": "blue",
        "size": "medium"
    }
]

Answer 3

Puede usar guiones bajos para esto:

//by size:
var uSize = _.uniq(arrayWithDuplicates, function(p){ return p.size; });

//by custom.price;
var uPrice = _.uniq(arrayWithDuplicates, function(p){ return p.custom.price; });

Answer 4

Utilice Array.filter() , Array.filter() seguimiento de los valores mediante el uso de un Object como un hash y filtre los elementos cuyo valor ya está contenido en el hash.

function trim(arr, key) {
    var values = {};
    return arr.filter(function(item){
        var val = item[key];
        var exists = values[val];
        values[val] = true;
        return !exists;
    });
}

Answer 5

function removeDuplicatesBy(keyFn, array) {
  var mySet = new Set();
  return array.filter(function(x) {
    var key = keyFn(x), isNew = !mySet.has(key);
    if (isNew) mySet.add(key);
    return isNew;
  });
}

uso (las funciones de la flecha EcmaScript6 lo hacen ver mejor):

removeDuplicatesBy(x => x.custom.price, yourArrayWithDuplicates);

EDITAR: el fragmento editado no utiliza el nombre de la propiedad, sino que utiliza una función de selector de tecla para que pueda llegar a las propiedades anidadas.

Answer 6

usando lodash puedes filtrarlo fácilmente

el primer parámetro será tu matriz y el segundo será tu campo con duplicados

_.uniqBy(arrayWithDuplicates, ''color'')

devolverá una matriz con un valor único

Answer 7

Solución simple aunque no el más eficiente:

var unique = [];
duplicates.forEach(function(d) {
    var found = false;
    unique.forEach(function(u) {
        if(u.key == d.key) {
            found = true;
        }
    });
    if(!found) {
        unique.push(d);
    }
});

Answer 8

Aquí está el camino mecanografiado

    public removeDuplicates(originalArray:any[], prop) {
    let newArray = [];
    let lookupObject = {};

    originalArray.forEach((item, index) => {
        lookupObject[originalArray[index][prop]] = originalArray[index];
    });

    Object.keys(lookupObject).forEach(element => {
        newArray.push(lookupObject[element]);
    });
    return newArray;
}

Y

let output = this.removeDuplicates(yourArray,''color'');