javascript - JS অ্যারের থেকে সদৃশ মানগুলি সরান




arrays duplicates (20)

এই মত Array.filter() ব্যবহার করুন

var actualArr = ['Apple', 'Apple', 'Banana', 'Mango', 'Strawberry', 'Banana'];

console.log('Actual Array: ' + actualArr);

var filteredArr = actualArr.filter(function(item, index) {
  if (actualArr.indexOf(item) == index)
    return item;
});

console.log('Filtered Array: ' + filteredArr);

এই ES6 থেকে খাটো করা যেতে পারে

actualArr.filter((item,index,self) => self.indexOf(item)==index);

Here Array.filter() চমৎকার ব্যাখ্যা Array.filter()

আমি একটি খুব সহজ জাভাস্ক্রিপ্ট অ্যারে আছে যা ডুপ্লিকেট অন্তর্ভুক্ত থাকতে পারে বা হতে পারে।

var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];

আমি সদৃশ অপসারণ এবং একটি নতুন অ্যারে অনন্য মান রাখা প্রয়োজন।

আমি যে সমস্ত কোড চেষ্টা করেছি তা নির্দেশ করতে পারব কিন্তু আমি মনে করি এটি নিরর্থক কারণ তারা কাজ করে না। আমি jQuery সমাধান খুব গ্রহণ।

একই প্রশ্ন:


"স্মার্ট" কিন্তু naive উপায়

uniqueArray = a.filter(function(item, pos) {
    return a.indexOf(item) == pos;
})

মূলত, আমরা অ্যারের উপর পুনরাবৃত্তি এবং, প্রতিটি উপাদান জন্য, অ্যারে এই উপাদানটির প্রথম অবস্থান বর্তমান অবস্থান সমান কিনা তা পরীক্ষা করুন। স্পষ্টতই, এই দুটি অবস্থানগুলি সদৃশ উপাদানগুলির জন্য আলাদা।

ফিল্টার কলব্যাকের তৃতীয়টি ("এই অ্যারে") পরামিতিটি ব্যবহার করে আমরা অ্যারের পরিবর্তনশীলের বন্ধ হওয়া এড়াতে পারি:

uniqueArray = a.filter(function(item, pos, self) {
    return self.indexOf(item) == pos;
})

সংক্ষেপে যদিও, এই অ্যালগরিদম বড় অ্যারে (চতুর্ভুজ সময়) জন্য বিশেষভাবে দক্ষ নয়।

উদ্ধারের জন্য হ্যাশট্যাবল

function uniq(a) {
    var seen = {};
    return a.filter(function(item) {
        return seen.hasOwnProperty(item) ? false : (seen[item] = true);
    });
}

এটি সাধারণত এটি করা হয় কিভাবে। ধারণা একটি হ্যাশ টেবিল প্রতিটি উপাদান স্থাপন করা এবং তার উপস্থিতি অবিলম্বে জন্য চেক করা হয়। এটি আমাদের রৈখিক সময় দেয়, কিন্তু অন্তত দুটি ত্রুটি রয়েছে:

  • যেহেতু হ্যাশ কী শুধুমাত্র জাভাস্ক্রিপ্টে স্ট্রিং হতে পারে, এই কোডটি সংখ্যা এবং "সংখ্যাসূচক স্ট্রিংগুলি" পার্থক্য করে না। যে, uniq([1,"1"]) শুধু ফিরে আসবে [1]
  • একই কারণে, সমস্ত বস্তু সমান বিবেচিত হবে: uniq([{foo:1},{foo:2}]) শুধু [{foo:1}] ফিরে আসবে।

যে বলেন, আপনার অ্যারে শুধুমাত্র primitives থাকে এবং আপনি ধরনের (যেমন এটি সবসময় সংখ্যা) যত্ন না, এই সমাধান অনুকূল।

দুই বিশ্বের থেকে সেরা

