Javaｓｃｒｉｐｔ实现数组权重删除的多种方法

不要说太多，直接拿干货！

首先讨论这个例子的要求：编写一个方法来实现数组的权重（要求：执行方法，传递数组，重新加载后返回新数组。原始数组不变。在实现过程中只能使用一层循环，也可以编写两层嵌套循环，仅供参考）。

首先，对初学者解释一下什么叫做阵列重量（意味着说：老鸟跳过）重复的元素删除阵列，例如var arr = { 3,2,4,2,1,2 }；新阵列得到{ 3,2,4,1 }，就是这样的一个功能。

实现方法比较简单，实现的途径很多。许多丹尼尔也写了相关文章。写这个博客的目的是备忘录，和两个是给初学者更好的理解其实现原理。

第一步，遍历一个新数组来运行。

var arr = { 1，B，B，4,3,3,4,5,1 }；

第一个
array.prototype.unique1 =函数（）{
VaR arr1 = {}； / /定义一个新的数组
对于（var i = 0；i < this.length；i++）{
如果（arr1.indexof（这{我}）= 1）{ / /判断存在原始阵列目标阵列
（这arr1.push {我}）；
}
}
返回前；
}
console.log（ARR）； / / { 1，B，B，4,3,3,4,5,1 }
console.log（arr.unique1（））； / / { 1、B
这种方法的主要思想是，一个新数组，然后在原始数组中，从第一个数组开始，查看新数组中的元素，如果有，则忽略，然后继续到下一个数组，如果没有，则将该存款放到新的数组元素中，
也就是说，每次都遍历新数组，直到找到相同的元素，消耗性能比较。
如果你不习惯这篇文章，你可以把它改成下面的文字，效果是一样的。
var arr = { 1，B，B，4,3,3,4,5,1 }；

功能unique1（ARR）{
VaR arr1 = { }；
对于（var i = 0；i < arr.length；i++）{
如果（arr1.indexof（ARR {我}）= 1）{ / /判断存在原始阵列目标阵列
arr1.push（ARR {我}）；
}
}
返回前；
}
console.log（ARR）； / / { 1，B，B，4,3,3,4,5,1 }
console.log（unique1（ARR））； / / { 1、B

我不会改变以下方式。你可以用上面的格式重写它，我不会输出结果，因为结果是一样的，注释写在代码中，我会慢慢理解它。

其次，通过哈希表（这个概念有点大，具体的原则这里不是细节，我会有时间再写一遍，这是很好的东西实现）
var arr = { 1，B，B，4,3,3,4,5,1 }；

array.prototype.unique2 =函数（）{
var哈希= }；哈希表定义
VaR arr1 = {}； / /定义一个新的数组
对于（var i = 0；i < this.length；i++）{
*
很难理解。我们一步一步看它。
哈希是一个对象，并且有一个键值对（key：value），但现在它是空的，所以哈希{ } = value = value；
第一步：i = 0；这个{ } =这个{ 0 } = 1；散列{此{ 0 } } =哈希{ 1 }，因为初始散列为空，未找到键= 1的值，所以未定义，
下一步：散列{ 1 } =真（此时哈希对象具有第一组键值），将原始数组的第一个数添加到新数组中，并重复第一步
因为哈希值不重复，所以值都是未定义的，并且重复是真的，因此不会在新数组中添加重复。
因为哈希表的值是存储在堆内存中的地址，所以有许多元素是不重复的。它需要被分成若干个存储器来存储。所以这个方法占用了更多的内存，但是相比之下，这个操作是最快的。
这是利用空间的时间，数据量相对较小，建议使用这种方法。
* /
如果（！散列{此{ } }）{
哈希{此} =真的；
（这arr1.push {我}）；
}
}
返回前；
}
console.log（ARR）；
console.log（arr.unique2（））；
第三，通过遍历自身位置的一致性来实现
var arr = { 1，B，B，4,3,3,4,5,1 }；

array.prototype.unique3 =函数（）{
VaR arr1 = {}； / /定义一个新的数组
对于（var i = 0；i < this.length；i++）{
如果（this.indexof（这{我}）= =我）{
/ /这里是索引遍历，看到从第一个元素的数组的原始位置，如果第一次发生下标元素的地位是平等的，表明当前不重复，如果前面的范围，已经有元素
（这arr1.push {我}）；
}
}
返回前；
}
console.log（ARR）；
console.log（arr.unique3（））；
第四个，这有点有趣，只能应用于一个特殊的场合，即先对数组进行排序，然后比较22个数组，然后输出一组新的排序。
array.prototype.unique4 =函数（）{
*
这是第一种排序（从小到大的默认值），然后是原始数组的第一个数组。
因为它被排序，重复只存在于相邻位置。
这相当于做了22个比较。如果相等，则继续到下一个组，如果不相等，则将这个数字存储在新数组中，并将其与这个数字进行比较。
* /
This.sort（）；
VaR arr1 = { { 0 } }；
对于（var i = 1；i < this.length；i++）{
如果（{ { }）！= arr1 {前。length-1 }）{
（这arr1.push {我}）；
}
}
返回前；
}
console.log（ARR）；
console.log（arr.unique4（））；
哇，结束了！

需求还说，您可以使用双层嵌套循环，并且不能使用循环的2层使每一层与原始数组进行比较。
array.prototype.unique5 =函数（）{
/双循环比较。
对于（var i = 0；i < this.length；i++）{ / /从0开始
为（j = i + 1；J < this.length；j++）{ / /从1年初开始，通过比较
如果（这个{这个} =这个{ }）如果常量
this.splice（J，1）； / /会删除该元素
}
}
}
返回此；
}
console.log（ARR）；
console.log（arr.unique5（））；
有太多的周期要写。这是不推荐的。有人会说第一和第三种每次都不通过吗它们与第五种感官相似，是的，你可以理解这种方式，这意味着你理解，但它不太明白。我们说这太糟糕了。indexOf（）意味着找到第一个匹配的元素。

停止遍历，第五个是你是否能找到它。它将穿过整个阵列。如果数据很大，你认为哪个性能更好

特别注意：如果22个值之间的比较是一致的或不相等的，则必须使用常数和常数（（= =））！= =），因为它涉及的元素的类型，如1和'1'are不相同！

以上是真正干货，一点水也不行，只能靠大家自己的理解！