जावास्क्रिप्ट सरणी में सभी अद्वितीय मान प्राप्त करें (डुप्लिकेट निकालें)

Question

मेरे पास संख्याओं की एक सरणी है जो मुझे सुनिश्चित करने की आवश्यकता है कि वे अद्वितीय हैं। मुझे इंटरनेट पर नीचे कोड स्निपेट मिला और यह तब तक बढ़िया काम करता है जब तक कि इसमें एक शून्य न हो। स्टैक ओवरफ्लो पर मुझे यह अन्य स्क्रिप्ट मिली, जो लगभग वैसी ही दिखती है, लेकिन यह विफल नहीं होती।

तो मुझे सीखने में मदद करने के लिए, क्या कोई मुझे यह निर्धारित करने में मदद कर सकता है कि प्रोटोटाइप स्क्रिप्ट गलत कहाँ है?

Array.prototype.getUnique = function() {
 var o = {}, a = [], i, e;
 for (i = 0; e = this[i]; i++) {o[e] = 1};
 for (e in o) {a.push (e)};
 return a;
}

डुप्लिकेट प्रश्न से अधिक उत्तर:

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

इसी तरह का सवाल:

• सभी गैर-अनूठे मान प्राप्त करें (जैसे: डुप्लिकेट / एक से अधिक घटनाएँ)

Comments

@hippietrail यह पुराना सवाल केवल डुप्लिकेट को खोजने और वापस करने के बारे में है (मैं भी भ्रमित था!)। मेरा सवाल इस बारे में अधिक है कि जब कोई सरणी इसमें शून्य है तो यह फ़ंक्शन विफल क्यों है।

— मोति

आप शायद अपने प्रश्न का शीर्षक कम अस्पष्ट भी बनाना चाहते हैं।

— हिप्पिएट्रेल

भविष्य के पाठकों के लिए, जब आपको लगता है कि आपको हर समय अपने डेटा संरचना की सामग्री को एल्गोरिदम में बदलना है, (उन्हें क्रम दें, तत्वों को दोहराएं, आदि) या हर पुनरावृत्ति पर इसके अंदर के तत्वों की खोज करें, यह मान लेना सुरक्षित है कि आप पहली जगह में गलत डेटा संरचना का उपयोग करना और एक का उपयोग करना शुरू करें जो हाथ में कार्य के लिए अधिक उपयुक्त है (इस मामले में सरणी के बजाय एक हैश सेट)।

— nurettin

मैंने कहीं और से कोड की प्रतिलिपि बनाई, एक loooong समय पहले ... लेकिन यह बहुत सीधा- oobjectaarrayiindexe

— सा

कैसे एक सरणी में अद्वितीय मूल्यों को प्राप्त करने के लिए

— एडिल इमरान

Answer 1

साथ जावास्क्रिप्ट 1.6 / ECMAScript 5 आप देशी उपयोग कर सकते हैं filterकिसी सरणी की विधि निम्नलिखित तरीके से अद्वितीय मूल्यों के साथ एक सरणी प्राप्त करने के लिए:

function onlyUnique(value, index, self) { 
    return self.indexOf(value) === index;
}

// usage example:
var a = ['a', 1, 'a', 2, '1'];
var unique = a.filter( onlyUnique ); // returns ['a', 1, 2, '1']

मूल विधि filterसरणी के माध्यम से लूप करेगी और केवल उन प्रविष्टियों को छोड़ देगी जो दिए गए कॉलबैक फ़ंक्शन को पास करती हैं onlyUnique।

onlyUniqueजाँचता है, यदि दिया गया मान पहली घटना है। यदि नहीं, तो यह एक डुप्लिकेट होना चाहिए और कॉपी नहीं किया जाएगा।

यह समाधान किसी भी अतिरिक्त पुस्तकालय जैसे jQuery या प्रोटोटाइप.js के बिना काम करता है।

यह मिश्रित मूल्य प्रकारों के साथ सरणियों के लिए भी काम करता है।

पुराने ब्राउज़रों (<ie9) के लिए, जो मूल तरीकों का समर्थन नहीं करते हैं filterऔर indexOfआप फ़िल्टर और इंडेक्सऑफ के लिए एमडीएन प्रलेखन में काम कर सकते हैं ।

आप एक मूल्य के अंतिम घटना रखना चाहते हैं, सरल की जगह indexOfसे lastIndexOf।

ES6 के साथ इसे छोटा किया जा सकता है:

// usage example:
var myArray = ['a', 1, 'a', 2, '1'];
var unique = myArray.filter((v, i, a) => a.indexOf(v) === i); 

// unique is ['a', 1, 2, '1']

टिप्पणी में संकेत के लिए कैमिलो मार्टिन के लिए धन्यवाद ।

ईएस 6 में Setअद्वितीय मूल्यों को संग्रहीत करने के लिए एक देशी वस्तु है। अद्वितीय मूल्यों के साथ एक सरणी प्राप्त करने के लिए आप अब यह कर सकते हैं:

var myArray = ['a', 1, 'a', 2, '1'];

let unique = [...new Set(myArray)]; 

// unique is ['a', 1, 2, '1']

Setऐरे की तरह एक चलने योग्य वस्तु का निर्माता , और प्रसार ऑपरेटर ...सेट को एक ऐरे में बदल देता है। टिप्पणी में संकेत के लिए लुकास Liese के लिए धन्यवाद ।

Comments

यह समाधान दुर्भाग्य से बहुत धीमी गति से चलेगा। आप दो बार लूपिंग कर रहे हैं, एक बार फिल्टर के साथ और एक बार

— जैक फ्रेंज़ेन

@JackFranzen धीमी की तुलना में क्या? राफेल से हल ? मिश्रित प्रकार के सरणियों के लिए राफेल समाधान काम नहीं करता है। मेरे उदाहरण के लिए ['a', 1, 'a', 2, '1']आपको मिलेगा ['a', 1, 2]। लेकिन यह वह नहीं है जिसकी मुझे उम्मीद थी। BTW, बहुत धीमी सापेक्ष है।

— १०:४० पर TLindig

आधुनिक जेएस में: .filter((v,i,a)=>a.indexOf(v)==i)(वसा तीर संकेतन)।

— कैमिलो मार्टिन

let unique_values = [...new Set(random_array)]; developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

— लुकास लेइसिस

बहुत अधिक विस्तृत उत्तर के लिए, कई संभावनाओं सहित - जैसे पहले छँटाई करना, और अलग-अलग डेटा प्रकारों के साथ व्यवहार करना - देखें stackoverflow.com/a/9229821/368896

— Dan Nissenbaum

Answer 2

ES6 / ES2015 के लिए अद्यतित उत्तर : सेट का उपयोग करके , एकल लाइन समाधान है:

