ฉันต้องตรวจสอบอาร์เรย์ JavaScript เพื่อดูว่ามีค่าซ้ำกันหรือไม่ วิธีที่ง่ายที่สุดในการทำเช่นนี้คืออะไร? ฉันแค่ต้องค้นหาว่าค่าที่ซ้ำกันคืออะไร - ฉันไม่ต้องการดัชนีของพวกเขาหรือพวกเขาจะทำซ้ำกี่ครั้ง

ฉันรู้ว่าฉันสามารถวนซ้ำอาร์เรย์และตรวจสอบค่าอื่น ๆ ทั้งหมดสำหรับการแข่งขัน แต่ดูเหมือนว่าควรจะมีวิธีที่ง่ายขึ้น

คำถามที่คล้ายกัน:

• รับค่าที่ไม่ซ้ำทั้งหมดในอาร์เรย์ JavaScript (ลบรายการที่ซ้ำกัน)

คุณสามารถจัดเรียงอาร์เรย์แล้วเรียกใช้ผ่านอาร์เรย์แล้วดูว่าดัชนีถัดไป (หรือก่อนหน้า) นั้นเหมือนกันกับปัจจุบันหรือไม่ สมมติว่าอัลกอริทึมการเรียงลำดับของคุณดีควรน้อยกว่า O (n ² ):

const findDuplicates = (arr) => {
  let sorted_arr = arr.slice().sort(); // You can define the comparing function here. 
  // JS by default uses a crappy string compare.
  // (we use slice to clone the array so the
  // original array won't be modified)
  let results = [];
  for (let i = 0; i < sorted_arr.length - 1; i++) {
    if (sorted_arr[i + 1] == sorted_arr[i]) {
      results.push(sorted_arr[i]);
    }
  }
  return results;
}

let duplicatedArray = [9, 9, 111, 2, 3, 4, 4, 5, 7];
console.log(`The duplicates in ${duplicatedArray} are ${findDuplicates(duplicatedArray)}`);

ในกรณีที่คุณจะกลับมาเป็นฟังก์ชั่นการทำซ้ำ นี่สำหรับกรณีที่คล้ายกัน

การอ้างอิง: https://stackoverflow.com/a/57532964/8119511

หากคุณต้องการทำให้ซ้ำซ้อนลองวิธีแก้ปัญหาที่ยอดเยี่ยมนี้:

function eliminateDuplicates(arr) {
  var i,
      len = arr.length,
      out = [],
      obj = {};

  for (i = 0; i < len; i++) {
    obj[arr[i]] = 0;
  }
  for (i in obj) {
    out.push(i);
  }
  return out;
}

ที่มา: http://dreaminginjavascript.wordpress.com/2008/08/22/eliminating-duplicates/

นี่คือคำตอบของฉันจากเธรดที่ซ้ำกัน (!):

เมื่อเขียนรายการนี้ 2014 - ตัวอย่างทั้งหมดเป็น for-loops หรือ jQuery Javascript มีเครื่องมือที่สมบูรณ์แบบสำหรับสิ่งนี้: เรียงลำดับแผนที่และลด

ค้นหารายการที่ซ้ำกัน

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 duplicates = Object.keys(uniq).filter((a) => uniq[a] > 1)

console.log(duplicates) // [ 'Nancy' ]

ไวยากรณ์การทำงานเพิ่มเติม

@ Dmytro-Laptin ชี้ให้เห็นว่ารหัสบางส่วนถูกลบ นี่เป็นรหัสเดียวกันที่มีขนาดกะทัดรัดกว่า ใช้เทคนิค ES6 และฟังก์ชั่นการสั่งซื้อที่สูงขึ้น:

const names = ['Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Nancy', 'Carl']

const count = names =>
  names.reduce((a, b) => ({ ...a,
    [b]: (a[b] || 0) + 1
  }), {}) // don't forget to initialize the accumulator

const duplicates = dict =>
  Object.keys(dict).filter((a) => dict[a] > 1)

console.log(count(names)) // { Mike: 1, Matt: 1, Nancy: 2, Adam: 1, Jenny: 1, Carl: 1 }
console.log(duplicates(count(names))) // [ 'Nancy' ]

ค้นหาค่าที่ซ้ำกันในอาร์เรย์

