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

我在谷歌搜索中发现了这一点，这是我试图学习如何做到这一点的第一个项目，我想我会与其他folsk分享我最近发现的解决方案，它使用了npm包不可变。

我觉得分享很有趣，因为不可变在他们自己的文档中使用了OP的EXACT情况——以下不是我自己的代码，而是从当前不可变的js文档中提取的：

const { Seq } = require('immutable')
const myObject = { a: 1, b: 2, c: 3 }
Seq(myObject).map(x => x * x).toObject();
// { a: 1, b: 4, c: 9 } 

这并不是说Seq有其他财产（“Seq描述了一个惰性操作，允许它们通过不创建中间集合来高效地链接所有高阶集合方法（如map和filter）的使用”），也不是说其他一些不可变js数据结构也可以非常有效地完成这项工作。

任何使用此方法的人都必须npm安装不可变，并且可能需要阅读文档：

https://facebook.github.io/immutable-js/

为了更准确地响应OP的要求，OP需要一个对象：

myObject=｛“a”：1，“b”：2，“c”：3｝

要使用映射方法myObject.map，

类似于Array.prototype.map，使用如下：newObject=myObject.map（函数（值，标签）{返回值*值；});//newObject现在是｛“a”：1，“b”：4，“c”：9｝

imho最佳答案（以“接近要求的内容”+“不需要ES｛5，6，7｝”来衡量）是：

myObject.map = function mapForObject(callback)
{
  var result = {};
  for(var property in this){
    if(this.hasOwnProperty(property) && property != "map"){
      result[property] = callback(this[property],property,this);
    }
  }
  return result;
}

上面的代码避免故意使用任何语言特性，这些特性仅在最近的ECMAScript版本中可用。使用上面的代码，问题可以通过以下方式解决：

myObject=｛“a”：1，“b”：2，“c”：3｝；myObject.map=函数mapForObject（回调）{var结果＝｛｝；for（此中的var属性）{如果（this.hasOwnProperty（property）&&property！=“地图”）{result[property]=回调（this[property]，property，this）；}}返回结果；}newObject=myObject.map（函数（值，标签）{返回值*值；});console.log（“newObject is now”，newObject）；此处为备选测试代码

除了受到一些人的反对外，还可以像这样将解决方案插入到原型链中。

Object.prototype.map = function(callback)
{
  var result = {};
  for(var property in this){
    if(this.hasOwnProperty(property)){
      result[property] = callback(this[property],property,this);
    }
  }
  return result;
}

在仔细监督的情况下进行的操作不会产生任何不良影响，也不会影响其他对象的贴图方法（即阵列的贴图）。

没有到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））

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（）转换对象。