একটি সর্বজনীন সমাধান উভয় পন্থাগুলিকে একত্রিত করে: এটি বস্তুর জন্য প্রাথমিক এবং রৈখিক অনুসন্ধানের জন্য হ্যাশ লুকসমূহ ব্যবহার করে।

function uniq(a) {
    var prims = {"boolean":{}, "number":{}, "string":{}}, objs = [];

    return a.filter(function(item) {
        var type = typeof item;
        if(type in prims)
            return prims[type].hasOwnProperty(item) ? false : (prims[type][item] = true);
        else
            return objs.indexOf(item) >= 0 ? false : objs.push(item);
    });
}

সাজান | uniq

অন্য বিকল্পটি প্রথমে অ্যারেটি সাজানোর জন্য এবং পূর্ববর্তীটির সমান প্রতিটি উপাদানকে সরাতে হবে:

function uniq(a) {
    return a.sort().filter(function(item, pos, ary) {
        return !pos || item != ary[pos - 1];
    })
}

আবার, এটি বস্তুর সাথে কাজ করে না (কারণ সমস্ত বস্তু sort জন্য সমান)। উপরন্তু, আমরা নীরবভাবে একটি মৌলিক প্রভাব হিসাবে মূল অ্যারে পরিবর্তন - ভাল না! যাইহোক, আপনার ইনপুট ইতিমধ্যে সাজানো হয়, এই যেতে উপায় (শুধু উপরে থেকে sort অপসারণ)।

অনন্য ...

কখনও কখনও এটি কেবলমাত্র সমতা ছাড়া অন্য কিছু মানদণ্ডের উপর ভিত্তি করে একটি তালিকাটিকে অনির্বাচিত করার জন্য পছন্দসই, উদাহরণস্বরূপ, বিভিন্ন বস্তুগুলি ফিল্টার করতে, তবে কিছু সম্পত্তি ভাগ করে নিতে। এই একটি কলব্যাক পাস করে সুন্দরভাবে সম্পন্ন করা যেতে পারে। এই "কী" কলব্যাক প্রতিটি উপাদান প্রয়োগ করা হয়, এবং সমান "কী" সমেত উপাদানগুলি সরিয়ে ফেলা হয়। যেহেতু key একটি আদিম ফেরত প্রত্যাশিত হওয়ার কারণে, হ্যাশ টেবিল এখানে সূক্ষ্ম কাজ করবে:

function uniqBy(a, key) {
    var seen = {};
    return a.filter(function(item) {
        var k = key(item);
        return seen.hasOwnProperty(k) ? false : (seen[k] = true);
    })
}

একটি বিশেষ দরকারী key() JSON.stringify যা শারীরিকভাবে আলাদা বস্তুগুলি সরাবে, কিন্তু একইভাবে "সন্ধান করবে":

a = [[1,2,3], [4,5,6], [1,2,3]]
b = uniqBy(a, JSON.stringify)
console.log(b) // [[1,2,3], [4,5,6]]

যদি key আদিম না হয় তবে আপনাকে রৈখিক অনুসন্ধানে অবলম্বন করতে হবে:

function uniqBy(a, key) {
    var index = [];
    return a.filter(function (item) {
        var k = key(item);
        return index.indexOf(k) >= 0 ? false : index.push(k);
    });
}

ES6 এ আপনি একটি Set ব্যবহার করতে পারেন:

function uniqBy(a, key) {
    var seen = new Set();
    return a.filter(item => {
        var k = key(item);
        return seen.has(k) ? false : seen.add(k);
    });
}

অথবা একটি Map :

function uniqBy(a, key) {
    return [
        ...new Map(
            myArr.map(x => [key(x), x])
        ).values()
    ]
}

যা উভয় অ আদিম কী দিয়ে কাজ।

লাইব্রেরি

underscore এবং Lo-Dash উভয় uniq পদ্ধতি প্রদান। তাদের অ্যালগরিদম মূলত উপরে প্রথম স্নিপেট অনুরূপ এবং এই পর্যন্ত উড়া:

var result = [];
a.forEach(function(item) {
     if(result.indexOf(item) < 0) {
         result.push(item);
     }
});

