在没有jQuery的情况下在node.js上合并或合并JSON

我有多个JSON这样的人

var object1 = {name: "John"};
var object2 = {location: "San Jose"};

它们不是嵌套的或类似的东西。基本上是不同的领域。我需要像这样JSON在node.js中将它们组合为一个：

{name: "John", location: "San Jose"}

我可以很好地使用jQuery。这是浏览器中的一个有效示例：

http://jsfiddle.net/qhoc/agp54/

但是，如果我在node.js中执行此操作，则不希望加载jQuery（这有点用处，加上node.js的jQuery在Windows计算机上不起作用）。

那么，有没有一种简单的方法可以执行类似于$.extend()不使用jQuery的事情？

正常循环？

function extend(target) {
    var sources = [].slice.call(arguments, 1);
    sources.forEach(function (source) {
        for (var prop in source) {
            target[prop] = source[prop];
        }
    });
    return target;
}

var object3 = extend({}, object1, object2);

这是一个基本的起点。您可能想要添加诸如hasOwnProperty检查之类的内容，或者添加一些逻辑以处理多个源对象具有具有相同标识符的属性的情况。

这是一个有效的例子。

旁注：您所说的“ JSON”实际上是普通的JavaScript对象。JSON只是一种文本格式，与JavaScript共享一些语法。

您应该使用“ Object.assign（） ”

如此简单的浅层合并用例无需重新发明轮子。

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

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 }
console.log(o1);  // { a: 1, b: 2, c: 3 }, target object itself is changed

甚至来自Node.js的人也这么说：

_extend从未打算在内部NodeJS模块之外使用。社区仍然找到并使用了它。它已被弃用，不应在新代码中使用。JavaScript通过附带了非常相似的内置功能Object.assign。

更新：

您可以使用点差运算符

从8.6版开始，可以在Node.js中本地使用传播运算符。下面的例子：

let o1 = { a: 1 };
let o2 = { b: 2 };
let obj = { ...o1, ...o2 }; // { a: 1, b: 2 }

Object.assign 仍然有效。

^{PS1：如果您实际上对深度合并感兴趣（内部对象数据（任何深度）都以递归方式合并），则可以使用deepmerge，Assign -deep或lodash.merge之类的包，它们非常小且易于操作使用。}

^{PS2：请记住，Object.assign不适用于Node.js的0.X版本。如果您使用的是其中一个版本（您现在真的不应该使用），则可以使用require("util")._extend上面的Node.js链接中所示的方式-有关更多详细信息，请查看tobymackenzie对相同问题的回答。}

如果使用节点版本> = 4，请使用Object.assign()（请参阅Ricardo Nolde的答案）。

如果使用节点0.x，则有内置的util._extend：

var extend = require('util')._extend
var o = extend({}, {name: "John"});
extend(o,  {location: "San Jose"});

它不做深层复制，一次只允许两个参数，而是内置的。我在关于克隆节点中的对象的问题上看到了这一点：https : //stackoverflow.com/a/15040626。

如果您担心使用“私有”方法，可以随时代理它：

// myutil.js
exports.extend = require('util')._extend;

如果它消失了，请用您自己的实现替换它。这是（大约）它们的实现：

exports.extend = function(origin, add) {
    if (!add || (typeof add !== 'object' && add !== null)){
        return origin;
    }

    var keys = Object.keys(add);
    var i = keys.length;
    while(i--){
        origin[keys[i]] = add[keys[i]];
    }
    return origin;
};

extend詹姆斯（James）评论说，下划线是实现这一目标的最简单，最快的方法。

这是使用下划线的示例：

var _ = require('underscore'), // npm install underscore to install
  object1 = {name: "John"},
  object2 = {location: "San Jose"};

var target = _.extend(object1, object2);

对象1将获得对象2的属性，并将其返回并分配给目标。您也可以这样做，具体取决于您是否介意对object1进行修改：

var target = {};
_.extend(target, object1, object2);

使用merge。

$ npm install merge

样例代码：

var merge = require('merge'), // npm install -g merge
    original, cloned;

console.log(

    merge({ one: 'hello' }, { two: 'world' })

); // {"one": "hello", "two": "world"}

original = { x: { y: 1 } };

cloned = merge(true, original);

cloned.x.y++;

console.log(original.x.y, cloned.x.y); // 1, 2

我看到这个线程太旧了，但是我在这里出于日志记录的目的回答了我。

在上面的评论之一中，您提到要在依赖项列表中具有“ connect”库的项目中使用“ express”。实际上，“ connect.utils”库包含执行此操作的“ merge”方法。因此，您可以使用第三方实现，而无需添加任何新的第三方库。

