array - javascript map object

Convierta la matriz de objetos en un mapa hash, indexado por un valor de atributo del objeto

Question

Caso de uso

El caso de uso es convertir una matriz de objetos en un mapa hash basado en una cadena o función proporcionada para evaluar y usar como clave en el mapa hash y el valor como objeto en sí. El caso común de usar esto es convertir una matriz de objetos en un mapa hash de objetos.

Código

El siguiente es un pequeño fragmento en javascript para convertir una matriz de objetos en un mapa hash, indexado por el valor del atributo del objeto. Puede proporcionar una función para evaluar la clave del mapa hash dinámicamente (tiempo de ejecución). Espero que esto ayude a cualquiera en el futuro.

function isFunction(func){
    return Object.prototype.toString.call(func) === ''[object Function]'';
}

/**
 * This function converts an array to hash map
 * @param {String | function} key describes the key to be evaluated in each object to use as key for hasmap
 * @returns Object
 * @Example 
 *      [{id:123, name:''naveen''}, {id:345, name:"kumar"}].toHashMap("id")
 *      Returns :- Object {123: Object, 345: Object}
 *
 *      [{id:123, name:''naveen''}, {id:345, name:"kumar"}].toHashMap(function(obj){return obj.id+1})
 *      Returns :- Object {124: Object, 346: Object}
 */
Array.prototype.toHashMap = function(key){
    var _hashMap = {}, getKey = isFunction(key)?key: function(_obj){return _obj[key];};
    this.forEach(function (obj){
        _hashMap[getKey(obj)] = obj;
    });
    return _hashMap;
};

Puede encontrar la esencia aquí: https://gist.github.com/naveen-ithappu/c7cd5026f6002131c1fa

Answer 1

Con lodash , esto se puede hacer usando keyBy :

var arr = [
    { key: ''foo'', val: ''bar'' },
    { key: ''hello'', val: ''world'' }
];

var result = _.keyBy(arr, o => o.key);

console.log(result);
// Object {foo: Object, hello: Object}

Answer 2

Con lodash :

const items = [
    { key: ''foo'', value: ''bar'' },
    { key: ''hello'', value: ''world'' }
];

const map = _.fromPairs(items.map(item => [item.key, item.value]));

console.log(map); // { foo: ''bar'', hello: ''world'' }

Answer 3

El siguiente es un pequeño fragmento que he creado en JavaScript para convertir una matriz de objetos en un mapa hash, indexado por el valor del atributo del objeto. Puede proporcionar una función para evaluar la clave del mapa hash dinámicamente (tiempo de ejecución).

function isFunction(func){
    return Object.prototype.toString.call(func) === ''[object Function]'';
}

/**
 * This function converts an array to hash map
 * @param {String | function} key describes the key to be evaluated in each object to use as key for hasmap
 * @returns Object
 * @Example 
 *      [{id:123, name:''naveen''}, {id:345, name:"kumar"}].toHashMap("id")
        Returns :- Object {123: Object, 345: Object}

        [{id:123, name:''naveen''}, {id:345, name:"kumar"}].toHashMap(function(obj){return obj.id+1})
        Returns :- Object {124: Object, 346: Object}
 */
Array.prototype.toHashMap = function(key){
    var _hashMap = {}, getKey = isFunction(key)?key: function(_obj){return _obj[key];};
    this.forEach(function (obj){
        _hashMap[getKey(obj)] = obj;
    });
    return _hashMap;
};

Puede encontrar la esencia aquí: https://gist.github.com/naveen-ithappu/c7cd5026f6002131c1fa

Answer 4

Esto es bastante trivial de hacer con Array.prototype.reduce :

var arr = [
    { key: ''foo'', val: ''bar'' },
    { key: ''hello'', val: ''world'' }
];

var result = arr.reduce(function(map, obj) {
    map[obj.key] = obj.val;
    return map;
}, {});

console.log(result);
// { foo:''bar'', hello:''world'' }

Nota: Array.prototype.reduce() es IE9 +, por lo que si necesita admitir navegadores más antiguos, deberá rellenarlo.

Answer 5

Esto es lo que estoy haciendo en TypeScript. Tengo una pequeña biblioteca de utilidades donde pongo cosas como esta.

export const arrayToHash = (array: any[], id: string = ''id'') => 
         array.reduce((obj, item) =>  (obj[item[id]] = item , obj), {})

uso:

const hash = arrayToHash([{id:1,data:''data''},{id:2,data:''data''}])

o si tiene un identificador que no sea ''id''

const hash = arrayToHash([{key:1,data:''data''},{key:2,data:''data''}], ''key'')

Answer 6

Hay mejores maneras de hacer esto como lo explican otros carteles. Pero si quiero apegarme a JS puro y a la antigua, entonces aquí está:

var arr = [
    { key: ''foo'', val: ''bar'' },
    { key: ''hello'', val: ''world'' },
    { key: ''hello'', val: ''universe'' }
];

var map = {};
for (var i = 0; i < arr.length; i++) {
    var key = arr[i].key;
    var value = arr[i].val;

    if (key in map) {
        map[key].push(value);
    } else {
        map[key] = [value];
    }
}

console.log(map);

Answer 7

Puede usar Array.prototype.reduce y el Map JavaScript real en lugar de solo un Object JavaScript.

