Konvertiere das Objekt-Array in eine Hashtabelle, indexiert nach einem Attributwert des Objekts

Question

Anwendungsfall

Der Anwendungsfall besteht darin, ein Array von Objekten in eine Hash-Map umzuwandeln, basierend auf einem String oder einer Funktion, die zur Auswertung und Verwendung als Schlüssel in der Hash-Map und als Wert als Objekt selbst dient. Ein häufiger Anwendungsfall für dies ist die Umwandlung eines Arrays von Objekten in eine Hash-Map von Objekten.

Code

Im Folgenden finden Sie einen kleinen Ausschnitt in JavaScript, um ein Array von Objekten in eine Hash-Map umzuwandeln, indexiert nach dem Attributwert des Objekts. Sie können eine Funktion angeben, um den Schlüssel der Hash-Map dynamisch (zur Laufzeit) zu bewerten.

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

/**
 * Diese Funktion wandelt ein Array in eine Hash-Map um
 * @param {String | function} key beschreibt den Schlüssel, der in jedem Objekt ausgewertet werden soll, um ihn als Schlüssel für die Hash-Map zu verwenden
 * @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;
};

Sie finden das Gist hier: Konvertiert Array von Objekten in HashMap.

Answer 1

Für mich ziehe ich es vor, keine map oder reduce zu verwenden und einfach beim einfachen for-Loop zu bleiben.

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

const hash = {};

for (const item of array) {
    hash[item.key] = item;
}

console.log(hash);

Answer 2

/**
* Konvertiert verschachteltes Objekt-Array zu Map nach Objektfeld
* @param {Array} array
* @param {String} fieldName
* @returns {Map}
*/
function convertNestObjectArrayToMapByField(array, fieldName){
    return new Map(array.map(obj => [obj[fieldName], obj]));
}

/* Beispiel
  const array = [
    { key: 'foo', val: 'bar' },
    { key: 'hello', val: 'world' }
  ];
  let map = convertNestObjectArrayToMapByField(array, 'key');
  console.log(map);
  console.log(map.get('foo'));
  # Konsole
  Map(2) {
    'foo' => { key: 'foo', val: 'bar' },
    'hello' => { key: 'hello', val: 'world' }
  }
  { key: 'foo', val: 'bar' }
*/

Answer 3

Verwenden Sie einfaches JavaScript

var createMapFromList = function(objectList, property) {
    var objMap = {};
    objectList.forEach(function(obj) {
      objMap[obj[property]] = obj;
    });
    return objMap;
  };
// objectList - das Array  ;  property - Eigenschaft als Schlüssel

Answer 4

Ich würde es in TypeScript klarer machen, falls es jemanden interessiert.

interface Person {
  id: number;
  name: string;
}
type Result = Map

const input: Array = [
  {
    id: 123,
    name: "naveen"
  },
  {
    id: 345,
    name: "kumar"
  },
];
const convertedToMap: Result = input.reduce(
  (map: Result, person: Person) => {
    map.set(person.id, person.name);
    return map;
  },
  new Map()
);

Answer 5

Versuch

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; // Funktion, die Objekt in einen String (Schlüssel) ändert

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

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

// Das Hinzufügen zum Prototyp wird NICHT empfohlen:
//
// Array.prototype.toHashMap = function(f) { return toHashMap(this,f) };
// console.log( arr.toHashMap(fkey) );