दिलचस्प पोस्ट
कैसे। Htaccess में RewriteBase काम करता है सी में (->) ऑपरेटर सी क्यों मौजूद है? CSS3 मार्की प्रभाव क्यों 3 और एक्स (जो 3 को सौंपा गया था) Haskell में अलग अनुमानित प्रकार हैं? एक स्प्रिंग निर्भरता को जेपीए इकाई लिस्टनर में इंजेक्शन करना पूरे दस्तावेज़ में एक निश्चित प्रकार के प्रथम / nth तत्व का मिलान करना क्या आपको वस्तुओं का निपटान करने और उन्हें रिक्त करने की आवश्यकता है? ऑब्जेक्ट शाब्दिक घोषणाओं में स्व-संदर्भ मैं सबवर्सन में फ़ाइलों को कैसे अनदेखा कर सकता हूं? PostgreSQL में स्थान की गणना और बचत करना मैं प्रोग्राम को कई लाइनों में लेआउट में एक-एक करके बटन कैसे जोड़ूं? नकली, मजाक और बदमाश के बीच क्या अंतर है? फाइल में सबसे छोटा फ्लोट ढूंढना और उसके ऊपर की रेखा प्रिंट करना HTTP_CLIENT_IP और HTTP_X_FORWARDED_FOR के बीच क्या अंतर है? पार्सिंग प्रदर्शन (यदि, ट्रायप्रॉर्स, टच-कैच)

जेएस सरणी से डुप्लिकेट मान निकालें

मेरे पास एक बहुत ही सरल JavaScript सरणी है जो डुप्लिकेट को शामिल या शामिल नहीं कर सकता है

names = new Array("Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"); 

मुझे डुप्लिकेट को निकालने की जरूरत है और एक नए सरणी में अद्वितीय मान डालते हैं।

मैं उन सभी कोडों को इंगित कर सकता हूं जिन्हें मैंने करने की कोशिश की है, लेकिन मुझे लगता है कि यह बेकार है क्योंकि वे काम नहीं करते हैं। मैं भी jQuery समाधान स्वीकार करते हैं

समान प्रश्न:

  • एक सरणी में सभी गैर-अद्वितीय मान प्राप्त करें (यानी: डुप्लिकेट / एक से अधिक घटना)

वेब के समाधान से एकत्रित समाधान "जेएस सरणी से डुप्लिकेट मान निकालें"

JQuery का उपयोग करके त्वरित और गंदा:

 var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"]; var uniqueNames = []; $.each(names, function(i, el){ if($.inArray(el, uniqueNames) === -1) uniqueNames.push(el); }); 

"स्मार्ट" लेकिन भोले तरीके से

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

असल में, हम सरणी से दोहराते हैं और, प्रत्येक तत्व के लिए, जांचें कि क्या सरणी में इस तत्व की पहली स्थिति वर्तमान स्थिति के बराबर है। जाहिर है, इन दो पदोन्नति डुप्लिकेट तत्वों के लिए अलग हैं।

फ़िल्टर कॉलबैक के 3 ("यह सरणी") पैरामीटर का उपयोग करके हम सरणी चर को बंद करने से बच सकते हैं:

 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}] लौटाएगा।

उसने कहा, यदि आपके arrays में केवल प्राथमिकताएं होती हैं और आप प्रकारों के बारे में परवाह नहीं करते हैं (जैसे यह हमेशा नंबर होता है), यह समाधान इष्टतम है

दो दुनिया से सर्वश्रेष्ठ

एक सार्वभौमिक समाधान दोनों तरीकों को जोड़ता है: यह प्राइमिटिव के लिए हैश लुकअप और वस्तुओं के लिए रैखिक खोज का उपयोग करता है।

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

(कुछ लोग पसंद करते हैं) देखा !seen.has(k) && seen.add(k) बजाय seen.has(k) ? false : seen.add(k) )।

पुस्तकालय

दोनों अंडरस्कोर और लो-डैश 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 के समान होता है, लेकिन तीव्रता का एक क्रम अधिक है (2017 तक यह केवल दो बार तेज़ है – जेएस कोर लोग एक अच्छा काम कर रहे हैं!)

 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) 

लूप या jQuery के साथ सभी बुरे उदाहरणों को देखने से थक गया जावास्क्रिप्ट आजकल इसके लिए सही उपकरण है: सॉर्ट, मैप और कम करें

मौजूदा आदेश को रखते हुए यूनीक को कम करते हैं

 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;},[]); 

सॉर्टिंग के साथ तेज यूनिक

