获取JavaScript数组中的所有唯一值（删除重复项）

我有一个数字数组，我需要确保它们是唯一的。我在互联网上找到了下面的代码片段，它非常有效，直到数组中有一个零为止。我发现这里的堆栈溢出看起来几乎完全一样，但它并没有失败

所以为了帮助我学习，有人能帮我确定原型脚本哪里出了问题吗

Array.prototype.getUnique = function() {
 var o = {}, a = [], i, e;
 for (i = 0; e = this[i]; i++) {o[e] = 1};
 for (e in o) {a.push (e)};
 return a;
}

重复问题的更多答案：

类似问题：

---

这是因为

0

在JavaScript中是一个虚假的值

如果数组的值为0或任何其他falsy值，则此[i]

将为falsy。

array.prototype.getUnique=function（）{
Array.prototype.getUnique = function() {
    var o = {}, a = []
    for (var i = 0; i < this.length; i++) o[this[i]] = 1
    for (var e in o) a.push(e)
    return a
}

变量o={}，a=[]
对于（var i=0；i

如果您使用的是Prototype framework，则无需执行“for”循环，您可以这样使用：

var a = Array.uniq();  

var a = Array.compact().uniq();  

const uniqArray = array.filter((obj, idx, arr) => (
  arr.findIndex((o) => o.id === obj.id) === idx
)) 

a.filter((item, pos, self) => self.indexOf(item) === pos);

const a = [
 { age: 4, name: 'fluffy' },
 { age: 5, name: 'spot' },
 { age: 2, name: 'fluffy' },
 { age: 3, name: 'toby' },
];

这将生成一个没有重复项的重复数组。我在搜索一种方法来计算不同的数组记录时遇到了你的问题
uniq（）
我曾经
大小（）
这就是我的简单结果。 p、 对不起，如果我打错了什么
编辑：如果要转义未定义的记录，可能需要添加
紧凑的
以前，像这样：

var a = Array.uniq();  

var a = Array.compact().uniq();  

const uniqArray = array.filter((obj, idx, arr) => (
  arr.findIndex((o) => o.id === obj.id) === idx
)) 

a.filter((item, pos, self) => self.indexOf(item) === pos);

const a = [
 { age: 4, name: 'fluffy' },
 { age: 5, name: 'spot' },
 { age: 2, name: 'fluffy' },
 { age: 3, name: 'toby' },
];

您也可以使用

console.log（q.uniq（[1,2,1,3,1,4]）
我找到了一个使用jQuery的好方法

arr = $.grep(arr, function(v, k){
    return $.inArray(v ,arr) === k;
});

注意：这个代码是从中提取出来的-我忘了给积分：p
这个原型
getUnique
不是完全正确的，因为如果我有一个数组，比如：
[“1”，1,2,3,4,1，“foo”]
它将返回
[“1”，“2”，“3”，“4”]
，
“1”是字符串，
1
是整数；他们是不同的

下面是一个正确的解决方案：

Array.prototype.unique = function(a){
    return function(){ return this.filter(a) }
}(function(a,b,c){ return c.indexOf(a,b+1) < 0 });

上述操作将生成
[“1”、2、3、4、1、“foo”]
使用JavaScript 1.6/ECMAScript 5，您可以通过以下方式使用数组的本机方法来获取具有唯一值的数组：


函数onlyUnique（值、索引、自身）{
返回self.indexOf（value）==索引；
}
//用法示例：
变量a=['a'，1'，a'，2'，1']；
var unique=a.过滤器（仅限YUNIQUE）；
console.log（唯一）；//['a'，1，2，'1']
如果不扩展Array.prototype（据说这是一种不好的做法）或使用jquery/下划线，您可以简单地
过滤数组

通过保留最后一个事件：

    function arrayLastUnique(array) {
        return array.filter(function (a, b, c) {
            // keeps last occurrence
            return c.indexOf(a, b + 1) < 0;
        });
    },

    function arrayFirstUnique(array) {
        return array.filter(function (a, b, c) {
            // keeps first occurrence
            return c.indexOf(a) === b;
        });
    },

嗯，这只是javascript ECMAScript 5+，也就是说只有IE9+，但是对于原生HTML/JS（Windows应用商店应用程序、Firefox操作系统、Sencha、Phonegap、Tianium等）的开发来说很好。
我不确定Gabriel Silveira为什么要这样编写函数，但一个同样适用于我且没有缩小的简单形式是：

Array.prototype.unique = function() {
  return this.filter(function(value, index, array) {
    return array.indexOf(value, index + 1) < 0;
  });
};

Array.prototype.unique=function（）{
返回此.filter（函数（值、索引、数组）{
返回数组.indexOf（值，索引+1）<0；
});
};

或者用咖啡脚本：

Array.prototype.unique = ->
  this.filter( (value, index, array) ->
    array.indexOf(value, index + 1) < 0
  )

Array.prototype.unique=->
this.filter（（值、索引、数组）->
数组.indexOf（值，索引+1）<0
)
这里的许多答案对初学者可能没有用处。如果阵列的重复数据消除很困难，那么他们真的知道原型链，甚至jQuery吗