นี่ควรเป็นหนึ่งในวิธีที่สั้นที่สุดในการค้นหาค่าที่ซ้ำกันในอาร์เรย์ ตามที่ OP ร้องขอมาโดยเฉพาะสิ่งนี้จะไม่ลบรายการที่ซ้ำกัน แต่ค้นหาพวกมัน

var input = [1, 2, 3, 1, 3, 1];

var duplicates = input.reduce(function(acc, el, i, arr) {
  if (arr.indexOf(el) !== i && acc.indexOf(el) < 0) acc.push(el); return acc;
}, []);

document.write(duplicates); // = 1,3 (actual array == [1, 3])

สิ่งนี้ไม่จำเป็นต้องเรียงลำดับหรือกรอบงานของบุคคลที่สาม นอกจากนี้ยังไม่ต้องการลูปแบบแมนนวล มันทำงานได้กับทุกค่าindexOf () (หรือจะชัดเจนกว่า: ตัวดำเนินการเปรียบเทียบที่เข้มงวด ) สนับสนุน

เพราะลด ()และindexOf ()มันต้องการอย่างน้อย IE 9

คุณสามารถเพิ่มฟังก์ชั่นนี้หรือปรับแต่งและเพิ่มไปยังต้นแบบ Array ของ Javascript:

Array.prototype.unique = function () {
    var r = new Array();
    o:for(var i = 0, n = this.length; i < n; i++)
    {
        for(var x = 0, y = r.length; x < y; x++)
        {
            if(r[x]==this[i])
            {
                alert('this is a DUPE!');
                continue o;
            }
        }
        r[r.length] = this[i];
    }
    return r;
}

var arr = [1,2,2,3,3,4,5,6,2,3,7,8,5,9];
var unique = arr.unique();
alert(unique);

UPDATED: ข้อมูลต่อไปนี้ใช้กลยุทธ์แบบรวมที่ได้รับการเพิ่มประสิทธิภาพ มันปรับการค้นหาแบบดั้งเดิมจะได้รับประโยชน์จากเวลาการค้นหากัญชา (1) (การเรียกใช้uniqueบนอาร์เรย์แบบดั้งเดิมคือ O (n)) การค้นหาวัตถุได้รับการปรับให้เหมาะสมโดยการติดแท็กวัตถุด้วย id ที่ไม่ซ้ำกันในขณะที่วนซ้ำดังนั้นการระบุวัตถุที่ซ้ำกันก็คือ O (1) ต่อรายการและ O (n) สำหรับรายการทั้งหมด ข้อยกเว้นเพียงอย่างเดียวคือไอเท็มที่ถูกแช่แข็ง แต่มีน้อยและมีทางเลือกให้โดยใช้อาร์เรย์และ indexOf

var unique = function(){
  var hasOwn = {}.hasOwnProperty,
      toString = {}.toString,
      uids = {};

  function uid(){
    var key = Math.random().toString(36).slice(2);
    return key in uids ? uid() : uids[key] = key;
  }

  function unique(array){
    var strings = {}, numbers = {}, others = {},
        tagged = [], failed = [],
        count = 0, i = array.length,
        item, type;

    var id = uid();

    while (i--) {
      item = array[i];
      type = typeof item;
      if (item == null || type !== 'object' && type !== 'function') {
        // primitive
        switch (type) {
          case 'string': strings[item] = true; break;
          case 'number': numbers[item] = true; break;
          default: others[item] = item; break;
        }
      } else {
        // object
        if (!hasOwn.call(item, id)) {
          try {
            item[id] = true;
            tagged[count++] = item;
          } catch (e){
            if (failed.indexOf(item) === -1)
              failed[failed.length] = item;
          }
        }
      }
    }

    // remove the tags
    while (count--)
      delete tagged[count][id];

    tagged = tagged.concat(failed);
    count = tagged.length;

    // append primitives to results
    for (i in strings)
      if (hasOwn.call(strings, i))
        tagged[count++] = i;

    for (i in numbers)
      if (hasOwn.call(numbers, i))
        tagged[count++] = +i;

    for (i in others)
      if (hasOwn.call(others, i))
        tagged[count++] = others[i];

    return tagged;
  }

  return unique;
}();