var items = [4,5,4,6,3,4,5,2,23,1,4,4,4]
var uniqueItems = Array.from(new Set(items))

जो लौटता है

[4, 5, 6, 3, 2, 23, 1]

जैसा कि le_m ने सुझाव दिया है, यह भी प्रसार ऑपरेटर का उपयोग करके छोटा किया जा सकता है , जैसे

var uniqueItems = [...new Set(items)]

Comments

ध्यान दें, कि आंतरिक सरणी काम नहीं करेगीArray.from(new Set([[1,2],[1,2],[1,2,3]]))

— अलेक्जेंडर गोंचारोव

की तुलना में इस समाधान का प्रदर्शन myArray.filter((v, i, a) => a.indexOf(v) === i);?

— सिमॉयव

कृपया ध्यान दें कि यदि आप Setआदिम मूल्यों के बजाय वस्तुओं का उपयोग करते हैं और जोड़ते हैं तो इसमें वस्तुओं के लिए अद्वितीय संदर्भ होंगे । इस प्रकार सेट sमें let s = new Set([{Foo:"Bar"}, {Foo:"Bar"}]);: इस वापस आ जाएगी Set { { Foo: 'Bar' }, { Foo: 'Bar' } }जो एक है Setवस्तुओं है कि एक ही मान होने के लिए अद्वितीय वस्तु संदर्भ के साथ। यदि आप लिखते हैं let o = {Foo:"Bar"};और फिर दो संदर्भों के साथ एक सेट बनाते हैं जैसे: let s2 = new Set([o,o]);तो s2 होगाSet { { Foo: 'Bar' } }

— मोर्टब

इन दोनों विकल्पों में IE10 पर भी एक polyfill.io परत मौजूद होने के साथ मुद्दे हैं

— Thymine

नया टेस्ट केस jsperf.com/array-filter-unique-vs-new-set/1 ऐसा लगता है जैसे new Setट्रॉफी

— शुक

Answer 3

मुझे पता है कि इस सवाल के 30 से अधिक उत्तर पहले से हैं। लेकिन मैंने पहले सभी मौजूदा उत्तरों को पढ़ा और अपना शोध किया।

मैंने सभी उत्तरों को 4 संभावित समाधानों में विभाजित किया है:

1. नई ES6 सुविधा का उपयोग करें: [...new Set( [1, 1, 2] )];
2. वस्तु का उपयोग करें { }डुप्लिकेट को रोकने के लिए का
3. सहायक सरणी का उपयोग करें [ ]
4. उपयोग filter + indexOf

यहाँ उत्तर में पाए गए नमूना कोड हैं:

नई ES6 सुविधा का उपयोग करें: [...new Set( [1, 1, 2] )];

function uniqueArray0(array) {
  var result = Array.from(new Set(array));
  return result    
}

{ }डुप्लिकेट को रोकने के लिए ऑब्जेक्ट का उपयोग करें

function uniqueArray1( ar ) {
  var j = {};

  ar.forEach( function(v) {
    j[v+ '::' + typeof v] = v;
  });

  return Object.keys(j).map(function(v){
    return j[v];
  });
} 

सहायक सरणी का उपयोग करें [ ]

function uniqueArray2(arr) {
    var a = [];
    for (var i=0, l=arr.length; i<l; i++)
        if (a.indexOf(arr[i]) === -1 && arr[i] !== '')
            a.push(arr[i]);
    return a;
}

उपयोग filter + indexOf

function uniqueArray3(a) {
  function onlyUnique(value, index, self) { 
      return self.indexOf(value) === index;
  }

  // usage
  var unique = a.filter( onlyUnique ); // returns ['a', 1, 2, '1']

  return unique;
}

और मैंने सोचा कि कौन सा तेज है। मैंने Google शीट का नमूना बनाया है कार्यों के परीक्षण के लिए का । नोट: ECMA 6 Google शीट में उपलब्ध नहीं है, इसलिए मैं इसका परीक्षण नहीं कर सकता।

यहाँ परीक्षण का परिणाम है:

मुझे उम्मीद थी कि ऑब्जेक्ट का उपयोग करने वाला कोड { }जीत जाएगा क्योंकि यह हैश का उपयोग करता है। इसलिए मुझे खुशी है कि क्रोम और IE में परीक्षणों ने इस एल्गोरिथ्म के लिए सर्वोत्तम परिणाम दिखाए। कोड के लिए @rab का धन्यवाद ।

Comments

विकल्प "फ़िल्टर + इंडेक्सऑफ" 100.000 वस्तुओं पर सरणियों पर बेहद धीमा है। मुझे "ऑब्जेक्ट मैप" दृष्टिकोण का उपयोग करना था लेकिन यह मूल छंटाई को तोड़ता है।

— नवजात शिशु

क्या उच्च संख्या धीमी है, तेज नहीं है?

— fletchsod

@ fletchsod, संख्याएँ एमएस में कोड चलाने का समय होता है।

— मैक्स मैखरोव

नंबर वोंग हैं! Google ऐप्स स्क्रिप्ट क्लाइंट के ब्राउज़र पर नहीं, बल्कि उनके सर्वर पर चलती है - और इसलिए Chrome / IE (या वस्तुतः किसी भी ब्राउज़र) पर प्रदर्शन समान होगा!

— जय दधानिया

हालांकि Google स्क्रिप्ट से क्लाइंट-साइड JS चलाना संभव है (या तो google.script.host या google.script.run के माध्यम से - जो निश्चित नहीं है), उत्तर स्पष्ट रूप से बताता है कि "ECMA 6 Google शीट्स में उपलब्ध नहीं है" - इसलिए हम सुरक्षित रूप से मान सकते हैं कि पोस्टर ने इसके लिए सर्वर-साइड Google स्क्रिप्ट का उपयोग किया है - और इस प्रकार उत्तर Google सर्वर के प्रदर्शन को दिखाता है, ब्राउज़र का नहीं !!

— जय दादानिया

Answer 4

आप अंडरस्कोर भी इस्तेमाल कर सकते हैं । js

console.log(_.uniq([1, 2, 1, 3, 1, 4]));

<script src="http://underscorejs.org/underscore-min.js"></script>

जो वापस आएगा:

[1, 2, 3, 4]

Comments

प्लीज ये लोग करें। ऐरे प्रोटोटाइप पर जैक कुछ न करें। कृप्या।

— जैकब डाल्टन

@JacobDalton - यह ऐरे प्रोटोटाइप का विस्तार नहीं कर रहा है। यह _ ऑब्जेक्ट में नामांकित है।

— सुपर जुमिनरी