संभवत: तेज तरीके हैं लेकिन यह एक बहुत अच्छा है

 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 के टक्स के साथ जाने के लिए टाई है, और बैकबोन.जेएस के निलंबन

_.uniq

_.uniq(array, [isSorted], [iterator]) उपनाम: अद्वितीय
ऑब्जेक्ट समानता का परीक्षण करने के लिए === का उपयोग करते हुए, सरणी के एक डुप्लिकेट-फ्री संस्करण का उत्पादन करता है। अगर आपको अग्रिम में पता है कि सरणी को सॉर्ट किया गया है, तो इसके लिए सही हो रहा है सोर्स एक बहुत तेजी से एल्गोरिदम चलाएगा। यदि आप परिवर्तन के आधार पर अनन्य आइटम्स की गणना करना चाहते हैं, तो इटरेटर फंक्शन पास करें।

उदाहरण

 var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"]; alert(_.uniq(names, false)); 

नोट: लो-डैश (एक अंडरस्कोर प्रतियोगी) भी तुलनीय प्रदान करता है।

वेनिला जेएस: एक सेट की तरह एक वस्तु का उपयोग कर डुप्लिकेट निकालें

आप हमेशा इसे किसी ऑब्जेक्ट में डालने की कोशिश कर सकते हैं, और उसके बाद अपनी चाबियों के माध्यम से दोहरा सकते हैं:

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

सरणी फिल्टर और indexOf फ़ंक्शंस का उपयोग करके एक एकल पंक्ति संस्करण:

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

देशी जावास्क्रिप्ट फ़ंक्शंस का उपयोग करके एक सरणी से डुप्लिकेट को निकालने का सबसे संक्षिप्त तरीका नीचे की तरह अनुक्रम का उपयोग करना है:

 vals.sort().reduce(function(a, b){ if (b != a[0]) a.unshift(b); return a }, []) 

indexOf को कम करने के भीतर, slice लिए कोई ज़रूरत नहीं है, और न ही किसी भी indexOf ज़रूरत है, जैसे मैंने अन्य उदाहरणों में देखा है! यद्यपि यह एक फिल्टर फ़ंक्शन के साथ इसका उपयोग करने का अर्थ है:

 vals.filter(function(v, i, a){ return i == a.indexOf(v) }) 

एक और ES6 (2015) ऐसा करने का तरीका जो कुछ ब्राउज़रों पर काम करता है वह है:

 Array.from(new Set(vals)) 

या यहां तक ​​कि फैल ऑपरेटर का उपयोग कर:

 [...new Set(vals)] 

चियर्स!

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

अब अद्वितीयअरेरे में कोई डुप्लिकेट नहीं है।

सरलतम मैंने अभी तक में भाग लिया है I Es6 में

  var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl", "Mike", "Nancy"] var noDupe = Array.from(new Set(names)) 

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set

मैंने कुछ अन्य प्रश्नों पर dupes हटाने की एक विस्तृत तुलना की है, लेकिन यह देखते हुए कि यह वास्तविक जगह है, मैं इसे यहां यहां साझा करना चाहता था।

मेरा मानना ​​है कि यह ऐसा करने का सबसे अच्छा तरीका है

 var myArray = [100, 200, 100, 200, 100, 100, 200, 200, 200, 200], reduced = Object.keys(myArray.reduce((p,c) => (p[c] = true,p),{})); console.log(reduced); 

नीचे सूचीबद्ध 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

यहां सवाल का एक सरल जवाब है

 var names = ["Alex","Tony","James","Suzane", "Marie", "Laurence", "Alex", "Suzane", "Marie", "Marie", "James", "Tony", "Alex"]; var uniqueNames = []; for(var i in names){ if(uniqueNames.indexOf(names[i]) === -1){ uniqueNames.push(names[i]); } } 

ECMAScript 6 (उर्फ ECMAScript 2015) में, डुप्लिकेट को फ़िल्टर करने के लिए Set का उपयोग किया जा सकता है। फिर इसे फैल ऑपरेटर का उपयोग करके एक सरणी में परिवर्तित किया जा सकता है।

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

एक पंक्ति:

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

शीर्ष उत्तरों में 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; } 

वर्तमान उत्तर (भविष्य में दिखने वाला ईएस 6 वाले) की तुलना में सरल और अधिक संक्षिप्त समाधान होने के अलावा, मैं पेर्फ ने यह परीक्षण किया और यह बहुत तेज था:

 var uniqueArray = dupeArray.filter(function(item, i, self){ return self.lastIndexOf(item) == i; }); 

