我已经提出了三种算法来实现这个目标：
array.prototype.unique1 =功能（）
{
新的临时数组
对于（var i = 0；i < this.length； / /我+ +）当前数组的遍历
{
如果当前数组已保存到临时数组中，则跳过，
否则将推送到临时数组中。
If (n.indexOf (this{i}) = -1 n.push (this{i}));
}
返回N；
}
array.prototype.unique2 =功能（）
{
用于临时数组的var、{ = }、r = {、}、n、n、r
对于（var i = 0；i < this.length； / /我+ +）当前数组的遍历
{
如果（{这个{ } }！）如果哈希表中没有当前项
{
在哈希表中，这个{ } = true；
R.push（本{我}）； / /投入临时阵列电流推力电流阵列
}
}
返回R；
}
array.prototype.unique3 =功能（）
{
{此{ 0 } }；数组结果
对于（var i = 1；i < this.length； / /我+ +）从第二导线
{
如果我第一次出现在数组中当前位置的当前数组不是i，
因此，重复i，忽略，否则，保存结果数组。
如果（this.indexof（这{我}）=我n.push（这{我}））；
}
返回N；
}
这些第一和第三是用数组中的索引的方法。这种方法的目的是在阵列的输入参数的第一次出现的位置。很显然，JS引擎遍历数组直到目标被发现时，它的实现。所以这个功能会浪费很多时间和方法2用在哈希表中。放在下标的形式已经存在为对象的下标引用数组的索引比搜索要快得多。
为了确定这三种方法的效率，我做了一个测试程序生成10000个随机数的数组的长度，然后用几种方法测试的执行时间。结果表明，二方法比其他两种方法快得多。但应该超过内存占用二方法，因为有一个哈希表，这是所谓的空间时间。这是测试页面，你可以去看看。
根据HPL丹尼尔的想法，我写的第四种方式：
array.prototype.unique4 =功能（）
{
This.sort（）；
var {此{ 0 } }；
对于（var i = 1；i < this.length；i++）
{
如果（{ { }）！=重新{重新length-1 }）。
{
Re.push（本{我}）；
}
}
重新回归；
}
该方法的基本思想是对数组的排序第一和比较相邻的两值。JS机排序方法排序时，JS引擎应使用快速排序，最后的测试结果，该方法的平均运行时间约为三倍，第二方法，但它比第一和第三快多了。
第五方法
最近的搜索历史，{ }的函数也使用，和IndexOf方法已被使用，这是支持的和不支持IE8 ecma5—。
我们可以自己编写函数（数组对象在原型对象上定义的方法），如下所示：
array.prototype.unique =函数（）{
VaR的长度= this.length；
如果（长度< = 1）{
返回此；
}
如果（！阵列。原型。指标）{
array.prototype.indexof =功能（项目）{
var = this.length，i = 0，r = 1；
如果（l = 0）{
返回- 1；
}
为（；；i；<；i +；+）{
如果（这个{ = } =项）{
r = i；
}
}
返回R；
}
}
数组的var
对于（var i = 0；i <长度；i + +）{
如果（result.indexof（这{我}）= 1）{
Result.push（本{我}）；
}
}
返回结果；
}
第六方法
数组类型不能提供重复的方法，如果您想清除数组的重复元素，您必须考虑它。
功能独特（ARR）{
var result = { }，重复；
对于（var i = 0，len = arr.length；我< len；i++）{
重复= false；
对于（var j = 0，len = result.length；J < len；j++）{
如果（ARR {我} = =结果{ J }）{
重复=真；
打破；
}
}
如果（！重复）{
result.push（ARR {我}）；
}
}
返回结果；
}
总的思路是将数组中的元素到另一个数组，并检查元件是否是反复的过程，如果有一个直接的损失。你可以看到从嵌套循环，这种方法是非常低效的，我们可以使用一个哈希表的结构来记录存在的元素，因此，内循环是可以避免的。
