वस्तुओं के 2 सरणियों को मिलाएं

Question

एक उदाहरण पर नजर डालते हैं।

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

मुझे उन 2 सरणियों को मर्ज करने और निम्न सरणी बनाने की आवश्यकता है:

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

क्या ऐसा करने के लिए कोई जावास्क्रिप्ट या jQuery फ़ंक्शन है?

$.extendमुझे शोभा नहीं देता। यह लौट आता है

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

Comments

क्या हुआ था {name: "lang", value: "English"}?

— शैडो विजार्ड इयर फॉर यू यू

माफ़ करना। मैं $ .extend का उल्लेख करता हूं, $ .merge का नहीं।

— अलेक्जेंडर

मेरा मतलब है, क्या तर्क शामिल है? आप ऐरे को कैसे मर्ज करना चाहते हैं? यह आपके उदाहरणों से स्पष्ट नहीं है।

— शैडो विजार्ड ईआर फॉर यू आपके लिए

आपको बहुत बहुत धन्यवाद। मैंने इसे मैन्युअल रूप से किया।

— अलेक्जेंडर

@ शडवॉइडर, मुझे लगता है कि ओपी का मतलब क्या था अगर मौजूद था और पुश नहीं था तो अपडेट था।

— अमीन मोहम्मद अजानी

Answer 1

यदि आप जावास्क्रिप्ट में वस्तुओं के 2 सरणियों को मर्ज करना चाहते हैं। आप इस एक लाइन ट्रिक का उपयोग कर सकते हैं

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

Comments

यह अब तक का सबसे सरल उपयोग है और ठीक काम करता है। इसे शेयर करने के लिए धन्यवाद।

— लियो केसीरो

बहुत सरल के रूप में एक ही परिणाम:arr1 = arr1.concat(arr2)

— कीथजॉली

लेकिन यह विलय नहीं है!

— दिमित्री कोपरीवा

परिणाम समान नहीं हैं। concatएक नया सरणी लौटाएगा और आपके पास मौजूद किसी भी संदर्भ को तोड़ देगा।

— Bpainter

यह प्रश्न का उत्तर नहीं देता है, जिसके परिणामस्वरूप सरणी में 3 ऑब्जेक्ट होना चाहिए, न कि 4. आपने नमूना मूल्यों को बदल दिया। मूल रूप से ओपी चाहता है कि दो ऑब्जेक्ट सरणियों को मर्ज किया जाए और डुप्लिकेट मानों को हटा दिया जाए।

— रंजन

Answer 2

ES6 के साथ आप इसे नीचे की तरह बहुत आसान कर सकते हैं:

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

Comments

यह शीर्ष उत्तर होना चाहिए।

— nocdib

यह वही ओपी लिए देख रहा था ऐसा नहीं करता है, वहाँ एक दूसरे से युक्त वस्तु नहीं होना चाहिए{ name: 'lang', value: 'German'}

— विल

मुझे इसका कारण पता नहीं है कि यह उत्तर क्यों दिया गया है। क्या @ daveanderson88 चाहते हैं यह जवाब अलग है।

— गुयेन

Answer 3

उन लोगों के लिए जो आधुनिक चीजों के साथ प्रयोग कर रहे हैं:

var odd = [
    { name : "1", arr: "in odd" },
    { name : "3", arr: "in odd" }
];

var even = [
    { name : "1", arr: "in even" },
    { name : "2", arr: "in even" },
    { name : "4", arr: "in even" }
];

// ----
// ES5 using Array.filter and Array.find
function merge(a, b, prop){
  var reduced = a.filter(function(aitem){
      return ! b.find(function(bitem){
          return aitem[prop] === bitem[prop];
      });
  });
  return reduced.concat(b);
}
console.log( "ES5", merge(odd, even, "name") );

// ----
// ES6 arrow functions
function merge(a, b, prop){
    var reduced =  a.filter( aitem => ! b.find ( bitem => aitem[prop] === bitem[prop]) )
  return reduced.concat(b);
}
console.log( "ES6", merge(odd, even, "name") );