এটি চতুর্ভুজীয়, তবে চমৎকার অতিরিক্ত গুডিজ রয়েছে, যেমন নেটিভ ইন্ডেক্স মোড়ানো, একটি কী দ্বারা ( iteratee তাদের কী), এবং ইতিমধ্যে সাজানো অ্যারেগুলির জন্য অপটিমাইজেশন করার ক্ষমতা।

আপনি যদি jQuery ব্যবহার করেন এবং এটির আগে ডলার ছাড়াই কিছু স্ট্যান্ড করতে না পারেন তবে এটি এভাবে চলবে:

  $.uniqArray = function(a) {
        return $.grep(a, function(item, pos) {
            return $.inArray(item, a) === pos;
        });
  }

যা আবার, প্রথম স্নিপেট একটি বৈচিত্র্য।

কর্মক্ষমতা

ফাংশন কলগুলি জাভাস্ক্রিপ্টে ব্যয়বহুল, তাই উপরের সমাধানগুলি, যত তাড়াতাড়ি সম্ভব, তা বিশেষভাবে কার্যকর নয়। সর্বাধিক কর্মক্ষমতা জন্য, একটি লুপ সঙ্গে filter প্রতিস্থাপন এবং অন্যান্য ফাংশন কল পরিত্রাণ পেতে:

function uniq_fast(a) {
    var seen = {};
    var out = [];
    var len = a.length;
    var j = 0;
    for(var i = 0; i < len; i++) {
         var item = a[i];
         if(seen[item] !== 1) {
               seen[item] = 1;
               out[j++] = item;
         }
    }
    return out;
}

কুৎসিত কোডের এই অংশটি উপরে উল্লিখিত স্ন্যিপেট # 3 এর মতো একই, কিন্তু তীব্রতার একটি ক্রম (২017 সালের মধ্যে এটি দ্রুত দ্রুত দুবার) - জেএস কোর লোকেরা দুর্দান্ত কাজ করছে!)

function uniq(a) {
    var seen = {};
    return a.filter(function(item) {
        return seen.hasOwnProperty(item) ? false : (seen[item] = true);
    });
}

function uniq_fast(a) {
    var seen = {};
    var out = [];
    var len = a.length;
    var j = 0;
    for(var i = 0; i < len; i++) {
         var item = a[i];
         if(seen[item] !== 1) {
               seen[item] = 1;
               out[j++] = item;
         }
    }
    return out;
}

/////

var r = [0,1,2,3,4,5,6,7,8,9],
    a = [],
    LEN = 1000,
    LOOPS = 1000;

while(LEN--)
    a = a.concat(r);

var d = new Date();
for(var i = 0; i < LOOPS; i++)
    uniq(a);
document.write('<br>uniq, ms/loop: ' + (new Date() - d)/LOOPS)

var d = new Date();
for(var i = 0; i < LOOPS; i++)
    uniq_fast(a);
document.write('<br>uniq_fast, ms/loop: ' + (new Date() - d)/LOOPS)

ES6

ES6 Set অবজেক্টটি সরবরাহ করে, যা জিনিসকে অনেক সহজ করে তোলে:

function uniq(a) {
   return Array.from(new Set(a));
}

অথবা

let uniq = a => [...new Set(a)];

উল্লেখ্য, পাইথনের বিপরীতে, ES6 সেটগুলি সন্নিবেশ আদেশে পুনরাবৃত্তি করা হয়, তাই এই কোডটি মূল অ্যারের ক্রমকে সংরক্ষণ করে।

যাইহোক, যদি আপনি অনন্য উপাদানের সাথে একটি অ্যারে প্রয়োজন, কেন শুরু থেকে সঠিক সেট ব্যবহার করবেন না?

জেনারেটর