एक चेतावनी: अर्रे.लास्ट इंडेक्स () को IE9 में जोड़ा गया था, इसलिए यदि आपको उस से कम जाना है, तो आपको कहीं और देखने की आवश्यकता होगी।

एक सरल लेकिन प्रभावी तकनीक, फ़िल्टर function(value, index){ return this.indexOf(value) == index } साथ संयोजन में 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>'; 

यहां कोई खास लाइब्रेरीज़ बिना सामान्य विधि है विशेष फ़ंक्शन,

 name_list = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"]; get_uniq = name_list.filter(function(val,ind) { return name_list.indexOf(val) == ind; }) console.log("Original name list:"+name_list.length, name_list) console.log("\n Unique name list:"+get_uniq.length, get_uniq) 

आप JavaScript लैब लाइब्रेरी से Array.unique() विधि का भी उपयोग कर सकते हैं – या वहां से एक विचार चोरी कर सकते हैं।

हालांकि, कोड बहुत अच्छी तरह से लिखा नहीं है, क्योंकि यह ऐरे प्रोटोटाइप की संपत्ति के रूप में unique() विधि को घोषित करता है, इस प्रकार यह प्रत्येक सरणी को जोड़ता है, कार्यप्रणाली for...in (क्योंकि इसके for...in लूप में हमेशा unique चर पर फिर से चलना होगा)।

जेनेरिक कार्यात्मक दृष्टिकोण

यहां 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) ); 

So the options is:

 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] 
 $(document).ready(function() { var arr1=["dog","dog","fish","cat","cat","fish","apple","orange"] var arr2=["cat","fish","mango","apple"] var uniquevalue=[]; var seconduniquevalue=[]; var finalarray=[]; $.each(arr1,function(key,value){ if($.inArray (value,uniquevalue) === -1) { uniquevalue.push(value) } }); $.each(arr2,function(key,value){ if($.inArray (value,seconduniquevalue) === -1) { seconduniquevalue.push(value) } }); $.each(uniquevalue,function(ikey,ivalue){ $.each(seconduniquevalue,function(ukey,uvalue){ if( ivalue == uvalue) { finalarray.push(ivalue); } }); }); alert(finalarray); }); 

If by any chance you were using

D3.js

You could do

 d3.set(["foo", "bar", "foo", "baz"]).values() ==> ["foo", "bar", "baz"] 

https://github.com/mbostock/d3/wiki/Arrays#set_values

Here is very simple for understanding and working anywhere (even in PhotoshopScript) code. Check it!

 var peoplenames = new Array("Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"); peoplenames = unique(peoplenames); alert(peoplenames); function unique(array){ var len = array.length; for(var i = 0; i < len; i++) for(var j = i + 1; j < len; j++) if(array[j] == array[i]){ array.splice(j,1); j--; len--; } return array; } //*result* peoplenames == ["Mike","Matt","Nancy","Adam","Jenny","Carl"] 

A slight modification of thg435's excellent answer to use a custom comparator:

 function contains(array, obj) { for (var i = 0; i < array.length; i++) { if (isEqual(array[i], obj)) return true; } return false; } //comparator function isEqual(obj1, obj2) { if (obj1.name == obj2.name) return true; return false; } function removeDuplicates(ary) { var arr = []; return ary.filter(function(x) { return !contains(arr, x) && arr.push(x); }); } 

This is probably one of the fastest way to remove permanently the duplicates from an array 10x times faster than the most functions here.& 78x faster in safari

 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. Test: http://jsperf.com/wgu
  2. Demo: http://jsfiddle.net/46S7g/
  3. More: https://stackoverflow.com/a/25082874/2450730

if you can't read the code above ask, read a javascript book or here are some explainations about shorter code. https://stackoverflow.com/a/21353032/2450730

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

Loop through, remove duplicates, and create a clone array place holder because the array index will not be updated.

Loop backward for better performance ( your loop wont need to keep checking the length of your array)

This was just another solution but different than the rest.

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

If using AngularJs then use filter like this

 angular.module("myApp", []).controller("myController", function($scope) { $scope.targetArray = ['Apple', 'Apple', 'Banana', 'Mango', 'Strawberry', 'Banana']; $scope.filteredArray = []; $scope.removeDuplicates = function() { $scope.filteredArray = $scope.targetArray.filter(function(item, pos) { return $scope.targetArray.indexOf(item) == pos; }); } }); 
 <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.2.23/angular.min.js"></script> <body ng-app="myApp"> <div ng-controller='myController'> <div> Actual Array: {{targetArray}} <br> Resulted Array: {{filteredArray}} <br> <button ng-click='removeDuplicates()'>Remove Duplicates</button> </div> </body>