let keyValueObjArray = [
  { key: ''key1'', val: ''val1'' },
  { key: ''key2'', val: ''val2'' },
  { key: ''key3'', val: ''val3'' }
];

let keyValueMap = keyValueObjArray.reduce((mapAccumulator, obj) => {
  // either one of the following syntax works
  // mapAccumulator[obj.key] = obj.val;
  mapAccumulator.set(obj.key, obj.val);

  return mapAccumulator;
}, new Map());

console.log(keyValueMap);
console.log(keyValueMap.size);

¿Qué es diferente entre mapa y objeto?
Anteriormente, antes de que Map se implementara en JavaScript, Object se usaba como Map debido a su estructura similar.
Dependiendo de su caso de uso, si necesita tener claves ordenadas, necesita acceder al tamaño del mapa o tener que agregar y quitar del mapa con frecuencia, es preferible un Mapa.

Cita del Object :
Los objetos son similares a los Mapas, ya que ambos le permiten establecer claves en valores, recuperar esos valores, eliminar claves y detectar si algo está almacenado en una clave. Debido a esto (y porque no había alternativas incorporadas), los Objetos se han utilizado como Mapas históricamente; sin embargo, existen diferencias importantes que hacen que el uso de un Mapa sea preferible en ciertos casos:

• Las claves de un objeto son cadenas y símbolos, mientras que pueden ser cualquier valor para un mapa, incluidas funciones, objetos y cualquier primitivo.
• Las claves en el Mapa se ordenan mientras que las claves agregadas al objeto no. Por lo tanto, al iterar sobre él, un objeto Map devuelve claves en orden de inserción.
• Puede obtener el tamaño de un Mapa fácilmente con la propiedad de tamaño, mientras que el número de propiedades en un Objeto debe determinarse manualmente.
• Un mapa es iterable y, por lo tanto, puede iterarse directamente, mientras que iterar sobre un objeto requiere obtener sus claves de alguna manera e iterar sobre ellas.
• Un objeto tiene un prototipo, por lo que hay claves predeterminadas en el mapa que podrían colisionar con sus claves si no tiene cuidado. A partir de ES5, esto se puede omitir usando map = Object.create (nulo), pero esto rara vez se hace.
• Un mapa puede funcionar mejor en escenarios que implican la adición y eliminación frecuente de pares de claves.

Answer 8

Puede usar el nuevo método Object.fromEntries()

const array = [
   {key: ''a'', value: ''b'', redundant: ''aaa''},
   {key: ''x'', value: ''y'', redundant: ''zzz''}
]

const hash = Object.fromEntries(
   array.map(e => [e.key, e.value])
)

console.log(hash) // {a: b, x: y}

Answer 9

Si desea convertir al nuevo Map ES6, haga esto:

var kvArray = [[''key1'', ''value1''], [''key2'', ''value2'']];
var myMap = new Map(kvArray);

¿Por qué deberías usar este tipo de mapa? Bueno, eso depende de ti. Mira this .

Answer 10

Una pequeña mejora en el uso reducido:

var arr = [
    { key: ''foo'', val: ''bar'' },
    { key: ''hello'', val: ''world'' }
];

var result = arr.reduce((map, obj) => ({
    ...map,
    [obj.key] = obj.val
}), {});

console.log(result);
// { foo: ''bar'', hello: ''world'' }

Answer 11

Usando ES6 Map ( bastante bien soportado ), puedes probar esto:

var arr = [
    { key: ''foo'', val: ''bar'' },
    { key: ''hello'', val: ''world'' }
];

var result = new Map(arr.map(i => [i.key, i.val]));

// When using TypeScript, need to specify type:
// var result = arr.map((i): [string, string] => [i.key, i.val])

// Unfortunately maps don''t stringify well.  This is the contents in array form.
console.log("Result is: " + JSON.stringify([...result])); 
// Map {"foo" => "bar", "hello" => "world"}

Answer 12

Usando ES6 spread + Object.assign:

array = [{key: ''a'', value: ''b'', redundant: ''aaa''}, {key: ''x'', value: ''y'', redundant: ''zzz''}]

const hash = Object.assign({}, ...array.map(s => ({[s.key]: s.value})));

console.log(hash) // {a: b, x: y}

Answer 13

Usando Javascript simple

var createMapFromList = function(objectList, property) {
    var objMap = {};
    objectList.forEach(function(obj) {
      objMap[obj[property]] = obj;
    });
    return objMap;
  };
// objectList - the array  ;  property - property as the key

Answer 14

Usando el operador de propagación:

const result = arr.reduce(
    (accumulator, target) => ({ ...accumulator, [target.key]: target.val }),
    {});

Demostración del fragmento de código en jsFiddle .

Answer 15

Versión es2015:

const myMap = new Map(objArray.map(obj => [ obj.key, obj.val ]));

Answer 16

tratar

let toHashMap = (a,f) => a.reduce((a,c)=> (a[f(c)]=c,a),{});

let arr=[
  {id:123, name:''naveen''}, 
  {id:345, name:"kumar"}
];

let fkey = o => o.id; // function changing object to string (key)

let toHashMap = (a,f) => a.reduce((a,c)=> (a[f(c)]=c,a),{});

console.log( toHashMap(arr,fkey) );

// Adding to prototype is NOT recommented:
//
// Array.prototype.toHashMap = function(f) { return toHashMap(this,f) };
// console.log( arr.toHashMap(fkey) );