একটি "অলস", uniq জেনারেটর ভিত্তিক সংস্করণ একই ভিত্তিতে তৈরি করা যেতে পারে:

  • যুক্তি থেকে পরবর্তী মান নিতে
  • যদি এটি ইতিমধ্যে দেখা যায়, এটা এড়িয়ে যান
  • অন্যথায়, এটি ফলন এবং ইতিমধ্যে দেখা মান সেট সেট যোগ করুন

function* uniqIter(a) {
    let seen = new Set();

    for (let x of a) {
        if (!seen.has(x)) {
            seen.add(x);
            yield x;
        }
    }
}

// example:

function* randomsBelow(limit) {
    while (1)
        yield Math.floor(Math.random() * limit);
}

// note that randomsBelow is endless

count = 20;
limit = 30;

for (let r of uniqIter(randomsBelow(limit))) {
    console.log(r);
    if (--count === 0)
        break
}

// exercise for the reader: what happens if we set `limit` less than `count` and why


জেনেরিক কার্যকরী পদ্ধতি

ES2015 এর সাথে এখানে একটি জেনেরিক এবং কঠোরভাবে কার্যকরী পদ্ধতি রয়েছে:

// small, reusable auxiliary functions

const apply = f => a => f(a);

const flip = f => b => a => f(a) (b);

const uncurry = f => (a, b) => f(a) (b);

const push = x => xs => (xs.push(x), xs);

const foldl = f => acc => xs => xs.reduce(uncurry(f), acc);

const some = f => xs => xs.some(apply(f));


// the actual de-duplicate function

const uniqueBy = f => foldl(
   acc => x => some(f(x)) (acc)
    ? acc
    : push(x) (acc)
 ) ([]);


// comparators

const eq = y => x => x === y;

// string equality case insensitive :D
const seqCI = y => x => x.toLowerCase() === y.toLowerCase();


// mock data

const xs = [1,2,3,1,2,3,4];

const ys = ["a", "b", "c", "A", "B", "C", "D"];


console.log( uniqueBy(eq) (xs) );

console.log( uniqueBy(seqCI) (ys) );

আমরা খুব সহজেই লাভ করতে পারি uniqueথেকে unqiueByঅথবা দ্রুততর বাস্তবায়ন ব্যবহার ব্যবহার SetS:

const unqiue = uniqueBy(eq);

// const unique = xs => Array.from(new Set(xs));

এই পদ্ধতির উপকারিতা:

  • একটি পৃথক comparator ফাংশন ব্যবহার করে জেনেরিক সমাধান
  • ঘোষণামূলক এবং সংক্ষিপ্ত বাস্তবায়ন
  • অন্যান্য ছোট, জেনেরিক ফাংশন পুনঃব্যবহার

কর্মক্ষমতা বিবেচনা

uniqueBy loops সঙ্গে একটি অপরিহার্য বাস্তবায়ন হিসাবে দ্রুত নয়, কিন্তু এটি তার জেনেরাসিটি কারণে উপায় আরো expressive।

আপনি যদি uniqueByআপনার অ্যাপ্লিকেশানে কংক্রিট পারফরম্যান্সের দণ্ড হিসাবে চিহ্নিত হন তবে এটি অপ্টিমাইজড কোড দিয়ে প্রতিস্থাপন করুন। অর্থাৎ, প্রথমে আপনার কোডটি একটি কার্যকরী, ঘোষণামূলক উপায়ে লিখুন। তারপরে, যদি আপনি কর্মক্ষমতা সমস্যা সম্মুখীন হন তবে সমস্যাগুলির কারণগুলির ক্ষেত্রে অবস্থানে কোডটি অনুকূল করার চেষ্টা করুন।

মেমরি খরচ এবং আবর্জনা সংগ্রহ

uniqueBymutations ( push(x) (acc)) তার শরীরের ভিতরে লুকানো ব্যবহার করে । এটি প্রতিটি পুনরাবৃত্তি পরে দূরে নিক্ষেপ করার পরিবর্তে সংশ্লেষকারী reuses। এটি মেমরি খরচ এবং জিসি চাপ হ্রাস। যেহেতু এই পার্শ্ব প্রতিক্রিয়াটি ফাংশনের ভেতরে মোড়ানো হয়, বাইরে সবকিছুই বিশুদ্ধ থাকে।


