복붙노트

[JQUERY] 객체의 두 배열을 병합

JQUERY

객체의 두 배열을 병합

해결법

  1. 1.경우에 당신은 자바 스크립트에서 객체의 두 배열을 병합 할. 이 한 줄의 트릭을 사용할 수 있습니다

    경우에 당신은 자바 스크립트에서 객체의 두 배열을 병합 할. 이 한 줄의 트릭을 사용할 수 있습니다

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

  2. 2.ES6하면 다음과 같이 매우 쉽게 그것을 할 수 있습니다 :

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

  3. 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"
//     }
// ]

  4. 4.CONST mergeByProperty = (대상, 소스, 소품) => { source.forEach (sourceElement => { {targetElement = 목표물에 (targetElement =>를 보자 창 sourceElement [소품] === targetElement [소품]; }) targetElement? Object.assign (targetElement, sourceElement) : target.push (sourceElement); }) } VAR 타겟 / arr1 * * / = [{상품명 : "LANG"값 "영어"}, {상품명 : 「연령」, 값 "18"}]; VAR 소스 / * * arr2 / = [{상품명 : "차일"값이 '5'}, {상품명 : "LANG"값 "독일어"}]; mergeByProperty (대상, 소스, '이름'); CONSOLE.LOG (목표)

    CONST mergeByProperty = (대상, 소스, 소품) => { source.forEach (sourceElement => { {targetElement = 목표물에 (targetElement =>를 보자 창 sourceElement [소품] === targetElement [소품]; }) targetElement? Object.assign (targetElement, sourceElement) : target.push (sourceElement); }) } VAR 타겟 / arr1 * * / = [{상품명 : "LANG"값 "영어"}, {상품명 : 「연령」, 값 "18"}]; VAR 소스 / * * arr2 / = [{상품명 : "차일"값이 '5'}, {상품명 : "LANG"값 "독일어"}]; mergeByProperty (대상, 소스, '이름'); CONSOLE.LOG (목표)

    이 답변 lodash처럼 LIBS, 늙어되고 밑줄 훨씬 덜 이러한 일이 필요하다. 이 새 버전에서는 대상 (arr1) 배열은 우리가 작업하고 최신 상태로 유지하려면하고있는 것입니다. 소스 (arr2) 배열은 새로운 데이터가 어디에서 오는이며, 우리는 우리의 대상 배열로 병합합니다.

    새로운 데이터를 찾고 소스 배열을 통해 우리는 루프, 아직 우리의 목표 배열에없는 모든 개체에 대해 우리는 단순히 target.push를 사용하여 해당 개체를 추가 (sourceElement) 우리의 주요 특성 ( '이름')을 기준으로하면, 객체는 목표 배열에 이미 - 우리가 Object.assign (targetElement, sourceElement)를 사용하여 해당 속성과 값을 업데이트합니다. 우리의 "대상"항상 같은 배열 및 업데이트 내용과 함께합니다.

    나는 항상 구글에서 여기에 도착하고 난 항상 답변에서 만족하고 있지 않다. 당신 대답은 잘하지만 underscore.js를 사용하여 깔끔한 쉽게하고 있습니다

    DEMO : http://jsfiddle.net/guya/eAWKR/

    여기에 해당 개체의 속성을 사용하여 두 배열을 병합하는 일반적인 기능입니다. 이 경우 속성은 '이름'입니다

    VAR arr1 = [{상품명 : "LANG"값 "영어"}, {상품명 : 「연령」, 값 "18"}]; VAR arr2 = [{상품명 : "차일"값이 '5'}, {상품명 : "LANG"값 "독일어"}]; 함수 mergeByProperty (arr1, arr2, 소품) { _.each (arr2 함수 (arr2obj) { VAR arr1obj = _.find (arr1 함수 (arr1obj) { arr1obj 복귀 [소품] === arr2obj [소품]; }); arr1obj? _.extend (arr1obj, arr2obj) arr1.push (arr2obj)를; }); } mergeByProperty (arr1, arr2, '이름'); CONSOLE.LOG (arr1); <스크립트 SRC = "https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.core.min.js"> 

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

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

  6. 6.매우 간단한 사용 ES6 확산 운영자 :

    매우 간단한 사용 ES6 확산 운영자 :

    CONST 배열 1 = [{A 'HI!}, {B :'HOW '}] CONST 배열 2 = [{(C) '는'}, {D '? YOU를'}] CONST mergedArray = ... 배열 1, ... 배열 2] 을 console.log ( '병합 된 배열', mergedArray) <스크립트 SRC = "https://cdnjs.cloudflare.com/ajax/libs/react/15.1.0/react.min.js"> <스크립트 SRC = "https://cdnjs.cloudflare.com/ajax/libs/react/15.1.0/react-dom.min.js">

    병합 어레이 [{A '안녕'}, {B : 'HOW'} {C '는'}, {D '? YOU를'}]

    참고 : 위의 솔루션은 단지 ES6 확산 연산자를 사용하여 두 배열을 병합하는 것입니다.

    @ bh4r4th 07 년 1 월 2020 편집 : 컨텍스트 내 초기 솔루션 후 편집에 의한 변경으로. 나는 현재의 기준에 맞게 내 솔루션을 업데이트하고 싶습니다. 즉

    CONST arr1 = {이름 : "LANG"값 : "영어"}, {이름 : "나이", 값 : "18"} ] CONST arr2 = {이름 : "차일", 값 : '2'} {이름 : "LANG"값 : "독일어"} ] CONST arr3 = {이름 : "LANG"값 : "독일어"}, {이름 : "나이", 값 : "28"}, {이름 : "차일", 값 : '5'} ] // 키 값을 사전 또는 개체로 변환 CONST convertToKeyValueDict arrayObj = => { CONST 브로 = {} arrayObj.forEach (OB => { 발 [ob.name = ob.value }) 반환 발 } // 갱신 또는 병합 배열 CONST updateOrMerge = (A1, A2) => { CONST OB1 convertToKeyValueDict = (A1) CONST OB2 convertToKeyValueDict = (A2) // 참고 : 개체가 확산 운영자는 여기에 사용 const를 merged_obj = {... OB1, ... OB2} CONST 브로 = Object.entries (merged_obj) 리턴 val.map (OBJ => ({상품명 : OBJ [0] 값 : OBJ [1]})) } V1 = CONST updateOrMerge (arr1, arr2) V2 = CONST updateOrMerge (V1, arr3) 을 console.log ( '병합하는 array1과 array2는 $ {JSON.stringify (V1)} \ n \ n`) CONSOLE.LOG (응답 array3 위의 합병`$ {JSON.stringify (V2)} \ n \ n`) <스크립트 SRC = "https://cdnjs.cloudflare.com/ajax/libs/react/16.6.3/umd/react.production.min.js"> <스크립트 SRC = "https://cdnjs.cloudflare.com/ajax/libs/react-dom/16.6.3/umd/react-dom.production.min.js">

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

  8. 8.가장 쉬운 방법은 몇 가지 ES6의 마법입니다 :

    가장 쉬운 방법은 몇 가지 ES6의 마법입니다 :

    중복 두 병합 :

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

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

    중복 없이는 위의 플러스와 동일합니다 :

    CONST 구별 = ... 새로운 세트 (result.map (항목 => item.YOUR_PROP_HERE))]

  9. 9.그러나 사용하여 다른 버전은 () 메소드를 줄일 수 :

    그러나 사용하여 다른 버전은 () 메소드를 줄일 수 :

    var에 arr1 새로운 배열 = ({이름 : "LANG을"값 : "영어"}, {이름 : "나이", 값 : "18"}); var에 arr2 새로운 배열 ({이름 : "LANG"값 : "독일어"} { "차일", 값 '5'이름}) =; VAR 도착 = arr1.concat (arr2) .reduce (함수 (이전, 현재, 인덱스 어레이) { 경우 (prev.keys에서! (current.name)) { prev.keys [current.name = 인덱스; prev.result.push (전류); } 그밖에{ prev.result [prev.keys [current.name] = 현재; } 이전 반환; }, {결과, [], 키 {}}) 결과]. . document.getElementById를 ( "출력") = innerHTML을 JSON.stringify (도착, NULL, 2); <프리 ID = "출력"/>

  10. 10.lodash로 :

    lodash로 :

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

  11. 11.이것은 내가 ES6의 맥락에서 유사한 문제를 달려 한 방법입니다 :

    이것은 내가 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);
    });
}

    참고 :이 방법은 배열 2에 표시되지 않습니다 배열 1에서 모든 항목을 반환하지 않습니다.

    편집 : 난 내가 다른 방법을 함께했다, 그래서 두 번째 배열에 표시되지 않는 항목을 유지하려면 몇 가지 시나리오가 있습니다.

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

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

  13. 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'}]
    )
);

    당신에게 "팬케이크"로 대체 "독일어"로 arr3에 있던에서 같은 일을 제공합니다.

    이러한 접근 방식은 당신의 객체가 모두 같은 있다고 가정 않습니다 {이름 : ..., 값 : ...} 물론 형태.

    당신이 (당신의 콘솔을하시기 바랍니다 열) 여기서 일하는 볼 수 있습니다 http://jsfiddle.net/ambiguous/UtBbB/

  14. 14.jQuery를 병합에 대해 무엇?

    jQuery를 병합에 대해 무엇?

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

    여기 jsFiddle 예 : http://jsfiddle.net/ygByD/

  15. 15.저도 같은 문제에 직면하고 guya의 답변에 따라 내가 조금 더 많은 기능의 내가 필요로하는 것을 추가 또한 밑줄 라이브러리를 확장하고있다. 여기에 요점이다.

    저도 같은 문제에 직면하고 guya의 답변에 따라 내가 조금 더 많은 기능의 내가 필요로하는 것을 추가 또한 밑줄 라이브러리를 확장하고있다. 여기에 요점이다.

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

    유용하기를 희망! 문안 인사!

  16. 16.나는 최근에이 문제로 난처한 상황에 빠진 있었고, 난 내가 선호하지 않을 루프에 대한 답변 만 허용 대답 사용하는 2를 가지고 희망으로 여기에왔다. 나는 마침내 내 자신을 만들 수 있었다. 어떤 라이브러리 무엇이든지에 의존하지 않는다 :

    나는 최근에이 문제로 난처한 상황에 빠진 있었고, 난 내가 선호하지 않을 루프에 대한 답변 만 허용 대답 사용하는 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의 순서를 유지한다.

  17. 17.당신은 다음과 같은 기능을 사용할 수 있습니다

    당신은 다음과 같은 기능을 사용할 수 있습니다

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

    시도

    merge(arr1, arr2, 'name');

  18. 18.여기서 I는 제 1 필터 arr1 arr2 또는 존재하지 요소에 기초. 그것의 존재는 다음 배열을 결과에 추가하지 않으면 다른 추가 기능을한다. 그리고 나는 결과에 arr2를 추가합니다.

    여기서 I는 제 1 필터 arr1 arr2 또는 존재하지 요소에 기초. 그것의 존재는 다음 배열을 결과에 추가하지 않으면 다른 추가 기능을한다. 그리고 나는 결과에 arr2를 추가합니다.

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

  19. 19.내 머리 위로 떨어져 - 시도는 확장 JQuery와

    내 머리 위로 떨어져 - 시도는 확장 JQuery와

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

  20. 20.VAR newArray = yourArray.concat (otherArray); 을 console.log ( '연접 newArray', newArray);

    VAR newArray = yourArray.concat (otherArray); 을 console.log ( '연접 newArray', newArray);

  21. 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

    나는이 솔루션은 효율성이 떨어집니다 알아,하지만 당신은 순서를 유지하고 여전히 개체를 업데이트 할 경우 필요합니다.

  22. 22.여기가 키에 의해 두 개의 객체 배열을 병합 작성하는 jQuery 플러그인입니다. 명심 현재 위치에서이 수정 대상 배열입니다.

    여기가 키에 의해 두 개의 객체 배열을 병합 작성하는 jQuery 플러그인입니다. 명심 현재 위치에서이 수정 대상 배열입니다.

    (함수 ($) { $ .extendObjectArray = 함수 (destArray, srcArray 키) { 위한 VAR (인덱스 = 0, 인덱스 0) { VAR existingIndex = destArray.indexOf (existObject [0]); $ .extend (참, destArray [existingIndex, srcObject); } 다른 { destArray.push (srcObject); } } destArray를 반환; }; }) (jQuery를); VAR arr1 = {이름 : "LANG"값 : "영어"}, {이름 : "나이", 값 : "18"} ]; VAR arr2 = {이름 : "차일", 값 : '5'} {이름 : "LANG"값 : "독일어"} ]; VAR arr3 = $ .extendObjectArray (arr1, arr2, '이름'); CONSOLE.LOG (JSON.stringify (arr3, NULL, 2)); 이 .as - 콘솔 래퍼 {최고 : 0; 최대 높이 : 100 % 중요한;! } <스크립트 SRC = "https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"> 

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

  23. 23.당신이 _.uniqBy을 원하는 lodash 사용

    당신이 _.uniqBy을 원하는 lodash 사용

    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 참조

  24. 24.

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

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

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

  26. 26.당신이 두 배열을 병합 할 만 제거하면 중복 된 개체를 사용합니다. 중복은 각 개체의 .uniqueId에 식별

    당신이 두 배열을 병합 할 만 제거하면 중복 된 개체를 사용합니다. 중복은 각 개체의 .uniqueId에 식별

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

  27. 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
  }]

  28. 28.

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

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


console.log(arr1)

  29. 29.솔루션은 JS지도를 활용 :

    솔루션은 JS지도를 활용 :

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

    어떤 생산 :

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

    31. from https://stackoverflow.com/questions/7146217/merge-2-arrays-of-objects by cc-by-sa and MIT license

'JQUERY' 카테고리의 다른 글

[JQUERY] 어떻게 jQuery를 사용하여 클래스의 변화에 ​​이벤트를 발생 하는가?  (0) 2020.10.10
[JQUERY] ReferenceError가 : 이벤트가 파이어 폭스에 오류가 정의되지 않은  (0) 2020.10.10
[JQUERY] JSON catch되지 않은 구문 에러 : 예기치 않은 토큰 :  (0) 2020.10.10
[JQUERY] 양식에 방지 기본은 jQuery를 제출  (0) 2020.10.10
[JQUERY] 미래 요소 jQuery를 CSTE 연구진 함수가 사용되지 .live 같이 중복]  (0) 2020.10.10
,

티스토리툴바