¿Cómo obtener valores distintos de una matriz de objetos en JavaScript?

Suponiendo que tengo lo siguiente:

var array = 
    [
        {"name":"Joe", "age":17}, 
        {"name":"Bob", "age":17}, 
        {"name":"Carl", "age": 35}
    ]

¿Cuál es la mejor manera de poder obtener una matriz de todas las edades distintas de modo que obtenga una matriz de resultados de:

[17, 35]

¿Hay alguna forma de estructurar alternativamente los datos o un método mejor de tal manera que no tenga que repetir cada matriz comprobando el valor de "edad" y comparar con otra matriz para su existencia, y agregarlo si no?

Si hubiera alguna manera, podría extraer las distintas edades sin iterar ...

De manera ineficaz actual me gustaría mejorar ... Si eso significa que en lugar de "matriz" ser una matriz de objetos, pero un "mapa" de objetos con alguna clave única (es decir, "1,2,3") sería esta bien tambien Solo estoy buscando la forma más eficiente de rendimiento.

Lo siguiente es cómo lo hago actualmente, pero para mí, la iteración parece ser mala para la eficiencia a pesar de que funciona ...

var distinct = []
for (var i = 0; i < array.length; i++)
   if (array[i].age not in distinct)
      distinct.push(array[i].age)

Si esto fuera PHP, construiría una matriz con las claves y las tomaría array_keysal final, pero JS no tiene ese lujo. En cambio, intente esto:

var flags = [], output = [], l = array.length, i;
for( i=0; i<l; i++) {
    if( flags[array[i].age]) continue;
    flags[array[i].age] = true;
    output.push(array[i].age);
}

Si está utilizando ES6 / ES2015 o posterior, puede hacerlo de esta manera:

const unique = [...new Set(array.map(item => item.age))];

Aquí hay un ejemplo de cómo hacerlo.

usando ES6

let array = [
  { "name": "Joe", "age": 17 },
  { "name": "Bob", "age": 17 },
  { "name": "Carl", "age": 35 }
];
array.map(item => item.age)
  .filter((value, index, self) => self.indexOf(value) === index)

> [17, 35]

Podría usar un enfoque de diccionario como este. Básicamente, asigna el valor que desea que sea distinto como clave en el "diccionario" (aquí usamos una matriz como un objeto para evitar el modo diccionario). Si la clave no existía, entonces agrega ese valor como distinto.

Aquí hay una demostración funcional:

var array = [{"name":"Joe", "age":17}, {"name":"Bob", "age":17}, {"name":"Carl", "age": 35}];
var unique = [];
var distinct = [];
for( let i = 0; i < array.length; i++ ){
  if( !unique[array[i].age]){
    distinct.push(array[i].age);
    unique[array[i].age] = 1;
  }
}
var d = document.getElementById("d");
d.innerHTML = "" + distinct;

<div id="d"></div>

Esto será O (n) donde n es el número de objetos en la matriz ym es el número de valores únicos. No hay una forma más rápida que O (n) porque debe inspeccionar cada valor al menos una vez.

La versión anterior de esto utilizaba un objeto, y para in. Estos eran de naturaleza menor, y desde entonces se han actualizado anteriormente. Sin embargo, la razón de un aparente avance en el rendimiento entre las dos versiones en el jsperf original se debe a que el tamaño de la muestra de datos es muy pequeño. Por lo tanto, la comparación principal en la versión anterior fue observar la diferencia entre el mapa interno y el uso del filtro versus las búsquedas en modo diccionario.

He actualizado el código anterior, como se señaló, sin embargo, también he actualizado jsperf para mirar a través de 1000 objetos en lugar de 3. 3 pasó por alto muchos de los escollos de rendimiento involucrados ( jsperf obsoleto ).

Actuación

https://jsperf.com/filter-vs-dictionary-more-data Cuando ejecuté este diccionario fue un 96% más rápido.

Así es como resolvería esto usando el nuevo Set a través de ES6 para Typecript a partir del 25 de agosto de 2017

Array.from(new Set(yourArray.map((item: any) => item.id)))

Con las funciones de ES6, puede hacer algo como:

