Eliminar duplicados de una matriz

Tengo una matriz de objetos que se parece a esto:

var array = [
    {id:123, value:"value1", name:"Name1"},
    {id:124, value:"value2", name:"Name1"},
    {id:125, value:"value3", name:"Name2"},
    {id:126, value:"value4", name:"Name2"}
    ...
];

Como puede ver, se repiten algunos nombres. Quiero obtener una nueva matriz solo con nombres, pero si algún nombre se repite, no quiero volver a agregarlo. Quiero esta matriz:

var newArray = ["Name1", "Name2"];

Estoy tratando de hacer esto con map:

var newArray = array.map((a) => {
    return a.name;
});

Pero el problema es que esto vuelve:

newArray = ["Name1", "Name1", "Name2", "Name2"];

¿Cómo puedo establecer alguna condición interna mappara que no devuelva un elemento que ya existe? Quiero hacer esto con mapo alguna otra característica de ECMAScript 5 o ECMAScript 6.

Con ES6, puede utilizar Setpara valores únicos, después de asignar solo los nombres de los objetos.

Esta propuesta utiliza una sintaxis de extensión... para recopilar los elementos en una nueva matriz.

const array = [{ id: 123, value: "value1", name:"Name1" }, { id: 124, value: "value2", name: "Name1" }, { id: 125, value: "value3", name: "Name2" }, { id: 126, value: "value4", name: "Name2" }],
      names = [...new Set(array.map(a => a.name))];

console.log(names);

Si está buscando una solución de JavaScript que no sea ES 6 (no Set), puede usar el método de Arrayreduce :

var array=[
  {id:123, value:"value1", name:"Name1"},
  {id:124, value:"value2", name:"Name1"},
  {id:125, value:"value3", name:"Name2"},
  {id:126, value:"value4", name:"Name2"}
];
var names = array.reduce(function (a, b) {
  if (a.indexOf(b.name) == -1) {
    a.push(b.name)
  }
  return a;
}, []);

console.log(names);

Personalmente, no veo por qué todo el mundo se está volviendo elegante con ES 6. Si fuera mi código, preferiría admitir tantos navegadores como sea posible.

var array=[
{id:123, value:"value1", name:"Name1"},
{id:124, value:"value2", name:"Name1"},
{id:125, value:"value3", name:"Name2"},
{id:126, value:"value4", name:"Name2"}
];

   // Create array of unique names
var a = (function(a){
  for (var i = array.length; i--;)
    if (a.indexOf(array[i].name) < 0) a.push(array[i].name);
  return a;
})([]);

console.log(a);

También puedes simplemente combinar mapconfilter

var array = [
  {id:123, value:"value1", name:"Name1"},
  {id:124, value:"value2", name:"Name1"},
  {id:125, value:"value3", name:"Name2"},
  {id:126, value:"value4", name:"Name2"}
];

var unique = array
  .map( item => item.name )
  .filter( ( item, idx, arr ) => arr.indexOf( item ) == idx ) 

console.log(unique)

Puede usar Object.keys () para obtener la matriz de los nombres de propiedad enumerables propios de un objeto dado del resultado del objeto de la arrayvariable iterativa con Array.prototype.reduce () donde las claves son los nombres destruidos

Código:

const array = [{id:123, value:"value1", name:"Name1"}, {id:124, value:"value2", name:"Name1"}, {id:125, value:"value3", name:"Name2"}, {id:126, value:"value4", name:"Name2"}],
      names = Object.keys(array.reduce((a, { name }) => (a[name] = 1, a), {}))

console.log(names)

Muchas buenas respuestas aquí. Solo me gustaría contribuir con algo de diversidad con la esperanza de darles otra perspectiva.

Las matrices son del tipo de objeto en JavaScript, por lo que se pueden usar como hash al mismo tiempo. Al utilizar esta funcionalidad, podemos simplificar enormemente el trabajo a realizar en una sola operación de reducción con una complejidad de tiempo O (n).

Si no está satisfecho con que su matriz tenga algunas propiedades distintas de las claves de la matriz, podría considerar mantener un objeto hash separado también.

var array = [{id:123, value:"value1", name:"Name1"},
             {id:124, value:"value2", name:"Name1"},
             {id:125, value:"value3", name:"Name2"},
             {id:126, value:"value4", name:"Name2"}
            ],
result = array.reduce((p,c) => p[c.name] ? p : (p[c.name] = true, p.push(c.name), p), []);
console.log(result);

Estoy de acuerdo en que si solo necesita los namevalores, a Setes el camino a seguir.

Sin embargo , si desea obtener una matriz de objetos únicos basados ​​en la namepropiedad, le sugiero que use un archivo Map. Una forma rápida de crear un mapa es a través de una matriz de [key, value]matrices:

const array = [{ id: 123, value: "value1", name:"Name1" }, { id: 124, value: "value2", name: "Name1" }, { id: 125, value: "value3", name: "Name2" }, { id: 126, value: "value4", name: "Name2" }],
      unique = new Map(array.map(obj => [obj.name, obj]));

// To get the unique objects
const uniques = Array.from(unique.values());

// Get the names like you already did:
console.log("Names:", uniques.map(obj => obj.name));

