මට ජාවාස්ක්‍රිප්ට් අරා දෙකක් තිබේ:

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

ප්‍රතිදානය මට අවශ්‍යයි:

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

ප්‍රතිදාන අරාවෙහි වචන නැවත නැවත ඉවත් කළ යුතුය.

ජාවාස්ක්‍රිප්ට් හි අරා දෙකක් ඒකාබද්ධ කරන්නේ කෙසේද, එවිට එක් එක් අරාව වෙතින් අද්විතීය අයිතම පමණක් මුල් අරා වලට ඇතුළත් කළ අනුපිළිවෙලින් ලබා ගන්නේ කෙසේද?

අරා ඒකාබද්ධ කිරීම සඳහා (අනුපිටපත් ඉවත් නොකර)

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 විසඳුමක් වන අතර එය පැතිරීමේ ක්‍රියාකරු සහ අරා ජනක භාවිතා කරයි.

දැනට එය ක්‍රියාත්මක වන්නේ ෆයර්ෆොක්ස් සහ සමහර විට ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් තාක්ෂණික පෙරදසුන සමඟ පමණි.

නමුත් ඔබ බාබෙල් භාවිතා කරන්නේ නම් , ඔබට එය දැන් ලබාගත හැකිය.

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

මෙන්න ලූපය තරමක් වෙනස් වේ. ක්‍රෝම් හි නවතම අනුවාදයේ ඇති සමහර ප්‍රශස්තිකරණයන් සමඟ, එය අරා දෙකේ එකමුතුව විසඳීම සඳහා වේගවත්ම ක්‍රමය වේ (ක්‍රෝම් 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);
  }
}

අතර පුඩුවක්: k 589k ops / s
filter: ~ 445k ops / s
lodash: 308k ops / s
ලූප සඳහා 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) ද්විත්ව පුඩුවක් සහිත ඉහළම පිළිතුර තවමත් සැලකිය යුතු ලෙස මන්දගාමී වේ. ලොඩාෂ් තවමත් ශක්තිමත්ව ක්‍රියාත්මක වන අතර ඔවුන්ගේ ව්‍යාපෘතියට පුස්තකාලයක් එක් කිරීමට අකමැති ඕනෑම කෙනෙකුට මම එය නිර්දේශ කරමි. අකමැති අයට, මගේ කාල ලූපය තවමත් හොඳ පිළිතුරක් වන අතර පෙරහන් පිළිතුර මෙහි ඉතා ප්‍රබල ලෙස පෙන්නුම් කරයි, මෙම ලිවීමේදී නවතම කැනරි ක්‍රෝම් (44.0.2360) සමඟ මගේ පරීක්ෂණ සියල්ලම පරාජය කරයි.

පරීක්ෂා කරන්න මයික් පිළිතුර හා දාන් ෆැක්ටරින් පිළිතුර ඔබ එය වේගය තුළ ලෝකයේ ප්රමුඛතම උත්සන්න කිරීමට අවශ්ය නම්. ශක්‍ය පිළිතුරු සියල්ලම පාහේ ලබා ගැනීමෙන් පසු ඒවා සියලු ප්‍රති results ල වලින් වේගවත්ම වේ.

ඔබට එය 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 = {}, 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);
}

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

මෙය මම බොහෝ දේ භාවිතා කරන ක්‍රමයකි, එය අනුපිටපත් පරීක්ෂා කිරීම සඳහා වස්තුවක් හැෂ්ලූකප් වගුවක් ලෙස භාවිතා කරයි. හෑෂ් O (1) යැයි උපකල්පනය කර, මෙය O (n) හි ක්‍රියාත්මක වන අතර n යනු a.length + b.length වේ. බ්‍රව්සරය හැෂ් කරන්නේ කෙසේදැයි මට අවංකවම අවබෝධයක් නැත, නමුත් එය දත්ත ලක්ෂ්‍ය දහස් ගණනක් හොඳින් ක්‍රියාත්මක කරයි.

ඔබ වස්තුවක් භාවිතා නොකරන්නේ ඇයි? ඔබ කට්ටලයක් ආදර්ශනය කිරීමට උත්සාහ කරන බවක් පෙනේ. කෙසේ වෙතත් මෙය ඇණවුම ආරක්ෂා නොකරයි.

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

ES6 සඳහා, එක් පේළියක් පමණි:

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

Underscore.js's => uniq භාවිතයෙන් ඔබට එය සාක්ෂාත් කරගත හැකිය :

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

console.log(array3)