const uniqueAges = [...new Set( array.map(obj => obj.age)) ];

Simplemente mapearía y eliminaría dups:

var ages = array.map(function(obj) { return obj.age; });
ages = ages.filter(function(v,i) { return ages.indexOf(v) == i; });

console.log(ages); //=> [17, 35]

Editar: Aight! No es la forma más eficiente en términos de rendimiento, sino la IMO más simple y legible. Si realmente le interesa la microoptimización o tiene grandes cantidades de datos, un forciclo regular será más "eficiente".

var unique = array
    .map(p => p.age)
    .filter((age, index, arr) => arr.indexOf(age) == index)
    .sort(); // sorting is optional

// or in ES6

var unique = [...new Set(array.map(p => p.age))];

// or with lodash

var unique = _.uniq(_.map(array, 'age'));

Ejemplo ES6

const data = [
  { name: "Joe", age: 17}, 
  { name: "Bob", age: 17}, 
  { name: "Carl", age: 35}
];

const arr = data.map(p => p.age); // [17, 17, 35]
const s = new Set(arr); // {17, 35} a set removes duplications, but it's still a set
const unique = [...s]; // [17, 35] Use the spread operator to transform a set into an Array
// or use Array.from to transform a set into an array
const unique2 = Array.from(s); // [17, 35]

Para aquellos que desean devolver objetos con todas las propiedades únicas por clave

const array =
  [
    { "name": "Joe", "age": 17 },
    { "name": "Bob", "age": 17 },
    { "name": "Carl", "age": 35 }
  ]

const key = 'age';

const arrayUniqueByKey = [...new Map(array.map(item =>
  [item[key], item])).values()];

console.log(arrayUniqueByKey);

   /*OUTPUT
       [
        { "name": "Bob", "age": 17 },
        { "name": "Carl", "age": 35 }
       ]
   */

 // Note: this will pick the last duplicated item in the list.

Ya hay muchas respuestas válidas, pero quería agregar una que use solo el reduce()método porque es limpio y simple.

function uniqueBy(arr, prop){
  return arr.reduce((a, d) => {
    if (!a.includes(d[prop])) { a.push(d[prop]); }
    return a;
  }, []);
}

Úselo así:

var array = [
  {"name": "Joe", "age": 17}, 
  {"name": "Bob", "age": 17}, 
  {"name": "Carl", "age": 35}
];

var ages = uniqueBy(array, "age");
console.log(ages); // [17, 35]

La forEachversión de la respuesta de @ travis-j (útil en los navegadores modernos y el mundo Node JS):

var unique = {};
var distinct = [];
array.forEach(function (x) {
  if (!unique[x.age]) {
    distinct.push(x.age);
    unique[x.age] = true;
  }
});

34% más rápido en Chrome v29.0.1547: http://jsperf.com/filter-versus-dictionary/3

Y una solución genérica que toma una función de mapeador (un poco más lento que el mapa directo, pero eso es de esperar):

function uniqueBy(arr, fn) {
  var unique = {};
  var distinct = [];
  arr.forEach(function (x) {
    var key = fn(x);
    if (!unique[key]) {
      distinct.push(key);
      unique[key] = true;
    }
  });
  return distinct;
}

// usage
uniqueBy(array, function(x){return x.age;}); // outputs [17, 35]

He empezado a poner a subrayado Underscore en todos los proyectos nuevos de forma predeterminada para no tener que pensar en estos pequeños problemas de mezcla de datos.

var array = [{"name":"Joe", "age":17}, {"name":"Bob", "age":17}, {"name":"Carl", "age": 35}];
console.log(_.chain(array).map(function(item) { return item.age }).uniq().value());

Produce [17, 35].

Aquí hay otra forma de resolver esto:

var result = {};
for(var i in array) {
    result[array[i].age] = null;
}
result = Object.keys(result);

No tengo idea de qué tan rápido se compara esta solución con las otras, pero me gusta el aspecto más limpio. ;-)

EDITAR: Bien, lo anterior parece ser la solución más lenta de todas aquí.

He creado un caso de prueba de rendimiento aquí: http://jsperf.com/distinct-values-from-array

