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

Hier ist eine wiederverwendbare generische TypeScript-Funktion, die für Eigenschaften eines Objekts der ersten Ebene geeignet ist und Ihnen Intellisense bietet, wenn Sie sie aufrufen. Sie gibt Ihnen auch korrekte Typen für die erstellte Map sowohl für Schlüssel als auch Werte.

const arrayToMap = (
  array: Array,
  mapByKey: K,
  fatalOnConflicts: boolean = false
): Map => {
  const map = new Map();
  for (const element of array) {
    const key = element[mapByKey];
    if (fatalOnConflicts && map.has(key)) {
      throw new Error(`Kann Array nicht in eine Map umwandeln wegen doppeltem Schlüssel '${key}' in der Eigenschaft '${String(mapByKey)}'`);
    }
    map.set(key, element);
  }

  return map;
};

Beispiele zur Verwendung

type MyType = {
  id: number,
  color: string
}

const array: Array = [
  { id: 1, color: "rot" },
  { id: 2, color: "blau" },
  { id: 1, color: "grün" }
];

// wird eine Map vom Typ Map ergeben (Schlüssel "1" wird den Wert {id: 1, color: "grün"} haben - letzter Wert überlebt)
const map = arrayToMap(array, "id");
// wird eine Map vom Typ Map ergeben
const map2 = arrayToMap(array, "color");
// wird während der Laufzeit einen Fehler für den doppelten Schlüssel '1' auslösen
const map3 = arrayToMap(array, "id", true);
// wird von VS Code als Fehler erkannt und einen Build-Fehler produzieren - "Argument vom Typ '"nicht-existente-eigenschaft"' ist nicht dem Parameter vom Typ '"id" | "color"' zuweisbar."
const map4 = arrayToMap(array, "nicht-existente-eigenschaft");

Answer 2

Lösung:

var keyValueObjectArray = [
  { key: "foo", val: "bar" },
  { key: "hello", val: "world" },
];

//array
var keyValueArray = keyValueObjectArray.map((elm) => [elm.key, elm.val]);
//console.log(keyValueArray);

//array to map
var keyValueMap = new Map(keyValueArray);
//console.log(keyValueMap);

//map to object
var result = {}
for (const [key, value] of keyValueMap) {
  result[key] = value
}
console.log(result)

Ausgabe:

{ foo: 'bar', hello: 'world' }

Answer 3

Nachfolgend finden Sie ein kleines Snippet, das ich in JavaScript erstellt habe, um ein Array von Objekten in eine Hash-Map umzuwandeln, die nach dem Attributwert des Objekts indiziert ist. Sie können eine Funktion bereitstellen, um den Schlüssel der Hash-Map dynamisch zu bewerten (zur Laufzeit).

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 Hasmap 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 den Gist hier: https://gist.github.com/naveen-ithappu/c7cd5026f6002131c1fa

Answer 4

Ordnen Sie das Array wie folgt zu:

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

let [k,v] = items.map(item => [item.key, item.value])   
console.log([k,v]) 

//Ausgabe: [ [ 'foo', 'bar' ], [ 'hallo', 'Welt' ] ]