Javascript 合并2个对象数组

让我们看一个例子

var arr1 = new Array({name: "lang", value: "English"},
                     {name: "age", value: "18"});

var arr2 = new Array({name : "childs", value: '5'},
                     {name: "lang", value: "German"});

我需要合并这两个对象数组并创建以下数组：

var arr3 = new Array({name: "lang", value: "German"},
                     {name: "age", value: "18"},
                     {name : "childs", value: '5'});

是否有任何JavaScript或jQuery函数可以执行此操作

$.extend

不适合我。它回来了

var arr4 = new Array({name : "childs", value: '5'},
                     {name: "lang", value: "German"});

---

jQuery合并怎么样

---

JSFIDLE示例：

您可以使用对象收集属性，同时替换重复项，然后将该对象展开/展平回数组。大概是这样的：

function merge(args) {
    args  = Array.prototype.slice.call(arguments);
    var o = { };
    for(var i = 0; i < args.length; ++i)
        for(var j = 0; j < args[i].length; ++j)
            o[args[i][j].name] = args[i][j].value;
    return o;
}

function expand(o) {
    var a = [ ];
    for(var p in o)
        if(o.hasOwnProperty(p))
            a.push({ name: p, value: o[p]});
    return a;
}

var arr1 = new Array({name: "lang", value: "English"}, {name: "age", value: "18"});
var arr2 = new Array({name : "childs", value: '5'}, {name: "lang", value: "German"});
var arr3 = expand(merge(arr1, arr2));

在

a

中提供与

arr3

中相同的内容，其中“德语”替换为“煎饼”

这种方法确实假设您的对象都具有相同的

{name:…，value:…}

形式

您可以看到它在这里工作（请打开控制台）：

合并两个阵列：

var arr1 = new Array({name: "lang", value: "English"}, {name: "age", value: "18"});
var arr2 = new Array({name : "childs", value: '5'}, {name: "lang", value: "German"});
var result=arr1.concat(arr2);
// result: [{name: "lang", value: "English"}, {name: "age", value: "18"}, {name : "childs", value: '5'}, {name: "lang", value: "German"}]

正在合并两个数组，但“name”的值不重复：

var arr1 = new Array({name: "lang", value: "English"}, {name: "age", value: "18"});
var arr2 = new Array({name : "childs", value: '5'}, {name: "lang", value: "German"});
var i,p,obj={},result=[];
for(i=0;i<arr1.length;i++)obj[arr1[i].name]=arr1[i].value;
for(i=0;i<arr2.length;i++)obj[arr2[i].name]=arr2[i].value;
for(p in obj)if(obj.hasOwnProperty(p))result.push({name:p,value:obj[p]});
// result: [{name: "lang", value: "German"}, {name: "age", value: "18"}, {name : "childs", value: '5'}]

var arr1=新数组（{name:“lang”，value:“English”}，{name:“age”，value:“18”}）；
var arr2=新数组（{name:'childs'，value:'5'}，{name:'lang'，value:'German'}）；
变量i，p，obj={}，结果=[]；
对于（i=0；i更新日期为2019年10月12日）
新版本仅基于较新的Javascript，不需要任何第三方库。

constmergebyproperty=（目标、源、属性）=>{
source.forEach（sourceElement=>{
让targetElement=target.find（targetElement=>{
返回sourceElement[prop]==targetElement[prop]；
})
targetElement？Object.assign（targetElement，sourceElement）：target.push（sourceElement）；
})
}
var target/*arr1*/=[{name:“lang”，value:“English”}，{name:“age”，value:“18”}]；
var source/*arr2*/=[{name:“childs”，value:'5'}，{name:“lang”，value:“德语”}]；
mergeByProperty（目标、源、“名称”）；
console.log（target）
我也遇到了同样的问题，基于此，我扩展了下划线库，并添加了我需要的更多功能。下面是示例

希望它有用！
问候！
另一个版本使用：


