Javascript 将包含对象的阵列展平为1个对象

给定输入：

[{ a: 1 }, { b: 2 }, { c: 3 }]

如何返回：

{ a: 1, b: 2, c: 3 }

对于包含lodash的数组，但这里有对象数组。

使用：

请注意，

Object.assign

尚未在许多环境中实现，您可能需要对其进行polyfill（使用core js、另一个polyfill或使用MDN上的polyfill）

您提到了lodash，因此值得指出的是，它附带了一个

\uASSIGN

函数，用于此目的，它执行相同的操作：

 var merged = _.assign.apply(_, [{ a: 1 }, { b: 2 }, { c: 3 }]);

---

但我真的建议使用新的标准库方法。

这里有一个不使用ES6方法的版本

var arr = [{ a: 1 }, { b: 2 }, { c: 3 }];
var obj = {};

for(var i = 0; i < arr.length; i++) {
    var o = arr[i];
    for(var key in o) {
        if(typeof o[key] != 'function'){
            obj[key] = o[key];
        }
    }
}

console.log(obj);

var-arr=[{a:1}，{b:2}，{c:3}]；
var obj={}；
对于（变量i=0；i

---

fiddle:

您可以使用下划线.extend函数，如下所示：

var _ = require('underscore');
var a = [{ a: 1 }, { b: 2 }, { c: 3 }];

var result = _.extend.apply(null, a);
console.log(result); // { a: 1, b: 2, c: 3 }
console.log(a); // [ { a: 1, b: 2, c: 3 }, { b: 2 }, { c: 3 } ]

---

为了防止修改原始数组，应该使用

var _ = require('underscore');
var a = [{ a: 1 }, { b: 2 }, { c: 3 }];

var result = _.extend.apply(null, [{}].concat(a));
console.log(result); // { a: 1, b: 2, c: 3 }
console.log(a); // [ { a: 1 }, { b: 2 }, { c: 3 } ]

---

我有一个干净的小解决方案，不需要填充胶

var arr = [{ a: 1 }, { b: 2 }, { c: 3 }];
var object = {};

arr.map(function(obj){
    var prop = Object.getOwnPropertyNames(obj);
    object[prop] = obj[prop];
});

希望对您有所帮助：）

对于lodash，您可以使用：

如果在多个位置执行此操作，则可以使用and使

merge（）

更加优雅：

---

下面是

对象的一个很好的用法。使用
数组分配
。prototype.reduce
函数：

let merged = arrOfObjs.reduce((accum, val) => {
  Object.assign(accum, val);
  return accum;
}, {})

这种方法不会改变对象的输入数组，这可以帮助您避免难以排除的问题。
您可以轻松地将对象展平到数组

function flatten(elements) {
  return elements.reduce((result, current) => {
    return result.concat(Array.isArray(current) ? flatten(current) : current);
  }, []);
};

在接受的答案中添加一个使用ES6运行的代码段


let input=[{a:1}，{b:2}，{c:3}]
//使用扩展运算符获取输入对象列表
console.log（…输入）
//获取一个对象中的所有元素
console.log（Object.assign（…input））
6年后提出这个问题

Object.assign是我最喜欢的答案

但这也合法吗

let res = {};
[{ a: 1 }, { b: 2 }, { c: 3 }].forEach(val => {
    let key = Object.keys(val);
    console.log(key[0]);
    res[key] = val[key];
})

问一下npm软件包可以吗？不可以。你可以像刚才那样描述你遇到的问题，如果答案是“安装这个npm软件包”，那就好了；但是你不应该特别要求一个包来解决这个问题。请注意，这也会复制可枚举原型属性（在这种特殊情况下这不是问题）。简单的`&&&&！o、 propertyIsEnumerable（key）`添加到if语句中修复此问题？嗯，对于。。。中仅枚举可枚举属性。一个
对象（o）
将修复它（确保它不在原型上）
对象（o）
部分是为了确保我们没有调用一个不存在的方法，例如传递
4
不会失败（并且不复制任何内容）。可枚举属性不是您想要复制的吗？例如，您不希望对象中出现类似于
Array.prototype.length的内容。。正确的？还是我完全忽略了这一点？@BenjaminGruenbaum:更好的是：
Object.prototype.hasOwnProperty.call（o，I）
以确保我们没有调用自定义方法，甚至没有调用非函数属性值。我不知道为什么这会被上浮，因为它不起作用-getOwnPropertyNames返回一个数组。这只是偶然的，因为所有对象都有一个属性，而
toString
使用单个属性对数组进行上浮会得到相同的结果，尝试向其中一个对象添加一个属性，但失败了：@BenjaminGruenbaum我完全理解它-我只是将一个解决方案应用到用例中。我可以说得更一般一些，但问题清楚地问到“对于这个输入，返回这个输出”，我只是这么做而已。@JonathanBrooks，这正是我想要的。：-）@超级哈哈！这就是我从你的问题中得到的信息；我很高兴我的反对票是毫无根据的：“）你不应该做
Object.assign（{}，…arr）
@如果我想保持
assign
的输入完整，我可以。如果我不这么做，我当然不必这么做。因为这不是一个要求，所以我没有这样对待它。@BenjaminGruenbaum:是的，保留输入是一个最佳实践：-）当它出乎意料时，它可能会导致丑陋的错误。我的linter抛出一个
参数，预期至少有1个参数，但得到0个或更多。
如果我没有添加额外的{}<代码>对象。分配（{}，…ID
。在转换为其他类型的对象时有用
let merged = arrOfObjs.reduce((accum, val) => {
  Object.assign(accum, val);
  return accum;
}, {})

function flatten(elements) {
  return elements.reduce((result, current) => {
    return result.concat(Array.isArray(current) ? flatten(current) : current);
  }, []);
};

let res = {};
[{ a: 1 }, { b: 2 }, { c: 3 }].forEach(val => {
    let key = Object.keys(val);
    console.log(key[0]);
    res[key] = val[key];
})