您可以在数组上使用map方法和forEach，但如果您想在Object上使用它，则可以使用如下扭曲：

使用Javascript（ES6）

var obj = { 'a': 2, 'b': 4, 'c': 6 };   
Object.entries(obj).map( v => obj[v[0]] *= v[1] );
console.log(obj); //it will log as {a: 4, b: 16, c: 36}

var obj2 = { 'a': 4, 'b': 8, 'c': 10 };
Object.entries(obj2).forEach( v => obj2[v[0]] *= v[1] );
console.log(obj2); //it will log as {a: 16, b: 64, c: 100}

使用jQuery

var ob = { 'a': 2, 'b': 4, 'c': 6 };
$.map(ob, function (val, key) {
   ob[key] *= val;
});
console.log(ob) //it will log as {a: 4, b: 16, c: 36}

或者也可以使用其他循环，例如$.each方法，如下所示：

$.each(ob,function (key, value) {
  ob[key] *= value;
});
console.log(ob) //it will also log as {a: 4, b: 16, c: 36}

编辑：使用较新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的全部潜力，但我分享这个答案，因为看到它可以应用到多少地方很有趣。如果您对它的派生方式和其他有用的方式感兴趣，请查看此答案。

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

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

最小版本

2017年

Object.entries(obj).reduce((a, [k, v]) => (a[k] = v * v, a), {})
                                                  ↑↑↑↑↑

ES2019年

Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, v * v]))
                                                           ↑↑↑↑↑

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 }

常量orig=｛“a”：1，“b”：2，“c”：3｝常量结果=_.变换（orig，（r，v，k）=>r[k.trim（）]=v*2）；console.log（结果）；<script src=“https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.min.js“></script>

使用new_.transform（）转换对象。