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

Question

मैं किसी सरणी में अद्वितीय मानों की सूची कैसे प्राप्त कर सकता हूं? क्या मुझे हमेशा दूसरी सारणी का उपयोग करना होगा या जावा में जावा के हैशमाप के समान कुछ है?

मैं केवल जावास्क्रिप्ट और jQuery का उपयोग करने जा रहा हूं । कोई अतिरिक्त लाइब्रेरी का उपयोग नहीं किया जा सकता है।

Comments

stackoverflow.com/questions/5381621/… - ठीक वही वर्णन करता है जो आप चाहते हैं कि मुझे लगता है?

— SpaceBison

क्या आप underscore.jsपुस्तकालय का उपयोग करने के लिए खुले हैं ?

— जेक

एक जावा हैशमैप मूल रूप से एक जावास्क्रिप्ट वस्तु के समान है। वाक्य रचना {"कुंजी": "मूल्य", "की 2": "मूल्य 2"}

— इयान

जावास्क्रिप्ट / टाइपस्क्रिप्ट संग्रह एपीआई स्केला की तुलना में भयानक हैं,list.toSet

— जॉर्डन स्टीवर्ट

Answer 1

जब से मैंने @ रॉकेट के उत्तर के लिए टिप्पणियों में इसके बारे में जाना, मैं एक उदाहरण प्रदान कर सकता हूं जिसमें कोई लाइब्रेरी का उपयोग नहीं किया गया है। इसके लिए दो नए प्रोटोटाइप फ़ंक्शन की आवश्यकता होती है, containsऔरunique

Array.prototype.contains = function(v) {
  for (var i = 0; i < this.length; i++) {
    if (this[i] === v) return true;
  }
  return false;
};

Array.prototype.unique = function() {
  var arr = [];
  for (var i = 0; i < this.length; i++) {
    if (!arr.contains(this[i])) {
      arr.push(this[i]);
    }
  }
  return arr;
}

var duplicates = [1, 3, 4, 2, 1, 2, 3, 8];
var uniques = duplicates.unique(); // result = [1,3,4,2,8]

console.log(uniques);

अधिक विश्वसनीयता के लिए, आप containsएमडीएन के indexOfशिम के साथ प्रतिस्थापित कर सकते हैं और जांच सकते हैं कि प्रत्येक तत्व indexOf-1: प्रलेखन के बराबर है या नहीं

Comments

~a.indexOf(b) === (a.indexOf(b) == -1)

— ऑरवेलोफाइल

@Lexynux: यह वह प्रकार था यदि geeky javascript-nerd उत्तर जो केवल किसी ऐसे व्यक्ति द्वारा उपयोग किया जाना चाहिए जो इसे समझता है, और संभवतः तब भी नहीं। यह क्या कह रहा है, कि लेखन है if (~a.indexOf(b)) ...है समान लंबे समय तक लिखने के लिए if (a.indexOf(b) == -1) ...।

— ओर्वेलोफाइल

यह एक उच्च समय जटिलता है (सबसे खराब स्थिति: O (n ^ 2))

— राहुल अरोड़ा

यह वास्तव में अक्षम कार्यान्वयन है। यह देखने के लिए कि क्या पहले से ही कोई आइटम भयानक है, परिणाम सरणी की जाँच करें। एक बेहतर दृष्टिकोण या तो एक ऑब्जेक्ट का उपयोग करना होगा जो मायने रखता है, या यदि आप aux भंडारण का उपयोग नहीं करना चाहते हैं, तो पहले इसे O (n लॉग एन) में सॉर्ट करें और फिर एक रैखिक स्वीप करें और साइड तत्वों द्वारा तुलना करें

— यशायाह ली

क्या हमें वास्तव में "समाहित" फ़ंक्शन की आवश्यकता है?

— अनिमेष कुमार

Answer 2

या एक-लाइनर (सरल और कार्यात्मक) की तलाश करने वालों के लिए, वर्तमान ब्राउज़रों के साथ संगत :

let a = ["1", "1", "2", "3", "3", "1"];
let unique = a.filter((item, i, ar) => ar.indexOf(item) === i);
console.log(unique);

अपडेट 18-04-2017