එය ["විජේන්ද්‍ර", "සිං", "ශාක්‍ය"] මුද්‍රණය කරනු ඇත .

එය සෙට් භාවිතයෙන් කළ හැකිය.

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>

අරා දෙකක් ඒකාබද්ධ කිරීම සඳහා බොහෝ විසඳුම් තිබේ. ඒවා ප්‍රධාන කාණ්ඩ දෙකකට බෙදිය හැකිය (ලොඩාෂ් හෝ අන්ඩර්ස්කෝර්.ජේ වැනි තෙවන පාර්ශවීය පුස්තකාල භාවිතය හැර).

අ) අරා දෙකක් ඒකාබද්ධ කර අනුපිටපත් අයිතම ඉවත් කරන්න.

ආ) අයිතම ඒකාබද්ධ කිරීමට පෙර ඒවා පෙරහන් කරන්න.

අරා දෙකක් ඒකාබද්ධ කර අනුපිටපත් අයිතම ඉවත් කරන්න

ඒකාබද්ධ කිරීම

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

මෙම ප්‍රශ්නය වස්තු සමූහයක් ගැන නොවන බව මම දනිමි, නමුත් සෙවුම්කරුවන් මෙහි අවසන් වේ.

එබැවින් අනාගත පා readers කයින් සඳහා නිසි 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 (අන්තර්ජාල ගවේෂක සඳහා):

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

Jsperf මත පදනම්ව, අළුත් එකක අරා දෙකක් ඒකාබද්ධ කිරීමේ වේගවත්ම ක්‍රමය පහත දැක්වේ:

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% මන්දගාමී වේ:

var a = [...new Set([...array1 ,...array2])];

පිළිගත් පිළිතුරු 55% මන්දගාමී වේ (සහ ලිවීමට වඩා දිගු වේ)

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

https://jsperf.com/merge-2-arrays-without-duplicate

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)

මෙහි ඇති හොඳ දෙය නම් කාර්ය සාධනය වන අතර ඔබ සාමාන්‍යයෙන් අරා සමඟ වැඩ කරන විට පෙරහන්, සිතියම වැනි දම්වැල් ක්‍රම වේ. එවිට ඔබට එම රේඛාව එක් කළ හැකි අතර එය පසුව අරාව 1 සමඟ අරාව 2 සමඟ සංයුක්ත කර අඩු කරනු ඇත. එකක් (ඔබ සතුව දම්වැල් දැමීමේ ක්‍රම නොමැති විට), උදාහරණය:

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 සමඟ ක්‍රියාකාරී ප්‍රවේශයක්

ක්‍රියාකාරී ප්‍රවේශය අනුගමනය කිරීමෙන් s unionදෙකක Arrayසංයුතිය යනු 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ශ්‍රිතයක් ක්‍රියාවට නැංවීම සුළුපටු වන අතර එය ඕනෑම අරා ගණනක් පිළිගනී (නයෝමික්ගේ අදහස් වලින් දේවානුභාවයෙන්):

// 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එහි අඩු කරන්නා ලෙස ගනී . සටහන: ක්‍රියාත්මක කිරීම අතිරේක සමුච්චයක් භාවිතා නොකරන බැවින්, ඔබ එය තර්ක නොමැතිව යොදන විට එය දෝෂයක් ඇති කරයි.

ඒ වෙනුවෙන් ... මෙන්න තනි පේළියේ විසඳුමක්:

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

විශේෂයෙන් කියවිය නොහැකි නමුත් එය යමෙකුට උපකාර කළ හැකිය:

1. ආරම්භක සමුච්චය අගය හිස් අරාවකට සකසා ඇති අඩු කිරීමේ ශ්‍රිතයක් යොදයි.
2. අඩු කිරීමේ ශ්‍රිතය එක් එක් උප-අරාව සමුච්චය අරා මත එකතු කිරීමට කොන්කට් භාවිතා කරයි.
3. මෙහි ප්‍රති result ලය නව එකක් නිර්මාණය කිරීම සඳහා ඉදිකිරීම් පරාමිතියක් ලෙස සම්මත Setවේ.
4. පැතිරීමේ ක්‍රියාකරු Setඅරාව බවට පරිවර්තනය කිරීම සඳහා භාවිතා කරයි.
5. මෙම sort()උත්සවය නව අරාව සඳහා ඉල්ලුම් කර ඇත.

තනි අණුවක් ඒකාබද්ධ කිරීම හෝ බහුවිධ අරා යෙදවුම් ඒකාබද්ධ කිරීම සහ ඉවත් කිරීම. පහත උදාහරණය.

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]