Gunakan Kasing

Use case adalah untuk mengubah array objek menjadi peta hash berdasarkan string atau fungsi yang disediakan untuk mengevaluasi dan menggunakan sebagai kunci dalam peta hash dan nilai sebagai objek itu sendiri. Kasus umum menggunakan ini adalah mengubah array objek menjadi peta objek hash.

Kode

Berikut ini adalah cuplikan kecil dalam JavaScript untuk mengonversi array objek ke peta hash, diindeks oleh nilai atribut objek. Anda dapat memberikan fungsi untuk mengevaluasi kunci dari peta hash secara dinamis (run time). Semoga ini bisa membantu seseorang di masa depan.

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 hashmap
 * @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;
};

Anda dapat menemukan intinya di sini: Konversi Array Objek ke HashMap .

Ini cukup sepele untuk dilakukan dengan 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' }

Catatan: Array.prototype.reduce() adalah IE9 +, jadi jika Anda perlu mendukung peramban yang lebih lama, Anda perlu mengisinya.

Menggunakan ES6 Map ( didukung dengan sangat baik ), Anda dapat mencoba ini:

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"}

Dengan lodash , ini bisa dilakukan menggunakan 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}

Menggunakan 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}

Menggunakan operator spread:

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

Demonstrasi potongan kode di jsFiddle .

Anda dapat menggunakan Array.prototype.reduce () dan Peta JavaScript yang sebenarnya, bukan hanya Obyek 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);

Apa perbedaan antara Map dan Object?
Sebelumnya, sebelum Peta diimplementasikan dalam JavaScript, Objek telah digunakan sebagai Peta karena strukturnya yang serupa.
Tergantung pada kasus penggunaan Anda, jika Anda perlu memiliki kunci yang dipesan, perlu mengakses ukuran peta atau memiliki penambahan dan penghapusan yang sering dari peta, Peta lebih disukai.

Kutipan dari dokumen MDN :
Objek mirip dengan Maps yang memungkinkan Anda mengatur kunci ke nilai, mengambil nilai-nilai itu, menghapus kunci, dan mendeteksi apakah ada sesuatu yang disimpan pada kunci. Karena ini (dan karena tidak ada alternatif bawaan), Objek telah digunakan sebagai Maps secara historis; namun, ada perbedaan penting yang membuat penggunaan Peta lebih disukai dalam kasus-kasus tertentu:

• Kunci dari suatu Objek adalah String dan Simbol, sedangkan mereka dapat berupa nilai apa pun untuk Peta, termasuk fungsi, objek, dan primitif apa pun.
• Kunci dalam Peta diurutkan sedangkan kunci yang ditambahkan ke objek tidak. Jadi, ketika iterasi di atasnya, objek Peta mengembalikan kunci dalam urutan penyisipan.
• Anda bisa mendapatkan ukuran Peta dengan mudah dengan properti ukuran, sedangkan jumlah properti di Objek harus ditentukan secara manual.
• Peta adalah iterable dan dengan demikian dapat langsung iterated, sedangkan iterasi atas suatu Object memerlukan memperoleh kuncinya dalam beberapa cara dan iterasi atas mereka.
• Objek memiliki prototipe, jadi ada kunci default di peta yang bisa bertabrakan dengan kunci Anda jika Anda tidak hati-hati. Pada ES5 ini dapat dilewati dengan menggunakan map = Object.create (null), tetapi ini jarang dilakukan.
• Peta dapat tampil lebih baik dalam skenario yang melibatkan penambahan dan penghapusan pasangan kunci yang sering.

Anda dapat menggunakan Object.fromEntries()metode baru .

Contoh:

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}

versi es2015:

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

Ini yang saya lakukan di TypeScript. Saya punya perpustakaan kecil di mana saya meletakkan hal-hal seperti ini

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

pemakaian:

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

atau jika Anda memiliki pengidentifikasi selain 'id'

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

Ada cara yang lebih baik untuk melakukan ini seperti yang dijelaskan oleh poster lain. Tetapi jika saya ingin tetap pada JS murni dan cara kuno maka di sini adalah:

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);

Jika Anda ingin mengonversi ke Peta ES6 baru, lakukan ini:

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

Mengapa Anda harus menggunakan jenis Peta ini? Nah itu terserah kamu. Lihatlah ini .

Menggunakan Javascript sederhana

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

Dengan 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' }

Peningkatan kecil pada reducepenggunaan:

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' }

mencoba

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) );

Berikut ini adalah potongan kecil yang saya buat dalam javascript untuk mengubah array objek ke peta hash, diindeks oleh nilai atribut objek. Anda dapat memberikan fungsi untuk mengevaluasi kunci dari peta hash secara dinamis (run time).

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;
};

Anda dapat menemukan intinya di sini: https://gist.github.com/naveen-ithappu/c7cd5026f6002131c1fa