ऐसा प्रतीत होता है मानो 'Array.prototype.includes' को अब मेनलाइन ब्राउज़रों ( संगतता ) के नवीनतम संस्करणों में व्यापक समर्थन प्राप्त है

अद्यतन 29-07-2015:

एक मानकीकृत 'Array.prototype.includes' पद्धति का समर्थन करने के लिए ब्राउज़रों के लिए कार्यों में योजनाएं हैं, जो हालांकि सीधे इस प्रश्न का उत्तर नहीं देती हैं; अक्सर संबंधित है।

उपयोग:

["1", "1", "2", "3", "3", "1"].includes("2");     // true

पॉलीफ़िल ( ब्राउज़र समर्थन , मोज़िला से स्रोत ):

// https://tc39.github.io/ecma262/#sec-array.prototype.includes
if (!Array.prototype.includes) {
  Object.defineProperty(Array.prototype, 'includes', {
    value: function(searchElement, fromIndex) {

      // 1. Let O be ? ToObject(this value).
      if (this == null) {
        throw new TypeError('"this" is null or not defined');
      }

      var o = Object(this);

      // 2. Let len be ? ToLength(? Get(O, "length")).
      var len = o.length >>> 0;

      // 3. If len is 0, return false.
      if (len === 0) {
        return false;
      }

      // 4. Let n be ? ToInteger(fromIndex).
      //    (If fromIndex is undefined, this step produces the value 0.)
      var n = fromIndex | 0;

      // 5. If n ≥ 0, then
      //  a. Let k be n.
      // 6. Else n < 0,
      //  a. Let k be len + n.
      //  b. If k < 0, let k be 0.
      var k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);

      // 7. Repeat, while k < len
      while (k < len) {
        // a. Let elementK be the result of ? Get(O, ! ToString(k)).
        // b. If SameValueZero(searchElement, elementK) is true, return true.
        // c. Increase k by 1.
        // NOTE: === provides the correct "SameValueZero" comparison needed here.
        if (o[k] === searchElement) {
          return true;
        }
        k++;
      }

      // 8. Return false
      return false;
    }
  });
}

Comments

यह केनेबेक से लगभग कॉपी पेस्ट है, लेकिन संभवतः एक पैरामीटर के रूप में सरणी को पास करना बंद करने का उपयोग करने के बजाय संभवतः प्रदर्शन में सुधार करेगा।

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

— जोश मैक

नाइस - उस फ़िल्टर को एक पैरामीटर के रूप में सरणी में नहीं भेजा गया था, और बाहरी वस्तु पर काम नहीं करना चाहता था। यह वही है जो मुझे चाहिए - मेरे जावास्क्रिप्ट संस्करण (पुराने xerces संस्करण) में थोड़ी देर के लिए नया उपहार नहीं होगा।

— गेरार्ड ओनील

@Gerardoneill हाँ, कुछ स्थितियों में यह बहुत महत्वपूर्ण है, उदाहरण के लिए अगर यह कार्यात्मक रूप से जंजीर है और आप एक ऐसी सरणी तक पहुंच चाहते हैं, जिसे कोई चर नहीं सौंपा गया है जैसे कि .map (...)। फ़िल्टर (...)

— जोश मैक

@ जोश मैक, क्या आप किसी तरह 'यूनिक' पद्धति में 'शामिल' का उपयोग कर सकते हैं?

— vkelman

Answer 3

यहाँ ES6 के लिए एक बहुत क्लीनर समाधान है जो मैं देख रहा हूँ यहाँ शामिल नहीं है। यह सेट और प्रसार ऑपरेटर का उपयोग करता है :...

var a = [1, 1, 2];

[... new Set(a)]

जो लौटता है [1, 2]

Comments

इतने चतुर!

— जोश मैक

अब, यह एक-लाइनर है!

— मैक

टाइपस्क्रिप्ट में आपको Array.from(... new Set(a))सेट के बाद से उपयोग करना होगा, जिसे अंतर्निहित रूप से किसी सरणी प्रकार में परिवर्तित नहीं किया जा सकता है। बिलकुल चौकन्ना!

— Zachscs