// ----
// ES6 one-liner
var merge = (a, b, p) => a.filter( aa => ! b.find ( bb => aa[p] === bb[p]) ).concat(b);


console.log( "ES6 one-liner", merge(odd, even, "name") );

// Results
// ( stuff in the "b" array replaces things in the "a" array )
// [
//    {
//         "name": "3",
//         "arr": "in odd"
//     },
//     {
//         "name": "1",
//         "arr": "in even"
//     },
//     {
//         "name": "2",
//         "arr": "in even"
//     },
//     {
//         "name": "4",
//         "arr": "in even"
//     }
// ]

Answer 4

अपडेट 12 अक्टूबर 2019

नया संस्करण केवल नए जावास्क्रिप्ट पर आधारित है और बिना किसी तीसरे पक्ष के पुस्तकालय की आवश्यकता के।

const mergeByProperty = (target, source, prop) => {
  source.forEach(sourceElement => {
    let targetElement = target.find(targetElement => {
      return 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: "German"}];

mergeByProperty(target, source, 'name');

console.log(target)

यह जवाब पुराना हो रहा था, इन दिनों लॉश और अंडरस्कोर जैसे कामों की बहुत कम जरूरत है। इस नए संस्करण में, लक्ष्य (arr1) सरणी वह है जिसके साथ हम काम कर रहे हैं और अद्यतित रहना चाहते हैं। स्रोत (arr2) सरणी जहां नए डेटा से आ रही है, और हम यह हमारे में विलय चाहते लक्ष्य सरणी।

हम से अधिक पाश स्रोत सरणी नए डेटा की तलाश में है, और हर वस्तु है कि अभी तक हमारे में नहीं पाया जाता के लिए लक्ष्य सरणी हम बस उस वस्तु का उपयोग कर जोड़ने के target.push (sourceElement) हैं, तो हमारे के आधार पर प्रमुख संपत्ति ( 'नाम') , एक ऑब्जेक्ट पहले से ही हमारे लक्षित सरणी में है - हम Object.assign (targetElement, sourceElement) का उपयोग करके इसके गुणों और मूल्यों को अपडेट करते हैं । हमारा "लक्ष्य" हमेशा एक ही सरणी और अद्यतन सामग्री के साथ होगा।

---

अंडरस्कोर या लॉश का उपयोग करके पुराना उत्तर

मैं हमेशा Google से यहां आता हूं और मैं हमेशा उत्तरों से संतुष्ट नहीं होता हूं। आप उत्तर अच्छा है लेकिन यह underscore.js का उपयोग करना आसान और आसान होगा

डेमो: http://jsfiddle.net/guya/eAWKR/

यहां एक अधिक सामान्य फ़ंक्शन है जो अपनी वस्तुओं की संपत्ति का उपयोग करके 2 सरणियों का विलय करेगा। इस मामले में संपत्ति 'नाम' है

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

function mergeByProperty(arr1, arr2, prop) {
  _.each(arr2, function(arr2obj) {
    var arr1obj = _.find(arr1, function(arr1obj) {
      return arr1obj[prop] === arr2obj[prop];
    });

    arr1obj ? _.extend(arr1obj, arr2obj) : arr1.push(arr2obj);
  });
}

mergeByProperty(arr1, arr2, 'name');

console.log(arr1);

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.core.min.js"></script>

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

Comments

LOC में लगभग समान, @ के जवाब के रूप में जटिलता, सिवाय इसके कि यह बहुत धीमा है (मोटे तौर पर अतिरिक्त फ़ंक्शन कॉल के कारण और तथ्य यह है कि आप का उत्तर जेएस साहचर्य सरणियों चाल का फायदा उठाकर ओ (1) लुकअप के साथ आइटम ढूंढता है)। यह इस तथ्य के अलावा है कि आपको एक अतिरिक्त पुस्तकालय लाने की आवश्यकता है।

— मृकफ

जब तक आप चरम किनारे के मामलों से निपट नहीं लेते आपको प्रदर्शन में कोई अंतर नहीं मिलेगा। अतिरिक्त परिवाद के बारे में - अंडरस्कोर, लॉश और एक जैसे आम तौर पर पहले से ही उपयोग किए जाते हैं और अन्य लाभ हैं, किसी को भी इसका उपयोग करने पर विचार करना चाहिए। अधिकांश डेवलपर्स और ऐप इस समाधान की सादगी और व्यापकता से लाभान्वित होंगे।

— गुया

@ गुय्या मुझे एहसास है कि यह पुराना है, लेकिन अंडरस्कोर, लॉश और एक जैसे आम तौर पर पहले से ही उपयोग किए जाते हैं और अन्य लाभ हैं, जबकि आप कहते हैं कि उनके पास अन्य लाभ हैं, यह कहने की एक बड़ी धारणा है कि वे आम तौर पर पहले से ही उपयोग किए जाते हैं।

— क्राइसिसजैक

Answer 5

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

Comments

इस उत्तर में समय की जटिलता है (O (n ^ 2))। हैश मैप का उपयोग करके O (n) समाधान संभव है।

— एलेक्स वॉन ब्रैंडेनफेल्स

Answer 6

ES6 प्रसार ऑपरेटर का उपयोग करके बहुत ही सरल:

const array1 = [{a: 'HI!'}, {b: 'HOW'}]
const array2 = [{c: 'ARE'}, {d: 'YOU?'}]

const mergedArray = [ ...array1, ...array2 ]
console.log('Merged Array: ', mergedArray)

<script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.1.0/react.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.1.0/react-dom.min.js"></script>

Merged Array: [ {a: 'HI!'}, {b: 'HOW'} {c: 'ARE'}, {d: 'YOU?'} ]

ध्यान दें: उपरोक्त समाधान ES6 स्प्रेड ऑपरेटर का उपयोग करके केवल दो सरणियों का विलय करना है।

07 जनवरी 2020 को @ bh4r4th द्वारा संपादित करें: जैसा कि मेरे प्रारंभिक समाधान के बाद संपादन के कारण संदर्भ बदल गया। मैं मौजूदा मानदंडों से मेल खाने के लिए अपने समाधान को अपडेट करना चाहूंगा। अर्थात,

1. डुप्लिकेट ऑब्जेक्ट्स बनाए बिना मर्ज सरणी ऑब्जेक्ट्स और

2. valueयदि nameसंपत्ति पहले से मौजूद है तो उसे अपडेट करें

const arr1 = [
    { name: "lang", value: "English" },
    { name: "age", value: "18" }
]
const arr2 = [
    { name: "childs", value: '2' }, 
    { name: "lang", value: "German" }
]
const arr3 = [
    { name: "lang", value: "German" },
    { name: "age", value: "28" },
    { name: "childs", value: '5' }
]

// Convert to key value dictionary or object
const convertToKeyValueDict = arrayObj => {
    const val = {}
    arrayObj.forEach(ob => {
        val[ob.name] = ob.value
    })
    return val
}

// update or merge array
const updateOrMerge = (a1, a2) => {
    const ob1 = convertToKeyValueDict(a1)
    const ob2 = convertToKeyValueDict(a2)
    // Note: Spread operator with objects used here
    const merged_obj = {...ob1, ...ob2}
    const val = Object.entries(merged_obj)
    return val.map(obj => ({ name: obj[0], value: obj[1] }))
}

const v1 = updateOrMerge(arr1, arr2)
const v2 = updateOrMerge(v1, arr3)
console.log(`Merged array1 and array2: ${JSON.stringify(v1)} \n\n`)
console.log(`Merged above response and array3: ${JSON.stringify(v2)} \n\n`)

<script src="https://cdnjs.cloudflare.com/ajax/libs/react/16.6.3/umd/react.production.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react-dom/16.6.3/umd/react-dom.production.min.js"></script>

Comments

यह 2019 में स्वीकृत उत्तर होना चाहिए! मैं उच्च मतों के साथ अन्य उत्तरों को देखने के बाद उसी समाधान का प्रस्ताव करने जा रहा था! @ अलेक्सेंडर को याद करना आसान है लेकिन कृपया इसे स्वीकार करें!

— iaforek

गलत। प्रश्नकर्ता विशेष रूप से वस्तुओं को REPLACE करना चाहता है यदि उनके पास एक डुप्लिकेट संपत्ति है, न कि केवल उन्हें संलग्न करें।

— हैवस्पेक्टस

यह इंगित करने के लिए धन्यवाद कि @HaveSpacesuit। मैंने 2018 में इस सवाल का जवाब दिया है जब संदर्भ सिर्फ दो सरणियों का विलय करना है। setडुप्लिकेट को हटाने के लिए मर्ज पर उपयोग करने के लिए जल्द ही इस जवाब को संपादित करेगा । यह नया चर तर्क लेकिन न्यूनतम कोड बनाएगा। हालांकि, मैं पेलोड का बहुत बड़ा प्रशंसक नहीं हूं, जिसमें विभिन्न प्रकार के गुणों और मूल्यों के रूप में परिभाषित नाम हैं। इसके बजाय मैं पसंद करता हूं [ { lang: 'German', age: 25}] । सेवाओं के बीच संचार करते समय इस तरह से पेलोड का वजन कम किया जाएगा।

— bh4r4th

मैंने अब प्रश्न के बदले हुए संदर्भ से मिलान करने के लिए समाधान को अपडेट कर दिया है।

— bh4r4th

Answer 7

दो सरणियों को जोड़ना:

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

'नाम' के डुप्लिकेट मानों के बिना दो सरणियों को जोड़ना:

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

Comments

Array.concat 2 सरणियों को एक में विलय करने का उचित तरीका है। मुझे यह भी विस्तारित धारणा पसंद है कि "सच्चे" मर्ज की अवधारणा को संबोधित किया गया था (प्रत्येक सरणी तत्व की दी गई कुंजी के आधार पर)।

— बॉब

Answer 8

सबसे आसान तरीका कुछ ES6 जादू के साथ है:

डुप्लिकेट के साथ दो मर्ज करें:

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

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

डुप्लिकेट के बिना यह ऊपर के प्लस के समान है:

const distinct = [...new Set(result.map(item => item.YOUR_PROP_HERE))]

Comments

concat अलग-अलग natures की वस्तुओं के साथ काम नहीं करता है

— fdsfdsfdsfds

Answer 9

दर्ज करने के साथ:

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

Comments

ES6 सिंटैक्स 2 सरणियों के साथ काम करता है, वस्तुओं के 2 सरणियों के साथ नहीं।

— डारियो

Answer 10

इस तरह से मैंने ES6 संदर्भ में इसी तरह के मुद्दे को निपटाया है:

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

नोट: यह दृष्टिकोण array1 से किसी भी आइटम को नहीं लौटाएगा जो array2 में दिखाई नहीं देता है।

---

संपादित करें: मेरे पास कुछ परिदृश्य हैं जहां मैं उन वस्तुओं को संरक्षित करना चाहता हूं जो दूसरी सरणी में दिखाई नहीं देती हैं इसलिए मैं दूसरी विधि के साथ आया हूं।

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

Answer 11

अभी तक एक और संस्करण का उपयोग कर reduce() method:

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 arr = arr1.concat(arr2).reduce(function(prev, current, index, array){ 
   
   if(!(current.name in prev.keys)) {
      prev.keys[current.name] = index;
      prev.result.push(current);   
   } 
   else{
       prev.result[prev.keys[current.name]] = current;
   }  

   return prev;
},{result: [], keys: {}}).result;
  
document.getElementById("output").innerHTML = JSON.stringify(arr,null,2);    

<pre id="output"/>

Comments

यह मेरे लिए बहुत अच्छा काम किया। एक छोटा सा मुद्दा है, हालांकि कभी-कभी 3 बड़े

— जोंस

Answer 12

सरल उपाय

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}];

Answer 13

आप डुप्लिकेट को प्रतिस्थापित करते समय अपने गुणों को इकट्ठा करने के लिए किसी ऑब्जेक्ट का उपयोग कर सकते हैं और फिर उस ऑब्जेक्ट को किसी सरणी में वापस फैला / समतल कर सकते हैं। कुछ इस तरह:

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

मुझे नहीं पता कि यह सबसे तेज़ तरीका है लेकिन यह किसी भी संख्या में इनपुट सरणियों के लिए काम करता है; उदाहरण के लिए, यह:

var a = expand(
    merge(
        [{name: "lang", value: "English"}, {name: "age", value: "18"}],
        [{name: "childs", value: '5'}, {name: "lang", value: "German"}],
        [{name: 'lang', value: 'Pancakes'}]
    )
);

तुम्हें वही चीज देता है, aजिसमें वह थाarr3 "पेनकेक्स" द्वारा प्रतिस्थापित "जर्मन" के साथ ।

यह दृष्टिकोण यह मानता है कि आपकी वस्तुओं में सभी का समान {name: ..., value: ...}रूप है।

आप इसे यहां काम करते हुए देख सकते हैं (कृपया अपना कंसोल खोलें): http://jsfiddle.net/ambiguous/UtBbB/

Answer 14

JQuery मर्ज के बारे में क्या?

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

jsFiddle उदाहरण यहां: http://jsfiddle.net/ygByD/

Comments

यह जर्मन के साथ अंग्रेजी को निर्दिष्ट नहीं करेगा, nameगुण के साथ विलय हो रहा है ।

— एमयू

आह, तुम ठीक कह रहे हो! मैंने उस विनिर्देश को एक नज़र में नहीं देखा!

— 321X

+1। कुंआ! दूसरी ओर वस्तुओं की जावास्क्रिप्ट सरणियों को मिलाने के लिए यह एक अच्छा कार्य है

— मुहम्मद रहेल

Answer 15

मैं एक ही समस्या का सामना कर रहा था और guya उत्तर के आधार पर मैंने अंडरस्कोर लाइब्रेरी का विस्तार किया है और थोड़ी और कार्यक्षमता भी जोड़ी है जो मुझे आवश्यक थी। यहाँ Gist है ।

/**
 * Merges two object-like arrays based on a key property and also merges its array-like attributes specified in objectPropertiesToMerge.
 * It also removes falsy values after merging object properties.
 *
 * @param firstArray The original object-like array.
 * @param secondArray An object-like array to add to the firstArray.
 * @param keyProperty The object property that will be used to check if objects from different arrays are the same or not.
 * @param objectPropertiesToMerge The list of object properties that you want to merge. It all must be arrays.
 * @returns The updated original array.
 */
function merge(firstArray, secondArray, keyProperty, objectPropertiesToMerge) {

    function mergeObjectProperties(object, otherObject, objectPropertiesToMerge) {
        _.each(objectPropertiesToMerge, function (eachProperty) {
            object[eachProperty] = _.chain(object[eachProperty]).union(otherObject[eachProperty]).compact().value();
        });
    }

    if (firstArray.length === 0) {
        _.each(secondArray, function (each) {
            firstArray.push(each);
        });
    } else {
        _.each(secondArray, function (itemFromSecond) {
            var itemFromFirst = _.find(firstArray, function (item) {
                return item[keyProperty] === itemFromSecond[keyProperty];
            });

            if (itemFromFirst) {
                mergeObjectProperties(itemFromFirst, itemFromSecond, objectPropertiesToMerge);
            } else {
                firstArray.push(itemFromSecond);
            }
    });
    }

    return firstArray;
}

_.mixin({
            merge: merge
        });

आशा है कि यह उपयोगी होगा! सादर!

Answer 16

मैं हाल ही में इस समस्या से रुका हुआ था और मैं यहां एक उत्तर पाने की उम्मीद के साथ आया था, लेकिन स्वीकृत उत्तर छोरों के लिए 2 का उपयोग करता है जिसे मैं पसंद नहीं करूंगा। मैं आखिरकार अपना बनाने में कामयाब रहा। किसी भी पुस्तकालय पर निर्भर नहीं करता है:

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

यह भी arr1 के क्रम को बनाए रखता है।

Answer 17

आप निम्नलिखित फ़ंक्शन का उपयोग कर सकते हैं

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

और कोशिश

merge(arr1, arr2, 'name');

Comments

ES6 अपरिवर्तनीय विशेषता के साथ डायगो के लिए धन्यवाद `` निर्यात कास्ट मर्जअरे = (a1, a2, key = "id") => a1 && a2! = Null [... a1.filter (a =>! a2.find (p => p [key] === [a key]), ... a2]: null; `` `

— मूसा

Answer 18

यहां मैं पहले arr1तत्व में मौजूद तत्व के आधार पर फ़िल्टर करता हूं arr2या नहीं। यदि यह मौजूद है तो इसे परिणामस्वरूप सरणी में न जोड़ें अन्यथा जोड़ दें। और फिर मैं arr2परिणाम के लिए संलग्न हूं ।

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

Comments

कृपया अपने उत्तर की व्याख्या प्रदान करें। इसलिए यदि कोई अन्य व्यक्ति प्रश्न और उत्तर को पढ़ता है तो इसे आसानी से समझा जा सकता है।

— मित्तल पटेल

हालांकि यह उत्तर संभवतः सही और उपयोगी है, यह पसंद किया जाता है यदि आप इसे समझाने के साथ कुछ स्पष्टीकरण भी शामिल करते हैं कि यह समस्या को हल करने में कैसे मदद करता है। यह भविष्य में विशेष रूप से उपयोगी हो जाता है, अगर कोई परिवर्तन (संभवतः असंबंधित) होता है जो इसे काम करना बंद कर देता है और उपयोगकर्ताओं को यह समझने की आवश्यकता है कि यह एक बार कैसे काम करता है।

— एरी सीदोएल

आप लोगों को धन्यवाद। मैंने समाधान का विवरण अपडेट किया। अगर यह सही लगता है तो pls upvote :)

— मौलिक भट्ट

Answer 19

मेरे सिर के ऊपर से - कोशिश करें jquery का विस्तार

var arr3 = jQuery.extend(arr1,arr2....)

Comments

माफ़ करना। वास्तव में यह फ़ंक्शन arr4 देता है। $ नहीं। आखिरी मुझे भी शोभा नहीं देता, क्योंकि यह वस्तुओं की नकल करता है।

— अलेक्जेंडर

Answer 20

var newArray = yourArray.concat(otherArray); console.log('Concatenated newArray: ', newArray);

Comments

मैं मानता हूं कि यह Array.protype.push.apply()उत्तर की तुलना में बहुत अधिक समझ में आता है , लेकिन, यह ओपी की तरह विलय नहीं करता है।

— 14

यदि आप वस्तुओं के दो मर्ज सरणी रखते हैं, तो आप 'कॉनकट' का उपयोग करके उपरोक्त आउटपुट प्राप्त नहीं कर सकते। कृपया इसे देखें: jsfiddle.net/jahanzaibaslam/z22n5tuo

— जहानज़ीब असलम

Answer 21

@ आप के उत्तर के आधार पर लेकिन आदेश रखते हुए:

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

मुझे पता है कि यह समाधान कम कुशल है, लेकिन यदि आप ऑर्डर रखना चाहते हैं और अभी भी वस्तुओं को अपडेट करना चाहते हैं तो यह आवश्यक है।

Answer 22

यहां एक jQuery प्लगइन है जिसे मैंने एक कुंजी द्वारा दो ऑब्जेक्ट सरणियों को मर्ज करने के लिए लिखा है। ध्यान रखें कि यह गंतव्य सरणी को जगह में संशोधित करता है।

(function($) {
  $.extendObjectArray = function(destArray, srcArray, key) {
    for (var index = 0; index < srcArray.length; index++) {
      var srcObject = srcArray[index];
      var existObject = destArray.filter(function(destObj) {
        return destObj[key] === srcObject[key];
      });
      if (existObject.length > 0) {
        var existingIndex = destArray.indexOf(existObject[0]);
        $.extend(true, destArray[existingIndex], srcObject);
      } else {
        destArray.push(srcObject);
      }
    }
    return destArray;
  };
})(jQuery);

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

console.log(JSON.stringify(arr3, null, 2));

.as-console-wrapper { top: 0; max-height: 100% !important; }

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

---

ES6 संस्करण

(function($) {
  $.extendObjectArray = (destArr, srcArr, key) => {
    srcArr.forEach(srcObj => (existObj => {
      if (existObj.length) {
        $.extend(true, destArr[destArr.indexOf(existObj[0])], srcObj);
      } else {
        destArr.push(srcObj);
      }
    })(destArr.filter(v => v[key] === srcObj[key])));
    return destArr;
  };
})(jQuery);

Answer 23

लॉश का उपयोग करके आप _.uniqBy चाहते हैं

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

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

Arr1 का आदेश, arr2 मामले!

डॉक्स https://lodash.com/docs/4.17.4#uniqBy देखें

Comments

तीसरे पक्ष का उपयोग करने की आवश्यकता है?

— गुयेन

नहीं, लेकिन इसे प्राप्त करने का सबसे संक्षिप्त तरीका है, और इसकी कोई तीसरी पार्टी नहीं है, इसकी लश्कर!

— danday74

Answer 24

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

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

Comments

बस प्रश्न का उत्तर प्रदान न करें। यह भी बताएं कि यह समाधान समस्या को कैसे हल करता है।

— मित्तल पटेल

Answer 25

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

Answer 26

यदि आप 2 सरणियों को मर्ज करना चाहते हैं, लेकिन निकालें डुप्लिकेट ऑब्जेक्ट इसका उपयोग करते हैं। .uniqueIdप्रत्येक वस्तु पर डुप्लिकेट की पहचान की जाती है

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

Answer 27

इसे इस्तेमाल करे:

var a = [{"a":20, "b":10,"c":"c","d":"asd","f":"any"}]
var b = [{"a":20, "b":10,"c":"c", "e":"nan","g":10200}]

var p = []
_.map(a, function(da){
var chk = _.filter(b, function(ds){
return da.a ===ds.a
})[0]
p.push(_.extend(da, chk))


})

console.log(p)

आउटपुट होगा:

  [{
    "a": 20,
    "b": 10,
    "c": "c",
    "d": "asd",
    "f": "any",
    "e": "nan",
    "g": 10200
  }]

Answer 28

const arr1 = ["Vijendra","Singh"];
const arr2 = ["Singh", "Shakya"];

arr2.forEach(item => {
        if(!arr1.find(k => k===item))
          arr1.push(item)
    });


console.log(arr1)

Answer 29

जेएस मैप का उपयोग कर समाधान:

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

जो उत्पादन करता है:

Answer 30

const array1 = [{id:1,name:'ganza'},
{id:2,name:'respice dddd'},{id:4,name:'respice dddd'},{id:6,name:'respice dddd'},
{id:7,name:'respice dddd'}];
const array2 = [{id:1,name:'ganza respice'},{id:2,name:'respice'},{id:3,name:'mg'}];

 function mergeTwoArray(array1,array2){

    return array1.map((item,i)=>{
        if(array2[i] && item.id===array2[i].id){
          return array2[i];
          }else{
            return item;
          }
    });
  }

const result = merge(array1,array2);
console.log(result);
//here is the result:  Array [Object { id: 1, name: "ganza respice" }, Object { id: 2, name: "respice" }, Object { id: 4, name: "respice dddd" }, Object { id: 6, name: "respice dddd" }, Object { id: 7, name: "respice dddd" }]