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




arrays duplicates (20)

इस तरह Array.filter() उपयोग करें

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

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

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

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

इसे ईएस 6 में छोटा बनाया जा सकता है

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

Array.filter() का अच्छा स्पष्टीकरण Here है

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

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

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

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

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

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


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

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


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.


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

ईसीएमएस्क्रिप्ट 6 (उर्फ ईसीएमएस्क्रिप्ट 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);

तो विकल्प है:

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]

प्रश्न का एक सरल जवाब यहां दिया गया है।

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

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

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

चियर्स!


मैंने किसी अन्य प्रश्न पर डुप्ली हटाने की विस्तृत तुलना की थी लेकिन ध्यान दिया कि यह वास्तविक जगह है जिसे मैं इसे यहां भी साझा करना चाहता था।

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

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

ठीक है .. भले ही यह एक ओ (एन) है और अन्य ओ (एन ^ 2) हैं, मैं इस कम / लुकअप टेबल और फ़िल्टर / इंडेक्स के बीच बेंचमार्क तुलना देखने के लिए उत्सुक था, कॉम्बो (मैं जीतेन्ड्रेस को बहुत अच्छा कार्यान्वयन चुनता हूं https://.com/a/37441144/4543207 )। मैं रेंज 0-99 99 में यादृच्छिक सकारात्मक पूर्णांक से भरे 100K आइटम सरणी तैयार करता हूं और यह डुप्लिकेट को हटा देता है। मैं 10 बार परीक्षण दोहराता हूं और परिणामों के औसत से पता चलता है कि वे प्रदर्शन में कोई मेल नहीं हैं।

  • फ़ायरफ़ॉक्स v47 में कम और लूट: 14.85ms बनाम फिल्टर और अनुक्रमणिका: 2836ms
  • क्रोम v51 कम और लूट में: 23.90 मिमी बनाम फ़िल्टर और अनुक्रमणिका: 1066ms

ठीक है अब तक बहुत अच्छा है। लेकिन चलिए इस बार ES6 शैली में ठीक से करते हैं। यह बहुत अच्छा लग रहा है ..! लेकिन अब तक शक्तिशाली लूट समाधान के खिलाफ यह कैसे किया जाएगा मेरे लिए एक रहस्य है। आइए पहले कोड देखें और फिर इसे बेंचमार्क करें।

var myArray = [100, 200, 100, 200, 100, 100, 200, 200, 200, 200],
    reduced = [...myArray.reduce((p,c) => p.set(c,true),new Map()).keys()];
console.log(reduced);

वाह कि छोटा था ..! लेकिन प्रदर्शन के बारे में कैसे ..? यह खूबसूरत है ... फिल्टर / इंडेक्स के भारी वजन के बाद से हमारे कंधों पर उठाए गए हैं, अब मैं 10 लगातार परीक्षणों से औसत प्राप्त करने के लिए 0..9 99 99 में सकारात्मक पूर्णांक के एक सरणी 1 एम यादृच्छिक आइटम का परीक्षण कर सकता हूं। मैं कह सकता हूं कि यह एक असली मैच है। अपने लिए परिणाम देखें :)

var ranar = [],
     red1 = a => Object.keys(a.reduce((p,c) => (p[c] = true,p),{})),
     red2 = a => reduced = [...a.reduce((p,c) => p.set(c,true),new Map()).keys()],
     avg1 = [],
     avg2 = [],
       ts = 0,
       te = 0,
     res1 = [],
     res2 = [],
     count= 10;
for (var i = 0; i<count; i++){
  ranar = (new Array(1000000).fill(true)).map(e => Math.floor(Math.random()*100000));
  ts = performance.now();
  res1 = red1(ranar);
  te = performance.now();
  avg1.push(te-ts);
  ts = performance.now();
  res2 = red2(ranar);
  te = performance.now();
  avg2.push(te-ts);
}

avg1 = avg1.reduce((p,c) => p+c)/count;
avg2 = avg2.reduce((p,c) => p+c)/count;

console.log("reduce & lut took: " + avg1 + "msec");
console.log("map & spread took: " + avg2 + "msec");

