本文翻译自：map function for objects (instead of arrays)
I have an object: 我有一个对象：
myObject = { 'a': 1, 'b': 2, 'c': 3 }
I am looking for a native method, similar to Array.prototype.map that would be used as follows: 我正在寻找类似于Array.prototype.map的本机方法，该方法将按以下方式使用：
newObject = myObject.map(function (value, label) {
return value * value;
});
// newObject is now { 'a': 1, 'b': 4, 'c': 9 }
Does JavaScript have such a map function for objects? JavaScript是否为对象提供了这种map功能？ (I want this for Node.JS, so I don't care about cross-browser issues.) （我想为Node.JS使用它，所以我不在乎跨浏览器的问题。）
#1楼
参考：https://stackoom.com/question/108t8/对象的映射功能-而不是数组
#2楼
The map function does not exist on the Object.prototype however you can emulate it like so map function在Object.prototype上不存在，但是您可以像这样模拟它
var myMap = function ( obj, callback ) {
var result = {};
for ( var key in obj ) {
if ( Object.prototype.hasOwnProperty.call( obj, key ) ) {
if ( typeof callback === 'function' ) {
result[ key ] = callback.call( obj, obj[ key ], key, obj );
}
}
}
return result;
};
var myObject = { 'a': 1, 'b': 2, 'c': 3 };
var newObject = myMap( myObject, function ( value, key ) {
return value * value;
});
#3楼
It's pretty easy to write one: 编写一个很简单：
Object.map = function(o, f, ctx) {
ctx = ctx || this;
var result = {};
Object.keys(o).forEach(function(k) {
result[k] = f.call(ctx, o[k], k, o);
});
return result;
}
with example code: 带有示例代码：
> o = { a: 1, b: 2, c: 3 };
> r = Object.map(o, function(v, k, o) {
return v * v;
});
> r
{ a : 1, b: 4, c: 9 }
NB: this version also allows you to (optionally) set the this context for the callback, just like the Array method. 注意：此版本还允许您（可选）设置回调的this上下文，就像Array方法一样。
EDIT - changed to remove use of Object.prototype , to ensure that it doesn't clash with any existing property named map on the object. 编辑 -更改为删除对Object.prototype使用，以确保它不与该对象上任何现有的名为map属性发生冲突。
#4楼
There is no native map to the Object object, but how about this: 没有到Object对象的本地map ，但是如何处理：
var myObject = { 'a': 1, 'b': 2, 'c': 3 }; Object.keys(myObject).map(function(key, index) { myObject[key] *= 2; }); console.log(myObject); // => { 'a': 2, 'b': 4, 'c': 6 }
But you could easily iterate over an object using for ... in : 但是您可以使用for ... in以下对象中轻松迭代对象：
var myObject = { 'a': 1, 'b': 2, 'c': 3 }; for (var key in myObject) { if (myObject.hasOwnProperty(key)) { myObject[key] *= 2; } } console.log(myObject); // { 'a': 2, 'b': 4, 'c': 6 }
Update 更新资料
A lot of people are mentioning that the previous methods do not return a new object, but rather operate on the object itself. 很多人提到，以前的方法不会返回新对象，而是对对象本身进行操作。 For that matter I wanted to add another solution that returns a new object and leaves the original object as it is: 为此，我想添加另一个解决方案，该解决方案返回一个新对象并保留原始对象不变：
var myObject = { 'a': 1, 'b': 2, 'c': 3 }; // returns a new object with the values at each key mapped using mapFn(value) function objectMap(object, mapFn) { return Object.keys(object).reduce(function(result, key) { result[key] = mapFn(object[key]) return result }, {}) } var newObject = objectMap(myObject, function(value) { return value * 2 }) console.log(newObject); // => { 'a': 2, 'b': 4, 'c': 6 } console.log(myObject); // => { 'a': 1, 'b': 2, 'c': 3 }
Array.prototype.reduce reduces an array to a single value by somewhat merging the previous value with the current. Array.prototype.reduce通过将先前值与当前值进行某种程度的合并，将数组减少为单个值。 The chain is initialized by an empty object {} . 该链由一个空对象{}初始化。 On every iteration a new key of myObject is added with twice the key as the value. 每次迭代时，都会添加myObject的新键，并将键的值加倍。
Update 更新资料
With new ES6 features, there is a more elegant way to express objectMap . 借助ES6的新功能，有一种更优雅的方式来表达objectMap 。
const objectMap = (obj, fn) => Object.fromEntries( Object.entries(obj).map( ([k, v], i) => [k, fn(v, k, i)] ) ) const myObject = { a: 1, b: 2, c: 3 } console.log(objectMap(myObject, v => 2 * v))
#5楼
You could use Object.keys and then forEach over the returned array of keys: 您可以使用Object.keys然后在返回的键数组上使用forEach ：
var myObject = { 'a': 1, 'b': 2, 'c': 3 },
newObject = {};
Object.keys(myObject).forEach(function (key) {
var value = myObject[key];
newObject[key] = value * value;
});
Or in a more modular fashion: 或更模块化的方式：
function map(obj, callback) {
var result = {};
Object.keys(obj).forEach(function (key) {
result[key] = callback.call(obj, obj[key], key, obj);
});
return result;
}
newObject = map(myObject, function(x) { return x * x; });
Note that Object.keys returns an array containing only the object's own enumerable properties, thus it behaves like a for..in loop with a hasOwnProperty check. 请注意， Object.keys返回一个仅包含对象自己的可枚举属性的数组，因此它的行为类似于带有hasOwnProperty检查的for..in循环。
#6楼
No native methods, but lodash#mapValues will do the job brilliantly 没有本机方法，但是lodash＃mapValues可以出色地完成这项工作
_.mapValues({ 'a': 1, 'b': 2, 'c': 3} , function(num) { return num * 3; });
// → { 'a': 3, 'b': 6, 'c': 9 }
