我有一个目标：
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是否有这样的对象映射函数？（我希望Node.JS使用这个，所以我不关心跨浏览器问题。）
当前回答
您可以在返回的键数组上使用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;
});
或者以更模块化的方式：
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。。在循环中使用hasOwnProperty检查。
其他回答
这是另一个版本，它允许映射函数根据当前键和值声明任意数量的新财产（键和值）。E： 现在也可以使用数组。
Object.defineProperty（Object.prototype，“mapEntries”{value：函数（f，a=Array.isArray（this）？[]:{}) {return Object.entries（this）.reduce（（o，[k，v]）=>对象赋值（o，f（v，Array.isArray（a）？数字（k）：k，this）），a） ；}});常量数据＝{a:1，b:2，c:3}；常量计算=（v，k）=>({[k+'_square']：v*v，[k+'_cube']：v*v*v});console.log（data.mapEntries（计算））；// {//“a_square”：1，“a_scube”：1，//“b_square”：4，“b_cube”：8，//“c_square”：9，“c_cube”：27// }//阵列演示：常量arr=[“a”、“b”、“c”]；常量重复=（v，i）=>({[i*2]：v，[i*2+1]：v+v});console.log（arr.mapEntries（重复））；//[“a”、“aa”、“b”、“bb”、“c”、“cc”]
写一个很简单：
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方法一样。
EDIT-更改为删除Object.prototype的使用，以确保它不会与对象上任何现有的名为map的属性冲突。
映射函数在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;
});
另一种不同的做法是使用自定义的json字符串函数，该函数也可以处理深层对象。如果您打算将其作为json发布到服务器，这可能很有用
常量obj=｛‘a’：1，‘b’：2，x:｛‘c’：3｝｝const json=json.stringify（obj，（k，v）=>typeof v==“number”？v*v:v）console.log（json）console.log（'返回json:'，json.parse（json））
我在谷歌搜索中发现了这一点，这是我试图学习如何做到这一点的第一个项目，我想我会与其他folsk分享我最近发现的解决方案，它使用了npm包不可变。
我觉得分享很有趣，因为不可变在他们自己的文档中使用了OP的EXACT情况——以下不是我自己的代码，而是从当前不可变的js文档中提取的：
const { Seq } = require('immutable')
const myObject = { a: 1, b: 2, c: 3 }
Seq(myObject).map(x => x * x).toObject();
// { a: 1, b: 4, c: 9 }
这并不是说Seq有其他财产（“Seq描述了一个惰性操作，允许它们通过不创建中间集合来高效地链接所有高阶集合方法（如map和filter）的使用”），也不是说其他一些不可变js数据结构也可以非常有效地完成这项工作。
任何使用此方法的人都必须npm安装不可变，并且可能需要阅读文档：
https://facebook.github.io/immutable-js/