@Zachscs, जब मैंने कोशिश की, तो मुझे एक जटिल त्रुटि मिली। क्या आपका मतलब बस था Array.from(new Set(a))? वह काम करने लगता है।

— adam0101

Answer 4

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

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

निश्चित नहीं है कि यह मतदान क्यों किया गया। यह पहली बार में थोड़ा अस्पष्ट हो सकता है, और शायद 'चतुर' के रूप में वर्गीकृत किया गया है और पढ़ने के लिए व्यावहारिक नहीं है, लेकिन यह घोषणात्मक, गैर-विनाशकारी और संक्षिप्त है, जहां अधिकांश अन्य उत्तरों की कमी है।

— लैरी

@ लॉरी में यह मतदान किया गया था क्योंकि ठीक इसी उत्तर को इस एक वर्ष से पहले प्रदान किया गया था।

— एलेक्स ओक्रुस्को

@AlexOkrushko मेला काफी - याद है कि जिस तरह से स्वरूपित किया गया था, उस कारण को याद किया

— लैरी

सब कुछ एक लाइनर है अगर आप एक लाइन पर सब कुछ डालते हैं :-)

— गैरी मैकगिल

समानता को कसने के a.indexOf(x) === iलिए तीन समान संकेतों पर ध्यान देना अच्छा हो सकता है ।

— वृहस्पतिवार

Answer 5

EcmaScript 2016 का उपयोग करके आप बस इसे इस तरह से कर सकते हैं।

 var arr = ["a", "a", "b"];
 var uniqueArray = Array.from(new Set(arr)); // Unique Array ['a', 'b'];

सेट हमेशा अद्वितीय होते हैं, और Array.from()आप एक सेट को एक सरणी में बदल सकते हैं। संदर्भ के लिए दस्तावेज़ों पर एक नज़र है।

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects /सेट

Comments

वह उत्तर है जिसका आपको उपयोग करना चाहिए। indexOf()उत्तर भयानक हैं क्योंकि वे O (N ^ 2) हैं। प्रसार उत्तर ठीक हैं लेकिन बड़े सरणियों के लिए काम नहीं करेंगे। यह सबसे अच्छा तरीका है।

— टिम्मम

Answer 6

अब ES6 में हम नए पेश किए गए ES6 फ़ंक्शन का उपयोग कर सकते हैं

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

या एरे द्वारा पुनरावृत्तियों पर वाक्य रचना का प्रसार किया

let items = [1,1,1,1,3,4,5,2,23,1,4,4,4,2,2,2]; 
let uniqueItems = [...new Set(items)];

यह अद्वितीय परिणाम लौटाएगा।

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

Comments

सबसे साफ समाधान!

— दिमित्रिस फिलिप्पो

यह जाने का रास्ता है, जब एक जेएस वातावरण में जो new Setइस तरह का समर्थन करता है (जैसे कि आधुनिक कोणीय / टाइपस्क्रिप्ट)

— डॉन चेडल

यह ध्यान देने योग्य है कि आप सेट और मैप जैसे let items = [1,1,1,1,3,4,5,2,23,1,4,4,4,2,2,2]; let uniqueItems = [...new Set(items)];

— iterables

मैं इन ES6 जवाब प्यार करता हूँ!

— ग्लेन थॉम्पसन

यह @Adeel इमरान के जवाब के समान है। कृपया ऐसे उत्तर न दें जो मौजूदा उत्तर के समान हों।

— टिम्मम

Answer 7

यदि आप मूल सरणी को छोड़ना चाहते हैं,

आप पहले के uniqe तत्वों को शामिल करने के लिए एक दूसरे सरणी की जरूरत है-

अधिकांश ब्राउज़र हैं Array.prototype.filter:

var unique= array1.filter(function(itm, i){
    return array1.indexOf(itm)== i; 
    // returns true for only the first instance of itm
});


//if you need a 'shim':
Array.prototype.filter= Array.prototype.filter || function(fun, scope){
    var T= this, A= [], i= 0, itm, L= T.length;
    if(typeof fun== 'function'){
        while(i<L){
            if(i in T){
                itm= T[i];
                if(fun.call(scope, itm, i, T)) A[A.length]= itm;
            }
            ++i;
        }
    }
    return A;
}
 Array.prototype.indexOf= Array.prototype.indexOf || function(what, i){
        if(!i || typeof i!= 'number') i= 0;
        var L= this.length;
        while(i<L){
            if(this[i]=== what) return i;
            ++i;
        }
        return -1;
    }

