ฉันมีสอง JavaScript อาร์เรย์:

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];

ฉันต้องการผลลัพธ์ที่จะเป็น:

var array3 = ["Vijendra","Singh","Shakya"];

อาร์เรย์เอาต์พุตควรลบคำที่ซ้ำออกไป

ฉันจะรวมสองอาร์เรย์ใน JavaScript เพื่อให้ฉันได้รับเฉพาะรายการที่ไม่ซ้ำกันจากแต่ละอาร์เรย์ในลำดับเดียวกันพวกเขาถูกแทรกลงในอาร์เรย์เดิมได้อย่างไร

เมื่อต้องการรวมอาร์เรย์ (โดยไม่ลบรายการที่ซ้ำกัน)

รุ่น ES5 ใช้Array.concat:

var array1 = ["Vijendra", "Singh"];
var array2 = ["Singh", "Shakya"];

console.log(array1.concat(array2));

รุ่น ES6 ใช้การทำลายล้าง

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

http://underscorejs.org/#union

http://lodash.com/docs#union

ก่อนเชื่อมทั้งสองอาร์เรย์ต่อไปกรองเฉพาะรายการที่ไม่ซ้ำกัน:

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]

นี่คือโซลูชัน ECMAScript 6 ที่ใช้ตัวดำเนินการสเปรดและอาเรย์ทั่วไป

ขณะนี้มันใช้งานได้กับ Firefox เท่านั้นและอาจเป็นตัวอย่างทางเทคนิคของ Internet Explorer

แต่ถ้าคุณใช้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));

ES6

array1.push(...array2) // => don't remove duplication 

หรือ

[...array1,...array2] //   =>  don't remove duplication 

หรือ

[...new Set([...array1 ,...array2])]; //   => remove duplication

การใช้ชุด (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);
  }
}

ในขณะที่ลูป: ~ 589k ops / s
ตัวกรอง: ~ 445k ops / s
lodash: 308k ops / s
สำหรับลูป: 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 ยังคงทำงานได้ดีและฉันยังคงแนะนำให้กับทุกคนที่ไม่สนใจที่จะเพิ่มห้องสมุดในโครงการของพวกเขา สำหรับผู้ที่ไม่ต้องการห่วงของฉันในขณะที่ยังคงเป็นคำตอบที่ดีและคำตอบตัวกรองมีการแสดงที่แข็งแกร่งมากที่นี่เต้นออกทั้งหมดในการทดสอบของฉันกับ 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"];

• ใช้โอเปอเรเตอร์การกระจายเพื่อต่ออาร์เรย์
• ใช้Setเพื่อสร้างชุดองค์ประกอบที่แตกต่าง
• ใช้ตัวดำเนินการสเปรดอีกครั้งเพื่อแปลง Set เป็นอาร์เรย์

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

ฟังก์ชันการรวมอาร์เรย์ที่ดีขึ้นมาก

เพียงแค่โยนสองเซ็นต์ของฉัน

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

นี่เป็นวิธีที่ฉันใช้บ่อย ๆ มันใช้วัตถุเป็นตาราง hashlookup เพื่อทำการตรวจสอบซ้ำ สมมติว่า hash คือ O (1) ดังนั้นสิ่งนี้จะทำงานใน O (n) โดยที่ n คือ a.length + b.length ฉันไม่รู้ว่าเบราว์เซอร์ทำแฮชอย่างไร แต่มันทำงานได้ดีกับจุดข้อมูลหลายพันจุด

เพียงคัดท้ายชัดเจนของลูปซ้อนกัน (O (n ^ 2)) และ.indexOf()(+ O (n))

function merge(a, b) {
    var hash = {}, 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);
}

แบบง่ายที่สุดของคำตอบนี้และเปลี่ยนเป็นฟังก์ชั่นที่ดี:

function mergeUnique(arr1, arr2){
    return arr1.concat(arr2.filter(function (item) {
        return arr1.indexOf(item) === -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
}

ทางออกที่ดีที่สุด ...

คุณสามารถตรวจสอบโดยตรงในคอนโซลของเบราว์เซอร์โดยการกดปุ่ม ...

ไม่ซ้ำซ้อน

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

หากคุณต้องการโดยไม่ซ้ำกันคุณสามารถลองวิธีการแก้ปัญหาที่ดีขึ้นจากที่นี่ - ตะโกนรหัส

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

เงินครึ่งหนึ่งของฉัน:

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's => uniq :

array3 = _.uniq(array1.concat(array2))

console.log(array3)

มันจะพิมพ์[ "Vijendra", "ซิงห์", "Shakya"]

สำหรับ ES6 เพียงหนึ่งบรรทัด:

a = [1, 2, 3, 4]
b = [4, 5]
[...new Set(a.concat(b))]  // [1, 2, 3, 4, 5]

ฉันรู้ว่าคำถามนี้ไม่ได้เกี่ยวกับอาร์เรย์ของวัตถุ แต่ผู้ค้นหาทำที่นี่

ดังนั้นจึงเป็นการเพิ่มมูลค่าให้กับผู้อ่านในอนาคตด้วยวิธีการรวม 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 => f.a == a) ));