หากคุณมีคอลเล็กชัน ES6 อยู่แสดงว่ามีเวอร์ชั่นที่ง่ายกว่าและเร็วกว่ามาก (shim สำหรับ IE9 + และเบราว์เซอร์อื่น ๆ ที่นี่: https://github.com/Benvie/ES6-Harmony-Collections-Shim )

function unique(array){
  var seen = new Set;
  return array.filter(function(item){
    if (!seen.has(item)) {
      seen.add(item);
      return true;
    }
  });
}

UPDATED: สั้นหนึ่งซับเพื่อรับข้อมูลซ้ำ:

[1, 2, 2, 4, 3, 4].filter((e, i, a) => a.indexOf(e) !== i) // [2, 4]

ในการรับอาร์เรย์โดยไม่มีการซ้ำซ้อนเพียงกลับเงื่อนไข:

[1, 2, 2, 4, 3, 4].filter((e, i, a) => a.indexOf(e) === i) // [1, 2, 3, 4]

ฉันไม่ได้คิดถึงfilter()คำตอบเก่าของฉันด้านล่าง;)

เมื่อสิ่งที่คุณต้องการคือการตรวจสอบว่าไม่มีการซ้ำซ้อนตามที่ถามในคำถามนี้คุณสามารถใช้every()วิธีการ:

[1, 2, 3].every((e, i, a) => a.indexOf(e) === i) // true

[1, 2, 1].every((e, i, a) => a.indexOf(e) === i) // false

โปรดทราบว่าevery()ใช้งานไม่ได้กับ IE 8 และด้านล่าง

var a = ["a","a","b","c","c"];

a.filter(function(value,index,self){ return (self.indexOf(value) !== index )})

สิ่งนี้จะทำให้คุณได้ในสิ่งที่คุณต้องการ

function find_duplicates(arr) {
  var len=arr.length,
      out=[],
      counts={};

  for (var i=0;i<len;i++) {
    var item = arr[i];
    counts[item] = counts[item] >= 1 ? counts[item] + 1 : 1;
    if (counts[item] === 2) {
      out.push(item);
    }
  }

  return out;
}

find_duplicates(['one',2,3,4,4,4,5,6,7,7,7,'pig','one']); // -> ['one',4,7] in no particular order.

ใช้ underscore.js

function hasDuplicate(arr){
    return (arr.length != _.uniq(arr).length);
}

ES2015

//          🚩🚩   🚩                 🚩 
var arr =  [1,2,2,3,3,4,5,6,2,3,7,8,5,22],
    arr2 = [1,2,511,12,50],
    arr3 = [22],
    unique;

// Combine all the arrays to a single one
unique = arr.concat(arr2, arr3)

// create a new (dirty) Array with only the unique items
unique = unique.map((item,i) => unique.includes(item, i+1) ? item : '' )

// Cleanup - remove duplicate & empty items items 
unique = [...new Set(unique)].filter(n => n)

console.log(unique)

ค้นหาค่าที่ไม่ซ้ำจาก 3 อาร์เรย์ (หรือมากกว่า):

Array.prototype.unique = function () {
    var arr = this.sort(), i; // input must be sorted for this to work
    for( i=arr.length; i--; )
      arr[i] === arr[i-1] && arr.splice(i,1); // remove duplicate item

    return arr;
}

var arr =  [1,2,2,3,3,4,5,6,2,3,7,8,5,9],
    arr2 = [1,2,511,12,50],
    arr3 = [22],
    // merge arrays & call custom Array Prototype - "unique"
    unique = arr.concat(arr2, arr3).unique();

console.log(unique);  // [22, 50, 12, 511, 2, 1, 9, 5, 8, 7, 3, 6, 4]

เพียงแค่ polyfill สำหรับ array indexOf สำหรับเบราว์เซอร์เก่า:

if (!Array.prototype.indexOf){
   Array.prototype.indexOf = function(elt /*, from*/){
     var len = this.length >>> 0;

     var from = Number(arguments[1]) || 0;
     from = (from < 0) ? Math.ceil(from) : Math.floor(from);
     if (from < 0)
        from += len;

     for (; from < len; from++){
        if (from in this && this[from] === elt)
           return from;
     }
     return -1;
  };
}

โซลูชัน jQuery โดยใช้ "inArray":

if( $.inArray(this[i], arr) == -1 )

แทนการเพิ่ม Array.prototype.indexOf

นี่คือทางออกที่ง่ายและหนึ่งบรรทัดของฉัน