在现代浏览器中，一个干净而简单的解决方案是将数据存储在一个数据库中，该数据库设计为一个唯一值列表


const cars=[‘沃尔沃’、‘吉普’、‘沃尔沃’、‘林肯’、‘林肯’、‘福特’]；
const uniqueCars=Array.from（新集合（cars））；
控制台日志（uniqueCars）最简单的方法（在Chrome中）：

Array.prototype.unique = function() {
    var a = [];
    for (var i=0, l=this.length; i<l; i++)
        if (a.indexOf(this[i]) === -1)
            a.push(this[i]);
    return a;
}

Array.prototype.unique=function（）{
var a=[]；
对于（var i=0，l=this.length；iES6的最短解：
[…新集合（[1,1,2]）；

或者，如果要修改阵列原型（如原始问题中所示）：

EcmaScript 6目前仅在现代浏览器中使用（2015年8月），但在将ES6（甚至ES7）传输回ES5方面已经非常流行。这样，您现在就可以编写ES6代码了

如果您想知道
…
是什么意思，那么它被称为.From:«扩展运算符允许在需要多个参数（用于函数调用）或多个元素（用于数组文本）的地方扩展表达式»。因为集合是一个iterable（并且只能有唯一的值），扩展运算符将展开集合以填充数组

学习ES6的资源：


Axel Rauschmayer博士
来自JS每周时事通讯
来自Mozilla黑客博客
仅限性能！此代码可能比此处的所有代码快10倍*适用于所有浏览器，并且对内存的影响最低。。。。
还有更多

如果您不需要重用旧阵列，顺便说一句，在将其转换为unique之前，请执行其他必要的操作。这里可能是实现这一点的最快方法，也非常简单

var array=[1,2,3,4,5,6,7,8,9,0,1,2,1];

那你可以试试这个


var数组=[1,2,3,4,5,6,7,8,9,0,1,2,1]；
函数toUnique（a，b，c）{//数组，占位符，占位符
b=a.长度；
而（c=--b）
而（c--）a[b]！==a[c]| a.拼接（c，1）；
返回//不需要；）
}
log（toUnique（数组））；
//[3,4,5,6,7,8,9,0,2,1]
[“缺陷”、“总数”、“天数”、“城市”、“缺陷”]。减少（功能（上、当前）{
返回（上一个索引值（当前值）<0）？上一个concat（[cur]）：上一个；
}, []);
[0,1,2,0,3,2,1,5].减少（函数（上、下）{
返回（上一个索引值（当前值）<0）？上一个concat（[cur]）：上一个；
}, []);
ES6/ES2015的更新答案：使用and（谢谢），单线解决方案是：

let uniqueItems = [...new Set(items)]

返回

[4, 5, 6, 3, 2, 23, 1]

用simple方法寻找唯一数组值

function arrUnique(a){
  var t = [];
  for(var x = 0; x < a.length; x++){
    if(t.indexOf(a[x]) == -1)t.push(a[x]);
  }
  return t;
}
arrUnique([1,4,2,7,1,5,9,2,4,7,2]) // [1, 4, 2, 7, 5, 9]

函数arrUnique（a）{
var t=[]；
对于（变量x=0；xfunction uniqueArray1( ar ) {
  var j = {};

  ar.forEach( function(v) {
    j[v+ '::' + typeof v] = v;
  });

  return Object.keys(j).map(function(v){
    return j[v];
  });
} 

function uniqueArray2(arr) {
    var a = [];
    for (var i=0, l=arr.length; i<l; i++)
        if (a.indexOf(arr[i]) === -1 && arr[i] !== '')
            a.push(arr[i]);
    return a;
}

function uniqueArray3(a) {
  function onlyUnique(value, index, self) { 
      return self.indexOf(value) === index;
  }

  // usage
  var unique = a.filter( onlyUnique ); // returns ['a', 1, 2, '1']

  return unique;
}

function uniqueArray4(a) {
  return [...new Set(a)];
}

const uniqArray = array.filter((obj, idx, arr) => (
  arr.findIndex((o) => o.id === obj.id) === idx
)) 

npm install lodash

import _ from 'lodash';
let idArray = _.uniq ([
    1,
    2,
    3,
    3,
    3
]);
console.dir(idArray);

[ 1, 2, 3 ]

a.filter(e=>!(t[e]=e in t)) 

[...new Set(duplicates)]

const numbers = [2,3,4,4,2,3,3,4,4,5,5,6,6,7,5,32,3,4,5]
console.log([...new Set(numbers)]) // [2, 3, 4, 5, 6, 7, 32]

a.filter((item, pos, self) => self.indexOf(item) === pos);

const a = [
 { age: 4, name: 'fluffy' },
 { age: 5, name: 'spot' },
 { age: 2, name: 'fluffy' },
 { age: 3, name: 'toby' },
];

a.filter((item, pos, self) => self.findIndex(v => v.name === item.name) === pos);

const array = [1, 1, 2, 2, 3, 5, 5, 2];
const uniqueArray = [...new Set(array)];
console.log(uniqueArray); // [1, 2, 3, 5]