Javascript 将对象数组转换为哈希映射，由对象的属性值索引 用例

用例是基于字符串或函数将对象数组转换为哈希映射，该字符串或函数用于计算并用作哈希映射中的键，值用作对象本身。使用此方法的常见情况是将对象数组转换为对象的哈希映射

代码 下面是JavaScript中的一个小片段，用于将对象数组转换为哈希映射，该映射由object的属性值索引。您可以提供一个函数来动态（运行时）计算哈希映射的键。希望这对将来的人有所帮助

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

---

您可以在这里找到要点：。

以下是我在javascript中创建的一个小片段，用于将对象数组转换为哈希映射，并按对象的属性值索引。您可以提供一个函数来动态（运行时）计算哈希映射的键

---

您可以在这里找到要点：

这与以下内容无关：

var-arr=[
{key'foo'，val'bar'}，
{key:'你好'，val:'世界'}
];
var结果=arr.REDUCT（功能（映射，对象）{
map[obj.key]=obj.val；
返回图；
}, {});
控制台日志（结果）；
//{foo:'bar'，hello:'world'}

使用ES6（），您可以尝试以下方法：

var-arr=[
{key'foo'，val'bar'}，
{key:'你好'，val:'世界'}
];
var结果=新映射（arr.Map（i=>i.key，i.val））；
//使用TypeScript时，需要指定类型：
//var result=arr.map（（i）：[string，string]=>[i.key，i.val]）
//不幸的是，地图不能很好地字符串化。这是数组形式的内容。
log（“结果是：+JSON.stringify（[…结果]））；
//映射{“foo”=>“bar”，“hello”=>“world”}

，这可以通过以下方式完成：

---

使用简单的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

es2015版本：

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

---

使用扩展运算符：

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

---

在上演示代码片段。

如其他海报所述，有更好的方法可以做到这一点。但如果我想坚持纯JS和ol’s的风格，那么它就是：

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

var-arr=[
{key'foo'，val'bar'}，
{key:'你好'，val:'世界'}，
{key:'你好'，val:'宇宙'}
];
var-map={}；
对于（变量i=0；i

这就是我在TypeScript中所做的，我有一个小的utils库，在那里我放置了这样的东西

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

您可以使用和实际的JavaScript，而不仅仅是JavaScript

地图和物体有什么不同？
以前，在用JavaScript实现Map之前，对象被用作Map，因为它们的结构相似。
根据您的使用情况，如果您需要有有序的键，需要访问映射的大小，或者需要频繁地从映射中添加和删除，那么映射是最好的

引用自：
对象与贴图类似，都允许您将关键点设置为值、检索这些值、删除关键点以及检测某个关键点是否存储了内容。正因为如此（也因为没有内置的替代品），历史上物体一直被用作地图；但是，在某些情况下，使用地图有一些重要的区别：

• 对象的键是字符串和符号，而它们可以是贴图的任何值，包括函数、对象和任何基元
• 贴图中的键是有序的，而添加到对象中的键不是有序的。因此，当对其进行迭代时，贴图对象将按插入顺序返回关键帧
• 使用size属性可以轻松获得贴图的大小，而对象中属性的数量必须手动确定
• 映射是一个iterable，因此可以直接迭代，而对对象进行迭代需要以某种方式获取其键并对其进行迭代
• 一个对象有一个原型，因此如果你不小心的话，地图中的默认关键点可能会与你的关键点发生碰撞。从ES5开始，这可以通过使用map=Object.create（null）来绕过，但很少这样做
• 在涉及频繁添加和删除密钥对的场景中，Map可能表现得更好

---

使用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}

---

对

的一个小小改进减少了
的使用：

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

如果要转换为新的ES6，请执行以下操作：

为什么要使用这种类型的地图？那就看你了。看看。
试试看

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


let-arr=[
{id:123，姓名：'naveen'}，
{id:345，姓名：“库马尔”}
];
设fkey=o=>o.id；//函数将对象更改为字符串（键）
设toHashMap=（a，f）=>a.reduce（（a，c）=>（a[f（c）]=c，a），{}）；
log（toHashMap（arr，fkey））；
//不建议添加到原型：
//
//Array.prototype.toHashMap=函数（f）{returntohashmap（this，f）}；
//log（arr.toHashMap（fkey））您可以使用新方法

例如：


const数组=[
{键：'a'，值：'b'，冗余：'aaa'}，
{键：'x'，值：'y'，冗余：'zzz'}
]
const hash=Object.fromEntries(
map（e=>[e.key，e.value]）
)
console.log（散列）/{a:b，x:y}
带有
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
函数提醒我

链接到
请，请，请不要建议扩展
数组。原型
！啊，我明白了。我最初认为这是一个建议的答案：）在这个示例中使用.map（…）是否没有意义，因为您没有返回任何内容？在这种情况下，我建议使用forEach。同样重要的是要注意，要从
映射中获取某些内容，您需要使用
result.get（keyName）
，而不仅仅是
result[keyName]
。还请注意，任何对象都可以用作键，而不仅仅是字符串。另一个TypeScript版本如下所示：
var result=new Map（arr.Map（i=>[i.key，i.val]as[string，string]）哪些可能是f
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' }

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

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

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