มันจะค้นหาองค์ประกอบที่ไม่ซ้ำกันก่อนจากนั้นจึงสร้างอาร์เรย์ที่ไม่ซ้ำกันด้วยการใช้ชุด

ดังนั้นเราจึงมีรายการที่ซ้ำกันในที่สุด

var array = [1, 2, 2, 3, 3, 4, 5, 6, 2, 3, 7, 8, 5, 22, 1, 2, 511, 12, 50, 22];

console.log([...new Set(
  array.filter((value, index, self) => self.indexOf(value) !== index))]
);

นี่คือข้อเสนอของฉัน (ES6):

let a = [1, 2, 3, 4, 2, 2, 4, 1, 5, 6]
let b = [...new Set(a.sort().filter((o, i) => o !== undefined && a[i + 1] !== undefined && o === a[i + 1]))]

// b is now [1, 2, 4]

var a = [324,3,32,5,52,2100,1,20,2,3,3,2,2,2,1,1,1].sort();
a.filter(function(v,i,o){return i&&v!==o[i-1]?v:0;});

หรือเมื่อเพิ่มเข้าไปใน prototyp.chain of Array

//copy and paste: without error handling
Array.prototype.unique = 
   function(){return this.sort().filter(function(v,i,o){return i&&v!==o[i-1]?v:0;});}

ดูที่นี่: https://gist.github.com/1305056

วิธีที่รวดเร็วและสง่างามโดยใช้การทำลายและลดขนาดวัตถุ es6

มันทำงานใน O (n) (1 ซ้ำมากกว่าอาร์เรย์) และไม่ซ้ำค่าที่ปรากฏมากกว่า 2 ครั้ง

const arr = ['hi', 'hi', 'hi', 'bye', 'bye', 'asd']
const {
  dup
} = arr.reduce(
  (acc, curr) => {
    acc.items[curr] = acc.items[curr] ? acc.items[curr] += 1 : 1
    if (acc.items[curr] === 2) acc.dup.push(curr)
    return acc
  }, {
    items: {},
    dup: []
  },
)

console.log(dup)
// ['hi', 'bye']

นี่เป็นวิธีที่ง่ายที่สุดที่ฉันคิดได้:

    const arr = [-1, 2, 2, 2, 0, 0, 0, 500, -1, 'a', 'a', 'a']

    const filtered = arr.filter((el, index) => arr.indexOf(el) !== index)
    // => filtered = [ 2, 2, 0, 0, -1, 'a', 'a' ]

    const duplicates = [...new Set(filtered)]

    console.log(duplicates)
    // => [ 2, 0, -1, 'a' ]

แค่นั้นแหละ.

บันทึก:

1. สามารถใช้งานได้กับตัวเลขใด ๆ รวมถึง0สตริงและจำนวนลบเช่น-1- คำถามที่เกี่ยวข้อง: รับ ค่าที่ไม่ซ้ำทั้งหมดในอาร์เรย์ JavaScript (ลบรายการที่ซ้ำกัน)

2. อาร์เรย์ดั้งเดิมarrถูกเก็บรักษาไว้ ( filterส่งคืนอาร์เรย์ใหม่แทนการแก้ไขต้นฉบับ)

3. filteredอาร์เรย์มีทุกรายการที่ซ้ำกัน; มันสามารถมีค่าเดียวกันมากกว่า 1 ค่า (เช่นอาร์เรย์ที่กรองของเราที่นี่คือ[ 2, 2, 0, 0, -1, 'a', 'a' ])

4. หากคุณต้องการได้รับเฉพาะค่าที่ซ้ำกัน (คุณไม่ต้องการให้มีหลายรายการซ้ำด้วยค่าเดียวกัน) คุณสามารถใช้[...new Set(filtered)](ES6 มีชุดวัตถุซึ่งสามารถเก็บค่าที่ไม่ซ้ำกันเท่านั้น)

หวังว่านี่จะช่วยได้

วานิลลาสั้นที่สุด JS :

[1,1,2,2,2,3].filter((v,i,a) => a.indexOf(v) !== i) // [1, 2, 2]

นี่เป็นวิธีที่เบาและง่ายมาก:

var codes = dc_1.split(',');
var i = codes.length;
while (i--) {
  if (codes.indexOf(codes[i]) != i) {
    codes.splice(i,1);
  }
}

