질문자 :Vijjendra
두 개의 JavaScript 배열이 있습니다.
var array1 = ["Vijendra","Singh"]; var array2 = ["Singh", "Shakya"];나는 출력을 원한다:
var array3 = ["Vijendra","Singh","Shakya"];출력 배열에는 반복되는 단어가 제거되어야 합니다.
JavaScript에서 두 개의 배열을 병합하여 원본 배열에 삽입된 것과 동일한 순서로 각 배열에서 고유한 항목만 가져오려면 어떻게 해야 합니까?
어레이를 병합하려면(중복을 제거하지 않고)
Array.concat 사용합니다. var array1 = ["Vijendra", "Singh"]; var array2 = ["Singh", "Shakya"]; console.log(array1.concat(array2)); const array1 = ["Vijendra","Singh"]; const array2 = ["Singh", "Shakya"]; const array3 = [...array1, ...array2]; 중복을 제거하는 '내장된' 방법이 없기 때문에( ECMA-262 에는 실제로 Array.forEach 가 있어 이에 적합함) 수동으로 수행해야 합니다.
Array.prototype.unique = function() { var a = this.concat(); for(var i=0; i<a.length; ++i) { for(var j=i+1; j<a.length; ++j) { if(a[i] === a[j]) a.splice(j--, 1); } } return a; };그런 다음 사용하려면:
var array1 = ["Vijendra","Singh"]; var array2 = ["Singh", "Shakya"]; // Merges both arrays and gets unique items var array3 = array1.concat(array2).unique();이것은 또한 배열의 순서를 보존합니다(즉, 정렬이 필요하지 않음).
Array.prototype 과 for in 루프의 프로토타입 확장에 짜증이 나기 때문에 이를 사용하는 덜 침습적인 방법은 다음과 같습니다.
function arrayUnique(array) { var a = array.concat(); for(var i=0; i<a.length; ++i) { for(var j=i+1; j<a.length; ++j) { if(a[i] === a[j]) a.splice(j--, 1); } } return a; } var array1 = ["Vijendra","Singh"]; var array2 = ["Singh", "Shakya"]; // Merges both arrays and gets unique items var array3 = arrayUnique(array1.concat(array2)); ES5를 사용할 수 있는 브라우저로 작업할 만큼 운이 좋은 사람들을 위해 Object.defineProperty 과 같이 Object.defineProperty를 사용할 수 있습니다.
Object.defineProperty(Array.prototype, 'unique', { enumerable: false, configurable: false, writable: false, value: function() { var a = this.concat(); for(var i=0; i<a.length; ++i) { for(var j=i+1; j<a.length; ++j) { if(a[i] === a[j]) a.splice(j--, 1); } } return a; } });Underscore.js 또는 Lo-Dash를 사용하여 다음을 수행할 수 있습니다.
console.log(_.union([1, 2, 3], [101, 2, 1, 10], [2, 1])); <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.min.js"></script>먼저 두 배열을 연결하고 다음으로 고유한 항목만 필터링합니다.
var a = [1, 2, 3], b = [101, 2, 1, 10] var c = a.concat(b) var d = c.filter((item, pos) => c.indexOf(item) === pos) console.log(d) // d is [1, 2, 3, 101, 10] 제안된 바와 같이 더 성능 현명한 솔루션은 다음과 연결하기 전에 b a .
var a = [1, 2, 3], b = [101, 2, 1, 10] var c = a.concat(b.filter((item) => a.indexOf(item) < 0)) console.log(c) // c is [1, 2, 3, 101, 10][...array1,...array2] // => don't remove duplication또는
[...new Set([...array1 ,...array2])]; // => remove duplication이것은 스프레드 연산자 와 배열 제네릭을 사용하는 ECMAScript 6 솔루션입니다.
현재는 Firefox 및 Internet Explorer Technical Preview에서만 작동합니다.
하지만 Babel 을 사용한다면 지금 사용할 수 있습니다.
const input = [ [1, 2, 3], [101, 2, 1, 10], [2, 1] ]; const mergeDedupe = (arr) => { return [...new Set([].concat(...arr))]; } console.log('output', mergeDedupe(input));세트 (ECMAScript 2015)를 사용하면 다음과 같이 간단합니다.
const array1 = ["Vijendra", "Singh"]; const array2 = ["Singh", "Shakya"]; console.log(Array.from(new Set(array1.concat(array2))));다음은 루프에 대한 약간 다른 해석입니다. 최신 버전의 Chrome에서 일부 최적화를 통해 두 어레이(Chrome 38.0.2111)의 합집합을 해결하는 가장 빠른 방법입니다.
http://jsperf.com/merge-two-arrays-keeping-only-unique-values
var array1 = ["Vijendra", "Singh"]; var array2 = ["Singh", "Shakya"]; var array3 = []; var arr = array1.concat(array2), len = arr.length; while (len--) { var itm = arr[len]; if (array3.indexOf(itm) === -1) { array3.unshift(itm); } } while 루프: ~589k ops/s
필터: ~445k ops/s
lodash: 308k ops/s
for 루프: 225k ops/s
내 설정 변수 중 하나가 쓰기 위해 빈 배열을 초기화할 필요가 없었기 때문에 루프가 나머지보다 먼저 당겨지는 원인이 되었다고 지적했습니다. 나는 그것에 동의합니다. 그래서 나는 심지어 경기장까지 테스트를 다시 작성했고 더 빠른 옵션을 포함했습니다.
http://jsperf.com/merge-two-arrays-keeping-only-unique-values/52
let whileLoopAlt = function (array1, array2) { const array3 = array1.slice(0); let len1 = array1.length; let len2 = array2.length; const assoc = {}; while (len1--) { assoc[array1[len1]] = null; } while (len2--) { let itm = array2[len2]; if (assoc[itm] === undefined) { // Eliminate the indexOf call array3.push(itm); assoc[itm] = null; } } return array3; }; 이 대체 솔루션에서는 하나의 답변의 연관 배열 솔루션을 결합 .indexOf() 호출을 제거하여 두 번째 루프로 작업 속도를 크게 늦추고 다른 사용자가 제안한 다른 최적화 중 일부를 포함했습니다. 그들의 대답도.
모든 값(i-1)에 이중 루프가 있는 여기의 최고 답변은 여전히 상당히 느립니다. lodash는 여전히 강력하며 프로젝트에 라이브러리를 추가하는 데 신경 쓰지 않는 사람에게 여전히 추천합니다. 원하지 않는 사람들을 위해 내 while 루프는 여전히 좋은 답변이며 필터 답변은 이 글을 쓰는 시점에서 최신 Canary Chrome(44.0.2360)으로 내 테스트에서 모든 것을 능가하는 매우 강력한 결과를 보여줍니다.
속도를 한 단계 높이려면 Mike의 답변 과 Dan Stocker의 답변을 확인하십시오. 거의 모든 실행 가능한 답변을 거친 후 모든 결과 중에서 가장 빠른 결과입니다.
ECMAScript 6으로 간단하게 할 수 있습니다.
var array1 = ["Vijendra", "Singh"]; var array2 = ["Singh", "Shakya"]; var array3 = [...new Set([...array1 ,...array2])]; console.log(array3); // ["Vijendra", "Singh", "Shakya"];이 답변 의 장점을 단순화하고 멋진 기능으로 바꿨습니다.
function mergeUnique(arr1, arr2){ return arr1.concat(arr2.filter(function (item) { return arr1.indexOf(item) === -1; })); }중첩 루프(O(n^2)) 및 .indexOf() (+O(n))를 피하십시오.
function merge(a, b) { var hash = {}; var i; for (i = 0; i < a.length; i++) { hash[a[i]] = true; } for (i = 0; i < b.length; i++) { hash[b[i]] = true; } return Object.keys(hash); } var array1 = ["Vijendra", "Singh"]; var array2 = ["Singh", "Shakya"]; var array3 = merge(array1, array2); console.log(array3);그냥 내 2 센트를 던지고.
function mergeStringArrays(a, b){ var hash = {}; var ret = []; for(var i=0; i < a.length; i++){ var e = a[i]; if (!hash[e]){ hash[e] = true; ret.push(e); } } for(var i=0; i < b.length; i++){ var e = b[i]; if (!hash[e]){ hash[e] = true; ret.push(e); } } return ret; }이것은 내가 많이 사용하는 방법이며 객체를 해시 조회 테이블로 사용하여 중복 검사를 수행합니다. 해시가 O(1)이라고 가정하면 이것은 O(n)에서 실행되며 여기서 n은 a.length + b.length입니다. 브라우저가 해시를 어떻게 수행하는지 솔직히 모르지만 수천 개의 데이터 포인트에서 잘 수행됩니다.
Array.prototype.merge = function(/* variable number of arrays */){ for(var i = 0; i < arguments.length; i++){ var array = arguments[i]; for(var j = 0; j < array.length; j++){ if(this.indexOf(array[j]) === -1) { this.push(array[j]); } } } return this; };훨씬 더 나은 배열 병합 기능.
편집하다:
첫 번째 솔루션은 항목이 거의 없을 때만 가장 빠릅니다. 항목이 400개가 넘으면 Set 솔루션이 가장 빠릅니다. 그리고 100,000개 항목이 있을 때 첫 번째 솔루션보다 천 배 빠릅니다.
항목이 많을 때만 성능이 중요하고 Set 솔루션이 가장 읽기 쉽다는 점을 고려하면 대부분의 경우 올바른 솔루션일 것입니다.
아래 성능 결과는 적은 수의 항목으로 계산되었습니다.
jsperf를 기반으로 두 배열을 새 배열로 병합 하는 가장 빠른 방법(편집: 항목이 400개 미만인 경우)은 다음과 같습니다.
for (var i = 0; i < array2.length; i++) if (array1.indexOf(array2[i]) === -1) array1.push(array2[i]);이것은 17% 더 느립니다.
array2.forEach(v => array1.includes(v) ? null : array1.push(v));이것은 45% 느립니다 (편집: 항목이 100개 미만일 때. 항목이 많을 때 훨씬 빠름) :
var a = [...new Set([...array1 ,...array2])];그리고 허용되는 답변은 55% 더 느립니다(그리고 작성하는 데 훨씬 더 깁니다) (편집: 100,000개 항목이 있는 경우 다른 방법보다 몇 배 더 느립니다).
var a = array1.concat(array2); for (var i = 0; i < a.length; ++i) { for (var j = i + 1; j < a.length; ++j) { if (a[i] === a[j]) a.splice(j--, 1); } }개체를 사용하지 않는 이유는 무엇입니까? 세트를 모델링하려는 것 같습니다. 그러나 이것은 순서를 유지하지 않습니다.
var set1 = {"Vijendra":true, "Singh":true} var set2 = {"Singh":true, "Shakya":true} // Merge second object into first function merge(set1, set2){ for (var key in set2){ if (set2.hasOwnProperty(key)) set1[key] = set2[key] } return set1 } merge(set1, set2) // Create set from array function setify(array){ var result = {} for (var item in array){ if (array.hasOwnProperty(item)) result[array[item]] = true } return result }나는 이 질문이 객체 배열에 관한 것이 아니라는 것을 알고 있지만 검색자는 여기에서 끝납니다.
따라서 미래의 독자를 위해 적절한 ES6 병합 및 중복 제거 방법을 추가할 가치가 있습니다.
객체 배열 :
var arr1 = [ {a: 1}, {a: 2}, {a: 3} ]; var arr2 = [ {a: 1}, {a: 2}, {a: 4} ]; var arr3 = arr1.concat(arr2.filter( ({a}) => !arr1.find(f => fa == a) )); // [ {a: 1}, {a: 2}, {a: 3}, {a: 4} ]오늘 2020.10.15 선택한 솔루션에 대해 Chrome v86, Safari v13.1.2 및 Firefox v81의 MacOs HighSierra 10.13.6에서 테스트를 수행합니다.
모든 브라우저용
2가지 테스트 케이스를 수행합니다.
솔루션 A , B , C , D , E , G , H , J , L , M 아래 스 니펫에 제시된
// https://stackoverflow.com/a/10499519/860099 function A(arr1,arr2) { return _.union(arr1,arr2) } // https://stackoverflow.com/a/53149853/860099 function B(arr1,arr2) { return _.unionWith(arr1, arr2, _.isEqual); } // https://stackoverflow.com/a/27664971/860099 function C(arr1,arr2) { return [...new Set([...arr1,...arr2])] } // https://stackoverflow.com/a/48130841/860099 function D(arr1,arr2) { return Array.from(new Set(arr1.concat(arr2))) } // https://stackoverflow.com/a/23080662/860099 function E(arr1,arr2) { return arr1.concat(arr2.filter((item) => arr1.indexOf(item) < 0)) } // https://stackoverflow.com/a/28631880/860099 function G(arr1,arr2) { var hash = {}; var i; for (i = 0; i < arr1.length; i++) { hash[arr1[i]] = true; } for (i = 0; i < arr2.length; i++) { hash[arr2[i]] = true; } return Object.keys(hash); } // https://stackoverflow.com/a/13847481/860099 function H(a, b){ var hash = {}; var ret = []; for(var i=0; i < a.length; i++){ var e = a[i]; if (!hash[e]){ hash[e] = true; ret.push(e); } } for(var i=0; i < b.length; i++){ var e = b[i]; if (!hash[e]){ hash[e] = true; ret.push(e); } } return ret; } // https://stackoverflow.com/a/1584377/860099 function J(arr1,arr2) { function arrayUnique(array) { var a = array.concat(); for(var i=0; i<a.length; ++i) { for(var j=i+1; j<a.length; ++j) { if(a[i] === a[j]) a.splice(j--, 1); } } return a; } return arrayUnique(arr1.concat(arr2)); } // https://stackoverflow.com/a/25120770/860099 function L(array1, array2) { const array3 = array1.slice(0); let len1 = array1.length; let len2 = array2.length; const assoc = {}; while (len1--) { assoc[array1[len1]] = null; } while (len2--) { let itm = array2[len2]; if (assoc[itm] === undefined) { // Eliminate the indexOf call array3.push(itm); assoc[itm] = null; } } return array3; } // https://stackoverflow.com/a/39336712/860099 function M(arr1,arr2) { const comp = f => g => x => f(g(x)); const apply = f => a => f(a); const flip = f => b => a => f(a) (b); const concat = xs => y => xs.concat(y); const afrom = apply(Array.from); const createSet = xs => new Set(xs); const filter = f => xs => xs.filter(apply(f)); const dedupe = comp(afrom) (createSet); const union = xs => ys => { const zs = createSet(xs); return concat(xs) ( filter(x => zs.has(x) ? false : zs.add(x) ) (ys)); } return union(dedupe(arr1)) (arr2) } // ------------- // TEST // ------------- var array1 = ["Vijendra","Singh"]; var array2 = ["Singh", "Shakya"]; [A,B,C,D,E,G,H,J,L,M].forEach(f=> { console.log(`${f.name} [${f([...array1],[...array2])}]`); }) <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.20/lodash.min.js" integrity="sha512-90vH1Z83AJY9DmlWa8WkjkV79yfS2n2Oxhsi2dZbIv0nC4E6m5AbH8Nh156kkM7JePmqD6tcZsfad1ueoaovww==" crossorigin="anonymous"></script> This snippet only presents functions used in performance tests - it not perform tests itself!다음은 크롬에 대한 테스트 실행 예입니다.
업데이트
입력 배열을 수정하고 벤치마크가 잘못된 결과를 제공하기 때문에 사례 F, I, K를 제거합니다.
최고의 솔루션...
다음을 눌러 브라우저 콘솔에서 직접 확인할 수 있습니다...
a = [1, 2, 3]; b = [3, 2, 1, "prince"]; a.concat(b.filter(function(el) { return a.indexOf(el) === -1; })); ["prince", "asish", 5].concat(["ravi", 4])중복 없이 원하는 경우 여기에서 더 나은 솔루션을 시도할 수 있습니다 - Shouting Code .
[1, 2, 3].concat([3, 2, 1, "prince"].filter(function(el) { return [1, 2, 3].indexOf(el) === -1; }));Chrome 브라우저 콘솔에서 시도
f12 > console산출:
["prince", "asish", 5, "ravi", 4] [1, 2, 3, "prince"]ES6의 경우 한 줄만:
a = [1, 2, 3, 4] b = [4, 5] [...new Set(a.concat(b))] // [1, 2, 3, 4, 5]두 어레이를 병합하기 위한 솔루션이 너무 많습니다. 두 가지 주요 범주로 나눌 수 있습니다(lodash 또는 underscore.js와 같은 타사 라이브러리 사용 제외).
a) 두 개의 배열을 결합하고 중복 항목을 제거합니다.
b) 항목을 결합하기 전에 항목을 필터링합니다.
// mutable operation(array1 is the combined array) array1.push(...array2); array1.unshift(...array2); // immutable operation const combined = array1.concat(array2); const combined = [...array1, ...array2]; // ES6배열을 통합하는 방법은 여러 가지가 있는데 개인적으로 아래 두 가지 방법을 제안합니다.
// a little bit tricky const merged = combined.filter((item, index) => combined.indexOf(item) === index); const merged = [...new Set(combined)];이 방법도 여러 가지가 있지만 개인적으로 단순함 때문에 아래 코드를 제안합니다.
const merged = array1.concat(array2.filter(secItem => !array1.includes(secItem)));내 1.5페니:
Array.prototype.concat_n_dedupe = function(other_array) { return this .concat(other_array) // add second .reduce(function(uniques, item) { // dedupe all if (uniques.indexOf(item) == -1) { uniques.push(item); } return uniques; }, []); }; var array1 = ["Vijendra","Singh"]; var array2 = ["Singh", "Shakya"]; var result = array1.concat_n_dedupe(array2); console.log(result);Underscore.js의 => uniq 를 사용하여 간단히 달성할 수 있습니다.
array3 = _.uniq(array1.concat(array2)) console.log(array3)["Vijendra", "Singh", "Shakya"] 를 인쇄 합니다.
Set을 사용하여 수행할 수 있습니다.
var array1 = ["Vijendra","Singh"]; var array2 = ["Singh", "Shakya"]; var array3 = array1.concat(array2); var tempSet = new Set(array3); array3 = Array.from(tempSet); //show output document.body.querySelector("div").innerHTML = JSON.stringify(array3); <div style="width:100%;height:4rem;line-height:4rem;background-color:steelblue;color:#DDD;text-align:center;font-family:Calibri" > temp text </div>//Array.indexOf was introduced in javascript 1.6 (ECMA-262) //We need to implement it explicitly for other browsers, if (!Array.prototype.indexOf) { Array.prototype.indexOf = function(elt, from) { var len = this.length >>> 0; for (; from < len; from++) { if (from in this && this[from] === elt) return from; } return -1; }; } //now, on to the problem var array1 = ["Vijendra","Singh"]; var array2 = ["Singh", "Shakya"]; var merged = array1.concat(array2); var t; for(i = 0; i < merged.length; i++) if((t = merged.indexOf(i + 1, merged[i])) != -1) { merged.splice(t, 1); i--;//in case of multiple occurrences } 다른 브라우저에 대한 indexOf 메소드 구현은 MDC에서 가져옴
새로운 솔루션( Array.prototype.indexOf 및 Array.prototype.concat ):
Array.prototype.uniqueMerge = function( a ) { for ( var nonDuplicates = [], i = 0, l = a.length; i<l; ++i ) { if ( this.indexOf( a[i] ) === -1 ) { nonDuplicates.push( a[i] ); } } return this.concat( nonDuplicates ) };용법:
>>> ['Vijendra', 'Singh'].uniqueMerge(['Singh', 'Shakya']) ["Vijendra", "Singh", "Shakya"]Array.prototype.indexOf(인터넷 익스플로러용):
Array.prototype.indexOf = Array.prototype.indexOf || function(elt) { var len = this.length >>> 0; var from = Number(arguments[1]) || 0; from = (from < 0) ? Math.ceil(from): Math.floor(from); if (from < 0)from += len; for (; from < len; from++) { if (from in this && this[from] === elt)return from; } return -1; };Array.prototype.add = function(b){ var a = this.concat(); // clone current object if(!b.push || !b.length) return a; // if b is not an array, or empty, then return a unchanged if(!a.length) return b.concat(); // if original is empty, return b // go through all the elements of b for(var i = 0; i < b.length; i++){ // if b's value is not in a, then add it if(a.indexOf(b[i]) == -1) a.push(b[i]); } return a; } // Example: console.log([1,2,3].add([3, 4, 5])); // will output [1, 2, 3, 4, 5]array1.concat(array2).filter((value, pos, arr)=>arr.indexOf(value)===pos)이것에 대한 좋은 점은 성능이며 일반적으로 배열로 작업할 때 필터, 맵 등과 같은 메서드를 연결하므로 해당 줄을 추가할 수 있으며 나중에 참조할 필요 없이 array2를 array1과 연결하고 중복 제거합니다. 하나(당신이 가지고 있지 않은 메소드를 연결하는 경우), 예:
someSource() .reduce(...) .filter(...) .map(...) // and now you want to concat array2 and deduplicate: .concat(array2).filter((value, pos, arr)=>arr.indexOf(value)===pos) // and keep chaining stuff .map(...) .find(...) // etc(저는 Array.prototype을 오염시키는 것을 좋아하지 않으며 이것이 체인을 존중하는 유일한 방법이 될 것입니다. 새 기능을 정의하면 체인이 끊어질 것입니다. 따라서 이와 같은 것이 이를 달성하는 유일한 방법이라고 생각합니다.)
기능적 접근 방식에 따르면 두 Array union concat 과 filter 의 구성일 뿐입니다. 최적의 성능을 제공하기 위해 속성 조회에 최적화된 Set
union 함수와 관련된 핵심 질문은 중복을 처리하는 방법입니다. 다음과 같은 순열이 가능합니다.
Array A + Array B [unique] + [unique] [duplicated] + [unique] [unique] + [duplicated] [duplicated] + [duplicated] 처음 두 순열은 단일 함수로 쉽게 처리할 수 있습니다. Set 조회에 의존하는 한 처리할 수 없기 때문에 더 복잡합니다. 일반 이전 Object 속성 조회로 전환하면 심각한 성능 저하가 수반되므로 다음 구현에서는 세 번째 및 네 번째 순열을 무시합니다. 이들을 지원하려면 별도의 버전의 union
// small, reusable auxiliary functions const comp = f => g => x => f(g(x)); const apply = f => a => f(a); const flip = f => b => a => f(a) (b); const concat = xs => y => xs.concat(y); const afrom = apply(Array.from); const createSet = xs => new Set(xs); const filter = f => xs => xs.filter(apply(f)); // de-duplication const dedupe = comp(afrom) (createSet); // the actual union function const union = xs => ys => { const zs = createSet(xs); return concat(xs) ( filter(x => zs.has(x) ? false : zs.add(x) ) (ys)); } // mock data const xs = [1,2,2,3,4,5]; const ys = [0,1,2,3,3,4,5,6,6]; // here we go console.log( "unique/unique", union(dedupe(xs)) (ys) ); console.log( "duplicated/unique", union(xs) (ys) ); unionn 함수를 구현하는 것은 간단합니다(naomik의 설명에서 영감을 얻음).
// small, reusable auxiliary functions const uncurry = f => (a, b) => f(a) (b); const foldl = f => acc => xs => xs.reduce(uncurry(f), acc); const apply = f => a => f(a); const flip = f => b => a => f(a) (b); const concat = xs => y => xs.concat(y); const createSet = xs => new Set(xs); const filter = f => xs => xs.filter(apply(f)); // union and unionn const union = xs => ys => { const zs = createSet(xs); return concat(xs) ( filter(x => zs.has(x) ? false : zs.add(x) ) (ys)); } const unionn = (head, ...tail) => foldl(union) (head) (tail); // mock data const xs = [1,2,2,3,4,5]; const ys = [0,1,2,3,3,4,5,6,6]; const zs = [0,1,2,3,4,5,6,7,8,9]; // here we go console.log( unionn(xs, ys, zs) ); unionn 은 단지 foldl (일명 Array.prototype.reduce )로, union 을 감속기로 사용합니다. 참고: 구현은 추가 누산기를 사용하지 않으므로 인수 없이 적용하면 오류가 발생합니다.
여러 배열 인수를 사용하는 이 간단한 함수를 작성했습니다. 위의 솔루션과 거의 동일하지만 더 실용적인 사용 사례가 있습니다. 이 함수는 중복 값을 하나의 배열에만 연결하지 않으므로 나중에 삭제할 수 있습니다.
짧은 함수 정의(9줄만)
/** * This function merging only arrays unique values. It does not merges arrays in to array with duplicate values at any stage. * * @params ...args Function accept multiple array input (merges them to single array with no duplicates) * it also can be used to filter duplicates in single array */ function arrayDeDuplicate(...args){ let set = new Set(); // init Set object (available as of ES6) for(let arr of args){ // for of loops through values arr.map((value) => { // map adds each value to Set object set.add(value); // set.add method adds only unique values }); } return [...set]; // destructuring set object back to array object // alternativly we culd use: return Array.from(set); }예제 코펜 사용 :
// SCENARIO let a = [1,2,3,4,5,6]; let b = [4,5,6,7,8,9,10,10,10]; let c = [43,23,1,2,3]; let d = ['a','b','c','d']; let e = ['b','c','d','e']; // USEAGE let uniqueArrayAll = arrayDeDuplicate(a, b, c, d, e); let uniqueArraySingle = arrayDeDuplicate(b); // OUTPUT console.log(uniqueArrayAll); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 43, 23, "a", "b", "c", "d", "e"] console.log(uniqueArraySingle); // [4, 5, 6, 7, 8, 9, 10]당신은 이것을 시도할 수 있습니다:
const union = (a, b) => Array.from(new Set([...a, ...b])); console.log(union(["neymar","messi"], ["ronaldo","neymar"])); var array1 = ["one","two"]; var array2 = ["two", "three"]; var collectionOfTwoArrays = [...array1, ...array2]; var uniqueList = array => [...new Set(array)]; console.log('Collection :'); console.log(collectionOfTwoArrays); console.log('Collection without duplicates :'); console.log(uniqueList(collectionOfTwoArrays));출처 : http:www.stackoverflow.com/questions/1584370/how-to-merge-two-arrays-in-javascript-and-de-duplicate-items
| enctype='multipart/form-data'는 무엇을 의미합니까? (0) | 2022.01.25 |
|---|---|
| 파일 내용에서 Java 문자열을 어떻게 생성합니까? (0) | 2022.01.25 |
| StringBuilder와 StringBuffer의 차이점 (0) | 2022.01.25 |
| 각 GROUP BY 그룹에서 첫 번째 행을 선택하시겠습니까? (0) | 2022.01.23 |
| 분리된 HEAD를 마스터/원본과 어떻게 조정할 수 있습니까? (0) | 2022.01.23 |