@superluminary मुझे पता है कि इसीलिए मैंने कहा कि कृपया ऐसा करें। स्वीकृत समाधान ऐरे प्रोटोटाइप को संशोधित करने का सुझाव देता है। ऐसा नहीं है।

— जैकब डाल्टन

@JacobDalton कृपया ऐसा न करें। केवल एक छोटी सी नौकरी के लिए एक अतिरिक्त पुस्तकालय जोड़ने की कोई आवश्यकता नहीं हैarray = [...new Set(array)]

इसने ES सुविधाओं का उपयोग करने और अधिक पुस्तकालयों को जोड़ने के उद्देश्य को हराकर केवल वेबसाइट को और अधिक प्रस्फुटित किया।

— fletchsod

Answer 5

वन लाइनर, प्योर जावास्क्रिप्ट

ES6 सिंटैक्स के साथ

list = list.filter((x, i, a) => a.indexOf(x) == i)

x --> item in array
i --> index of item
a --> array reference, (in this case "list")

ES5 सिंटैक्स के साथ

list = list.filter(function (x, i, a) { 
    return a.indexOf(x) == i; 
});

ब्राउज़र संगतता : IE9 +

Comments

@Spets में द्विघात लागत है, इसलिए यह सबसे अच्छा उत्तर नहीं है

— Oriol

@ सभी तरह के आइकॉन / स्पेसिफिकेशन्स ... हां, होशियार रहें, सबसे पहले छांटने के लिए मूलांक का प्रयोग करें, ज्यादातर मामलों में 0 (n2) क्विकसर्च से धीमी रहें।

— डॉकर

धन्यवाद दोस्तों! इसका एहसास तब नहीं हुआ जब मैंने पहली बार कोड को देखा था लेकिन अब यह थोड़ा और स्पष्ट है।

— Spets

Answer 6

मैंने तब से एक अच्छा तरीका ढूंढ लिया है जो jQuery का उपयोग करता है

arr = $.grep(arr, function(v, k){
    return $.inArray(v ,arr) === k;
});

नोट: इस कोड को पॉल आयरिश के बतख पंचिंग पोस्ट से खींचा गया था - मैं क्रेडिट देना भूल गया: पी

Comments

एक संक्षिप्त समाधान, लेकिन कॉलिंग inArray हैसऑनप्रोपरेटी कॉलिंग की तुलना में कम कुशल है।

— मिस्टर स्मिथ

यह O (N ^ 2) भी है, है ना? जबकि शब्दकोश या hasOwnProperty दृष्टिकोण संभवतः O (N * logN) होगा।

— स्पीडप्लेन

यह मेरे लिए काम करता है, अन्य सभी समाधानों का समर्थन नहीं किया गया था इंटरनेट एक्सप्लोरर।

— kerl

Answer 7

ES6 के साथ सबसे छोटा समाधान: [...new Set( [1, 1, 2] )];

या यदि आप ऐरे प्रोटोटाइप को संशोधित करना चाहते हैं (जैसे मूल प्रश्न में):

Array.prototype.getUnique = function() {
    return [...new Set( [this] )];
};

EcmaScript 6 वर्तमान में केवल आधुनिक ब्राउज़रों में आंशिक रूप से लागू किया गया है (अगस्त 2015), लेकिन बैबेल ES6 (और यहां तक ES7) transpiling वापस ES5 करने के लिए बहुत लोकप्रिय हो गया है। इस तरह से आप आज ES6 कोड लिख सकते हैं!

यदि आप सोच रहे हैं कि ...इसका क्या मतलब है, तो इसे प्रसार ऑपरेटर कहा जाता है । से MDN : «प्रसार ऑपरेटर एक अभिव्यक्ति स्थानों पर जहां कई तर्क या एक से अधिक तत्वों (सरणी शाब्दिक के लिए) (समारोह कॉल के लिए) उम्मीद कर रहे हैं में विस्तार करने की अनुमति देता है»। क्योंकि एक सेट एक चलने योग्य है (और केवल अनन्य मान हो सकते हैं), प्रसार ऑपरेटर सरणी को भरने के लिए सेट का विस्तार करेगा।

ईएस 6 सीखने के लिए संसाधन:

• ES6 तलाश डॉ एक्सल Rauschmayer द्वारा
• जेएस साप्ताहिक समाचार पत्र से "ईएस 6" खोजें
• ईएस 6 मोज़िला हक्स ब्लॉग से गहराई से लेख

Comments

आप इसे छोटा भी कर सकते हैं a = [...Set(a)], लेकिन, वैसे भी, यह अभी के लिए फ़ायरफ़ॉक्स है।

— c69

@ c69, ठीक है, इससे कम नहीं मिलेगा। स्पाइडरमॉन्की उपयोगकर्ता भी सराहना करेंगे।

— टॉरस्टेन बेकर

बबेल के साथ काम करता है। आपको बस Array.from शिम को भी शामिल करने की आवश्यकता है:require ( "core-js/fn/array/from" );

— व्लादिस्लाव Rastrusny

क्या यह Array.prototype.getUnique = function () {वापसी [... नया सेट ([यह])] होना चाहिए; }; या, Array.prototype.getUnique = function () {वापसी [... नया सेट (यह)]; }; मैंने इसे निम्नलिखित पर लागू किया- $ ('बॉडी')। html () .LowerCase ()। मैच (/ ([a-zA-Z0-9 ._ + +]] + @ [a-zA-Z0 -9। । _-] \ [एक-zA-Z0-9 ._-]) / गी) .getUnique (); पहले एक ने मुझे एक अनोखा मूल्य लौटाया, जबकि दूसरे ने सभी डुप्लिकेट को हटा दिया।

— ashique

[...Set(['a', 1, 'a', 2, '1'])]TypeError को फेंक देंगे, इसलिए इसे बनाए रखना अभी भी समझदारी है new:[...new Set(['a', 1, 'a', 2, '1'])]

— एडम काट्ज

Answer 8

सबसे सरल समाधान:

var arr = [1, 3, 4, 1, 2, 1, 3, 3, 4, 1];
console.log([...new Set(arr)]);

या:

var arr = [1, 3, 4, 1, 2, 1, 3, 3, 4, 1];
console.log(Array.from(new Set(arr)));

Comments

ध्यान दें कि यह IE10 और नीचे पर समर्थित नहीं है। ध्यान दें कि IE11 + और सफारी सीमित समर्थन प्रदान करते हैं (यह भी सुनिश्चित नहीं है कि उपरोक्त उदाहरण काम करता है) डेवलपर.

— mozilla.org/en-US/docs/Web/JavaScript/Reference/…

Answer 9

ऐसा करने का सबसे सरल और सबसे तेज़ (Chrome में) तरीका:

Array.prototype.unique = function() {
    var a = [];
    for (var i=0, l=this.length; i<l; i++)
        if (a.indexOf(this[i]) === -1)
            a.push(this[i]);
    return a;
}

बस सरणी में प्रत्येक आइटम के माध्यम से जाता है, परीक्षण करता है कि क्या वह आइटम पहले से ही सूची में है, और यदि यह नहीं है, तो उस सरणी पर धक्का दें जो वापस आ जाती है।

JsPerf के अनुसार, यह फ़ंक्शन उन सबसे तेज़ है जो मुझे कहीं भी मिल सकते हैं - हालांकि खुद को जोड़ने के लिए स्वतंत्र महसूस करें।

गैर-प्रोटोटाइप संस्करण:

function uniques(arr) {
    var a = [];
    for (var i=0, l=arr.length; i<l; i++)
        if (a.indexOf(arr[i]) === -1 && arr[i] !== '')
            a.push(arr[i]);
    return a;
}

छंटाई

जब सरणी को क्रमबद्ध करने की आवश्यकता होती है, तो निम्नलिखित सबसे तेज़ होता है:

Array.prototype.sortUnique = function() {
    this.sort();
    var last_i;
    for (var i=0;i<this.length;i++)
        if ((last_i = this.lastIndexOf(this[i])) !== i)
            this.splice(i+1, last_i-i);
    return this;
}

या गैर-प्रोटोटाइप:

function sortUnique(arr) {
    arr.sort();
    var last_i;
    for (var i=0;i<arr.length;i++)
        if ((last_i = arr.lastIndexOf(arr[i])) !== i)
            arr.splice(i+1, last_i-i);
    return arr;
}

अधिकांश गैर-क्रोम ब्राउज़रों में यह उपरोक्त विधि से भी तेज़ है ।

Comments

Linux पर, Chrome 55.0.2883 आपके arr.unique () और swilliams की arrclone2.sortFilter () सबसे धीमी (78% धीमी) पसंद करता है। हालांकि, फ़ायरफ़ॉक्स 51.0.0 (बहुत सारे एडोनों के साथ) में स्विटीलीयाज़ के रूप में सबसे तेज़ है (अभी भी ऑप्स / किसी भी अन्य क्रोम परिणाम की तुलना में सेकंड से धीमी है) मॉटी के jQuery $ के साथ। Grep (गिरफ्तारी, jqFilter) सबसे धीमी (46% धीमी) है। आपका arr.uniq () 30% धीमा था। मैंने प्रत्येक परीक्षण को दो बार चलाया और लगातार परिणाम प्राप्त किए। दोनों ब्राउज़रों में राफेल की arr.getUnique () को दूसरा स्थान मिला।

— एडम काटज़

jsPerf इस समय छोटी गाड़ी है , इसलिए इस परीक्षण के लिए मेरे संपादन ने सब कुछ नहीं किया, लेकिन इसने दो परीक्षणों को जोड़ दिया: Cocco's toUnique () ने दोनों ब्राउज़रों की धड़कन स्वामिलीयर्स की सॉर्टफ़िल्टर () को मारते हुए दोनों ब्राउज़रों के लिए Vamsi का ES6 list.filter () धड़कता है। एफएफ पर # 1 के लिए (सॉर्टफ़िल्टर 16% धीमा था) और क्रोम पर # 3 के लिए अपने सॉर्ट किए गए परीक्षण (जो 2% से धीमा था) को हराकर।

— एडम काटज़

आह, मैंने नहीं पकड़ा था कि वे परीक्षण तुच्छ रूप से छोटे थे और वास्तव में मायने नहीं रखते थे। स्वीकार किए गए उत्तर की एक टिप्पणी उस समस्या का वर्णन करती है और परीक्षण के लिए एक संशोधन में सुधार प्रदान करती है , जिसमें राफेल का कोड आसानी से सबसे तेज है और जोएत्जे 50 का एरेक्टिक कोड 98% धीमा है। मैंने इस टिप्पणी में एक और संशोधन भी किया है ।

— एडम काटज़

ठीक है, वास्तव में आपके द्वारा uniqueफ़ंक्शन में लागू किए गए एल्गोरिथ्म में O (n ^ 2) जटिलता है, जबकि getUniqueO (n) है। पहला डेटा डेटा सेट पर अधिक तेज़ हो सकता है, लेकिन आप मैथ्स के साथ कैसे बहस कर सकते हैं :) आप सुनिश्चित कर सकते हैं कि बाद वाला तेज है अगर आप इसे एक सरणी पर चलाते हैं, तो कहें, 1e5 अद्वितीय आइटम

— मिखाइल

Answer 10

केवल प्रदर्शन! यह कोड शायद यहां के सभी कोडों से 10X तेज है सभी ब्राउज़रों पर काम करता है और इसमें सबसे कम मेमोरी प्रभाव भी होता है .... और अधिक

यदि आपको पुराने सरणी का पुन: उपयोग करने की आवश्यकता नहीं है, तो इससे पहले कि आप इसे अनूठे में बदल दें, आवश्यक अन्य संचालन करें, ऐसा करने का शायद सबसे तेज़ तरीका है, बहुत कम।

var array=[1,2,3,4,5,6,7,8,9,0,1,2,1];

तो आप यह कोशिश कर सकते हैं

var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 1];

function toUnique(a, b, c) { //array,placeholder,placeholder
  b = a.length;
  while (c = --b)
    while (c--) a[b] !== a[c] || a.splice(c, 1);
  return a // not needed ;)
}
console.log(toUnique(array));
//[3, 4, 5, 6, 7, 8, 9, 0, 2, 1]

मैं इस लेख को पढ़ने के साथ आया हूं ...

http://www.shamasis.net/2009/09/fast-algorithm-to-find-unique-items-in-javascript-array/

मुझे लूप पसंद नहीं है। यह कई मापदंडों के लिए है। मैं जबकि लूप की तरह। जबकि सभी ब्राउज़रों में सबसे तेज़ लूप है, सिवाय हम सभी को इतना पसंद है ... क्रोम।

वैसे भी मैंने पहला फ़ंक्शन लिखा है जो उपयोग करता है। और हां यह लेख में पाए गए फ़ंक्शन की तुलना में थोड़ा तेज़ है। लेकिन पर्याप्त नहीं है।unique2()

अगले चरण में आधुनिक जे.एस. Object.keys मैंने js1.7 के Object.keys के साथ लूप के लिए दूसरे को बदल दिया ... थोड़ा तेज और छोटा (क्रोम 2x में तेजी से);)। पर्याप्त नहीं!।unique3()।