आप किस का उपयोग करेंगे ..? ठीक है इतना तेज़ नहीं ...! धोखा मत बनो। मानचित्र विस्थापन पर है। अब देखो ... उपर्युक्त सभी मामलों में हम श्रेणी n की संख्या के साथ आकार n की एक सरणी भरते हैं <n। मेरा मतलब है कि हमारे पास आकार 100 की एक सरणी है और हम यादृच्छिक संख्या 0..9 भरते हैं, इसलिए निश्चित डुप्लिकेट हैं और "लगभग" निश्चित रूप से प्रत्येक संख्या में डुप्लिकेट होता है। अगर हम यादृच्छिक संख्या 0..9 999 के साथ आकार 100 में सरणी भरते हैं। आइए अब घर पर मानचित्र खेल रहे हैं। इस बार 100 के आइटमों का एक ऐरे लेकिन यादृच्छिक संख्या सीमा 0..100 मीटर है। हम परिणामों को औसत करने के लिए लगातार 100 परीक्षण करेंगे। ठीक है चलो देखते हैं ..! <- कोई टाइपो नहीं

var ranar = [],
     red1 = a => Object.keys(a.reduce((p,c) => (p[c] = true,p),{})),
     red2 = a => reduced = [...a.reduce((p,c) => p.set(c,true),new Map()).keys()],
     avg1 = [],
     avg2 = [],
       ts = 0,
       te = 0,
     res1 = [],
     res2 = [],
     count= 100;
for (var i = 0; i<count; i++){
  ranar = (new Array(100000).fill(true)).map(e => Math.floor(Math.random()*100000000));
  ts = performance.now();
  res1 = red1(ranar);
  te = performance.now();
  avg1.push(te-ts);
  ts = performance.now();
  res2 = red2(ranar);
  te = performance.now();
  avg2.push(te-ts);
}

avg1 = avg1.reduce((p,c) => p+c)/count;
avg2 = avg2.reduce((p,c) => p+c)/count;

console.log("reduce & lut took: " + avg1 + "msec");
console.log("map & spread took: " + avg2 + "msec");

अब यह मानचित्र () .. की शानदार वापसी है! जब आप डुप्लिकेट को हटाना चाहते हैं तो अब आप बेहतर निर्णय ले सकते हैं।

ठीक है, हम सब अब खुश हैं। लेकिन कुछ प्रशंसा के साथ मुख्य भूमिका हमेशा आखिरी होती है। मुझे यकीन है कि आप में से कुछ आश्चर्य करते हैं कि सेट ऑब्जेक्ट क्या करेगा। अब जब से हम ईएस 6 के लिए खुले हैं और हम जानते हैं कि नक्शा पिछले खेलों के विजेता है, तो हम अंतिम के रूप में सेट के साथ मानचित्र की तुलना करें। इस समय एक सामान्य रियल मैड्रिड बनाम बार्सिलोना खेल ... या यह है? चलो देखते हैं कि एल क्लासिको कौन जीतेंगे :)

var ranar = [],
     red1 = a => reduced = [...a.reduce((p,c) => p.set(c,true),new Map()).keys()],
     red2 = a => Array.from(new Set(a)),
     avg1 = [],
     avg2 = [],
       ts = 0,
       te = 0,
     res1 = [],
     res2 = [],
     count= 100;
for (var i = 0; i<count; i++){
  ranar = (new Array(100000).fill(true)).map(e => Math.floor(Math.random()*10000000));
  ts = performance.now();
  res1 = red1(ranar);
  te = performance.now();
  avg1.push(te-ts);
  ts = performance.now();
  res2 = red2(ranar);
  te = performance.now();
  avg2.push(te-ts);
}

avg1 = avg1.reduce((p,c) => p+c)/count;
avg2 = avg2.reduce((p,c) => p+c)/count;

console.log("map & spread took: " + avg1 + "msec");
console.log("set & A.from took: " + avg2 + "msec");

वाह .. आदमी ..! अच्छी तरह से अप्रत्याशित रूप से यह एक एल क्लासिको नहीं बन गया। सीए ओसासुन के खिलाफ बार्सिलोना एफसी की तरह :) :)


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

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

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

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

Set


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


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)


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

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

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

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


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


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




duplicates