var arr1=新数组（{name:“lang”，value:“English”}，{name:“age”，value:“18”}）；
var arr2=新数组（{name:'childs'，value:'5'}，{name:'lang'，value:'German'}）；
var arr=arr1.concat（arr2）.reduce（函数（prev，current，index，array）{
如果（！（上一个键中的current.name））{
上一个键[当前名称]=索引；
上一结果推送（当前）；
} 
否则{
上一个结果[上一个关键字[当前名称]]=当前；
}  
返回上一个；
}，{result:[]，键：{}）；
document.getElementById（“output”）.innerHTML=JSON.stringify（arr，null，2）；
var newArray=yourArray.concat（otherArray）；
console.log（'concatated newArray:'，newArray）；
如果您想在JavaScript中合并两个对象数组。您可以使用这一行技巧

Array.prototype.push.apply（arr1，arr2）；

比如说

var arr1 = [{name: "lang", value: "English"},{name: "age", value: "18"}];
var arr2 = [{name : "childs", value: '5'}, {name: "lang", value: "German"}];

Array.prototype.push.apply(arr1,arr2); 

console.log(arr1);  // final merged result will be in arr1

输出：

[{"name":"lang","value":"English"},
{"name":"age","value":"18"},
{"name":"childs","value":"5"},
{"name":"lang","value":"German"}]

    arr3 = [
      {"name":"lang","value":"German"},
      {"name":"age","value":"18"},
      {"name":"childs","value":"5"},
      {"name":"lang","value":"German"}
    ]

我最近被这个问题难住了，我来到这里是希望得到一个答案，但被接受的答案使用了2 for in循环，这是我不喜欢的。我最终成功地制作了自己的。不依赖任何库：

function find(objArr, keyToFind){
    var foundPos = objArr.map(function(ob){
        return ob.type;
    }).indexOf(keyToFind);
    return foundPos;
}

function update(arr1,arr2){
    for(var i = 0, len = arr2.length, current; i< len; i++){
        var pos = find(arr1, arr2[i].name); 
        current = arr2[i];
        if(pos !== -1) for(var key in arr2) arr1[pos][key] = arr2[key];
        else arr1[arr1.length] = current;
    } 
}

函数查找（objArr，keyToFind）{
var foundPos=objArr.map（函数（ob））{
返回ob.type；
}).indexOf（keyToFind）；
返回foundPos；
}
功能更新（arr1、arr2）{
对于（var i=0，len=arr2.length，current；i

这也保持了arr1的顺序。
与lodash：

_.uniqBy([...arr1, ...arr2], 'name')

根据@YOU的回答，但遵守秩序：

var arr3 = [];
for(var i in arr1){
   var shared = false;
   for (var j in arr2)
       if (arr2[j].name == arr1[i].name) {
           arr3.push(arr1[j]
           shared = true;
           break;
       }
   if(!shared) arr3.push(arr1[i])
}

for(var j in arr2){
   var shared = false;
   for (var i in arr1)
       if (arr2[j].name == arr1[i].name) {
           shared = true;
           break;
       }
   if(!shared) arr3.push(arr2[j])
}
arr3

我知道这种解决方案效率较低，但如果您想保持秩序，同时仍要更新对象，就必须这样做。
对于那些正在尝试现代事物的人：


var奇数=[{
名称：“1”，
arr：“奇数”
},
{
名称：“3”，
arr：“奇数”
}
];
var偶数=[{
名称：“1”，
arr：“偶数”
},
{
名称：“2”，
arr：“偶数”
},
{
名称：“4”，
arr：“偶数”
}
];
// ----
//ES5使用Array.filter和Array.find
函数合并（a、b、prop）{
var reduced=a.filter（函数（aitem）{
return！b.find（函数（bitem）{
返回aitem[prop]==bitem[prop]；
});
});
收益减少。concat（b）；
}
log（“ES5”，merge（奇数、偶数，“name”）；
// ----
//ES6箭头函数
函数合并（a、b、prop）{
var reduced=a.filter（aitem=>！b.find（bitem=>aitem[prop]==bitem[prop]））
收益减少。concat（b）；
}
log（“ES6”，merge（奇数、偶数，“name”）；
// ----
//ES6单班轮
var merge=（a，b，p）=>a.filter（aa=>！b.find（bb=>aa[p]==bb[p]））.concat（b）；
log（“ES6一行程序”，合并（奇数、偶数，“名称”）；
//结果
//（b数组中的内容替换a数组中的内容）
// [
//    {
//“名称”：“3”，
//“arr”：“奇数”
//     },
//     {
//“名称”：“1”，
//“arr”：“偶数”
//     },
//     {
//“名称”：“2”，
//“arr”：“偶数”
//     },
//     {
//“名称”：“4”，
//“arr”：“偶数”
//     }
//]
我编写了一个jQuery插件，用一个键合并两个对象数组。请记住，这会修改目标数组


