对我来说，我不喜欢使用任何map或reduce，只坚持简单的For循环。

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

这对于Array.prototype.reduce来说是相当简单的:

Var arr = [ {key: 'foo'， val: 'bar'}， {key: 'hello'， val: 'world'} ]; Var结果= arr。Reduce(函数(map, obj) { 地图(obj。Key] = obj.val; 返回地图; }, {}); console.log(结果); // {foo:'bar'， hello:'world'}

注意:Array.prototype.reduce()是IE9+，所以如果你需要支持旧的浏览器，你需要对它进行填充。

es2015版本:

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

我会在TypeScript中说得更清楚，以防有人感兴趣。

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

const input: Array<Person> = [
  {
    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()
);

你可以使用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和Object之间有什么不同? 以前，在Map在JavaScript中实现之前，Object一直被用作Map，因为它们的结构相似。 根据你的用例，如果你需要有有序的键，需要访问映射的大小，或者需要频繁地从映射中添加和删除，map是更可取的。

引用自MDN文档: 对象与map类似，它们都允许您将键设置为值、检索这些值、删除键以及检测是否在键处存储了某些内容。正因为如此(也因为没有内置的替代品)，对象在历史上一直被用作地图;然而，在某些情况下使用Map有一些重要的区别:

The keys of an Object are Strings and Symbols, whereas they can be any value for a Map, including functions, objects, and any primitive. The keys in Map are ordered while keys added to object are not. Thus, when iterating over it, a Map object returns keys in order of insertion. You can get the size of a Map easily with the size property, while the number of properties in an Object must be determined manually. A Map is an iterable and can thus be directly iterated, whereas iterating over an Object requires obtaining its keys in some fashion and iterating over them. An Object has a prototype, so there are default keys in the map that could collide with your keys if you're not careful. As of ES5 this can be bypassed by using map = Object.create(null), but this is seldom done. A Map may perform better in scenarios involving frequent addition and removal of key pairs.

lodash:

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

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

// OR: if you want to index the whole item by key:
// const map = _.fromPairs(items.map(item => [item.key, item]));

lodash fromPairs函数让我想起了Python中的zip函数

链接到lodash