En lugar de probar las edades (enteros), elegí comparar los nombres (cadenas).

El método 1 (solución de TS) es muy rápido. Curiosamente, el Método 7 supera a todas las demás soluciones, aquí me acabo de deshacer de .indexOf () y utilicé una implementación "manual" del mismo, evitando llamadas a funciones en bucle:

var result = [];
loop1: for (var i = 0; i < array.length; i++) {
    var name = array[i].name;
    for (var i2 = 0; i2 < result.length; i2++) {
        if (result[i2] == name) {
            continue loop1;
        }
    }
    result.push(name);
}

La diferencia en el rendimiento con Safari y Firefox es sorprendente, y parece que Chrome hace el mejor trabajo en optimización.

No estoy exactamente seguro de por qué los fragmentos anteriores son tan rápidos en comparación con los demás, tal vez alguien más sabio que yo tenga una respuesta. ;-)

usando lodash

var array = [
    { "name": "Joe", "age": 17 },
    { "name": "Bob", "age": 17 },
    { "name": "Carl", "age": 35 }
];
_.chain(array).pluck('age').unique().value();
> [17, 35]

Usando Lodash

var array = [
    { "name": "Joe", "age": 17 },
    { "name": "Bob", "age": 17 },
    { "name": "Carl", "age": 35 }
];

_.chain(array).map('age').unique().value();

Devoluciones [17,35]

function get_unique_values_from_array_object(array,property){
    var unique = {};
    var distinct = [];
    for( var i in array ){
       if( typeof(unique[array[i][property]]) == "undefined"){
          distinct.push(array[i]);
       }
       unique[array[i][property]] = 0;
    }
    return distinct;
}

underscore.js _.uniq(_.pluck(array,"age"))

Aquí hay una solución versátil que utiliza reduce, permite el mapeo y mantiene el orden de inserción.

elementos : una matriz

asignador : una función unaria que asigna el elemento a los criterios, o vacía para asignar el elemento en sí.

function distinct(items, mapper) {
    if (!mapper) mapper = (item)=>item;
    return items.map(mapper).reduce((acc, item) => {
        if (acc.indexOf(item) === -1) acc.push(item);
        return acc;
    }, []);
}

Uso

const distinctLastNames = distinct(items, (item)=>item.lastName);
const distinctItems = distinct(items);

Puede agregar esto a su prototipo de matriz y omitir el parámetro de elementos si ese es su estilo ...

const distinctLastNames = items.distinct( (item)=>item.lastName) ) ;
const distinctItems = items.distinct() ;

También puede usar un conjunto en lugar de una matriz para acelerar la coincidencia.

function distinct(items, mapper) {
    if (!mapper) mapper = (item)=>item;
    return items.map(mapper).reduce((acc, item) => {
        acc.add(item);
        return acc;
    }, new Set());
}

Acabo de encontrar esto y pensé que es útil

_.map(_.indexBy(records, '_id'), function(obj){return obj})

Nuevamente usando subrayado , así que si tienes un objeto como este

var records = [{_id:1,name:'one', _id:2,name:'two', _id:1,name:'one'}]

te dará solo los objetos únicos.

Lo que sucede aquí es que indexBydevuelve un mapa como este

{ 1:{_id:1,name:'one'}, 2:{_id:2,name:'two'} }

y solo porque es un mapa, todas las claves son únicas.

Entonces solo estoy asignando esta lista de nuevo a la matriz.

En caso de que solo necesite los valores distintos

_.map(_.indexBy(records, '_id'), function(obj,key){return key})

Tenga en cuenta que keyse devuelve como una cadena, por lo que si necesita números enteros, debe hacerlo

_.map(_.indexBy(records, '_id'), function(obj,key){return parseInt(key)})

Creo que estás buscando la función groupBy (usando Lodash)

_personsList = [{"name":"Joe", "age":17}, 
                {"name":"Bob", "age":17}, 
                {"name":"Carl", "age": 35}];
_uniqAgeList = _.groupBy(_personsList,"age");
_uniqAges = Object.keys(_uniqAgeList);