ECMAScript 6 (উকিল ইসিএমএসক্রিপ্ট 2015), Set সদৃশগুলি ফিল্টার করার জন্য ব্যবহার করা যেতে পারে। তারপর এটি স্প্রেড অপারেটর ব্যবহার করে একটি অ্যারে রূপান্তর করা যেতে পারে।

var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"],
    unique = [...new Set(names)];

অ্যারে ফিল্টার এবং সূচী ব্যবহার করে একটি একক লাইন সংস্করণ ফাংশন:

arr = arr.filter (function (value, index, array) { 
    return array.indexOf (value) == index;
});

আপনি কেবল জাভাস্ক্রিপ্টে এটি করতে পারেন, দ্বিতীয় সাহায্যে - সূচকের - filter পদ্ধতির প্যারামিটার:

var a = [2,3,4,5,5,4];
a.filter(function(value, index){ return a.indexOf(value) == index });

বা স্বল্প হাতে

a.filter((v,i) => a.indexOf(v) == i)

এই এক জন্য যান:

var uniqueArray = duplicateArray.filter(function(elem, pos) {
    return duplicateArray.indexOf(elem) == pos;
}); 

এখন uniqueArray কোন সদৃশ থাকে।


এক লাইন:

let names = ['Mike','Matt','Nancy','Adam','Jenny','Nancy','Carl', 'Nancy'];
let dup = [...new Set(names)];
console.log(dup);

জন্য-loops বা jQuery সঙ্গে সব খারাপ উদাহরণ দেখতে ক্লান্ত পেয়েছেন। জাভাস্ক্রিপ্ট এই আজকাল জন্য নিখুঁত সরঞ্জাম আছে: সাজান, মানচিত্র এবং কমাতে।

বর্তমান আদেশ পালন যখন Uniq হ্রাস

var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];

var uniq = names.reduce(function(a,b){
    if (a.indexOf(b) < 0 ) a.push(b);
    return a;
  },[]);

console.log(uniq, names) // [ 'Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Carl' ]

// one liner
return names.reduce(function(a,b){if(a.indexOf(b)<0)a.push(b);return a;},[]);

সাজানোর সঙ্গে দ্রুত unic

সম্ভবত দ্রুত উপায় আছে কিন্তু এই এক বেশ শালীন।

var uniq = names.slice() // slice makes copy of array before sorting it
  .sort(function(a,b){
    return a > b;
  })
  .reduce(function(a,b){
    if (a.slice(-1)[0] !== b) a.push(b); // slice(-1)[0] means last item in array without removing it (like .pop())
    return a;
  },[]); // this empty array becomes the starting value for a

// one liner
return names.slice().sort(function(a,b){return a > b}).reduce(function(a,b){if (a.slice(-1)[0] !== b) a.push(b);return a;},[]);

আপডেট 2015: ES6 সংস্করণ:

ES6 এ আপনার সেট এবং স্প্রেড রয়েছে যা সমস্ত সদৃশগুলি সরানোর জন্য এটি খুব সহজ এবং ফলপ্রসূ করে তোলে:

var uniq = [ ...new Set(names) ]; // [ 'Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Carl' ]

ঘটনার উপর ভিত্তি করে বাছাই করুন:

কেউ কতগুলি অনন্য নাম আছে তার উপর ভিত্তি করে ফলাফলগুলি অর্ডার করার বিষয়ে জিজ্ঞাসা করেছে:

var names = ['Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Nancy', 'Carl']

var uniq = names
  .map((name) => {
    return {count: 1, name: name}
  })
  .reduce((a, b) => {
    a[b.name] = (a[b.name] || 0) + b.count
    return a
  }, {})

var sorted = Object.keys(uniq).sort((a, b) => uniq[a] < uniq[b])

console.log(sorted)