ด้วย ES6 (หรือใช้ Babel หรือ Typescipt) คุณสามารถทำได้:

var duplicates = myArray.filter(i => myArray.filter(ii => ii === i).length > 1);

https://es6console.com/j58euhbt/

รหัสอย่างง่ายพร้อมด้วยไวยากรณ์ ES6 (ส่งคืนอาร์เรย์ที่เรียงลำดับรายการที่ซ้ำกัน):

let duplicates = a => {d=[]; a.sort((a,b) => a-b).reduce((a,b)=>{a==b&&!d.includes(a)&&d.push(a); return b}); return d};

วิธีใช้:

duplicates([1,2,3,10,10,2,3,3,10]);

หนึ่งในสายการบิน

var arr = [9,1,2,4,3,4,9]
console.log(arr.filter((ele,indx)=>indx!==arr.indexOf(ele))) //get the duplicates
console.log(arr.filter((ele,indx)=>indx===arr.indexOf(ele))) //remove the duplicates

คำตอบนี้อาจเป็นประโยชน์โดยใช้ประโยชน์จาก js reduce operator / methodเพื่อลบรายการที่ซ้ำกันออกจาก array

const result = [1, 2, 2, 3, 3, 3, 3].reduce((x, y) => x.includes(y) ? x : [...x, y], []);

console.log(result);

ฟังก์ชั่นต่อไปนี้ (รูปแบบของฟังก์ชั่น ElimDuplicates ที่กล่าวถึงแล้ว) ดูเหมือนจะทำเคล็ดลับกลับมาทดสอบ 2,1,7,5 สำหรับการป้อนข้อมูล ["ทดสอบ", "test2", "test2", 1, 1, 1, 1, 2 , 3, 4, 5, 6, 7, 7, 10, 22, 43, 1, 5, 8]

โปรดทราบว่าปัญหาเป็นคนแปลกหน้าใน JavaScript มากกว่าในภาษาอื่น ๆ ส่วนใหญ่เนื่องจากอาร์เรย์ JavaScript สามารถเก็บอะไรก็ได้ โปรดทราบว่าโซลูชันที่ใช้การเรียงลำดับอาจจำเป็นต้องจัดเตรียมฟังก์ชันการเรียงลำดับที่เหมาะสม - ฉันยังไม่ได้ลองเส้นทางนั้น

การใช้งานเฉพาะนี้ใช้งานได้กับสตริงและตัวเลข (อย่างน้อย)

function findDuplicates(arr) {
    var i,
        len=arr.length,
        out=[],
        obj={};

    for (i=0;i<len;i++) {
        if (obj[arr[i]] != null) {
            if (!obj[arr[i]]) {
                out.push(arr[i]);
                obj[arr[i]] = 1;
            }
        } else {
            obj[arr[i]] = 0;            
        }
    }
    return out;
}

ES5 เท่านั้น (เช่นต้องใช้ตัวกรอง () polyfill สำหรับ IE8 และด้านล่าง):

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

arrayToFilter.
    sort().
    filter( function(me,i,arr){
       return (i===0) || ( me !== arr[i-1] );
    });

var arr = [2, 1, 2, 2, 4, 4, 2, 5];

function returnDuplicates(arr) {
  return arr.reduce(function(dupes, val, i) {
    if (arr.indexOf(val) !== i && dupes.indexOf(val) === -1) {
      dupes.push(val);
    }
    return dupes;
  }, []);
}

alert(returnDuplicates(arr));

ฟังก์ชันนี้จะหลีกเลี่ยงขั้นตอนการเรียงลำดับและใช้เมธอดลด () เพื่อส่งข้อมูลที่ซ้ำซ้อนไปยังอาร์เรย์ใหม่หากยังไม่มีอยู่ในนั้น

นี่อาจเป็นวิธีที่เร็วที่สุดในการลบรายการที่ซ้ำกันออกจากอาเรย์ 10 เท่าเร็วกว่าฟังก์ชั่นส่วนใหญ่ที่นี่ & ซาฟารี 78x เร็วขึ้น

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

1. ทดสอบ: http://jsperf.com/wgu
2. การสาธิต: http://jsfiddle.net/46S7g/
3. เพิ่มเติมได้ที่: https://stackoverflow.com/a/25082874/2450730

