我有一个目标：
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使用这个，所以我不关心跨浏览器问题。）
当前回答
我需要一个允许修改密钥的版本（基于@Amberlamps和@yonatanmn答案）；
var facts = [ // can be an object or array - see jsfiddle below
{uuid:"asdfasdf",color:"red"},
{uuid:"sdfgsdfg",color:"green"},
{uuid:"dfghdfgh",color:"blue"}
];
var factObject = mapObject({}, facts, function(key, item) {
return [item.uuid, {test:item.color, oldKey:key}];
});
function mapObject(empty, obj, mapFunc){
return Object.keys(obj).reduce(function(newObj, key) {
var kvPair = mapFunc(key, obj[key]);
newObj[kvPair[0]] = kvPair[1];
return newObj;
}, empty);
}
factObject（事实对象）=
{
"asdfasdf": {"color":"red","oldKey":"0"},
"sdfgsdfg": {"color":"green","oldKey":"1"},
"dfghdfgh": {"color":"blue","oldKey":"2"}
}
编辑：对传入起始对象｛｝进行轻微更改。允许为[]（如果键是整数）
其他回答
ES6:
Object.prototype.map = function(mapFunc) {
return Object.keys(this).map((key, index) => mapFunc(key, this[key], index));
}
2015年：
Object.prototype.map = function (mapFunc) {
var _this = this;
return Object.keys(this).map(function (key, index) {
return mapFunc(key, _this[key], index);
});
};
节点中的测试：
> a = {foo: "bar"}
{ foo: 'bar' }
> a.map((k,v,i) => v)
[ 'bar' ]
Hey编写了一个可能有帮助的小映射器函数。
function propertyMapper(object, src){
for (var property in object) {
for (var sourceProp in src) {
if(property === sourceProp){
if(Object.prototype.toString.call( property ) === '[object Array]'){
propertyMapper(object[property], src[sourceProp]);
}else{
object[property] = src[sourceProp];
}
}
}
}
}
如果您不仅对值感兴趣，而且对键感兴趣，我已经编写了Object.map（valueMapper，keyMapper），其行为如下：
var source = { a: 1, b: 2 };
function sum(x) { return x + x }
source.map(sum); // returns { a: 2, b: 4 }
source.map(undefined, sum); // returns { aa: 1, bb: 2 }
source.map(sum, sum); // returns { aa: 2, bb: 4 }
这是另一个版本，它允许映射函数根据当前键和值声明任意数量的新财产（键和值）。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”]
我在谷歌搜索中发现了这一点，这是我试图学习如何做到这一点的第一个项目，我想我会与其他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/
