如何连接性能从多个JavaScript对象

Question

我正在寻找最好的办法"添加"多JavaScript对象(联阵).

例如，给定：

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

什么是最好的方式计算：

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

Answer 1

的EcmaScript 6引入Object.assign()实现这一本身在Javascript。

  

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

上Object.assign MDN文档（）

var o1 = { a: 1 };
var o2 = { b: 2 };
var o3 = { c: 3 };

var obj = Object.assign({}, o1, o2, o3);
console.log(obj); // { a: 1, b: 2, c: 3 }

Object.assign在许多现代浏览器都支持的但尚未全部。使用transpiler如巴贝尔和 Traceur 产生向后兼容ES5的JavaScript。

Answer 2

jQuery的具有这样做的一个很好的方法。

http://api.jquery.com/jQuery.extend/

Answer 3

此应该这样做：

function collect() {
  var ret = {};
  var len = arguments.length;
  for (var i=0; i<len; i++) {
    for (p in arguments[i]) {
      if (arguments[i].hasOwnProperty(p)) {
        ret[p] = arguments[i][p];
      }
    }
  }
  return ret;
}

输入：

a = { "one" : 1, "two" : 2 };
b = { "three" : 3 };
c = { "four" : 4, "five" : 5 };
d = collect(a, b, c);
console.log(d);

输出：

Object one=1 two=2  three=3 four=4 five=5

Answer 4

的ECMAScript 6具有传播算子。现在你可以这样做：

const obj1 = {1: 11, 2: 22}
const obj2 = {3: 33, 4: 44}
const obj3 = {...obj1, ...obj2} 
console.log(obj3)

// {1: 11, 2: 22, 3: 33, 4: 44}

Answer 5

下划线有几种方法做到这一点;

<强> 1。 _.extend（目的地，*源）

全部复制在源的属性对象到的目的地对象，并返回的目的地对象。

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

或者

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

<强> 2。 _.defaults（对象，*缺省值）

填充在未定义在默认对象，并且其值在的对象属性返回的对象即可。

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

或者

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

Answer 6

为什么要功能被限制为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;
}

Answer 7

function Collect(a, b, c) {
    for (property in b)
        a[property] = b[property];

    for (property in c)
        a[property] = c[property];

    return a;
}

说明：在先前的对象的现有属性将被覆盖

Answer 8

浅的克隆(不包括原型)或合并的对象是现在可以使用一个短语法 对象。分配().

传播的语法 对于 目文字 被引入 写2018):

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 }

传播(...)操作者 是的支持 许多现代化的浏览器 但不是所有的人。

因此，它建议使用一个 transpiler 喜欢 巴别塔 转换写2015年代码进入一个向后兼容的版本JavaScript在当前的和老的浏览器或环境。

这是等效的代码 巴别塔中将产生 你：

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

Answer 9

也许，速度最快，效率和更通用的方法是这样的（你可以合并任意数目的对象，甚至复制到第一个 - >分配）：

function object_merge(){
    for (var i=1; i<arguments.length; i++)
       for (var a in arguments[i])
         arguments[0][a] = arguments[i][a];
   return arguments[0];
}

它还可以以修改的第一个对象，因为它传递通过引用。 如果你不希望这一点，但想拥有包含所有属性的一个完全新的对象做，那么你可以通过{}作为第一个参数。

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); 

和combined_object既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); 

在这种情况下，combined_object包含object1，Object2的，object3性质但object1不被修改。

检查这里： https://jsfiddle.net/ppwovxey/1/

注意：JavaScript对象通过引用传递。

Answer 10

最简单的：运营商扩展

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

Answer 11

ES6++

问题是添加各种 不同的 物体合而为一。

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

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

let objAll = {};

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

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

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

Answer 12

function collect(a, b, c){
    var d = {};

    for(p in a){
        d[p] = a[p];
    }
    for(p in b){
        d[p] = b[p];
    }
    for(p in c){
        d[p] = c[p];
    }

    return d;
}