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




arrays duplicates (24)

इस प्रश्न का उत्तर यहां दिया गया है:

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

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

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

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

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


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

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

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

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)


फॉर-लूप या 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;},[]);

सॉर्टिंग के साथ तेज uniq

शायद तेज़ तरीके हैं लेकिन यह एक बहुत सभ्य है।

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: ईएस 6 संस्करण:

ईएस 6 में आपके पास सेट्स और स्प्रेड है जो सभी डुप्लिकेट को हटाने के लिए बहुत आसान और निष्पादक बनाता है:

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)

एक पंक्ति:

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

तो विकल्प है:

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]

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

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

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


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)


यहां कोई विशेष पुस्तकालय विशेष कार्य नहीं होने के बिना सरल विधि है,

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)


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

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

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

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

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;

}

ईसीएमएस्क्रिप्ट 6: नई सेट डेटा संरचना का उपयोग करें (ऑर्डर-सुरक्षित)

ईसीएमएस्क्रिप्ट 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"]

सबसे सरल मैं अब तक चला गया है। Es6 में।

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

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

Set


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

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}] वापस आ जाएगा।

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

दो दुनिया से सबसे अच्छा

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

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 करें)।

द्वारा अनोखा ...

कभी-कभी यह समानता के अलावा कुछ मानदंडों के आधार पर एक सूची को विशिष्ट बनाना चाहता है, उदाहरण के लिए, अलग-अलग ऑब्जेक्ट्स को फ़िल्टर करने के लिए, लेकिन कुछ संपत्ति साझा करें। कॉलबैक पास करके इसे सुंदर ढंग से किया जा सकता है। यह "कुंजी" कॉलबैक प्रत्येक तत्व पर लागू होता है, और समान "कुंजी" वाले तत्व हटा दिए जाते हैं। चूंकि 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 ऑब्जेक्ट का उपयोग 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) )।

पुस्तकालय

underscore और Lo-Dash दोनों uniq विधियां प्रदान करते हैं। उनके एल्गोरिदम मूल रूप से उपरोक्त पहले स्निपेट के समान होते हैं और इससे उबालते हैं:

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

यह वर्गबद्ध है, लेकिन अच्छी अतिरिक्त उपहार हैं, जैसे देशी सूचकांक लपेटना, एक कुंजी ( iteratee अपने iteratee में iteratee ) द्वारा uniqify करने की क्षमता, और पहले से क्रमबद्ध सरणी के लिए अनुकूलन।

यदि आप 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)

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


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

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

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

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

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

Array.from(new Set(vals))

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

[...new Set(vals)]

चियर्स!


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

एक साधारण लेकिन प्रभावी तकनीक, फिल्टर 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>';

यह पहेली भी देखें।


इस के लिए जाओ:

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

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


Generic Functional Approach

Here is a generic and strictly functional approach with 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) );

We can easily derive unique from unqiueBy or use the faster implementation utilizing Set s:

const unqiue = uniqueBy(eq);

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

Benefits of this approach:

  • generic solution by using a separate comparator function
  • declarative and succinct implementation
  • reuse of other small, generic functions

Performance Considerations

uniqueBy isn't as fast as an imperative implementation with loops, but it is way more expressive due to its genericity.

If you identify uniqueBy as the cause of a concrete performance penalty in your app, replace it with optimized code. That is, write your code first in an functional, declarative way. Afterwards, provided that you encounter performance issues, try to optimize the code at the locations, which are the cause of the problem.

Memory Consumption and Garbage Collection

uniqueBy utilizes mutations ( push(x) (acc) ) hidden inside its body. It reuses the accumulator instead of throwing it away after each iteration. This reduces memory consumption and GC pressure. Since this side effect is wrapped inside the function, everything outside remains pure.


सरणी फ़िल्टर और अनुक्रमणिका का उपयोग कर एक एकल संस्करण संस्करण:

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

You could also use the Array.unique() method from the JavaScript Lab library – or steal an idea from there.

However, the code there isn't very well written, since it declares the unique() method as a property of the Array prototype, thus adding it to every Array, breaking the for...in functionality (because a for...in loop will always iterate over the unique variable, too).


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


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






duplicates