Answer 8

इन दिनों, आप अपने सरणी को एक अद्वितीय सेट में बदलने के लिए ES6 के सेट डेटा प्रकार का उपयोग कर सकते हैं। फिर, यदि आपको सरणी विधियों का उपयोग करने की आवश्यकता है, तो आप इसे वापस सरणी में बदल सकते हैं:

var arr = ["a", "a", "b"];
var uniqueSet = new Set(arr); // {"a", "b"}
var uniqueArr = Array.from(uniqueSet); // ["a", "b"]
//Then continue to use array methods:
uniqueArr.join(", "); // "a, b"

Comments

नीट, कुछ परफॉमेंस नंबरों को देखकर अच्छा लगेगा, मुझे लगता है कि थॉटसेट को विशेष रूप से परिवर्तित करना अगर वे बहुत गतिशील हैं और बड़े एक प्रदर्शन हिकअप हो सकते हैं, तो बताने का एकमात्र तरीका परीक्षण करना है :)

— अंतरिक्ष यात्री

यदि आप एक ट्रांसपिलर का उपयोग कर रहे हैं या एक ऐसे वातावरण में हैं जो इसका समर्थन करता है, तो आप उसी चीज़ को और अधिक संक्षिप्त रूप से कर सकते हैं:var uniqueArr = [...new Set(arr)]; // ["a", "b"]

— Stenerson

अरे @Astronaut ने प्रदर्शन के बारे में कुछ परीक्षण किए हैं जैसे आपने कहा था?

— अलेवेंटुरायो जूल

Answer 9

जावास्क्रिप्ट में मूल नहीं है, लेकिन बहुत सारे पुस्तकालयों में यह विधि है।

Underscore.js _.uniq(array)( लिंक ) काफी अच्छी तरह से काम करता है ( स्रोत )।

Comments

बांटने के लिए धन्यवाद! यह फ़ंक्शन v1.4.3 से एक तर्क सूची के रूप में सरणी के साथ पुनरावृत्ति और संदर्भ लेता है।

— कुंज

Answer 10

JQuery का उपयोग करके, यहाँ एक ऐरे अनोखा फंक्शन है जिसे मैंने बनाया है:

Array.prototype.unique = function () {
    var arr = this;
    return $.grep(arr, function (v, i) {
        return $.inArray(v, arr) === i;
    });
}

console.log([1,2,3,1,2,3].unique()); // [1,2,3]

Comments

यदि आप एक javascript ऑब्जेक्ट के प्रोटोटाइप के अंदर jQuery का उपयोग करने जा रहे हैं, तो क्या jQuery फ़ंक्शन लिखना बेहतर नहीं हो सकता है, जैसे $.uniqueArray(arr)? JQuery के Arrayप्रोटोटाइप के संदर्भ में एम्बेड करना संदिग्ध लगता है

— jackwanders

@jackwanders: इसके बारे में इतना संदिग्ध क्या है? यदि आपको पृष्ठ पर jQuery मिला है, तो इसका उपयोग करें।

— रॉकेट हज़मत

बस यह है कि आपके द्वारा लिखा गया नया अनूठा फ़ंक्शन अब jQuery पर निर्भर है; आप यह सुनिश्चित करने के बिना इसे किसी नई साइट या ऐप पर नहीं ले जा सकते कि jQuery वहां उपयोग में है।

— जैकवंडर्स

यह मेरी बात थी; यदि आप jQuery का उपयोग करने जा रहे हैं, तो फ़ंक्शन को jQuery का हिस्सा बनाएं। अगर मैं किसी कोर ऑब्जेक्ट के प्रोटोटाइप का विस्तार करने जा रहा हूं, तो मैं चीजों को पुन: प्रयोज्य रखने के लिए, कोर जावास्क्रिप्ट से चिपक जाऊंगा। यदि कोई और आपके कोड को देख रहा है, तो यह स्पष्ट है कि $.uniqueArrayjQuery पर निर्भर है; कम स्पष्ट है कि Array.prototype.uniqueके रूप में अच्छी तरह से है।