इस बिंदु पर मैं इस बारे में सोच रहा था कि मुझे वास्तव में MY के अनोखे कार्य की क्या आवश्यकता है। मैं पुराने सरणी की जरूरत नहीं है, मैं एक तेजी से कार्य करना चाहते हैं। इसलिए मैंने 2 का उपयोग किया, जबकि लूप + ब्याह।unique4()

यह कहने के लिए बेकार है कि मैं प्रभावित था।

क्रोम: सामान्य 150,000 ऑपरेशन प्रति सेकंड 1,800,000 ऑपरेशन प्रति सेकंड की छलांग लगाते हैं।

यानी: 80,000 से अधिक ऑप्स बनाम ऑप्स

ios: 18,000 op / s बनाम 170,000 सेशन / से

सफारी: 80,000 से अधिक ऑप्स 6,000,000 ऑप्स / एस

सबूत http://jsperf.com/wgu या बेहतर उपयोग कंसोल.टाइम ... माइक्रोटाइम ... जो भी हो

unique5() बस आपको यह दिखाना है कि यदि आप पुरानी सारणी रखना चाहते हैं तो क्या होगा।

Array.prototypeअगर यू को पता नहीं है कि आपका क्या कर रहा है तो इसका उपयोग न करें । मैं बस कॉपी और अतीत की एक बहुत कुछ किया था। Object.defineProperty(Array.prototype,...,writable:false,enumerable:false})यदि आप एक मूल प्रोटोटाइप बनाना चाहते हैं तो उपयोग करें। उदाहरण: https://stackoverflow.com/a/20463021/2450730

डेमो http://jsfiddle.net/46S7g/

नोट: आपका पुराना सरणी नष्ट हो गया है / इस ऑपरेशन के बाद becomestheunique।

यदि आप ऊपर दिए गए कोड को नहीं पूछ सकते हैं, तो एक जावास्क्रिप्ट पुस्तक पढ़ें या यहां छोटे कोड के बारे में कुछ स्पष्टीकरण दिए गए हैं। https://stackoverflow.com/a/21353032/2450730

कुछ का उपयोग कर रहे हैं indexOf ... नहीं ... http://jsperf.com/dgfgghfghfghghgfhgfhfghfhgfh

खाली सरणियों के लिए

!array.length||toUnique(array); 

Comments

उरल्स (तार) के 100k सरणी के साथ नोड.जेएस पर परीक्षण किया गया। परिणाम underscore.js _.uniq की तुलना में 2x धीमा था ... हालाँकि एक अलग jsperf आपके साथ सहमत है ( jsperf.com/uniq-performance/5 ), मैं निराश हूँ :(

— xShirase

आप jsperf में सही ढंग से परीक्षण नहीं कर रहे हैं ... आपके उदाहरण में आप फ़ंक्शन को हर बार परिभाषित करते हैं ... लेकिन अंडरस्कोर.जेएस फ़ंक्शन पहले से ही परिभाषित हैं .. यह मेरे फ़ंक्शन को दंडित करता है। 3 और 4 का भी परीक्षण करें। एक और बात जो मुझे कहनी चाहिए वह यह है कि यदि आप मिश्रित चर (स्ट्रिंग्स और संख्या) का उपयोग करते हैं, तो आपको [b] = [a] को [b]! = a [c]

— cocco से

मुझे यकीन नहीं है कि अगर jsPerf सही है, लेकिन लगता है कि Reduce वैकल्पिक (कि, मेरे लिए समझने में आसान है) आपके समाधान से कुछ हद तक 94% तेज है। jsperf.com/reduce-for-distinct संपादित करें: आपका क्रोम पर धीमा है, एज पर समान है और फ़ायरफ़ॉक्स पर तेजी से है।

— विक्टर Ivens

केवल छोटे सरणियों / कम डुप्लिकेट प्रतिशत के साथ प्रयोग करने योग्य । हर बार गैर-अनोखी वस्तु मिली है, इंजन को बाकी सभी तत्वों को बाईं ओर स्थानांतरित करने के लिए मजबूर किया जाएगा : 1) उन पर पुनरावृत्ति करते हुए 2) उन्हें पढ़ें 3) उन्हें नए स्थान पर लिखें। और फिर, यह उस एक spliced ​​तत्व के साथ नई सरणी भी बनाता है, और परिणाम के रूप में इसे वापस करता है ... एल्गोरिथ्म जल्दी से बड़े सरणियों / अधिक लगातार डुप्लिकेट के साथ नीचा दिखाता है। आकार की सरणियों के लिए 1000-> 10000-> 50000 और ~ 40% डुप्लिकेट, औसत लिया समय 2-> 775-> 19113 एमएस की तरह होगा। (क्रोम में 1-> x10-> x5 के रूप में आकार बदलता है, क्रोम में 1-> x10-> x25 के रूप में समय)।

— एखज़ेट

धन्यवाद। अच्छा तरीका। लेकिन सही आइटम ऑर्डर के बारे में क्या?

— नवजात शिशु

Answer 11

यहां कई उत्तर शुरुआती के लिए उपयोगी नहीं हो सकते हैं। यदि किसी सरणी को डी-डुबाना मुश्किल है, तो क्या वे वास्तव में प्रोटोटाइप चेन, या यहां तक ​​कि jQuery के बारे में जान पाएंगे?

आधुनिक ब्राउज़रों में, एक साफ और सरल समाधान सेट में डेटा स्टोर करना है , जिसे अद्वितीय मूल्यों की सूची के लिए डिज़ाइन किया गया है।

const cars = ['Volvo', 'Jeep', 'Volvo', 'Lincoln', 'Lincoln', 'Ford'];
const uniqueCars = Array.from(new Set(cars));

Array.fromताकि आप भयानक तरीकों के सभी (विशेषताएं) पर आसान पहुंच के किसी सरणी के लिए सेट वापस कन्वर्ट करने के लिए सरणियों है कि उपयोगी है। एक ही काम करने के अन्य तरीके भी हैं । लेकिन आपको इसकी बिल्कुल भी आवश्यकता नहीं है Array.from, क्योंकि सेट में फॉरचैक जैसी बहुत सी उपयोगी सुविधाएँ होती हैं ।

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

// Create a list of cars, with duplicates.
var cars = ['Volvo', 'Jeep', 'Volvo', 'Lincoln', 'Lincoln', 'Ford'];
// Create a list of unique cars, to put a car in if we haven't already.
var uniqueCars = [];

// Go through each car, one at a time.
cars.forEach(function (car) {
    // The code within the following block runs only if the
    // current car does NOT exist in the uniqueCars list
    // - a.k.a. prevent duplicates
    if (uniqueCars.indexOf(car) === -1) {
        // Since we now know we haven't seen this car before,
        // copy it to the end of the uniqueCars list.
        uniqueCars.push(car);
    }
});