// If you ever need the complete array of unique objects, you got a ref:
console.log(JSON.stringify(uniques));

.as-console-wrapper { min-height: 100%; }

Un beneficio adicional Mapes que obtiene la filterfuncionalidad que elimina los no únicos, sin perder la conexión con los objetos de origen. Por supuesto, solo es necesario si necesita hacer referencia al conjunto único de objetos varias veces.

Si está limitado a ES5, usaría Lodash's_.uniq

var newArray = _.uniq(array.map(function(a) {
  return a.name;
}));

Con ES6 esto debería funcionar.

var array=[
    {id:123, value:"value1", name:"Name1"},
    {id:124, value:"value2", name:"Name1"},
    {id:125, value:"value3", name:"Name2"},
    {id:126, value:"value4", name:"Name2"}
];

var set = new Set();

array.forEach((a)=>{
    set.add(a.name);
}); 

console.log(Array.from(set));

Usando UnderscoreJS,

array = [{id:123, value:"value1", name:"Name1"}, {id:124, value:"value2", name:"Name1"}, {id:125, value:"value3", name:"Name2"}, {id:126, value:"value4", name:"Name2"}];
get_names =  _.pluck(_.uniq(array, 'name'), 'name')
console.log(get_names)

<script src="https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.8.3/underscore-min.js"></script>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js"></script>

'

En ES5, use un objeto como diccionario para el rendimiento de O ( n ).

Esto solo funcionará si todas las claves son cadenas.

var array = [
    {id: 123, value: "value1", name: "Name1"},
    {id: 124, value: "value2", name: "Name1"},
    {id: 125, value: "value3", name: "Name2"},
    {id: 126, value: "value4", name: "Name2"}
];

var allNames = array.map(item => item.name);

var map = {};
allNames.forEach(name => {
  map[name] = true;
});
var uniqueNames = Object.keys(map);

console.log(uniqueNames);

Puede hacer lo mismo en una expresión si lo desea:

var uniqueNames = Object.keys(allNames.reduce((m, n) => (m[n] = true, m), {}));

pero encuentro la forma imperativa más fácil de leer.

Prueba esto:

nArr = [];
array.forEach((a) => {
    if (nArr.indexOf(a.name) < 0) { 
        nArr.push(a.name); 
    }
}); 

Utilice métodos array#forEach()y array#indexOf()como este si desea la máxima compatibilidad , sintaxis concisa:

const array = [{ id: 123, value: "value1", name:"Name1" }, { id: 124, value: "value2", name: "Name1" }, { id: 125, value: "value3", name: "Name2" }, { id: 126, value: "value4", name: "Name2" }]

// initialize an empty array named names
let names = [];

// iterate through every element of `array` & check if it's 'name' key's value already in names array if not ADD it 
array.forEach(function(element) { if (names.indexOf(element.name) === -1) names.push(element.name) });
// or use tilde like this:
//array.forEach(function(element) { if (~names.indexOf(element.name)) names.push(element.name) });

console.log(names);

Sin embargo, si la compatibilidad es no es un problema uso ECMAScript 6 's Setde objeto, array#mapy Array.from()métodos como este:

const array = [{ id: 123, value: "value1", name:"Name1" }, { id: 124, value: "value2", name: "Name1" }, { id: 125, value: "value3", name: "Name2" }, { id: 126, value: "value4", name: "Name2" }];

// iterate through every element from array using map and store it in Set(a Set won't have duplicates) then convert the Set back to Array(using Array.from)
let names = Array.from(new Set(array.map(element => element.name)));

console.log(names);

Así es como lo hice, usando una matriz vacía separada.

var array = [
   {id:123, value:"value1", name:"Name1"},
   {id:124, value:"value2", name:"Name1"},
   {id:125, value:"value3", name:"Name2"},
   {id:126, value:"value4", name:"Name2"}	    
];

var array2 = []		
		
for (i=0; i<array.length;i++){						
   if (array2.indexOf(array[i].name) == -1){				
     array2.push(array[i].name);
    }
}			

console.log(array2)	

Para aquellos que buscan un delineador 1

const names = array.reduce((acc, {name}) => acc.includes(name) ? acc : [name, ...acc], []);

o sin usar métodos en el prototipo de la matriz

const { reduce, includes } = Array;
const names = reduce(array, (acc, {name}) => includes(acc, name) ? acc : [name, ...acc], []);

podría ser útil para escribir algunas funciones puras para lidiar con esto

const get_uniq_values = (key, arr) => reduce(arr, (a, o) => includes(a, o[key]) ? a : [o[key], ...a], []);

var __array=[{id:123, value:"value1", name:"Name1"},{id:124, value:"value2", name:"Name1"},{id:125, value:"value3", name:"Name2"},{id:126, value:"value4", name:"Name2"}];

function __checkArray(__obj){
    var flag = true;
    for(let i=0; i < __array.length; i++){
        if(__obj.id == __array.id){
            flag = false;
            break;
        }
    }

    return flag;
}

var __valToPush = {id: 127, value: "value5", name: "Name3"};
if(__checkArray(__valToPush)){
    __array.push(__valToPush)
}