— जैकवंडर्स

@ जैकेवंडर्स: मुझे लगता है। मैं अपने कोड में इसका उपयोग करता हूं, जैसा कि मैं हमेशा jQuery का उपयोग करता हूं, और मुझे सिर्फ prototypes का विस्तार करना पसंद है । लेकिन, मैं अब आपकी बात समझ गया हूं। मैं इसे यहाँ वैसे भी छोड़ दूँगा।

— रॉकेट हज़मत

Answer 11

दूसरे सरणी का उपयोग करके छोटा और मीठा समाधान;

var axes2=[1,4,5,2,3,1,2,3,4,5,1,3,4];

    var distinct_axes2=[];

    for(var i=0;i<axes2.length;i++)
        {
        var str=axes2[i];
        if(distinct_axes2.indexOf(str)==-1)
            {
            distinct_axes2.push(str);
            }
        }
    console.log("distinct_axes2 : "+distinct_axes2); // distinct_axes2 : 1,4,5,2,3

Comments

कम? और मीठा? क्या आपने शीर्ष समाधानों को देखा है?

— एलेक्स ओक्रुस्को 20

Answer 12

फास्ट, कॉम्पैक्ट, कोई नेस्टेड लूप नहीं, किसी भी वस्तु के साथ काम करता है न कि केवल तार और संख्या, एक विधेय लेता है, और कोड की केवल 5 पंक्तियाँ !!

function findUnique(arr, predicate) {
  var found = {};
  arr.forEach(d => {
    found[predicate(d)] = d;
  });
  return Object.keys(found).map(key => found[key]); 
}

उदाहरण: प्रकार द्वारा अद्वितीय आइटम खोजने के लिए:

var things = [
  { name: 'charm', type: 'quark'},
  { name: 'strange', type: 'quark'},
  { name: 'proton', type: 'boson'},
];

var result = findUnique(things, d => d.type);
//  [
//    { name: 'charm', type: 'quark'},
//    { name: 'proton', type: 'boson'}
//  ] 

यदि आप चाहते हैं कि अंतिम के बजाय पहला अनूठा आइटम मिल जाए तो एक फाउंड .hasOwnPropery () चेक करें।

Answer 13

Array.some और Array.reduce के साथ uniques खोजने के लिए आपको केवल वेनिला JS की आवश्यकता है। ES2015 सिंटैक्स के साथ यह केवल 62 अक्षर है।

a.reduce((c, v) => b.some(w => w === v) ? c : c.concat(v)), b)

Array.some और Array.reduce IE9 + और अन्य ब्राउज़रों में समर्थित हैं। ईएस2015 सिंटैक्स का समर्थन नहीं करने वाले ब्राउज़रों में समर्थन के लिए नियमित कार्यों के लिए बस वसा तीर फ़ंक्शन को बदलें।

var a = [1,2,3];
var b = [4,5,6];
// .reduce can return a subset or superset
var uniques = a.reduce(function(c, v){
    // .some stops on the first time the function returns true                
    return (b.some(function(w){ return w === v; }) ?  
      // if there's a match, return the array "c"
      c :     
      // if there's no match, then add to the end and return the entire array                                        
      c.concat(v)}),                                  
  // the second param in .reduce is the starting variable. This is will be "c" the first time it runs.
  b);                                                 

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects / सरणी / कम

Answer 14

ऊपर दिए गए समाधानों में अधिकांश समय उच्च जटिलता है।

यहाँ समाधान है जो O (n) समयreduce में उपयोग करता है और कर सकता है ।

Array.prototype.unique = Array.prototype.unique || function() {
        var arr = [];
	this.reduce(function (hash, num) {
		if(typeof hash[num] === 'undefined') {
			hash[num] = 1; 
			arr.push(num);
		}
		return hash;
	}, {});
	return arr;
}
    
var myArr = [3,1,2,3,3,3];
console.log(myArr.unique()); //[3,1,2];

ध्यान दें:

यह समाधान कम करने पर निर्भर नहीं है। विचार एक ऑब्जेक्ट मैप बनाने और अद्वितीय लोगों को सरणी में धकेलने का है।

