我有一个目标：
myObject = { 'a': 1, 'b': 2, 'c': 3 }
我正在寻找一个本地方法，类似于Array.prototype.map，可按如下方式使用：
newObject = myObject.map(function (value, label) {
return value * value;
});
// newObject is now { 'a': 1, 'b': 4, 'c': 9 }
JavaScript是否有这样的对象映射函数？（我希望Node.JS使用这个，所以我不关心跨浏览器问题。）
当前回答
另一种不同的做法是使用自定义的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.prototype上不存在，但是您可以这样模拟它
var myMap = function ( obj, callback ) {
var result = {};
for ( var key in obj ) {
if ( Object.prototype.hasOwnProperty.call( obj, key ) ) {
if ( typeof callback === 'function' ) {
result[ key ] = callback.call( obj, obj[ key ], key, obj );
}
}
}
return result;
};
var myObject = { 'a': 1, 'b': 2, 'c': 3 };
var newObject = myMap( myObject, function ( value, key ) {
return value * value;
});
var myObject=｛“a”：1，“b”：2，“c”：3｝；Object.keys（myObject）.filter（（item）=>myObject[item]*=2）console.log（myObject）
使用以下映射函数定义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）；
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之后的原因是它是可选的。
*亚历山大·米尔斯的回答值得称赞。
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}]}]}
此函数递归地遍历对象和对象数组。如果返回未定义，则可以删除属性
