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

只需使用以下命令，即可将对象转换为数组：

可以将对象值转换为数组：

myObject=｛“a”：1，“b”：2，“c”：3｝；let valuesArray=Object.values（myObject）；console.log（valuesArray）；

可以将对象关键帧转换为数组：

myObject=｛“a”：1，“b”：2，“c”：3｝；let keysArray=Object.keys（myObject）；console.log（keyArray）；

现在您可以执行正常的数组操作，包括“map”函数

TypeScript中的对象映射器

我喜欢像这样使用Object.fromEntries的示例，但它们仍然不太好用。使用Object.keys然后查找关键字的答案实际上是在进行可能不需要的多次查找。

我希望有一个Object.map函数，但我们可以创建自己的函数，并将其称为objectMap，同时可以修改键和值：

用法（JavaScript）：

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

// keep the key and modify the value
let obj = objectMap(myObject, val => val * 2);
// obj = { a: 2, b: 4, c: 6 }


// modify both key and value
obj = objectMap(myObject,
    val => val * 2 + '',
    key => (key + key).toUpperCase());
// obj = { AA: '2', BB: '4', CC: '6' }

代码（TypeScript）：

interface Dictionary<T> {
    [key: string]: T;
}

function objectMap<TValue, TResult>(
    obj: Dictionary<TValue>,
    valSelector: (val: TValue, obj: Dictionary<TValue>) => TResult,
    keySelector?: (key: string, obj: Dictionary<TValue>) => string,
    ctx?: Dictionary<TValue>
) {
    const ret = {} as Dictionary<TResult>;
    for (const key of Object.keys(obj)) {
        const retKey = keySelector
            ? keySelector.call(ctx || null, key, obj)
            : key;
        const retVal = valSelector.call(ctx || null, obj[key], obj);
        ret[retKey] = retVal;
    }
    return ret;
}

如果您没有使用TypeScript，请在TypeScript Playground中复制上述代码以获取JavaScript代码。

此外，我在参数列表中将keySelector放在valSelector之后的原因是它是可选的。

*亚历山大·米尔斯的回答值得称赞。

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

写一个很简单：

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

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

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}