// [ {a: 1}, {a: 2}, {a: 3}, {a: 4} ]

//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 (สำหรับ internet explorer):

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

มันสามารถทำได้โดยใช้ชุด

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>

มีวิธีแก้ปัญหามากมายสำหรับการรวมสองอาร์เรย์ พวกเขาสามารถแบ่งออกเป็นสองประเภทหลัก (ยกเว้นการใช้ห้องสมุดบุคคลที่สามเช่น 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)));

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)

สิ่งที่ดีเกี่ยวกับอันนี้คือประสิทธิภาพการทำงานและคุณโดยทั่วไปเมื่อทำงานกับอาร์เรย์มีวิธีการผูกมัดเช่นตัวกรองแผนที่ ฯลฯ เพื่อให้คุณสามารถเพิ่มบรรทัดนั้นและมันจะ concat และ deduplicate 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 และนั่นเป็นวิธีเดียวในการเคารพห่วงโซ่ - การกำหนดฟังก์ชั่นใหม่จะทำลายมัน - ดังนั้นฉันคิดว่าสิ่งนี้เป็นวิธีเดียวที่จะทำให้สำเร็จ)

คุณสามารถลองสิ่งนี้:

const union = (a, b) => Array.from(new Set([...a, ...b]));

console.log(union(["neymar","messi"], ["ronaldo","neymar"]));

วิธีการทำงานกับ ES2015

ต่อไปนี้วิธีการทำงานunionของทั้งสองArrays เป็นเพียงองค์ประกอบของและ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(aka Array.prototype.reduce) ซึ่งใช้unionเป็นตัวลด หมายเหตุ: เนื่องจากการใช้งานไม่ได้ใช้ตัวสะสมเพิ่มเติมมันจะโยนข้อผิดพลาดเมื่อคุณใช้โดยไม่มีข้อโต้แย้ง

เพื่อประโยชน์ของมัน ... นี่คือทางออกบรรทัดเดียว:

const x = [...new Set([['C', 'B'],['B', 'A']].reduce( (a, e) => a.concat(e), []))].sort()
// ['A', 'B', 'C']

ไม่สามารถอ่านได้โดยเฉพาะ แต่อาจช่วยคนได้:

1. ใช้ฟังก์ชันลดพร้อมกับค่าสะสมเริ่มต้นตั้งค่าเป็นอาร์เรย์ว่าง
2. ฟังก์ชั่นลดใช้ concat เพื่อผนวกแต่ละแถวย่อยลงในอาร์เรย์ตัวสะสม
3. Setผลจากการนี้จะถูกส่งเป็นพารามิเตอร์ตัวสร้างที่จะสร้างใหม่
4. ผู้ประกอบการแพร่กระจายจะใช้ในการแปลงSetเป็นอาร์เรย์
5. มีการsort()ใช้ฟังก์ชันกับอาร์เรย์ใหม่

DeDuplicate เดี่ยวหรือผสานและ DeDuplicate หลายอินพุต ตัวอย่างด้านล่าง

ใช้ ES6 - ตั้งค่าสำหรับการทำลาย

ฉันเขียนฟังก์ชันง่าย ๆ นี้ซึ่งใช้อาร์กิวเมนต์หลายตัว สวยมากเหมือนกันกับวิธีแก้ปัญหาข้างต้นมันมีกรณีใช้งานจริงมากกว่า ฟังก์ชั่นนี้ไม่ได้เชื่อมต่อค่าที่ซ้ำกันในหนึ่งอาเรย์เท่านั้นเพื่อให้สามารถลบค่าได้ในระยะหลัง

ฟังก์ชั่นระยะสั้น (เพียง 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]

var arr1 = [1, 3, 5, 6];
var arr2 = [3, 6, 10, 11, 12];
arr1.concat(arr2.filter(ele => !arr1.includes(ele)));
console.log(arr1);

output :- [1, 3, 5, 6, 10, 11, 12]