这应该是在数组中查找重复值的最短和最简单的方法之一。

Var arr = [1,2,3,4,5,6,7,8,1,2,3,4,5,3,4]; Var数据= arr.filter(函数(项目，索引，arr){ 返回arr.indexOf(item) != arr.lastIndexOf(item) && arr.indexOf(item) == index; }) console.log(数据);

//find duplicates: //sort, then reduce - concat values equal previous element, skip others //input var a = [1, 2, 3, 1, 2, 1, 2] //short version: var duplicates = a.sort().reduce((d, v, i, a) => i && v === a[i - 1] ? d.concat(v) : d, []) console.log(duplicates); //[1, 1, 2, 2] //readable version: var duplicates = a.sort().reduce((output, element, index, input) => { if ((index > 0) && (element === input[index - 1])) return output.concat(element) return output }, []) console.log(duplicates); //[1, 1, 2, 2]

下面的函数(前面提到的eliminateduplates函数的变体)似乎可以做到这一点，它为输入["test"， "test2"， "test2"， 1,1,2,3,4,5,6,7,7,10,22,43,1,5,5,8]返回test2,1,7,7,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;
}

我只需要找到复制的值是什么——实际上我不需要它们的索引，也不需要它们复制了多少次。

这是一个有趣而简单的任务，有许多难以阅读的答案……

打印稿

function getDuplicatedItems<T>(someArray: T[]): T[] {
    // create a set to iterate through (we only need to check each value once)
    const itemSet = new Set<T>(someArray);

    // from that Set, we check if any of the items are duplicated in someArray
    const duplicatedItems = [...itemSet].filter(
        (item) => someArray.indexOf(item) !== someArray.lastIndexOf(item)
    );

    return duplicatedItems;
}

JavaScript

function getDuplicatedItems(someArray) {
    // check for misuse if desired
    // if (!Array.isArray(someArray)) {
    //     throw new TypeError(`getDuplicatedItems requires an Array type, received ${typeof someArray} type.`);
    // }
    const itemSet = new Set(someArray);
    const duplicatedItems = [...itemSet].filter(
        (item) => someArray.indexOf(item) !== someArray.lastIndexOf(item)
    );
    return duplicatedItems;
}

var input = ['a', 'b', 'a', 'c', 'c'],
    duplicates = [],
    i, j;
for (i = 0, j = input.length; i < j; i++) {
  if (duplicates.indexOf(input[i]) === -1 && input.indexOf(input[i], i+1) !== -1) {
    duplicates.push(input[i]);
  }
}

console.log(duplicates);

返回副本并保留数据类型。

具有O(4n)性能

const dupes = arr => {
  const map = arr.reduce((map, curr) => {
    return (map.set(curr, (map.get(curr) || 0) + 1), map)
  }, new Map());

  return Array.from(map).filter(([key, val])=> val > 1).map(([key, val]) => key)
}

具有O(2n)性能

const dupes = arr => {
  const map = arr.reduce((map, curr) => {
    return (map.set(curr, (map.get(curr) || 0) + 1), map)
  }, new Map());

  const dupes_ = [];
  for (let [key, val] of map.entries()) {
    if (val > 1) dupes_.push(key);
  }
  return dupes_;
}