নিম্নোক্ত jQuery পদ্ধতি তালিকাভুক্তির চেয়ে 80% বেশি দ্রুত (নীচে পরীক্ষা দেখুন)। এটা কয়েক বছর আগে একই প্রশ্ন থেকে একটি উত্তর। যদি আমি মূলত প্রস্তাবিত ব্যক্তি জুড়ে আসি তবে আমি ক্রেডিট পোস্ট করব। বিশুদ্ধ জেএস।

var temp = {};
for (var i = 0; i < array.length; i++)
  temp[array[i]] = true;
var r = [];
for (var k in temp)
  r.push(k);
return r;

আমার পরীক্ষার ক্ষেত্রে তুলনা: http://jsperf.com/remove-duplicate-array-tests


সরলতম এক আমি এতদূর মধ্যে চালানো করেছি। Es6 মধ্যে।

 var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl", "Mike", "Nancy"]

 var noDupe = Array.from(new Set(names))

Set


https://jsfiddle.net/2w0k5tz8/

function remove_duplicates(array_){
    var ret_array = new Array();
    for (var a = array_.length - 1; a >= 0; a--) {
        for (var b = array_.length - 1; b >= 0; b--) {
            if(array_[a] == array_[b] && a != b){
                delete array_[b];
            }
        };
        if(array_[a] != undefined)
            ret_array.push(array_[a]);
    };
    return ret_array;
}

console.log(remove_duplicates(Array(1,1,1,2,2,2,3,3,3)));

লুপ মাধ্যমে, সদৃশ অপসারণ, এবং একটি ক্লোন অ্যারে স্থান ধারক তৈরি করুন কারণ অ্যারে সূচী আপডেট করা হবে না।

ভাল কর্মক্ষমতা জন্য পশ্চাদপসরণ পশ্চাদপসরণ (আপনার লুপ আপনার অ্যারের দৈর্ঘ্য পরীক্ষা রাখা প্রয়োজন হবে না)


এটি সম্ভবত সর্বাধিক ফাংশনগুলির চেয়ে 10x গুণে অ্যারে থেকে স্থায়ীভাবে সদৃশগুলি মুছে ফেলার দ্রুততম উপায় । & Safari তে 78x দ্রুত

function toUnique(a,b,c){               //array,placeholder,placeholder
 b=a.length;while(c=--b)while(c--)a[b]!==a[c]||a.splice(c,1)
}
  1. পরীক্ষা: http://jsperf.com/wgu
  2. ডেমো: http://jsfiddle.net/46S7g/
  3. আরো: https://.com/a/25082874/2450730

যদি আপনি উপরের কোডটি পড়তে না পারেন তবে জাভাস্ক্রিপ্ট বইটি পড়ুন বা এখানে সংক্ষিপ্ত কোড সম্পর্কে কিছু ব্যাখ্যা রয়েছে। https://.com/a/21353032/2450730


ভ্যানিলা জেএস: একটি সেট মত একটি বস্তু ব্যবহার করে ডুপ্লিকেট মুছে ফেলুন

আপনি সর্বদা এটি একটি বস্তুর মধ্যে স্থাপন করার চেষ্টা করতে পারেন এবং তারপরে তার কীগুলির মাধ্যমে পুনরাবৃত্তি করতে পারেন:

function remove_duplicates(arr) {
    var obj = {};
    var ret_arr = [];
    for (var i = 0; i < arr.length; i++) {
        obj[arr[i]] = true;
    }
    for (var key in obj) {
        ret_arr.push(key);
    }
    return ret_arr;
}

ভ্যানিলা জেএস: ইতিমধ্যে দেখা মান ট্র্যাকিং দ্বারা সদৃশ সরান (অর্ডার-নিরাপদ)

অথবা, অর্ডার-নিরাপদ সংস্করণের জন্য, সমস্ত পূর্বের দেখা মান সংরক্ষণ করার জন্য একটি বস্তু ব্যবহার করুন এবং একটি অ্যারে যোগ করার আগে এটির বিরুদ্ধে মানগুলি পরীক্ষা করুন।