Answer 15

ES6 रास्ता:

const uniq = (arr) => (arr.filter((item, index, arry) => (arry.indexOf(item) === index)));

Answer 16

आप उपयोग कर सकते हैं,

let arr1 = [1,2,1,3];
let arr2 = [2,3,4,5,1,2,3];

let arr3 = [...new Set([...arr1,...arr2])];

यह आपको अद्वितीय तत्व देगा,

** - लेकिन एक पकड़ है,

इस "1" और 1 के लिए और अलग तत्व हैं, **

दूसरा विकल्प सरणी पर फ़िल्टर विधि का उपयोग करना है।

Answer 17

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

function getUniqueArray(array){
    var uniqueArray = [];
    if (array.length > 0) {
       uniqueArray[0] = array[0];
    }
    for(var i = 0; i < array.length; i++){
        var isExist = false;
        for(var j = 0; j < uniqueArray.length; j++){
            if(array[i] == uniqueArray[j]){
                isExist = true;
                break;
            }
            else{
                isExist = false;
            }
        }
        if(isExist == false){
            uniqueArray[uniqueArray.length] = array[i];
        }
    }
    return uniqueArray;
}

Answer 18

अब तक दिए गए समाधानों के साथ एकमात्र समस्या दक्षता है। यदि आप इसके बारे में चिंतित हैं (और आपको शायद चाहिए) तो आपको नेस्टेड छोरों से बचने की आवश्यकता है: * के लिए, * indexOf, grep * inArray को फ़िल्टर करें, वे सभी सरणी को कई बार पुनरावृत्त करते हैं। आप इस या इस तरह के समाधान के साथ एक ही लूप को लागू कर सकते हैं

Answer 19

Array.prototype.unique = function () {
    var dictionary = {};
    var uniqueValues = [];
    for (var i = 0; i < this.length; i++) {
        if (dictionary[this[i]] == undefined){
            dictionary[this[i]] = i;
            uniqueValues.push(this[i]);
        }
    }
    return uniqueValues; 
}

Answer 20

मैंने शुद्ध जेएस में इस समस्या की कोशिश की है। मैंने निम्नलिखित चरणों का पालन किया है 1. दिए गए सरणी को क्रमबद्ध करें, 2. छांटे गए सरणी के माध्यम से लूप, 3. पिछले मूल्य को सत्यापित करें और वर्तमान मान के साथ अगला मान

// JS
var inpArr = [1, 5, 5, 4, 3, 3, 2, 2, 2,2, 100, 100, -1];

//sort the given array
inpArr.sort(function(a, b){
    return a-b;
});

var finalArr = [];
//loop through the inpArr
for(var i=0; i<inpArr.length; i++){
    //check previous and next value 
  if(inpArr[i-1]!=inpArr[i] && inpArr[i] != inpArr[i+1]){
        finalArr.push(inpArr[i]);
  }
}
console.log(finalArr);

डेमो

Answer 21

function findUniques(arr){
  let uniques = []
  arr.forEach(n => {
    if(!uniques.includes(n)){
      uniques.push(n)
    }       
  })
  return uniques
}

let arr = ["3", "3", "4", "4", "4", "5", "7", "9", "b", "d", "e", "f", "h", "q", "r", "t", "t"]

findUniques(arr)
// ["3", "4", "5", "7", "9", "b", "d", "e", "f", "h", "q", "r", "t"]

Answer 22

ध्यान में रखते हुए कि indexOfकिसी तत्व की पहली घटना वापस आ जाएगी, आप कुछ इस तरह कर सकते हैं:

Array.prototype.unique = function(){
        var self = this;
        return this.filter(function(elem, index){
            return self.indexOf(elem) === index;
        })
    }

Answer 23

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

सेट ऑब्जेक्ट आपको किसी भी प्रकार के अनूठे मानों को संग्रहीत करने देता है, चाहे आदिम मान या ऑब्जेक्ट संदर्भ।

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

const set1 = new Set([1, 2, 3, 4, 5, 1]);
// returns Set(5) {1, 2, 3, 4, 5}

Answer 24