produce resultado:

17,35

Demostración de jsFiddle: http://jsfiddle.net/4J2SX/201/

Si, como yo, prefiere una opción más "funcional" sin comprometer la velocidad, este ejemplo utiliza una búsqueda rápida del diccionario envuelta en el interior para reducir el cierre.

var array = 
[
    {"name":"Joe", "age":17}, 
    {"name":"Bob", "age":17}, 
    {"name":"Carl", "age": 35}
]
var uniqueAges = array.reduce((p,c,i,a) => {
    if(!p[0][c.age]) {
        p[1].push(p[0][c.age] = c.age);
    }
    if(i<a.length-1) {
        return p
    } else {
        return p[1]
    }
}, [{},[]])

Según esta prueba, mi solución es dos veces más rápida que la respuesta propuesta

[...new Set([
    { "name": "Joe", "age": 17 },
    { "name": "Bob", "age": 17 },
    { "name": "Carl", "age": 35 }
  ].map(({ age }) => age))]

Sé que mi código tiene poca longitud y poca complejidad de tiempo, pero es comprensible, así que lo intenté de esta manera.

Estoy tratando de desarrollar una función basada en prototipos aquí y el código también cambia.

Aquí, Distinct es mi propia función prototipo.

<script>
  var array = [{
      "name": "Joe",
      "age": 17
    },
    {
      "name": "Bob",
      "age": 17
    },
    {
      "name": "Carl",
      "age": 35
    }
  ]

  Array.prototype.Distinct = () => {
    var output = [];
    for (let i = 0; i < array.length; i++) {
      let flag = true;
      for (let j = 0; j < output.length; j++) {
        if (array[i].age == output[j]) {
          flag = false;
          break;
        }
      }
      if (flag)
        output.push(array[i].age);
    }
    return output;
  }
  //Distinct is my own function
  console.log(array.Distinct());
</script>

Si tiene Array.prototype.includes o está dispuesto a rellenarlo , esto funciona:

var ages = []; array.forEach(function(x) { if (!ages.includes(x.age)) ages.push(x.age); });

El siguiente código mostrará la matriz única de edades, así como la nueva matriz que no tiene edad duplicada

var data = [
  {"name": "Joe", "age": 17}, 
  {"name": "Bob", "age": 17}, 
  {"name": "Carl", "age": 35}
];

var unique = [];
var tempArr = [];
data.forEach((value, index) => {
    if (unique.indexOf(value.age) === -1) {
        unique.push(value.age);
    } else {
        tempArr.push(index);    
    }
});
tempArr.reverse();
tempArr.forEach(ele => {
    data.splice(ele, 1);
});
console.log('Unique Ages', unique);
console.log('Unique Array', data);```

Escribí el mío en TypeScript, para un caso genérico, como el de Kotlin Array.distinctBy {}...

function distinctBy<T, U extends string | number>(array: T[], mapFn: (el: T) => U) {
  const uniqueKeys = new Set(array.map(mapFn));
  return array.filter((el) => uniqueKeys.has(mapFn(el)));
}

Donde Ues hashable, por supuesto. Para los objetos, es posible que necesite https://www.npmjs.com/package/es6-json-stable-stringify

En caso de que necesite un objeto entero único

const _ = require('lodash');

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

_.uniqWith(objects, _.isEqual);

[Objeto {x: 1, y: 2}, Objeto {x: 2, y: 1}]

Responder esta vieja pregunta no tiene sentido, pero hay una respuesta simple que habla de la naturaleza de Javascript. Los objetos en Javascript son inherentemente tablas hash. Podemos usar esto para obtener un hash de claves únicas:

var o = {}; array.map(function(v){ o[v.age] = 1; });

Entonces podemos reducir el hash a una matriz de valores únicos:

var a2 = []; for (k in o){ a2.push(k); }

Eso es todo lo que necesitas. La matriz a2 contiene solo las edades únicas.

Simple línea con gran rendimiento. 6% más rápido que las soluciones ES6 en mis pruebas .

var ages = array.map(function(o){return o.age}).filter(function(v,i,a) {
    return a.indexOf(v)===i
});