इसे तुरंत पुन: प्रयोज्य बनाने के लिए, आइए इसे एक फ़ंक्शन में रखें।

function deduplicate(data) {
    if (data.length > 0) {
        var result = [];

        data.forEach(function (elem) {
            if (result.indexOf(elem) === -1) {
                result.push(elem);
            }
        });

        return result;
    }
}

इसलिए डुप्लिकेट से छुटकारा पाने के लिए, हम अब ऐसा करेंगे।

var uniqueCars = deduplicate(cars);

वह deduplicate(cars)हिस्सा बन जाता है जिसे हमने परिणाम नाम दिया है जब समारोह पूरा करती है।

बस इसे अपने पसंद के किसी भी सरणी का नाम दें।

Comments

वैसे, मैंने यह दिखाने के लिए कि मेरी तकनीक लचीली है, स्ट्रिंग्स से भरे एक सरणी का उपयोग किया। यह संख्याओं के लिए ठीक से काम करेगा।

— सेठ होलादाय

Answer 12

["Defects", "Total", "Days", "City", "Defects"].reduce(function(prev, cur) {
  return (prev.indexOf(cur) < 0) ? prev.concat([cur]) : prev;
 }, []);

[0,1,2,0,3,2,1,5].reduce(function(prev, cur) {
  return (prev.indexOf(cur) < 0) ? prev.concat([cur]) : prev;
 }, []);

Comments

क्या आप बता सकते हैं कि आपने pushउपयोग करने के बजाय केवल सरणी पर तत्व क्यों नहीं बनाया concat? मैंने पुश का उपयोग करने की कोशिश की और यह विफल रहा। मैं स्पष्टीकरण की तलाश कर रहा हूं।

— makenova

इसका कारण रिटर्न वैल्यू है। कॉन्कैट संशोधित सरणी देता है (वास्तव में क्या कम फ़ंक्शन के अंदर वापस करने की आवश्यकता है), जबकि धक्का एक सूचकांक देता है जिस पर आप पुश मूल्य तक पहुंच सकते हैं। क्या वह आपके सवाल का जवाब है?

— नागार्जुन

जाहिरा तौर पर, यह समाधान क्रोम (और नोड) में काफी तेज है। jsperf.com/reduce-for-distinct वह ES6 संस्करण है: [0,1,2,0,3,2,1,5].reduce((prev, cur) => ~prev.indexOf(cur) ? prev : prev.concat([cur]), []);

— विक्टर Ivens

साइड नोट: यह कार्यान्वयन NaNमैत्रीपूर्ण नहीं है

— एलेरिज़ा

Answer 13

हम ES6 सेट का उपयोग करके ऐसा कर सकते हैं:

var duplicatedArray = [1, 2, 3, 4, 5, 1, 1, 1, 2, 3, 4];
var uniqueArray = Array.from(new Set(duplicatedArray));

console.log(uniqueArray);

// आउटपुट होगा

uniqueArray = [1,2,3,4,5];

Answer 14

यह प्रोटोटाइप getUniqueपूरी तरह से सही नहीं है, क्योंकि अगर मेरे पास एक ऐरे है जैसे: ["1",1,2,3,4,1,"foo"]यह वापस आ जाएगा ["1","2","3","4"]और "1"स्ट्रिंग है और 1एक पूर्णांक है; वे भिन्न हैं।

यहाँ एक सही समाधान है:

Array.prototype.unique = function(a){
    return function(){ return this.filter(a) }
}(function(a,b,c){ return c.indexOf(a,b+1) < 0 });

का उपयोग करते हुए:

var foo;
foo = ["1",1,2,3,4,1,"foo"];
foo.unique();

ऊपर उत्पादन होगा ["1",2,3,4,1,"foo"]।

Comments

ध्यान दें कि $foo = 'bar'चर घोषित करने का PHP तरीका है। यह जावास्क्रिप्ट में काम करेगा, लेकिन एक अंतर्निहित वैश्विक पैदा करेगा, और आमतौर पर ऐसा नहीं किया जाना चाहिए।

— कैमिलो मार्टिन

@CamiloMartin क्षमा करें, लेकिन आप गलत हैं, $ foo वैश्विक है क्योंकि उदाहरण एक क्लोजर में नहीं है और वह var कीवर्ड को याद नहीं कर रहा है। डॉलर के साथ कुछ नहीं करना है jsfiddle.net/robaldred/L2MRb

— Rob

@ यह वही है जो मैं कह रहा हूं, PHP लोग सोचेंगे कि $fooजावास्क्रिप्ट में चर घोषित करने का तरीका वास्तव में var fooहै।

— कैमिलो मार्टिन

Answer 15

Array.prototype (इसे एक बुरा अभ्यास कहा जाता है) या jquery / अंडरस्कोर का उपयोग किए बिना, आप बस filterसरणी का उपयोग कर सकते हैं ।

अंतिम घटना रखने से:

    function arrayLastUnique(array) {
        return array.filter(function (a, b, c) {
            // keeps last occurrence
            return c.indexOf(a, b + 1) < 0;
        });
    },

या पहली घटना:

    function arrayFirstUnique(array) {
        return array.filter(function (a, b, c) {
            // keeps first occurrence
            return c.indexOf(a) === b;
        });
    },

खैर, यह केवल जावास्क्रिप्ट ECMAScript 5+ है, जिसका अर्थ केवल IE9 + है, लेकिन यह मूल HTML / JS (Windows Store App, Firefox OS, Sencha, Phonegap, Titanium, ...) में विकास के लिए अच्छा है।

Comments

तथ्य यह है कि यह js 1.6 है इसका मतलब यह नहीं है कि आप उपयोग नहीं कर सकते filter। पर MDN पेज वे इंटरनेट एक्सप्लोरर के लिए एक कार्यान्वयन है, मेरा मतलब है, पुराने ब्राउज़र। इसके अलावा: JS 1.6 केवल फ़ायरफ़ॉक्स के js इंजन को संदर्भित करता है, लेकिन यह कहने के लिए सही बात है कि यह ECMAScript 5 है

— कैमिलो मार्टिन

@CamiloMartin मैं ECMAScript5 में 1.6 बदल गया। धन्यवाद।

— C --ur

Answer 16

जादू

a.filter(e=>!(t[e]=e in t)) 

ओ (एन) प्रदर्शन ; हम यह मान अपने सरणी में है aऔर t={}। यहाँ स्पष्टीकरण (+ जेपी छाप)

let t={}, unique= a=> a.filter(e=>!(t[e]=e in t));

// "stand-alone" version working with global t:
// a1.filter((t={},e=>!(t[e]=e in t)));