这是合并JSON的简单解决方案。我做了以下。

• 使用将每个JSON转换为字符串JSON.stringify(object)。
• 使用+运算符连接所有JSON字符串。
• 替换模式/}{/g与","

• 将结果字符串解析回JSON对象

  var object1 = {name: "John"};
  var object2 = {location: "San Jose"};
  var merged_object = JSON.parse((JSON.stringify(object1) + JSON.stringify(object2)).replace(/}{/g,","))
  

合并后的JSON将是

{name: "John", location: "San Jose"}

您还可以使用这种称为吸收的轻量级npm软件包

它是27行代码（1kb），并使用递归执行深度对象合并。

var absorb = require('absorb');
var obj1, obj2;

obj1 = { foo: 123, bar: 456 };
obj2 = { bar: 123, key: 'value' }

absorb(obj1, obj2);

console.log(obj1); // Output: { foo: 123, bar: 123, key: 'value' }

如果源对象中不存在值，也可以使用它进行克隆或仅传输值，有关方法的详细说明，请参见所提供的链接。

使用Object.assign（）方法可以轻松完成-

 var object1 = {name: "John"};
 var object2 = {location: "San Jose"};
 var object3 = Object.assign(object1,object2);
 console.log(object3);

现在object3为{名称：'John'，位置：'San Jose'}

在Node.js中有一种简单的方法

var object1 = {name: "John"};
var object2 = {location: "San Jose"};

为了结合/扩展这一点，我们可以...在ECMA6中使用运算符

var object1 = {name: "John"};
var object2 = {location: "San Jose"};

var result = {
  ...object1,
  ...object2
}

console.log(result)

如果您需要特殊的行为，例如嵌套对象扩展或数组替换，则可以使用Node.js的extendify。

var extendify = require('extendify');

_.extend = extendify({
    inPlace: false,
    arrays : 'replace',
    isDeep: true
});

obj1 = {
    a:{
        arr: [1,2]
    },
    b: 4
};

obj2 = {
    a:{
        arr: [3]
    }
};

res = _.extend(obj1,obj2);
console.log(JSON.stringify(res)); //{'a':{'arr':[3]},'b':4}

Lodash是这些实用程序的另一个强大的工具带选项。参见：（_.merge()这是递归的）

var object = {
  'a': [{ 'b': 2 }, { 'd': 4 }]
};
var other = {
  'a': [{ 'c': 3 }, { 'e': 5 }]
}; 
_.merge(object, other);
// => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] } 

使用传播算子。自8.6版开始在Node中受支持

const object1 = {name: "John"};
const object2 = {location: "San Jose"};

const obj = {...object1, ...object2}

console.log(obj)
//   {
//     "name": "John",
//     "location": "San Jose"
//   }

您可以使用Lodash

const _ = require('lodash');

let firstObject = {'email' : 'email@email.com};
let secondObject = { 'name' : { 'first':message.firstName } };
_.merge(firstObject, secondObject)

下面的代码将帮助您合并具有嵌套对象的两个JSON对象。

function mergeJSON(source1,source2){
    /*
     * Properties from the Souce1 object will be copied to Source2 Object.
     * Note: This method will return a new merged object, Source1 and Source2 original values will not be replaced.
     * */
    var mergedJSON = Object.create(source2);// Copying Source2 to a new Object

    for (var attrname in source1) {
        if(mergedJSON.hasOwnProperty(attrname)) {
          if ( source1[attrname]!=null && source1[attrname].constructor==Object ) {
              /*
               * Recursive call if the property is an object,
               * Iterate the object and set all properties of the inner object.
              */
              mergedJSON[attrname] = zrd3.utils.mergeJSON(source1[attrname], mergedJSON[attrname]);
          } 

        } else {//else copy the property from source1
            mergedJSON[attrname] = source1[attrname];

        }
      }

      return mergedJSON;
}

为了避免更改目标，此处提供了一种来自正确解决方案的更好方法：

function extend(){
  let sources = [].slice.call(arguments, 0), result = {};
  sources.forEach(function (source) {
    for (let prop in source) {
      result[prop] = source[prop];
    }
  });
  return result;
}

您可以内联完成此操作，而无需更改任何变量，如下所示：

let obj1 = { name: 'John' };
let obj2 = { surname: 'Smith' };
let obj = Object.assign({}, obj1, obj2); // { name: 'John', surname: 'Smith' }

让object1和object2是两个JSON对象。

var object1 = [{"name": "John"}];
var object2 = [{"location": "San Jose"}];

object1.push(object2);

这将简单地附加object2在object1：

[{"name":"John"},{"location":"San Jose"}]