写一个很简单：

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

公认的答案有两个缺点：

它误用了Array.prototype.reduce，因为reduce意味着改变复合类型的结构，这在这种情况下不会发生。它不是特别可重复使用

ES6/ES2015功能方法

请注意，所有函数都是以货币形式定义的。

//小型、可重复使用的辅助功能constkeys=o=>对象.keys（o）；constassign=（…o）=>对象.assign（｛｝，…o）；const-map=f=>xs=>xs.map（x=>f（x））；常量mul=y=>x=>x*y；常量sqr=x=>mul（x）（x）；//实际地图功能常量omap=f=>o=>{o=分配（o）；//A.映射（x=>o[x]=f（o[x]））（键（o））；//B返回o；};//模拟数据常量o={“a”：1，“b”：2，“c”：3}；//并运行控制台日志（omap（sqr）（o））；控制台日志（omap（mul（10））（o））；

在线A o被重新分配。由于Javascript通过共享传递引用值，因此生成了o的浅拷贝。我们现在能够在omap中突变o，而不在父作用域中突变o。在B行中，map的返回值被忽略，因为map执行了o的变异。由于此副作用仍在omap中，并且在父范围中不可见，因此完全可以接受。

这不是最快的解决方案，而是一个声明性和可重用的解决方案。以下是与单行相同的实现，简洁但可读性较差：

const omap = f => o => (o = assign(o), map(x => o[x] = f(o[x])) (keys(o)), o);

附录-为什么默认情况下对象不可迭代？

ES2015指定了迭代器和可迭代协议。但对象仍然不可迭代，因此不可映射。原因是数据和程序级别的混合。

const mapObject = (targetObject, callbackFn) => {
    if (!targetObject) return targetObject;
    if (Array.isArray(targetObject)){
        return targetObject.map((v)=>mapObject(v, callbackFn))
    }
    return Object.entries(targetObject).reduce((acc,[key, value]) => {
        const res = callbackFn(key, value);
        if (!Array.isArray(res) && typeof res ==='object'){
            return {...acc, [key]: mapObject(res, callbackFn)}
        }
        if (Array.isArray(res)){
            return {...acc, [key]: res.map((v)=>mapObject(v, callbackFn))}
        }
        return {...acc, [key]: res};
    },{})
};
const mapped = mapObject(a,(key,value)=> {
    if (!Array.isArray(value) && key === 'a') return ;
    if (!Array.isArray(value) && key === 'e') return [];
    if (!Array.isArray(value) && key === 'g') return value * value;
    return value;
});
console.log(JSON.stringify(mapped)); 
// {"b":2,"c":[{"d":2,"e":[],"f":[{"g":4}]}]}

此函数递归地遍历对象和对象数组。如果返回未定义，则可以删除属性

另一种不同的做法是使用自定义的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））

我需要一个函数，不仅可以选择性地映射（也可以选择性地）值，还可以映射键。原始对象不应更改。该对象也仅包含基本值。

function mappedObject(obj, keyMapper, valueMapper) {

    const mapped = {};
    const keys   = Object.keys(obj);
    const mapKey = typeof keyMapper == 'function';
    const mapVal = typeof valueMapper == 'function';

    for (let i = 0; i < keys.length; i++) {
        const key = mapKey ? keyMapper(keys[i]) : keys[i];
        const val = mapVal ? valueMapper(obj[keys[i]]) : obj[keys[i]];
        mapped[key] = val;
    }

    return mapped;
}

使用传递keymapper和valuemapper函数：

const o1 = { x: 1, c: 2 }
mappedObject(o1, k => k + '0', v => v + 1) // {x0: 2, c0: 3}

编辑：使用较新JavaScript功能的规范方法是-

const identity = x =>
  x

const omap = (f = identity, o = {}) =>
  Object.fromEntries(
    Object.entries(o).map(([ k, v ]) =>
      [ k, f(v) ]
    )
  )

其中o是某个对象，f是映射函数。或者我们可以说，给定一个a->b的函数和一个值为a的对象，生成一个值类型为b的对象。作为伪类型签名-

// omap : (a -> b, { a }) -> { b }

最初的答案是为了演示一个强大的组合子mapReduce，它允许我们以不同的方式思考我们的转换

m、 映射函数–让您有机会在…r、 reduce函数–此函数将累加器与映射元素的结果组合

直观地说，mapReduce创建了一个新的reduce，我们可以直接插入Array.prototype.reduce中。但更重要的是，我们可以通过使用对象幺半群、object.assign和{}来简单地实现我们的对象函子实现omap。

常量标识=x=>x（x）常量mapReduce=（m，r）=>（a，x）=>r（a，m（x））常量omap=（f=身份，o={}）=>对象.键（o）减少（mapReduce（k=>（{[k]：f（o[k]）}），对象分配), {})常量平方=x=>x×x常量数据=｛a:1，b:2，c:3｝console.log（omap（方形，数据））//｛a:1，b:4，c:9｝

请注意，我们实际需要编写的程序的唯一部分是映射实现本身——

k => ({ [k]: f (o[k]) })

也就是说，给定已知对象o和某个键k，构造一个对象，其计算属性k是对键的值o[k]调用f的结果。

如果我们首先抽象oreduce，我们就可以一窥mapReduce的测序潜力

// oreduce : (string * a -> string * b, b, { a }) -> { b }
const oreduce = (f = identity, r = null, o = {}) =>
  Object
    .keys (o)
    .reduce
      ( mapReduce
          ( k => [ k, o[k] ]
          , f
          )
      , r
      )

// omap : (a -> b, {a}) -> {b}
const omap = (f = identity, o = {}) =>
  oreduce
    ( mapReduce
        ( ([ k, v ]) =>
            ({ [k]: f (v) })
        , Object.assign
        )
    , {}
    , o
    )

一切都是一样的，但现在可以在更高级别上定义omap。当然，新的Object.entries让这看起来很愚蠢，但练习对学习者来说仍然很重要。

你不会在这里看到mapReduce的全部潜力，但我分享这个答案，因为看到它可以应用到多少地方很有趣。如果您对它的派生方式和其他有用的方式感兴趣，请查看此答案。