// Test data
let a1 = [5,6,0,4,9,2,3,5,0,3,4,1,5,4,9];
let a2 = [[2, 17], [2, 17], [2, 17], [1, 12], [5, 9], [1, 12], [6, 2], [1, 12]];
let a3 = ['Mike', 'Adam','Matt', 'Nancy', 'Adam', 'Jenny', 'Nancy', 'Carl'];

// Results
console.log(JSON.stringify( unique(a1) ))
console.log(JSON.stringify( unique(a2) ))
console.log(JSON.stringify( unique(a3) ))

Comments

यह बहुत अच्छा लग रहा है, कि एक ठोस विवरण के बिना मैं गिर गया जब आप मेरा

— बिटकॉइन करने जा

मेरा मतलब है कि आपको कुछ स्पष्टीकरण के साथ अपने उत्तर का विस्तार करना चाहिए और इसके बारे में टिप्पणी करनी चाहिए। उम्मीद नहीं है कि लोगों को इस तरह उपयोगी उत्तर मिलेंगे। (हालांकि यह वास्तव में एक अच्छा काम करता है शांत दिखता है)

— Ondjej koelazko

@Jeppe जब मैं आपका सुधार चलाता हूं तो मुझे aha प्रभाव का अनुभव होता है (इससे पहले कि मुझे नहीं पता कि मैं लूप की inतुलना में अन्य निर्माण के बाहर ऑपरेटर का उपयोग कर सकता हूं for: P) - धन्यवाद - मैं इसकी सराहना करता हूं और आपके अन्य अच्छे उत्तरों को +2 दूंगा ।

— कामिल Kiełczewski

एक वैश्विक वैरिएबल नहीं बनाता है tजो फ़िल्टरिंग के बाद जीवित रहता है ... ??

— फिलिप

यह वास्तव में एक मुश्किल समाधान है। दुर्भाग्य से, आपको अभिव्यक्ति के बाहर टी घोषित नहीं करना है जब तक कि आप एक वैश्विक चर को परिभाषित नहीं करना चाहते और / या वैश्विक छिपाने के लिए अपने मॉड्यूल बंडल पर भरोसा करते हैं। यह फैंसी लग रहा है, लेकिन अपने आप को (और आपकी देव टीम) एक एहसान करो और बस एक दो लाइनर लिखो: चलो टी = {}; a.filter (e =>! (t [e] = e in t))

— ford04

Answer 17

[...new Set(duplicates)]

यह एमडीएन वेब डॉक्स से सबसे सरल और संदर्भित है ।

const numbers = [2,3,4,4,2,3,3,4,4,5,5,6,6,7,5,32,3,4,5]
console.log([...new Set(numbers)]) // [2, 3, 4, 5, 6, 7, 32]

Comments

इस कोड, प्रश्न का समाधान हो सकता है एक सहित व्याख्या कैसे और क्यों यह हल समस्या वास्तव में मदद की अपनी पोस्ट की गुणवत्ता में सुधार होगा, और शायद अधिक को वोट में परिणाम। याद रखें कि आप भविष्य में पाठकों के लिए सवाल का जवाब दे रहे हैं, न कि केवल उस व्यक्ति से जो अब पूछ रहा है। कृपया स्पष्टीकरण जोड़ने के लिए अपना उत्तर संपादित करें, और इस बात का संकेत दें कि क्या सीमाएँ और मान्यताएँ लागू होती हैं।

— id.ot

Answer 18

यदि आप प्रोटोटाइप फ्रेमवर्क का उपयोग कर रहे हैं तो 'लूप्स' के लिए 'करने की कोई आवश्यकता नहीं है, तो आप इस तरह http://www.prototypjs.org/api/array/uniq का उपयोग कर सकते हैं :

var a = Array.uniq();  

जो एक डुप्लिकेट सरणी का उत्पादन करेगा जिसमें कोई डुप्लिकेट नहीं होगा। मैं आपके प्रश्न के बाद अलग-अलग सरणी रिकॉर्ड्स को गिनने के लिए एक विधि खोज रहा हूं

uniq ()

मैंनें इस्तेमाल किया

आकार ()

और मेरा साधारण परिणाम था। पी एस क्षमा करें, अगर मैंने कुछ गलत किया है

संपादित करें: यदि आप अपरिभाषित रिकॉर्ड से बचना चाहते हैं तो आप जोड़ना चाह सकते हैं

कॉम्पैक्ट ()

इससे पहले, इस तरह:

var a = Array.compact().uniq();  

Comments

क्योंकि मुझे एक बेहतर उत्तर मिला, मुझे लगता है कि विषयों के बारे में सभी लोगों के लिए है न कि केवल पूछने वाले के लिए

— Decebal

Answer 19

अब सेट का उपयोग करके आप डुप्लिकेट को हटा सकते हैं और उन्हें वापस सरणी में बदल सकते हैं।

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

console.log([...new Set(names)])

एक अन्य समाधान सॉर्ट और फिल्टर का उपयोग करना है

var names = ["Mike","Matt","Nancy", "Matt","Adam","Jenny","Nancy","Carl"];
var namesSorted = names.sort();
const result = namesSorted.filter((e, i) => namesSorted[i] != namesSorted[i+1]);
console.log(result);

Answer 20

ऐसा इसलिए 0है क्योंकि जावास्क्रिप्ट में एक मिथ्या मूल्य है।

this[i] गलत होगा यदि सरणी का मान 0 या किसी अन्य गलत मान है।

Comments

आह, ठीक है, अब मैं देख रहा हूं ... लेकिन क्या यह काम करना आसान होगा?

— मॉटी

Answer 21

Array.prototype.getUnique = function() {
    var o = {}, a = []
    for (var i = 0; i < this.length; i++) o[this[i]] = 1
    for (var e in o) a.push(e)
    return a
}

Comments

मुझे लगता है कि यह काम नहीं करेगा यदि सरणी में ऑब्जेक्ट / सरणियाँ हैं, और मुझे यकीन नहीं है कि यह स्केलर्स के प्रकार को संरक्षित करेगा।

— कैमिलो मार्टिन

हां, सब कुछ कठोर हो जाता है। यह oसिर्फ एक के बजाय मूल मूल्य को संग्रहीत करके तय किया जा सकता है 1, हालांकि समानता की तुलना अभी भी कठोर होगी (हालांकि, सभी संभावित जावास्क्रिप्ट समानताओं में से, यह बहुत अनुचित नहीं लगता है)।

— १३

Array.prototype को केवल गैर-असंख्य तरीकों से बढ़ाया जा सकता है .... Object.defineProperty (Array.prototype, "getUnique", {}) ... लेकिन एक सहायक वस्तु का उपयोग करने का विचार बहुत अच्छा है