function remove_duplicates_safe(arr) {
    var seen = {};
    var ret_arr = [];
    for (var i = 0; i < arr.length; i++) {
        if (!(arr[i] in seen)) {
            ret_arr.push(arr[i]);
            seen[arr[i]] = true;
        }
    }
    return ret_arr;

}

ECMAScript 6: নতুন সেট তথ্য গঠন ব্যবহার করুন (অর্ডার-নিরাপদ)

ECMAScript 6 নতুন Set ডেটা-স্ট্রাকচার যোগ করে, যা আপনাকে কোনও ধরণের মান সঞ্চয় করতে দেয়। Set.values সন্নিবেশ আদেশ উপাদান ফেরত।

function remove_duplicates_es6(arr) {
    let s = new Set(arr);
    let it = s.values();
    return Array.from(it);
}

উদাহরণ ব্যবহার:

a = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];

b = remove_duplicates(a);
// b:
// ["Adam", "Carl", "Jenny", "Matt", "Mike", "Nancy"]

c = remove_duplicates_safe(a);
// c:
// ["Mike", "Matt", "Nancy", "Adam", "Jenny", "Carl"]

d = remove_duplicates_es6(a);
// d:
// ["Mike", "Matt", "Nancy", "Adam", "Jenny", "Carl"]

এটি শুধু অন্য সমাধান কিন্তু বাকি চেয়ে ভিন্ন ছিল।

function diffArray(arr1, arr2) {
  var newArr = arr1.concat(arr2);
  newArr.sort();
  var finalArr = [];
  for(var i = 0;i<newArr.length;i++) {
   if(!(newArr[i] === newArr[i+1] || newArr[i] === newArr[i-1])) {
     finalArr.push(newArr[i]);
   } 
  }
  return finalArr;
}

তাই অপশন হল:

let a = [11,22,11,22];
let b = []


b = [ ...new Set(a) ];     
// b = [11, 22]

b = Array.from( new Set(a))   
// b = [11, 22]

b = a.filter((val,i)=>{
  return a.indexOf(val)==i
})                        
// b = [11, 22]


একটি সহজ কিন্তু কার্যকর কৌশল, filterফিল্টার সঙ্গে সমন্বয় পদ্ধতি ব্যবহার করা হয় function(value, index){ return this.indexOf(value) == index }

কোড উদাহরণ:

var data = [2,3,4,5,5,4];
var filter = function(value, index){ return this.indexOf(value) == index };
var filteredData = data.filter(filter, data );

document.body.innerHTML = '<pre>' + JSON.stringify(filteredData, null, '\t') +  '</pre>';

আরও দেখুন এই বেহালার


শীর্ষ উত্তরগুলির জটিলতা রয়েছে O(n²), তবে এটি O(n)একটি হ্যাস হিসাবে একটি বস্তু ব্যবহার করে সম্পন্ন করা যেতে পারে :

function getDistinctArray(arr) {
    var dups = {};
    return arr.filter(function(el) {
        var hash = el.valueOf();
        var isDup = dups[hash];
        dups[hash] = true;
        return !isDup;
    });
}

এই স্ট্রিং, সংখ্যা, এবং তারিখের জন্য কাজ করবে। যদি আপনার অ্যারের জটিল বস্তুগুলি থাকে (অর্থাত্, তাদের সাথে তুলনা করতে হবে ===), উপরের সমাধানটি কাজ করবে না। আপনি O(n)বস্তুর উপর একটি পতাকা সেট করে বস্তুর জন্য একটি বাস্তবায়ন পেতে পারেন :

function getDistinctObjArray(arr) {
    var distinctArr = arr.filter(function(el) {
        var isDup = el.inArray;
        el.inArray = true;
        return !isDup;
    });
    distinctArr.forEach(function(el) {
        delete el.inArray;
    });
    return distinctArr;
}

for (i=0; i<originalArray.length; i++) {  
    if (!newArray.includes(originalArray[i])) {
        newArray.push(originalArray[i]); 
    }
}




unique