Tôi cần kiểm tra một mảng JavaScript để xem liệu có bất kỳ giá trị trùng lặp nào không. Cách dễ nhất để làm điều này là gì? Tôi chỉ cần tìm các giá trị trùng lặp là gì - tôi thực sự không cần chỉ mục của chúng hoặc số lần chúng được nhân đôi.

Tôi biết tôi có thể lặp qua mảng và kiểm tra tất cả các giá trị khác cho một trận đấu, nhưng có vẻ như nên có một cách dễ dàng hơn.

Câu hỏi tương tự:

• Nhận tất cả các giá trị duy nhất trong một mảng JavaScript (loại bỏ trùng lặp)

Bạn có thể sắp xếp mảng và sau đó chạy qua nó và sau đó xem liệu chỉ mục tiếp theo (hoặc trước đó) có giống với hiện tại không. Giả sử thuật toán sắp xếp của bạn là tốt, giá trị này sẽ nhỏ hơn 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)}`);

Trong trường hợp, nếu bạn trở lại là một hàm cho các bản sao. Đây là loại trường hợp tương tự.

Tham khảo: https://stackoverflow.com/a/57532964/8119511

Nếu bạn muốn tách ra các bản sao, hãy thử giải pháp tuyệt vời này:

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

Nguồn: http://dreaminginjavascript.wordpress.com/2008/08/22/006inating-d repeatates /

Đây là câu trả lời của tôi từ chuỗi trùng lặp (!):

Khi viết mục này 2014 - tất cả các ví dụ là vòng lặp for hoặc jQuery. Javascript có các công cụ hoàn hảo cho việc này: sắp xếp, ánh xạ và thu nhỏ.

Tìm các mục trùng lặp

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

Cú pháp chức năng khác:

@ Dmytro-Laptin đã chỉ ra một số mã mã bị xóa. Đây là một phiên bản nhỏ gọn hơn của cùng một mã. Sử dụng một số thủ thuật ES6 và các hàm bậc cao hơn:

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

Tìm các giá trị trùng lặp trong một mảng

Đây phải là một trong những cách ngắn nhất để thực sự tìm thấy các giá trị trùng lặp trong một mảng. Như OP yêu cầu cụ thể, điều này không loại bỏ trùng lặp mà tìm thấy chúng .

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

Điều này không cần sắp xếp hoặc bất kỳ khuôn khổ bên thứ ba. Nó cũng không cần vòng lặp thủ công. Nó hoạt động với mọi giá trị indexOf () (hoặc rõ ràng hơn: toán tử so sánh nghiêm ngặt ) hỗ trợ.

Do giảm () và indexOf (), nó cần ít nhất IE 9.

Bạn có thể thêm chức năng này hoặc điều chỉnh nó và thêm nó vào nguyên mẫu Array của 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);

CẬP NHẬT: Sau đây sử dụng một chiến lược kết hợp tối ưu hóa. Nó tối ưu hóa tra cứu nguyên thủy để hưởng lợi từ thời gian tra cứu băm O (1) (chạy uniquetrên một mảng nguyên thủy là O (n)). Tra cứu đối tượng được tối ưu hóa bằng cách gắn thẻ các đối tượng với một id duy nhất trong khi lặp qua để xác định các đối tượng trùng lặp cũng là O (1) cho mỗi mục và O (n) cho toàn bộ danh sách. Ngoại lệ duy nhất là các mặt hàng bị đóng băng, nhưng những thứ đó rất hiếm và dự phòng được cung cấp bằng cách sử dụng một mảng và 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;
}();

Nếu bạn có Bộ sưu tập ES6, thì có một phiên bản đơn giản hơn và nhanh hơn đáng kể. (shim cho IE9 + và các trình duyệt khác tại đây: 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;
    }
  });
}

CẬP NHẬT: Một lớp lót ngắn để có được các bản sao:

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

Để có được mảng mà không trùng lặp, chỉ cần đảo ngược điều kiện:

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

Tôi chỉ đơn giản là không nghĩ về filter()câu trả lời cũ của tôi dưới đây;)

Khi tất cả những gì bạn cần là kiểm tra xem không có bản sao nào được hỏi trong câu hỏi này, bạn có thể sử dụng every()phương thức:

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

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

Lưu ý rằng every()không hoạt động cho IE 8 trở xuống.

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

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

Điều này sẽ giúp bạn có được những gì bạn muốn, Chỉ là các bản sao.

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.

sử dụng 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)

Tìm các giá trị duy nhất từ ​​3 mảng (hoặc nhiều hơn):

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]

Chỉ là một polyfill cho mảng indexOf cho các trình duyệt cũ:

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

Giải pháp jQuery sử dụng "inArray":

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

thay vì thêm Array.prototype.indexOf

Đây là giải pháp đơn giản và một dòng của tôi.

Nó tìm kiếm các phần tử duy nhất trước tiên, sau đó làm cho mảng tìm thấy là duy nhất với việc sử dụng Set.

Vì vậy, chúng tôi có mảng trùng lặp cuối cùng.

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

Đây là đề xuất của tôi (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;});

hoặc khi được thêm vào 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;});}

Xem tại đây: https://gist.github.com/1305056

Cách nhanh chóng và thanh lịch bằng cách sử dụng phá hủy và giảm đối tượng es6

Nó chạy trong O (n) (1 lần lặp trên mảng) và không lặp lại các giá trị xuất hiện hơn 2 lần

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

Đây là giải pháp đơn giản nhất tôi có thể nghĩ ra:

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

Đó là nó.

Ghi chú:

1. Nó hoạt động với bất kỳ số bao gồm 0, chuỗi và số âm ví dụ -1- câu hỏi liên quan: Nhận tất cả các giá trị duy nhất trong một mảng JavaScript (bản sao remove)

2. Mảng ban đầu arrđược bảo tồn ( filtertrả về mảng mới thay vì sửa đổi bản gốc)

3. Các filteredmảng chứa tất cả các bản sao; nó cũng có thể chứa nhiều hơn 1 giá trị giống nhau (ví dụ: mảng được lọc của chúng tôi ở đây là [ 2, 2, 0, 0, -1, 'a', 'a' ])

4. Nếu bạn muốn nhận được chỉ giá trị được nhân đôi (bạn không muốn có nhiều trùng lặp có giá trị như nhau), bạn có thể sử dụng [...new Set(filtered)](ES6 có một đối tượng Set mà có thể lưu trữ các giá trị chỉ duy nhất)

Hi vọng điêu nay co ich.

JS vanilla ngắn nhất :

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

Đây là một cách rất nhẹ nhàng và dễ dàng:

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

Với ES6 (hoặc sử dụng Babel hoặc Formscipt), bạn chỉ cần thực hiện:

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

https://es6console.com/j58euhbt/

Mã đơn giản với cú pháp ES6 (trả về mảng trùng lặp được sắp xếp):

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

Cách sử dụng:

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

lót

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

Câu trả lời này cũng có thể hữu ích, nó tận dụng reduce toán tử / phương thức js để loại bỏ các bản sao khỏi mảng.

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

console.log(result);

Hàm sau (một biến thể của hàm ElimD repeatates đã được đề cập) dường như thực hiện thủ thuật, trả về test2,1,7,5 cho đầu vào ["test", "test2", "test2", 1, 1, 1, 2 , 3, 4, 5, 6, 7, 7, 10, 22, 43, 1, 5, 8]

Lưu ý rằng vấn đề lạ ở JavaScript hơn ở hầu hết các ngôn ngữ khác, bởi vì một mảng JavaScript có thể chứa bất cứ thứ gì. Lưu ý rằng các giải pháp sử dụng sắp xếp có thể cần cung cấp chức năng sắp xếp phù hợp - Tôi chưa thử tuyến đường đó.

Việc triển khai cụ thể này hoạt động đối với (ít nhất) chuỗi và số.

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

Chỉ ES5 (nghĩa là nó cần một bộ lọc () polyfill cho IE8 trở xuống):

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

Hàm này tránh bước sắp xếp và sử dụng phương thức less () để đẩy các bản sao sang một mảng mới nếu nó không tồn tại trong đó.

Đây có lẽ là một trong những cách nhanh nhất để loại bỏ vĩnh viễn các bản sao khỏi một mảng nhanh gấp 10 lần so với hầu hết các chức năng ở đây. & Nhanh hơn 78 lần trong safari

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. Kiểm tra: http://jsperf.com/wgu
2. Bản trình diễn: http://jsfiddle.net/46S7g/
3. Thêm: https://stackoverflow.com/a/25082874/2450730

nếu bạn không thể đọc mã ở trên, hãy đọc một cuốn sách javascript hoặc đây là một số giải thích về mã ngắn hơn. https://stackoverflow.com/a/21353032/2450730

EDIT Như đã nêu trong các bình luận, hàm này không trả về một mảng có dấu, tuy nhiên câu hỏi yêu cầu tìm các bản sao. trong trường hợp đó, một sửa đổi đơn giản cho hàm này cho phép đẩy các bản sao vào một mảng, sau đó sử dụng hàm trước đó toUniquesẽ loại bỏ các bản sao của các bản sao.

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

Sử dụng "bao gồm" để kiểm tra xem phần tử đã tồn tại chưa.

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 cung cấp cấu trúc dữ liệu Set, về cơ bản là một mảng không chấp nhận trùng lặp. Với cấu trúc dữ liệu Đặt, có một cách rất dễ dàng để tìm các bản sao trong một mảng (chỉ sử dụng một vòng lặp).

Đây là mã của tôi

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

Tôi vừa tìm ra một cách đơn giản để đạt được điều này bằng bộ lọc 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);

Theo logic sẽ dễ dàng hơn và nhanh hơn

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

Ưu điểm:

1. Dòng đơn :-P
2. Tất cả cấu trúc dữ liệu sẵn có giúp nâng cao hiệu quả
3. Nhanh hơn

Mô tả logic:

1. Chuyển đổi để thiết lập để loại bỏ tất cả các bản sao
2. Lặp lại thông qua các giá trị được đặt
3. Với mỗi lần kiểm tra giá trị được đặt trong mảng nguồn cho điều kiện "giá trị chỉ mục đầu tiên không bằng chỉ mục cuối cùng" ==> Sau đó suy ra là trùng lặp khác, đó là 'duy nhất'

Lưu ý: các phương thức map () và filter () hiệu quả và nhanh hơn.