如何连接来自多个JavaScript对象的属性

我正在寻找“添加”多个JavaScript对象（关联数组）的最佳方法

例如，假设：

a = { "one" : 1, "two" : 2 };
b = { "three" : 3 };
c = { "four" : 4, "five" : 5 };

最好的计算方法是什么：

{ "one" : 1, "two" : 2, "three" : 3, "four" : 4, "five" : 5 }

注意：以前对象中的现有属性将被覆盖。

这应该可以做到：

函数collect（）{
var ret={}；
var len=arguments.length；
对于（变量i=0；i您可以像这样使用jquery：


设a={“一”：1，“二”：2}，
b={“三”：3}，
c={“四”：4，“五”：5}；
设d=$.extend（{}，a，b，c）
控制台日志（d）
为什么函数应限制为3个参数？另外，请检查
hasOwnProperty

function Collect() {
    var o={};
    for(var i=0;i<arguments.length;i++) {
      var arg=arguments[i];
      if(typeof arg != "object") continue;
      for(var p in arg) {
        if(arg.hasOwnProperty(p)) o[p] = arg[p];
      }
    }
    return o;
}

函数Collect（）{
var o={}；
对于（var i=0；i而言，几乎没有什么方法可以做到这一点

1.

将源对象中的所有属性复制到目标对象，并返回目标对象

_.extend(a, _.extend(b, c));
=> {"one" : 1, "two" : 2, "three" : 3, "four" : 4, "five" : 5 }

或

2.

用默认值对象中的值填充对象中未定义的属性，并返回对象

_.defaults(a, _.defaults(b, c));
=> {"one" : 1, "two" : 2, "three" : 3, "four" : 4, "five" : 5 }

或

ECMAscript 6引入了
Object.assign（）
，以在Javascript中本机实现这一点

Object.assign（）方法用于将所有可枚举自身属性的值从一个或多个源对象复制到目标对象。它将返回目标对象



varo1={a:1}；
VarO2={b:2}；
var o3={c:3}；
var obj=Object.assign（{}，o1，o2，o3）；
console.log（obj）；//{a:1，b:2，c:3}
也许，最快、有效和更通用的方法是这样的（您可以合并任意数量的对象，甚至复制到第一个对象->分配）：

组合的_对象和object1都包含object1、object2和object3的属性

var object1={a:1,b:2};
var object2={c:3,d:4};
var object3={d:5,e:6};
var combined_object=object_merge({},object1,object2,object3); 

在本例中，组合的_对象包含object1、object2、object3的属性，但object1未被修改

请点击此处：

注意：JavaScript对象是通过引用传递的。
ECMAScript 6有。现在您可以这样做：


constobj1={1:11,2:22}；
常量obj2={3:33,4:44}；
常量obj3={…obj1，…obj2}；
console.log（obj3）；//{1:11,2:22,3:33,4:44}
最简单的：扩展运算符

var obj1 = {a: 1}
var obj2 = {b: 2}
var concat = { ...obj1, ...obj2 } // { a: 1, b: 2 }

ES6++

问题是将各种不同的对象添加到一个对象中

let obj = {};
const obj1 = { foo: 'bar' };
const obj2 = { bar: 'foo' };
Object.assign(obj, obj1, obj2);
//output => {foo: 'bar', bar: 'foo'};

// Output => { bar: 'foo', foo: 'bar' }

假设一个对象具有多个关键点，这些关键点是对象：

let obj = {
  foo: { bar: 'foo' },
  bar: { foo: 'bar' }
}

这就是我找到的解决方案（仍然需要foreach:/）

通过这样做，我们可以动态地将所有对象键添加到一个对象键中

let obj = {};
const obj1 = { foo: 'bar' };
const obj2 = { bar: 'foo' };
Object.assign(obj, obj1, obj2);
//output => {foo: 'bar', bar: 'foo'};

// Output => { bar: 'foo', foo: 'bar' }

现在可以使用比以前更短的语法进行对象的浅层克隆（不包括原型）或合并

例如，在中引入了：

扩展（…）运算符在中受支持，但并非所有运算符都受支持

因此，建议使用like将ECMAScript 2015+代码转换为当前和旧浏览器或环境中向后兼容的JavaScript版本

这是您的等效代码：

“严格使用”；
var _extends=Object.assign | |函数（目标）{
for（var i=1；i
在浏览器控制台中为对象使用ES7 spread操作符很容易

({ name: "Alex", ...(true  ? { age: 19 } : { })}) // {name: "Alex", age: 19}
({ name: "Alex", ...(false ? { age: 19 } : { })}) // {name: "Alex",        }

要合并动态数量的对象，可以使用

上述函数接受任意数量的对象，将其所有属性合并到一个新对象中，其中来自后续对象的属性将覆盖来自以前对象的属性

演示：


constmergeobjs=（…objs）=>Object.assign（{}，…objs）；
常量a={prop:1，prop2:'2'}，
b={prop3:3，prop4:[1,2,3,4]}
c={prop5:5}，
d={prop6:true，prop7:-1}，
e={prop1:2}；
const abcd=mergeObjs（a，b，c，d）；
日志（“合并的a、b、c、d:”，abcd）；
const abd=mergeObjs（a，b，d）；
日志（“合并的a、b、d:”，abd）；
const ae=mergeObjs（a，e）；//来自e的prop1将覆盖来自a的prop1
console.log（“合并的a，e:，ae）；
+1即使您不使用jQuery的方法，您也可以使用他们的代码来帮助构建您自己（也许更具体）的实现。@Randal:不使用jQuery有很多非常好的理由。编辑：
d=$.extend（{}，a，b，c）；
语义注释：尽管有[]语法，它们根本不是数组。顺序并没有真正的保证。根据ecma标准，迭代顺序并没有保证。但大多数浏览器都是这样实现的。（来自John Resig）ECMAScript规范明确未定义此行为。在ECMA-262第12.6.4节：枚举属性的机制…依赖于实现。但是，规范与实现有很大不同。ECMAScript的所有现代实现都会按照对象属性的顺序迭代对象属性被定义。正因为如此，Chrome团队认为这是一个bug，并将对其进行修复。不是每次调用时都要查找数组的大小吗？我已经习惯于为（var I=0，len=array.length；I
我已经记不清我为什么开始这么做了。是的，没错。缓存
let obj = {};
const obj1 = { foo: 'bar' };
const obj2 = { bar: 'foo' };
Object.assign(obj, obj1, obj2);
//output => {foo: 'bar', bar: 'foo'};

let obj = {
  foo: { bar: 'foo' },
  bar: { foo: 'bar' }
}

let objAll = {};

Object.values(obj).forEach(o => {
  objAll = {...objAll, ...o};
});

// Output => { bar: 'foo', foo: 'bar' }

const a = { "one": 1, "two": 2 };
const b = { "three": 3 };
const c = { "four": 4, "five": 5 };

const result = {...a, ...b, ...c};
// Object { "one": 1, "two": 2 , "three": 3, "four": 4, "five": 5 }

"use strict";

var _extends = Object.assign || function(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i];
    for (var key in source) {
      if (Object.prototype.hasOwnProperty.call(source, key)) {
        target[key] = source[key];
      }
    }
  }
  return target;
};

var a = { "one": 1, "two": 2 };
var b = { "three": 3 };
var c = { "four": 4, "five": 5 };

var result = _extends({}, a, b, c);
// Object { "one": 1, "two": 2 , "three": 3, "four": 4, "five": 5 }

({ name: "Alex", ...(true  ? { age: 19 } : { })}) // {name: "Alex", age: 19}
({ name: "Alex", ...(false ? { age: 19 } : { })}) // {name: "Alex",        }

const mergeObjs = (...objs) => Object.assign({}, ...objs);