Question

我们假设我有;

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

我想要它;

var newArray = [1,2,3];

我想完全删除重复项，而不是将它们保留为唯一值。有没有办法通过reduce方法实现呢？

Answer 1

您可以将Array#filter与Array#indexOf和Array#lastIndexOf一起使用，并仅返回共享相同索引的值。

＆＃13;

var array = [1, 2, 3, 4, 4, 5, 5],
    result = array.filter(function (a, _, aa) {
        return aa.indexOf(a) === aa.lastIndexOf(a);
    });

console.log(result);

＆＃13;

Answer 2

我想它不会有一些非凡的表现，但我喜欢这个想法。

＆＃13;

var array = [1,2,3,4,4,5,5],
    res = array.reduce(function(s,a) {
      if (array.filter(v => v !== a).length == array.length-1) {
        s.push(a);
      }
      return s;
    }, []);
    console.log(res);

＆＃13;

Answer 3

另一种选择是使用对象来跟踪元素的使用次数。这将破坏数组顺序，但在非常大的数组上应该快得多。

function nukeDuplications(arr) {
  const hash = {};
  arr.forEach(el => {
    const qty = hash[el] || 0;
    hash[el] = qty+1;
  });
  
  const ret = [];
  Object.keys(hash).forEach(key => {
    if (hash[key] === 1) {
      ret.push(Number(key));
    }
  })
  return ret;
}

var array = [1,2,3,4,4,5,5];
console.log(nukeDuplications(array));

Answer 4

稍微更有效的解决方案是循环遍历数组1次并计算每个值中出现的次数并使用.reduce()将它们存储在对象中，然后使用{{1}再次遍历数组仅返回发生过一次的项目。

此方法还将保留数组的顺序，因为它仅使用对象键作为引用 - 它不会迭代它们。

＆＃13;

.filter()

＆＃13;

Answer 5

另一种选择是使用对象来跟踪元素的使用次数。这将破坏数组顺序，但在非常大的数组上应该快得多。

// Both versions destroy array order.

// ES6 version
function nukeDuplications(arr) {
  "use strict";
  const hash = {};
  arr.forEach(el => {
    const qty = hash[el] || 0;
    hash[el] = qty + 1;
  });

  const ret = [];
  Object.keys(hash).forEach(key => {
    if (hash[key] === 1) {
      ret.push(Number(key));
    }
  })
  return ret;
}

// ES5 version
function nukeDuplicationsEs5(arr) {
  "use strict";
  var hash = {};
  for (var i = 0; i < arr.length; i++) {
    var el = arr[i];
    var qty = hash[el] || 0;
    hash[el] = qty + 1;
  };

  var ret = [];
  for (let key in hash) {
    if (hash.hasOwnProperty(key)) {
        if (hash[key] === 1) {
          ret.push(Number(key));
        }
      }
    }
    return ret;
  }


  var array = [1, 2, 3, 4, 4, 5, 5];
  console.log(nukeDuplications(array));

  console.log(nukeDuplicationsEs5(array));

Answer 6

这里有很多过于复杂且运行缓慢的代码。这是我的解决方案：

let numbers = [1,2,3,4,4,4,4,5,5]
let filtered = []

numbers.map((n) => {
    if(numbers.indexOf(n) === numbers.lastIndexOf(n)) // If only 1 instance of n
        filtered.push(n)
})

console.log(filtered)

Answer 7

您可以使用此功能：

function isUniqueInArray(array, value) {
  let counter = 0;
  for (let index = 0; index < array.length; index++) {
    if (array[index] === value) {
      counter++;
    }
  }
  if (counter === 0) {
    return null;
  }
  return counter === 1 ? true : false;
}

const array = [1,2,3,4,4,5,5];
let uniqueValues = [];

array.forEach(element => {
  if(isUniqueInArray(array ,element)){
    uniqueValues.push(element);
  }
});

console.log(`the unique values is ${uniqueValues}`);

如果有帮助，可以从我的软件包https://www.npmjs.com/package/jotils或直接从https://bit.dev/joshk/jotils/is-unique-in-array位安装isUniqueInArray函数。

Answer 8

我的答案用于地图和过滤器，如下所示：

x = [1,2,3,4,2,3]
x.map(d => x.filter(i => i == d).length < 2 ? d : null).filter(d => d != null)
// [1, 4]

Answer 9

从ES2017开始支持

Object.values（不用说-不在IE上）。累加器是一个对象，每个键都是一个值，因此，当重复项覆盖相同的键时，将删除重复项。但是，此解决方案可能会有错误的值（空值，未定义等）的风险，但对于现实生活中的场景可能有用。

let NukeDeps = (arr) => {
  return Object.values(arr.reduce((curr, i) => {
    curr[i] = i;
    return curr;
  }, {}))  
}

Answer 10

我想用我再次阅读后想出的答案来回答我的问题

const array = [1, 2, 3, 4, 4, 5, 5];
const filtered = array.filter(item => {
  const { length }  = array.filter(currentItem => currentItem === item)
  if (length === 1) {
     return true;
   }
});
console.log(filtered)

Answer 11

//Try with this code
var arr = [1,2, 3,3,4,5,5,5,6,6];

arr = arr.filter( function( item, index, inputArray ) {
           return inputArray.indexOf(item) == index;
      });

同时查看此链接https://fiddle.jshell.net/5hshjxvr/

从阵列中完全删除重复的项目

11 个答案: