我有一个对象：
myObject = { 'a': 1, 'b': 2, 'c': 3 }
我正在寻找一种与本机方法类似的方法，Array.prototype.map如下所示：
newObject = myObject.map(function (value, label) {
return value * value;
});
// newObject is now { 'a': 1, 'b': 4, 'c': 9 }
JavaScript 有这样的map对象函数吗？（我想要这个用于 Node.JS，所以我不关心跨浏览器的问题。）
没有原生map的Object对象，但这个怎么样：
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 }但是您可以使用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 }更新
很多人都提到，前面的方法不返回新对象，而是对对象本身进行操作。就此而言，我想添加另一个解决方案，该解决方案返回一个新对象并将原始对象保持原样：
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通过将前一个值与当前值进行某种程度的合并，将数组缩减为单个值。该链由一个空对象初始化{}。在每次迭代中，myObject都会添加一个新的键，并将键作为值的两倍。
更新
有了新的 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)) JS ES10 / ES2019 中的单行怎么样？
利用Object.entries()和Object.fromEntries()：
let newObj = Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, v * v]));
同样的事情写成一个函数：
function objMap(obj, func) {
return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, func(v)]));
}
// To square each value you can call it like this:
let mappedObj = objMap(obj, (x) => x * x);
此函数也使用递归来平方嵌套对象：
function objMap(obj, func) {
return Object.fromEntries(
Object.entries(obj).map(([k, v]) =>
[k, v === Object(v) ? objMap(v, func) : func(v)]
)
);
}
// To square each value you can call it like this:
let mappedObj = objMap(obj, (x) => x * x);
在ES7 / ES2016 中，您不能使用Objects.fromEntries，但您可以Object.assign结合使用扩展运算符和计算键名称语法来实现相同的效果：
let newObj = Object.assign({}, ...Object.entries(obj).map(([k, v]) => ({[k]: v * v})));
ES6 / ES2015不允许Object.entries，但您可以使用Object.keys：
let newObj = Object.assign({}, ...Object.keys(obj).map(k => ({[k]: obj[k] * obj[k]})));
ES6 还引入了for...of循环，允许更命令式的风格：
let newObj = {}
for (let [k, v] of Object.entries(obj)) {
newObj[k] = v * v;
}
代替Object.fromEntriesandObject.assign你也可以使用reduce来做到这一点：
let newObj = Object.entries(obj).reduce((p, [k, v]) => ({ ...p, [k]: v * v }), {});
在一些罕见的情况下，您可能需要映射一个类对象，该对象在其原型链上保存继承对象的属性。在这种情况下Object.keys()并Object.entries()不会起作用，因为这些函数不包括原型链。
如果需要映射继承的属性，可以使用for (key in myObj) {...}.
下面是这种情况的一个例子：
const obj1 = { 'a': 1, 'b': 2, 'c': 3}
const obj2 = Object.create(obj1); // One of multiple ways to inherit an object in JS.
// Here you see how the properties of obj1 sit on the 'prototype' of obj2
console.log(obj2) // Prints: obj2.__proto__ = { 'a': 1, 'b': 2, 'c': 3}
console.log(Object.keys(obj2)); // Prints: an empty Array.
console.log(Object.entries(obj2)); // Prints: an empty Array.
for (let key in obj2) {
console.log(key); // Prints: 'a', 'b', 'c'
}
但是，请帮我一个忙，避免继承。:-)
没有本地方法，但lodash#mapValues可以出色地完成这项工作
_.mapValues({ 'a': 1, 'b': 2, 'c': 3} , function(num) { return num * 3; });
// → { 'a': 3, 'b': 6, 'c': 9 }
写一个很容易：
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;
}
使用示例代码：
> 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 }
注意：此版本还允许您（可选）设置this回调的上下文，就像Array方法一样。
编辑- 更改为删除 , 的使用Object.prototype，以确保它不会与map对象上命名的任何现有属性发生冲突。
您可以使用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;
});
或者以更module化的方式：
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; });
请注意，Object.keys返回一个仅包含对象自己的可枚举属性的数组，因此它的行为类似于for..in带有hasOwnProperty检查的循环。