对象的映射函数(而不是数组)

我有一个对象:

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,所以我不关心跨浏览器问题。map


答案 1

对象没有本机,但是这个怎么样:mapObject

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

Object.keys(myObject).forEach(function(key, index) {
  myObject[key] *= 2;
});

console.log(myObject);
// => { 'a': 2, 'b': 4, 'c': 6 }

但是您可以使用以下方法轻松迭代对象:for ... in

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

for (var key in myObject) {
  if (myObject.hasOwnProperty(key)) {
    myObject[key] *= 2;
  }
}

console.log(myObject);
// { 'a': 2, 'b': 4, 'c': 6 }

更新

很多人提到以前的方法不会返回新对象,而是对对象本身进行操作。为此,我想添加另一个解决方案,该解决方案返回一个新对象并保持原始对象不变:

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

// returns a new object with the values at each key mapped using mapFn(value)
function objectMap(object, mapFn) {
  return Object.keys(object).reduce(function(result, key) {
    result[key] = mapFn(object[key])
    return result
  }, {})
}

var newObject = objectMap(myObject, function(value) {
  return value * 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

const objectMap = (obj, fn) =>
  Object.fromEntries(
    Object.entries(obj).map(
      ([k, v], i) => [k, fn(v, k, i)]
    )
  )
  
const myObject = { a: 1, b: 2, c: 3 }

console.log(objectMap(myObject, v => 2 * v)) 

答案 2

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 中,您无法使用 ,但您可以使用 Object.assign 结合展开运算符计算键名语法来实现相同的目标:Objects.fromEntries

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

ES6 / ES2015不允许 ,但您可以改用 Object.keysObject.entries

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.fromEntriesObject.assign

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


继承的属性和原型链:

在极少数情况下,您可能需要映射一个类状对象,该对象在其原型链上保存继承对象的属性。在这种情况下,并且不起作用,因为这些函数不包括原型链。Object.keys()Object.entries()

如果需要映射继承的属性,可以使用 。for (key in 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'
}

但是,请帮我一个忙,避免继承。:-)