หากคุณไม่สามารถอ่านรหัสข้างต้นถามอ่านหนังสือจาวาสคริปต์หรือนี่คือคำอธิบายเกี่ยวกับรหัสที่สั้นกว่า https://stackoverflow.com/a/21353032/2450730

แก้ไข ตามที่ระบุไว้ในความคิดเห็นฟังก์ชั่นนี้จะส่งกลับอาร์เรย์ที่ไม่ซ้ำกับคำถาม แต่ขอให้ค้นหาซ้ำกัน ในกรณีนั้นการปรับเปลี่ยนอย่างง่าย ๆ ในฟังก์ชั่นนี้จะช่วยให้การซ้ำซ้อนลงในอาเรย์แล้วใช้ฟังก์ชั่นก่อนหน้านี้toUniqueจะลบรายการที่ซ้ำกันของซ้ำ

function theDuplicates(a,b,c,d){//array,placeholder,placeholder
 b=a.length,d=[];
 while(c=--b)while(c--)a[b]!==a[c]||d.push(a.splice(c,1))
}
var array=[1,2,3,4,5,6,7,8,9,0,1,2,1];

toUnique(theDuplicates(array));

การใช้ "รวม" เพื่อทดสอบว่ามีองค์ประกอบอยู่แล้ว

var arr = [1, 1, 4, 5, 5], darr = [], duplicates = [];

for(var i = 0; i < arr.length; i++){
  if(darr.includes(arr[i]) && !duplicates.includes(arr[i]))
    duplicates.push(arr[i])
  else
    darr.push(arr[i]);
}

console.log(duplicates);

<h3>Array with duplicates</h3>
<p>[1, 1, 4, 5, 5]</p>
<h3>Array with distinct elements</h3>
<p>[1, 4, 5]</p>
<h3>duplicate values are</h3>
<p>[1, 5]</p>

ES6 เสนอโครงสร้างข้อมูลชุดซึ่งโดยทั่วไปจะเป็นอาร์เรย์ที่ไม่ยอมรับการทำซ้ำ ด้วยโครงสร้างข้อมูล Set มีวิธีที่ง่ายมากในการค้นหารายการที่ซ้ำกันในอาร์เรย์ (ใช้วนเดียวเท่านั้น)

นี่คือรหัสของฉัน

function findDuplicate(arr) {
var set = new Set();
var duplicates = new Set();
  for (let i = 0; i< arr.length; i++) {
     var size = set.size;
     set.add(arr[i]);
     if (set.size === size) {
         duplicates.add(arr[i]);
     }
  }
 return duplicates;
}

ฉันเพิ่งค้นพบวิธีง่ายๆในการบรรลุสิ่งนี้โดยใช้ตัวกรอง Array

    var list = [9, 9, 111, 2, 3, 4, 4, 5, 7];
    
    // Filter 1: to find all duplicates elements
    var duplicates = list.filter(function(value,index,self) {
       return self.indexOf(value) !== self.lastIndexOf(value) && self.indexOf(value) === index;
    });
    
    console.log(duplicates);

ตรรกะต่อไปนี้จะง่ายขึ้นและเร็วขึ้น

// @Param:data:Array that is the source 
// @Return : Array that have the duplicate entries
findDuplicates(data: Array<any>): Array<any> {
        return Array.from(new Set(data)).filter((value) => data.indexOf(value) !== data.lastIndexOf(value));
      }

ข้อดี:

1. บรรทัดเดียว :-P
2. โครงสร้างข้อมูลแบบ inbuilt ทั้งหมดช่วยในการปรับปรุงประสิทธิภาพ
3. ได้เร็วขึ้น

คำอธิบายของตรรกะ:

1. การแปลงเป็นชุดเพื่อลบรายการซ้ำทั้งหมด
2. วนซ้ำตามค่าที่ตั้งไว้
3. ด้วยการตรวจสอบค่าแต่ละชุดในอาเรย์ของแหล่งข้อมูลสำหรับเงื่อนไข "ค่าดัชนีแรกไม่เท่ากับดัชนีสุดท้าย" ==> จากนั้นอนุมานว่าเป็นรายการซ้ำมันเป็น 'ไม่ซ้ำกัน'

หมายเหตุ: วิธีการ map () และ filter () นั้นมีประสิทธิภาพและเร็วขึ้น