（函数（$）{
$.extendObjectArray=函数（destArray、srcArray、key）{
对于（var index=0；index0）{
var existingIndex=destArray.indexOf（existObject[0]）；
$.extend（true，destArray[existingIndex]，srcObject）；
}否则{
destArray.push（srcObject）；
}
}
返回数组；
};
})（jQuery）；
变量arr1=[
{name:“lang”，value:“English”}，
{名称：
_.uniqBy([...arr1, ...arr2], 'name')

var arr3 = [];
for(var i in arr1){
   var shared = false;
   for (var j in arr2)
       if (arr2[j].name == arr1[i].name) {
           arr3.push(arr1[j]
           shared = true;
           break;
       }
   if(!shared) arr3.push(arr1[i])
}

for(var j in arr2){
   var shared = false;
   for (var i in arr1)
       if (arr2[j].name == arr1[i].name) {
           shared = true;
           break;
       }
   if(!shared) arr3.push(arr2[j])
}
arr3

var arr3 = _.uniqBy(arr1.concat(arr2), 'name'); // es5

let arr3 = _.uniqBy([...arr1, ...arr2], 'name'); // es6

const a = [{a: 1}, {b: 2}]
const b = [{a: 1}]

const result = a.concat(b) // [{a: 1}, {b: 2}, {a: 1}]

function merge(array1, array2, prop) {
    return array2.map(function (item2) {
        var item1 = array1.find(function (item1) {
            return item1[prop] === item2[prop];
        });
        return Object.assign({}, item1, item2);
    });
}

function mergeArrays(arrays, prop) {
    const merged = {};

    arrays.forEach(arr => {
        arr.forEach(item => {
            merged[item[prop]] = Object.assign({}, merged[item[prop]], item);
        });
    });

    return Object.values(merged);
}

var arr1 = [
    { name: 'Bob', age: 11 },
    { name: 'Ben', age: 12 },
    { name: 'Bill', age: 13 },
];

var arr2 = [
    { name: 'Bob', age: 22 },
    { name: 'Fred', age: 24 },
    { name: 'Jack', age: 25 },
    { name: 'Ben' },
];

console.log(mergeArrays([arr1, arr2], 'name'));

arr1.filter(item => {
  if (!arr2.some(item1=>item.name==item1.name)) {
    return item
  }
}).concat(arr2)

const extend = function*(ls,xs){
   yield* ls;
   yield* xs;
}

console.log( [...extend([1,2,3],[4,5,6])]  );

merge(a, b, key) {
    let merged = [];
    a.forEach(aitem => {
        let found = b.find( bitem => aitem[key] === bitem[key]);
        merged.push(found? found: aitem);
    });
    return merged;
}

const merge = (a, b, key = "id") =>
  a.filter(elem => !b.find(subElem => subElem[key] === elem[key]))
   .concat(b);

merge(arr1, arr2, 'name');

var tx = [{"id":1},{"id":2}];
var tx1 = [{"id":3},{"id":4}];


var txHistory = tx.concat(tx1)

console.log(txHistory); 
// output
 // [{"id":1},{"id":2},{"id":3},{"id":4}];

var arr1 = new Array({name: "lang", value: "German"}, {name: "age", value: "18"});
var arr2 = new Array({name : "childs", value: '5'}, {name: "lang", value: "German"});
var arr3 = [...arr1, ...arr2];

    arr3 = [
      {"name":"lang","value":"German"},
      {"name":"age","value":"18"},
      {"name":"childs","value":"5"},
      {"name":"lang","value":"German"}
    ]

function mergeObjectArraysRemovingDuplicates(firstObjectArray, secondObjectArray) {
  return firstObjectArray.concat(
    secondObjectArray.filter((object) => !firstObjectArray.map((x) => x.uniqueId).includes(object.uniqueId)),
  );
}

const merge = (arr1, arr2, prop) => {
    const resultMap = new Map(arr1.map((item) => [item[prop], item]));
    arr2.forEach((item) => {
        const mapItem = resultMap.get(item[prop]);
        if (mapItem) Object.assign(mapItem, item);
        else resultMap.set(item[prop], item);
    });
    return [...resultMap.values()];
};

const arr1 = new Array({name: "lang", value: "English"}, {name: "age", value: "18"});
const arr2 = new Array({name : "childs", value: '5'}, {name: "lang", value: "German"});

console.log(merge(arr1, arr2, "name"));

let mergeArray = arrA.filter(aItem => !arrB.find(bItem => aItem.name === bItem.name))