JavaScript刚刚获得了新的Object.fromEntries方法。

实例

函数mapObject（obj，fn）{返回Object.fromEntries(对象.entries（对象）.map（fn）)}常量myObject=｛a:1，b:2，c:3｝const myNewObject=mapObject（myObject，（[key，value]）=>（[key、value*value]））console.log（myNewObject）

解释

上面的代码将Object转换为可以映射的嵌套数组（[[<key>，<value>]，…]）。Object.fromEntries将数组转换回对象。

这种模式最酷的一点是，现在可以在映射时轻松地考虑对象关键点。

文档

对象.fromEntries（）Object.entries（）

浏览器支持

Object.fromEntries目前仅受这些浏览器/引擎支持，但仍有polyfill可用（例如@babel/polyfill）。

没有原生方法，但lodash#mapValues将出色地完成这项工作

_.mapValues({ 'a': 1, 'b': 2, 'c': 3} , function(num) { return num * 3; });
// → { 'a': 3, 'b': 6, 'c': 9 }

根据@Amberlamps的回答，这里有一个实用函数（作为评论，它看起来很难看）

function mapObject(obj, mapFunc){
    return Object.keys(obj).reduce(function(newObj, value) {
        newObj[value] = mapFunc(obj[value]);
        return newObj;
    }, {});
}

其用途是：

var obj = {a:1, b:3, c:5}
function double(x){return x * 2}

var newObj = mapObject(obj, double);
//=>  {a: 2, b: 6, c: 10}

没有到Object对象的本机映射，但这如何：

var myObject=｛“a”：1，“b”：2，“c”：3｝；Object.keys（myObject）.forEach（函数（键，索引）{myObject[key]*=2；});console.log（myObject）；//=>｛“a”：2，“b”：4，“c”：6｝

但是您可以使用for。。。在：

var myObject=｛“a”：1，“b”：2，“c”：3｝；for（myObject中的var键）{if（myObject.hasOwnProperty（键））{myObject[key]*=2；}}console.log（myObject）；//｛“a”：2，“b”：4，“c”：6｝

使现代化

很多人都提到，以前的方法不会返回新对象，而是对对象本身进行操作。为此，我想添加另一个解决方案，该方案返回一个新对象并保持原始对象的原样：

var myObject=｛“a”：1，“b”：2，“c”：3｝；//返回一个新对象，其中每个键的值都使用mapFn（value）映射函数objectMap（对象，mapFn）{return Object.keys（Object）.reduce（function（result，key）{result[key]=mapFn（对象[key]）返回结果}, {})}var newObject=对象映射（myObject，函数（值）{返回值*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。

常量对象映射=（obj，fn）=>对象.fromEntries(对象条目（obj）.map(（[k，v]，i）=>[k，fn（v，k，i）]))常量myObject=｛a:1，b:2，c:3｝console.log（objectMap（myObject，v=>2*v））

写一个很简单：

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的属性冲突。

使用以下映射函数定义myObject.map

o => f=> Object.keys(o).reduce((a,c)=> c=='map' ? a : (a[c]=f(o[c],c),a), {})

让map=o=>f=>Object.keys（o）.reduce（（a，c）=>c=='map'？a:（a[c]=f（o[c]，c），a），{}）//测试初始化myObject=｛“a”：1，“b”：2，“c”：3｝myObject.map=map（myObject）；//你可以这样做，但不建议这样做//（您将看到“map”键任意/所有对象）//Object.prototype.map=map（myObject）；//所述OP所需接口newObject=myObject.map（函数（值，标签）{返回值*值；});console.log（newObject）；