Використовуйте кейс

Випадок використання полягає в перетворенні масиву об'єктів у хеш-карту на основі рядка або функції, наданої для оцінки та використання як ключа в хеш-карті та значення як самого об'єкта. Поширений випадок використання цього - перетворення масиву об’єктів у хеш-карту об'єктів.

Код

Далі наведено невеликий фрагмент JavaScript для перетворення масиву об’єктів на хеш-карту, індексовану значенням атрибута об'єкта. Ви можете надати функцію динамічно оцінювати ключ хеш-карти (час виконання). Сподіваюся, це допоможе комусь у майбутньому.

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

Ви можете знайти суть тут: Перетворює масив об’єктів у HashMap .

Це досить банально 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' }

Примітка: Array.prototype.reduce() це IE9 +, тому якщо вам потрібно підтримувати старіші веб-переглядачі, вам потрібно буде заповнити його.

Використовуючи ES6 Map ( досить добре підтримується ), ви можете спробувати це:

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

З lodash це можна зробити за допомогою 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}

Використання ES6 спред + 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}

Використання оператора спред:

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

Демонстрація фрагмента коду на jsFiddle .

Ви можете використовувати Array.prototype.reduce () та фактичну JavaScript Map, а не просто Об'єкт 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);

Що відрізняється між картою та об’єктом?
Раніше, до того, як Map було впроваджено в JavaScript, Object використовувався як Map через їх подібну структуру.
Залежно від випадку використання, якщо вам потрібно мати замовлені ключі, вам потрібно отримати доступ до розміру карти або мати часті додавання та видалення з карти, карта є кращою.

Цитата з документа MDN :
Об'єкти схожі на "Карти", оскільки обидва дозволяють встановлювати значення для ключів, витягувати ці значення, видаляти ключі та визначати, чи зберігається щось у ключі. Через це (і тому, що не було вбудованих альтернатив), Об'єкти історично використовувались як Карти; однак є важливі відмінності, які в певних випадках дозволяють використовувати карту:

• Клавішами Об’єкта є рядки та символи, тоді як вони можуть мати будь-яке значення для карти, включаючи функції, об'єкти та будь-який примітив.
• Ключі в Map впорядковуються, тоді як ключі, додані до об'єкта, не є. Таким чином, під час ітерації над ним об’єкт Map повертає ключі в порядку вставки.
• Ви можете легко отримати розмір карти за допомогою властивості розміру, при цьому кількість властивостей об’єкта потрібно визначити вручну.
• Карта є ітерабельною і тому може бути безпосередньо повторена, тоді як ітерація над Об'єктом вимагає отримання його ключів певним чином та повторення над ними.
• Об'єкт має прототип, тому на карті є ключі за замовчуванням, які можуть зіткнутися з вашими ключами, якщо ви не будете обережні. Станом на ES5 це можна обійти за допомогою map = Object.create (null), але це робиться рідко.
• Карта може працювати краще в сценаріях, що передбачають часте додавання та видалення пар ключів.

Можна скористатися новим 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}

версія2015:

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

Це те, що я роблю в TypeScript У мене є невелика бібліотека утиліт, куди я розміщую такі речі

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

використання:

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

або якщо у вас є ідентифікатор, відмінний від "id"

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

Є кращі способи зробити це, як пояснено іншими плакатами. Але якщо я хочу дотримуватися чистого модного JS та ol 'способу, то ось це:

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

Якщо ви хочете перетворити в нову ES6 карту зробити це:

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

Навіщо використовувати цей тип Карти? Ну, це залежить від вас. Погляньте на це .

Використання простого Javascript

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

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

Невелике покращення reduceвикористання:

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

спробуйте

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

Далі йде невеликий фрагмент, який я створив у javascript для перетворення масиву об’єктів у хеш-карту, індексованого значенням атрибута об’єкта. Ви можете надати функцію динамічно оцінювати ключ хеш-карти (час виконання).

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

Ви можете знайти суть тут: https://gist.github.com/naveen-ithappu/c7cd5026f6002131c1fa