用例
这个用例是根据提供的字符串或函数将对象数组转换为哈希映射,并将其作为哈希映射中的键来计算和使用,并将值作为对象本身。使用这种方法的常见情况是将对象数组转换为对象的哈希映射。
Code
下面是一个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;
};
你可以在这里找到要点:将数组对象转换为HashMap。
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
你可以使用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.
正如其他帖子解释的那样,有更好的方法来做到这一点。但如果我想坚持纯JS和老式的方式,那么它是:
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);
以下是我在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