您可以在数组上使用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}

这真的很烦人，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

写一个很简单：

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

最小版本

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]))
                                                           ↑↑↑↑↑

公认的答案有两个缺点：

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

JS ES10/ES2019中的一行怎么样？

使用Object.entries（）和Object.fromEntries（）：

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

同样的东西写为函数：

function objMap(obj, func) {
  return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, func(v)]));
}

// To square each value you can call it like this:
let mappedObj = objMap(obj, (x) => x * x);

此函数还使用递归对嵌套对象进行平方：

function objMap(obj, func) {
  return Object.fromEntries(
    Object.entries(obj).map(([k, v]) => 
      [k, v === Object(v) ? objMap(v, func) : func(v)]
    )
  );
}

// To square each value you can call it like this:
let mappedObj = objMap(obj, (x) => x * x);

对于ES7/ES2016，您不能使用Objects.fromEntries，但可以使用Object.assign结合排列运算符和计算的关键字名称语法实现相同的功能：

let newObj = Object.assign({}, ...Object.entries(obj).map(([k, v]) => ({[k]: v * v})));

ES6/ES2015不允许Object.entries，但可以改用Object.keys：

let newObj = Object.assign({}, ...Object.keys(obj).map(k => ({[k]: obj[k] * obj[k]})));

ES6还为。。。循环，允许更命令式的样式：

let newObj = {}

for (let [k, v] of Object.entries(obj)) {
  newObj[k] = v * v;
}

array.reduce（）

您也可以使用reduce代替Object.fromEntries和Object.assign：

let newObj = Object.entries(obj).reduce((p, [k, v]) => ({ ...p, [k]: v * v }), {});

继承的财产和原型链：

在一些罕见的情况下，您可能需要映射一个类类对象，该类对象在其原型链上保存继承对象的财产。在这种情况下，Object.keys（）和Object.entries（）将无法工作，因为这些函数不包括原型链。

如果需要映射继承的财产，可以使用for（myObj中的键）{…}。

以下是此类情况的示例：

const obj1 = { 'a': 1, 'b': 2, 'c': 3}
const obj2 = Object.create(obj1);  // One of multiple ways to inherit an object in JS.

// Here you see how the properties of obj1 sit on the 'prototype' of obj2
console.log(obj2)  // Prints: obj2.__proto__ = { 'a': 1, 'b': 2, 'c': 3}

console.log(Object.keys(obj2));  // Prints: an empty Array.
console.log(Object.entries(obj2));  // Prints: an empty Array.

for (let key in obj2) {
  console.log(key);              // Prints: 'a', 'b', 'c'
}

不过，请帮我一个忙，避免继承