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｝

这真的很烦人，JS社区的每个人都知道。应该有这样的功能：

const obj1 = {a:4, b:7};
const obj2 = Object.map(obj1, (k,v) => v + 5);

console.log(obj1); // {a:4, b:7}
console.log(obj2); // {a:9, b:12}

这是一个幼稚的实现：

Object.map = function(obj, fn, ctx){

    const ret = {};

    for(let k of Object.keys(obj)){
        ret[k] = fn.call(ctx || null, k, obj[k]);
    });

    return ret;
};

总是要自己实现这一点非常令人讨厌；）

如果您想要一些更复杂的、不干扰Object类的东西，请尝试以下操作：

let map = function (obj, fn, ctx) {
  return Object.keys(obj).reduce((a, b) => {
    a[b] = fn.call(ctx || null, b, obj[b]);
    return a;
  }, {});
};


const x = map({a: 2, b: 4}, (k,v) => {
    return v*2;
});

但将此映射函数添加到Object是安全的，只是不要添加到Object.prototype。

Object.map = ... // fairly safe
Object.prototype.map ... // not ok

var myObject = { 'a': 1, 'b': 2, 'c': 3 };


Object.prototype.map = function(fn){
    var oReturn = {};
    for (sCurObjectPropertyName in this) {
        oReturn[sCurObjectPropertyName] = fn(this[sCurObjectPropertyName], sCurObjectPropertyName);
    }
    return oReturn;
}
Object.defineProperty(Object.prototype,'map',{enumerable:false});





newObject = myObject.map(function (value, label) {
    return value * value;
});


// newObject is now { 'a': 1, 'b': 4, 'c': 9 }

公认的答案有两个缺点：

它误用了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指定了迭代器和可迭代协议。但对象仍然不可迭代，因此不可映射。原因是数据和程序级别的混合。

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' ]

var myObject=｛“a”：1，“b”：2，“c”：3｝；Object.keys（myObject）.filter（（item）=>myObject[item]*=2）console.log（myObject）