इस सवाल का एक और विचार। यहां मैंने कम कोड के साथ इसे हासिल करने के लिए क्या किया।

var distinctMap = {};
var testArray = ['John', 'John', 'Jason', 'Jason'];
for (var i = 0; i < testArray.length; i++) {
  var value = testArray[i];
  distinctMap[value] = '';
};
var unique_values = Object.keys(distinctMap);

console.log(unique_values);

Answer 25

function findUnique(arr) {
  var result = [];
  arr.forEach(function(d) {
    if (result.indexOf(d) === -1)
      result.push(d);
  });
  return result;
}

var unique = findUnique([1, 2, 3, 1, 2, 1, 4]); // [1,2,3,4]
console.log(unique);

Answer 26

यहां अनुकूलन योग्य equalsफ़ंक्शन के साथ एक दृष्टिकोण दिया गया है जिसका उपयोग प्राथमिकताओं के साथ-साथ कस्टम ऑब्जेक्ट के लिए भी किया जा सकता है:

Array.prototype.pushUnique = function(element, equalsPredicate = (l, r) => l == r) {
    let res = !this.find(item => equalsPredicate(item, element))
    if(res){
        this.push(element)
    }
    return res
}

उपयोग:

//with custom equals for objects
myArrayWithObjects.pushUnique(myObject, (left, right) => left.id == right.id)

//with default equals for primitives
myArrayWithPrimitives.pushUnique(somePrimitive)

Answer 27

मेरा उत्तर अद्वितीय मूल्यों को प्राप्त करने के लिए उपयोग करता है Array.filterऔर Array.indexOfतरीके हैं

array.filter((value, index, self)=>self.indexOf(value)===index)

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

नोट: मेरा दृष्टिकोण जोश द्वारा पोस्ट किए गए एक लाइनर के समान या समान है। मैं इसे यहां छोड़ रहा हूं क्योंकि चर नाम मेरे कोड में स्वयं व्याख्यात्मक हैं।

Answer 28

मैं सोच रहा था कि क्या हम डुप्लिकेट को खत्म करने के लिए रैखिक खोज का उपयोग कर सकते हैं:

JavaScript:
function getUniqueRadios() {

var x=document.getElementById("QnA");
var ansArray = new Array();
var prev;


for (var i=0;i<x.length;i++)
  {
    // Check for unique radio button group
    if (x.elements[i].type == "radio")
    {
            // For the first element prev will be null, hence push it into array and set the prev var.
            if (prev == null)
            {
                prev = x.elements[i].name;
                ansArray.push(x.elements[i].name);
            } else {
                   // We will only push the next radio element if its not identical to previous.
                   if (prev != x.elements[i].name)
                   {
                       prev = x.elements[i].name;
                       ansArray.push(x.elements[i].name);
                   }
            }
    }

  }

   alert(ansArray);

}

HTML:

<body>

<form name="QnA" action="" method='post' ">

<input type="radio"  name="g1" value="ANSTYPE1"> good </input>
<input type="radio" name="g1" value="ANSTYPE2"> avg </input>

<input type="radio"  name="g2" value="ANSTYPE3"> Type1 </input>
<input type="radio" name="g2" value="ANSTYPE2"> Type2 </input>


<input type="submit" value='SUBMIT' onClick="javascript:getUniqueRadios()"></input>


</form>
</body>

Answer 29

यहाँ समस्या का एक लाइनर समाधान है:

var seriesValues = [120, 120, 120, 120];
seriesValues = seriesValues.filter((value, index, seriesValues) => (seriesValues.slice(0, index)).indexOf(value) === -1);
console.log(seriesValues);

इसे कॉपी करके ब्राउजर्स कंसोल पर लाएं और परिणाम प्राप्त करें, यो :-)

Answer 30

मेरे पास JQuery का अनोखा फंक्शन है।

uniqueValues= jQuery.unique( duplicateValues );

अधिक के लिए आप jquery API डॉक्यूमेंटेशन का उल्लेख कर सकते हैं।

http://api.jquery.com/jquery.unique/

Comments

ध्यान दें कि यह केवल DOM तत्वों के सरणियों पर काम करता है, न कि तार या संख्याओं पर। - प्रलेखन से उद्धरण।

— 22