— bortunac

Answer 22

मुझे एक अलग समस्या थी जहाँ मुझे एक सरणी से डुप्लिकेट आईडी गुणों वाली वस्तुओं को हटाने की आवश्यकता थी। यह काम किया।

let objArr = [{
  id: '123'
}, {
  id: '123'
}, {
  id: '456'
}];

objArr = objArr.reduce((acc, cur) => [
  ...acc.filter((obj) => obj.id !== cur.id), cur
], []);

console.log(objArr);

Answer 23

सबसे सरल उत्तर है:

const array = [1, 1, 2, 2, 3, 5, 5, 2];
const uniqueArray = [...new Set(array)];
console.log(uniqueArray); // [1, 2, 3, 5]

Comments

सरल लेकिन यह वस्तुओं की एक सरणी के साथ काम नहीं करता है।

— थानवा चौ।

Answer 24

मुझे यकीन नहीं है कि गेब्रियल सिलवीरा ने इस तरह से समारोह क्यों लिखा लेकिन एक सरल रूप जो मेरे लिए भी काम करता है और बिना किसी संशोधन के:

Array.prototype.unique = function() {
  return this.filter(function(value, index, array) {
    return array.indexOf(value, index + 1) < 0;
  });
};

या कॉफीस्क्रिप्ट में:

Array.prototype.unique = ->
  this.filter( (value, index, array) ->
    array.indexOf(value, index + 1) < 0
  )

Answer 25

यदि आप अतिरिक्त निर्भरता के साथ ठीक हैं, या आपके पास पहले से ही अपने कोडबेस में पुस्तकालयों में से एक है, तो आप LoDash (या अंडरस्कोर) का उपयोग करके किसी सरणी से डुप्लिकेट निकाल सकते हैं।

प्रयोग

यदि आपके पास पहले से यह कोडबेस में नहीं है, तो इसे npm का उपयोग करके इंस्टॉल करें:

npm install lodash

फिर इसे निम्नानुसार उपयोग करें:

import _ from 'lodash';
let idArray = _.uniq ([
    1,
    2,
    3,
    3,
    3
]);
console.dir(idArray);

बाहर:

[ 1, 2, 3 ]

Answer 26

इसका बहुत उत्तर दिया गया है, लेकिन इसने मेरी विशेष आवश्यकता को संबोधित नहीं किया है।

कई उत्तर इस तरह हैं:

a.filter((item, pos, self) => self.indexOf(item) === pos);

लेकिन यह जटिल वस्तुओं के सरणियों के लिए काम नहीं करता है।

कहें कि हमारे पास एक सरणी है:

const a = [
 { age: 4, name: 'fluffy' },
 { age: 5, name: 'spot' },
 { age: 2, name: 'fluffy' },
 { age: 3, name: 'toby' },
];

यदि हम अद्वितीय नामों वाली वस्तुओं को चाहते हैं, तो हमें array.prototype.findIndexइसके स्थान पर उपयोग करना चाहिए array.prototype.indexOf:

a.filter((item, pos, self) => self.findIndex(v => v.name === item.name) === pos);

Comments

महान समाधान, सावधान रहें कि एक नया सरणी एक फ़ंक्शन से वापस आ जाएगा। (यह खुद को संशोधित नहीं करता है)

— थानवा च।

Answer 27

से Shamasis भट्टाचार्य के ब्लॉग (ओ (2n) समय जटिलता):

Array.prototype.unique = function() {
    var o = {}, i, l = this.length, r = [];
    for(i=0; i<l;i+=1) o[this[i]] = this[i];
    for(i in o) r.push(o[i]);
    return r;
};

से पॉल आयरिश के ब्लॉग : JQuery पर सुधार .unique():

(function($){

    var _old = $.unique;

    $.unique = function(arr){

        // do the default behavior only if we got an array of elements
        if (!!arr[0].nodeType){
            return _old.apply(this,arguments);
        } else {
            // reduce the array to contain no dupes via grep/inArray
            return $.grep(arr,function(v,k){
                return $.inArray(v,arr) === k;
            });
        }
    };
})(jQuery);

// in use..
var arr = ['first',7,true,2,7,true,'last','last'];
$.unique(arr); // ["first", 7, true, 2, "last"]

var arr = [1,2,3,4,5,4,3,2,1];
$.unique(arr); // [1, 2, 3, 4, 5]

Answer 28

सरल विधि में अद्वितीय ऐरे मूल्यों को खोजना

function arrUnique(a){
  var t = [];
  for(var x = 0; x < a.length; x++){
    if(t.indexOf(a[x]) == -1)t.push(a[x]);
  }
  return t;
}
arrUnique([1,4,2,7,1,5,9,2,4,7,2]) // [1, 4, 2, 7, 5, 9]

Answer 29

ऐसा प्रतीत होता है कि हमने राफेल का जवाब खो दिया है , जो कुछ वर्षों के लिए स्वीकृत उत्तर के रूप में खड़ा था। यदि आपके पास मिश्रित प्रकार का सरणी नहीं है, तो यह (कम से कम 2017 में) सबसे अच्छा प्रदर्शन करने वाला समाधान था :

Array.prototype.getUnique = function(){
    var u = {}, a = [];
    for (var i = 0, l = this.length; i < l; ++i) {
        if (u.hasOwnProperty(this[i])) {
            continue;
        }
        a.push(this[i]);
        u[this[i]] = 1;
    }
return a;
}

यदि आपके पास मिश्रित प्रकार की सरणी है, तो आप हैश कुंजी को क्रमबद्ध कर सकते हैं:

Array.prototype.getUnique = function() {
    var hash = {}, result = [], key; 
    for ( var i = 0, l = this.length; i < l; ++i ) {
        key = JSON.stringify(this[i]);
        if ( !hash.hasOwnProperty(key) ) {
            hash[key] = true;
            result.push(this[i]);
        }
    }
    return result;
}

Answer 30

समस्या को दूसरे तरीके से संबोधित करने के लिए, आपके सरणी को लोड करते समय कोई डुप्लिकेट होना उपयोगी हो सकता है, जिस तरह से सेट ऑब्जेक्ट करेगा, लेकिन यह अभी तक सभी ब्राउज़रों में उपलब्ध नहीं है। यह मेमोरी को बचाता है और अधिक कुशल है यदि आपको इसकी सामग्री को कई बार देखने की आवश्यकता है।

Array.prototype.add = function (elem) {
   if (this.indexOf(elem) == -1) {
      this.push(elem);
   }
}

नमूना:

set = [];
[1,3,4,1,2,1,3,3,4,1].forEach(function(x) { set.add(x); });

आपको देता है set = [1,3,4,2]