这真的很烦人，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 mapped = [item].map(myMapFunction).pop();

我来到这里是为了查找并回答将对象映射到数组的问题，结果得到了这个页面。如果你来这里寻找与我相同的答案，这里是如何映射和对象到一个数组。

您可以使用map从对象返回一个新数组，如下所示：

var newObject = Object.keys(myObject).map(function(key) {
   return myObject[key];
});

const mapObject = (targetObject, callbackFn) => {
    if (!targetObject) return targetObject;
    if (Array.isArray(targetObject)){
        return targetObject.map((v)=>mapObject(v, callbackFn))
    }
    return Object.entries(targetObject).reduce((acc,[key, value]) => {
        const res = callbackFn(key, value);
        if (!Array.isArray(res) && typeof res ==='object'){
            return {...acc, [key]: mapObject(res, callbackFn)}
        }
        if (Array.isArray(res)){
            return {...acc, [key]: res.map((v)=>mapObject(v, callbackFn))}
        }
        return {...acc, [key]: res};
    },{})
};
const mapped = mapObject(a,(key,value)=> {
    if (!Array.isArray(value) && key === 'a') return ;
    if (!Array.isArray(value) && key === 'e') return [];
    if (!Array.isArray(value) && key === 'g') return value * value;
    return value;
});
console.log(JSON.stringify(mapped)); 
// {"b":2,"c":[{"d":2,"e":[],"f":[{"g":4}]}]}

此函数递归地遍历对象和对象数组。如果返回未定义，则可以删除属性

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

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

使用以下映射函数定义myObject.map

o => f=> Object.keys(o).reduce((a,c)=> c=='map' ? a : (a[c]=f(o[c],c),a), {})

让map=o=>f=>Object.keys（o）.reduce（（a，c）=>c=='map'？a:（a[c]=f（o[c]，c），a），{}）//测试初始化myObject=｛“a”：1，“b”：2，“c”：3｝myObject.map=map（myObject）；//你可以这样做，但不建议这样做//（您将看到“map”键任意/所有对象）//Object.prototype.map=map（myObject）；//所述OP所需接口newObject=myObject.map（函数（值，标签）{返回值*值；});console.log（newObject）；