js数组去重的5种方法,js中怎么把数组中重复的数据取出来

js数组去重的5种方法,js中怎么把数组中重复的数据取出来详细介绍

本文目录一览： JS删除数组重复元素有哪些方法

这次给大家带来JS删除数组重复元素有哪些方法，JS删除数组重复元素的注意事项有哪些，下面就是实战案例，一起来看一下。 这里就 js 如何实现数组去重整理出5种方法，并附上演示Demo 以及 源码。 1.遍历数组法 最简单的去重方法， 实现思路：新建一新数组，遍历传入数组，值不在新数组就加入该新数组中；注意点：判断值是否在数组的方法“indexOf”是ECMAScript5 方法，IE8以下不支持，需多写一些兼容低版本浏览器代码，源码如下：// 最简单数组去重法function unique1(array){ var n = []; //一个新的临时数组 //遍历当前数组 for(var i = 0; i < array.length; i++){ //如果当前数组的第i已经保存进了临时数组，那么跳过， //否则把当前项push到临时数组里面 if (n.indexOf(array[i]) == -1) n.push(array[i]); } return n;}// 判断浏览器是否支持indexOf ，indexOf 为ecmaScript5新方法 IE8以下（包括IE8， IE8只支持部分ecma5）不支持if (!Array.prototype.indexOf){ // 新增indexOf方法 Array.prototype.indexOf = function(item){ var result = -1, a_item = null; if (this.length == 0){ return result; } for(var i = 0, len = this.length; i < len; i++){ a_item = this[i]; if (a_item === item){ result = i; break; } } return result; }} 2.对象键值对法 该方法执行的速度比其他任何方法都快， 就是占用的内存大一些； 实现思路：新建一js对象以及新数组，遍历传入数组时，判断值是否为js对象的键，不是的话给对象新增该键并放入新数组。注意点： 判断是否为js对象键时，会自动对传入的键执行“toString()”，不同的键可能会被误认为一样；例如： a[1]、a["1"] 。解决上述问题还是得调用“indexOf”。// 速度最快， 占空间最多（空间换时间）function unique2(array){ var n = {}, r = [], len = array.length, val, type; for (var i = 0; i < array.length; i++) { val = array[i]; type = typeof val; if (!n[val]) { n[val] = [type]; r.push(val); } else if (n[val].indexOf(type) < 0) { n[val].push(type); r.push(val); } } return r;} 3.数组下标判断法 还是得调用“indexOf”性能跟方法1差不多， 实现思路：如果当前数组的第i项在当前数组中第一次出现的位置不是i，那么表示第i项是重复的，忽略掉。否则存入结果数组。function unique3(array){ var n = [array[0]]; //结果数组 //从第二项开始遍历 for(var i = 1; i < array.length; i++) { //如果当前数组的第i项在当前数组中第一次出现的位置不是i， //那么表示第i项是重复的，忽略掉。否则存入结果数组 if (array.indexOf(array[i]) == i) n.push(array[i]); } return n;} 4.排序后相邻去除法 虽然原生数组的”sort”方法排序结果不怎么靠谱，但在不注重顺序的去重里该缺点毫无影响。 实现思路：给传入数组排序，排序后相同值相邻，然后遍历时新数组只加入不与前一值重复的值。// 将相同的值相邻，然后遍历去除重复值function unique4(array){ array.sort(); var re=[array[0]]; for(var i = 1; i < array.length; i++){ if( array[i] !== re[re.length-1]) { re.push(array[i]); } } return re;} 5.优化遍历数组法 源自外国博文，该方法的实现代码相当酷炫； 实现思路：获取没重复的最右一值放入新数组。（检测到有重复值时终止当前循环同时进入顶层循环的下一轮判断）// 思路：获取没重复的最右一值放入新数组function unique5(array){ var r = []; for(var i = 0, l = array.length; i < l; i++) { for(var j = i + 1; j < l; j++) if (array[i] === array[j]) j = ++i; r.push(array[i]); } return r;}相信看了本文案例你已经掌握了方法，更多精彩请关注Gxl网其它相关文章！推荐阅读：用laravel5.3 vue做出收藏夹功能vue.js的数据传递与数据分发步骤详解

js中数组去重方法总结

1.es6有了Set，可以通过成员唯一性去重

2.使用数组对象的lastIndexOf()方法。
(关于lastIndexOf():( https://www.jianshu.com/p/d75886bc6c75 )

3.定义新数组，存入原数组第一个元素，再将原数组元素和新数组元素比较，不同的继续push到新数组。

4.splice()方法从数组中添加/删除重复值。

5.使用includes()方法{ps:可搭配foreach()方法||filter()方法;}。

6.采用indexOf()获取索引查询去重

7.利用对象属性存在与否判断，这个方法没什么意思，但是也可行

js数组去重常见的七种方法

直接给一个新的数组里面，利用es6的延展运算符

filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。item是当前元素的值，index是当前元素的索引值。indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置。利用indexOf() 查询到数组的下标，看是否等于当前的下标，相等的话就返回，否则不返回值。

5、借助新数组 通过 indexOf 方法判断当前元素在数组中的索引，如果与循环的下标相等则添加到新数组中

6、利用双重for循环

7、利用includes实现数组去重

以上就是比较常用的七种方法了，有不懂的留言吧。

js实现数组去重的几种方法总结

方法一：双层循环，外层循环元素，内层循环时比较值如果有相同的值则跳过，不相同则push进数组Array.prototype.distinct = function(){var arr = this, result = [], i, j, len = arr.length;for(i = 0; i < len; i++){for(j = i + 1; j < len; j++){if(arr[i] === arr[j]){ j = ++i; } } result.push(arr[i]); }return result;}var arra = [1,2,3,4,4,1,1,2,1,1,1];arra.distinct(); //返回[3,4,2,1]方法二：利用splice直接在原数组进行操作双层循环，外层循环元素，内层循环时比较值值相同时，则删去这个值注意点:删除元素之后，需要将数组的长度也减1.Array.prototype.distinct = function (){var arr = this, i, j, len = arr.length;for(i = 0; i < len; i++){for(j = i + 1; j < len; j++){if(arr[i] == arr[j]){ arr.splice(j,1); len--; j--; } } }return arr;};var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,];var b = a.distinct();console.log(b.toString()); //1,2,3,4,5,6,56优点：简单易懂缺点：占用内存高，速度慢方法三：利用对象的属性不能相同的特点进行去重Array.prototype.distinct = function (){var arr = this, i, obj = {}, result = [], len = arr.length;for(i = 0; i< arr.length; i++){if(!obj[arr[i]]){ //如果能查找到，证明数组元素重复了obj[arr[i]] = 1; result.push(arr[i]); } }return result;};var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,];var b = a.distinct();console.log(b.toString()); //1,2,3,4,5,6,56方法四：数组递归去重运用递归的思想先排序，然后从最后开始比较，遇到相同，则删除Array.prototype.distinct = function (){var arr = this, len = arr.length; arr.sort(function(a,b){ //对数组进行排序才能方便比较return a - b; })function loop(index){if(index >= 1){if(arr[index] === arr[index-1]){ arr.splice(index,1); } loop(index - 1); //递归loop函数进行去重 } } loop(len-1);return arr;};var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,56,45,56];var b = a.distinct();console.log(b.toString()); //1,2,3,4,5,6,45,56方法五：利用indexOf以及forEachArray.prototype.distinct = function (){var arr = this, result = [], len = arr.length; arr.forEach(function(v, i ,arr){ //这里利用map，filter方法也可以实现var bool = arr.indexOf(v,i+1); //从传入参数的下一个索引值开始寻找是否存在重复if(bool === -1){ result.push(v); } })return result;};var a = [1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,3,3,3,2,3,3,2,2,1,23,1,23,2,3,2,3,2,3];var b = a.distinct();console.log(b.toString()); //1,23,2,3方法六：利用ES6的setSet数据结构，它类似于数组，其成员的值都是唯一的。利用Array.from将Set结构转换成数组function dedupe(array){return Array.from(new Set(array));}dedupe([1,1,2,3]) //[1,2,3]拓展运算符(...)内部使用for...of循环let arr = [1,2,3,3];let resultarr = [...new Set(arr)]; console.log(resultarr); //[1,2,3]

JavaScript数组去重的几种方法分享

数组去重，一般需求是给你一个数组，调用去重方法，返回数值副本，副本中没有重复元素。一般来说，两个元素通过 === 比较返回 true 的视为相同元素，需要去重，所以，1 和 "1" 是不同的元素，1 和 new Number(1) 是不同的元素，{} 和 {} 是不同的元素（引用不同）。（当然如果需求认为 {} 和 {} 算作相同的元素，那么解法就不一样了），本文主要和大家分享JavaScript数组去重的几种方法。method 1使用两重循环function unique(arr) { var res = []; for(var i = 0, len = arr.length;i < len; i++) { var item = arr[i]; for(var j = 0, jLen = res.length; j
<jlen; j++) { if(item="=" res[j]) break; } if(j="=" jlen) res.push(item); return res;}method 2function unique(arr) var ret="[];" for (var i < arr.length; i++) item="arr[i];" if (ret.indexof(item)="==" -1) ret.push(item) ret}这里判断可以使用一个语法糖function res="[];" for(var len="a.length;" len; (res.indexof(item)="==" && res;}但是在低版本浏览器并没有 indexofvar indexof="[].indexOf" ? function(arr, item)="==" arr.indexof(item) : function indexof(arr, (arr[i]="==" -1 }function (indexof(ret, ret}method3使用两重循环的另外一种比较方式,前面是将原数组的元素和结果数组一一比较，下面我们可以将原数组的重复元素的最后一个元素放入数组中function isrepeat; i<len; isrepeat="true;" j="i" j<len; if(arr[i]="==" arr[j]){ if(!isrepeat){ ret.push(arr[i]); ret;}这里还有一个优化的版本function unique(a) + 1; 这一步十分巧妙 如果发现相同元素 则 自增进入下一个循环比较 (a[i]="==" a[j]) = res.push(a[i]); res;}method4用 javascript 中的 object 对象来当作 哈希表function dedup(arr) hashtable="{};" arr.filter(function(value,index,arr){ key="typeof(item)" match="Boolean(hashTable[key]);" (match false hashtable[key]="true);" });}因为 的 值都是 string 类型，所以对于 1 和 "1" 无法分别，我们可以稍微改进下，将类型也存入 中function hash="{};" item; if(hash[key] !="=" 1) hash[key]="1;" ret;}

Js中去除数组中重复元素的几种方法

方法1：
[js] view plain copy
Array.prototype.method1 = function(){
var arr[]; //定义一个临时数组
for(var i = 0; i < this.length; i++){ //循环遍历当前数组
//判断当前数组下标为i的元素是否已经保存到临时数组
//如果已保存，则跳过，否则将此元素保存到临时数组中
if(arr1.indexOf(this[i]) == -1){
arr.push(this[i]);
}
}
return arr;
}
方法2：
[js] view plain copy
Array.prototype.method2 = function(){
var h{}; //定义一个hash表
var arr[]; //定义一个临时数组
for(var i = 0; i < this.length; i++){ //循环遍历当前数组
//对元素进行判断，看是否已经存在表中，如果存在则跳过，否则存入临时数组
if(!h[this[i]]){
//存入hash表
h[this[i]] = true;
//把当前数组元素存入到临时数组中
arr.push(this[i]);
}
}
return arr;
}
方法3：
[js] view plain copy
Array.prototype.method3 = function(){
//直接定义结果数组
var arr[this[0]];
for(var i = 1; i < this.length; i++){ //从数组第二项开始循环遍历此数组
//对元素进行判断：
//如果数组当前元素在此数组中第一次出现的位置不是i
//那么我们可以判断第i项元素是重复的，否则直接存入结果数组
if(this.indexOf(this[i]) == i){
arr.push(this[i]);
}
}
return arr;
}
方法4：
[js] view plain copy
Array.prototype.method4 = function(){
//将数组进行排序
this.sort();
//定义结果数组
var arr[this[0]];
for(var i = 1; i < this.length; i++){ //从数组第二项开始循环遍历数组
//判断相邻两个元素是否相等，如果相等说明数据重复，否则将元素写入结果数组
if(this[i] !== arr[arr.length - 1]){
arr.push(this[i]);
}
}
return arr;
}

JavaScript数组去重的几种方法

前言有时候我们做项目的时候往往会需要把数组里面一些重复的项去掉，但是原生JS有排序，有筛选等等，但是就是没有数组去重怎么办呢？这能怎么办，自己手动实现嘛。数组不像对象和hash有唯一的标志特征(key)。所以，数组去重的核心就是【1】数组内元素互相比较，然后放入新的数组中。【2】参照对象构建一个唯一的特征标志，然后放入新数组中。以下就是依照这种思路产生的方法。【3】数组中含对象的去重方式我采用使用JSON.stringify()将对象转换成JSON字符串进行比较的方式。1.最基础的去重：双重遍历双重遍历的核心就是依据【1】，通过拿出一个元素和剩下的元素依次比较，如果全部不相等则证明此元素为唯一。let a=[{a:1},{b:2},{c:3},{a:1},{d:2}]let c=[1,2,3,4,5,6,1,2,3]function unique(arr){ let b=[] for(let i=0;i
<arr.length;i++){ let unexit="true" for(let j="i+1;j<arr.length;j++){" if(json.stringify(arr[i])="==JSON.stringify(arr[j])){" break } else{ if(unexit){ b.push(arr[i]) return b}关于数组中存在对象，是采用json.stringify()转换成json字符串进行的比较，后续不再叙述。双重遍历的缺点是复杂度太高。上面的代码去重得到的结果的顺序会改变，所以如果想要顺序按照原有顺序，数组在进行去重时建议重新申明一个新的数组（var new="old.reverse()" ）得到一个新的相反的数组，最后再使用reverse()。之所以新建数组而不是直接取反是因为：reverse()会修改原数组。2.array.prototype.sort()：相邻元素去重相邻元素去重的核心在于array.sort()能够对数组进行排序。这样相等的数组就会在相邻的位置，通过比较相邻的元素就可以起到去重的作用【1】。let c="[1,2,3,4,5,6,1,2,3]function" unique(arr){ arr="arr.sort()" b="[]" i="0;i
{a.key-b.ky})进行对象的排序，前提是数组中的对象存在相同的key值。3.Object.keys()：存在唯一性在一个对象里面key值是唯一的，所以通过遍历数组给每个数组一个标志，通过标志去重【2】let a=[{a:1},{b:2},{c:3},{a:1},{d:2}]let c=[1,2,3,4,5,6,1,2,3]function unique(arr){ let b=[] let hash={} for(let i=0;i
<arr.length;i++){ if(!hash[json.stringify(arr[i])]){ hash[json.stringify(arr[i])]="true" b.push(arr[i]) } return b}4.双重遍历去重改良之：indexof双重遍历的思路我们都知道，先拿出一个元素，然后使用循环再次遍历数组去一一比较。如果有一个方式能够让我们不再遍历一遍数组，那么复杂度相对而言会减少一点。indexof 方法返回给定元素在数组中第一次出现的位置，如果没有出现则返回-1。首先我们新建一个空数组(arry)，如果：arry.indexof(数组元素)="==-1，那么我们就可以知道arry中不存在元素。let" c="[1,2,3,4,5,6,1,2,3]function" unique(arr){ let b="[]" for(let i="0;i
{ if(b.indexOf(res)==-1){ b.push(res) } }) return b}6.ES6：Set数据结构Set数据类似于数组，但是成员的值都是唯一的，没有重复的值。它可以接收一个数组，类于：let a=[1,2,3,1,2] Set(a)=>1,2,3 所以可以使用Set()实现去重。let c=[1,2,3,4,5,6,1,2,3]function unique(arr){ let b=new Set(arr) let c=Array.from(b) return c}Set去重不适用于含对象的数组，因为Set的去重参照的是（===），数组中的元素对象，虽然可能数值相等，但是地址不相等。所以Set无法实现去重。7.总结实现数组的去重，要么通过元素对比，要么设置特殊标志识别。元素对比的思路有2种：一种是和原数组一一对比；另一种和新的数组对比。如果要实现含对象的数组去重，一般使用遍历的方式，包括使用遍历类的方法(map、forEach、reduce等)。像Set、sort等通过改变数组的方式一般是不可行的。好了，

JS数组去重的几种常见方法

js 数组去重
1
注：应该也可以适用于 object数组，但是本人没有进行验证，贴出来仅供你参考
第一种是比较常规的方法思路：1.构建一个新的数组存放结果2.for循环中每次从原数组中取出一个元素，用这个元素循环与结果数组对比3.若结果数组中没有该元素，则存到结果数组中代码如下:
Array.prototype.unique1 = function(){ var res = [this[0]]; for(var i = 1; i < this.length; i++){ var repeat = false; for(var j = 0; j < res.length; j++){ if(this[i] == res[j]){ repeat = true; break; } } if(!repeat){ res.push(this[i]); } } return res;}var arr = [1, 'a', 'a', 'b', 'd', 'e', 'e', 1, 0]alert(arr.unique1());
第二种方法比上面的方法效率要高思路：1.先将原数组进行排序2.检查原数组中的第i个元素 与 结果数组中的最后一个元素是否相同，因为已经排序，所以重复元素会在相邻位置3.如果不相同，则将该元素存入结果数组中代码如下：
Array.prototype.unique2 = function(){ this.sort(); //先排序 var res = [this[0]]; for(var i = 1; i < this.length; i++){ if(this[i] !== res[res.length - 1]){ res.push(this[i]); } } return res;}var arr = [1, 'a', 'a', 'b', 'd', 'e', 'e', 1, 0]alert(arr.unique2());
二种方法也会有一定的局限性，因为在去重前进行了排序，所以最后返回的去重结果也是排序后的。如果要求不改变数组的顺序去重，那这种方法便不可取了。第三种方法（推荐使用）思路：1.创建一个新的数组存放结果2.创建一个空对象3.for循环时，每次取出一个元素与对象进行对比，如果这个元素不重复，则把它存放到结果数组中，同时把这个元素的内容作为对象的一个属性，并赋值为1，存入到第2步建立的对象中。说明：至于如何对比，就是每次从原数组中取出一个元素，然后到对象中去访问这个属性，如果能访问到值，则说明重复。代码如下：
Array.prototype.unique3 = function(){ var res = []; var json = {}; for(var i = 0; i < this.length; i++){ if(!json[this[i]]){ res.push(this[i]); json[this[i]] = 1; } } return res;}var arr = [112,112,34,'你好',112,112,34,'你好','str','str1'];alert(arr.unique3());

js中怎么把数组中重复的数据取出来

js数组中取重复数据的方法：
方法一：去重复数据

　　思路：定义一个空的新数组，然后循环目标数组，判断，新数组中是否包含循环的数据，如果不包含就放入新的数组。
　　代码示例：
var myArr = [1,2,3,3,4,5,6,6];var newArr = [];for(var s in myArr){ if(newArr.indexOf(myArr[s])<0){ newArr.push(myArr[s]); }}最终。newArr就是去重后的数据
把数组元素逐个搬运到另一个数组，搬运的过程中检查这个元素是否有重复，如果有就直接丢掉
function unique(arr) {
var result = [], isRepeated;
for (var i = 0, len1 = arr.length; i < len1; i++) {
isRepeated = false;
for (var j = 0, len = result.length; j < len; j++) {
if (arr[i] == result[j]) {
isRepeated = true;
break;
}
}
if (!isRepeated) {
result.push(arr[i]);
}
}
return result;
}
或者：
function unique(arr) {
var result = [], hash = {};
for (var i = 0, elem; (elem = arr[i]) != null; i++) {
if (!hash[elem]) {
result.push(elem);
hash[elem] = true;
}
}
return result;
}
var arr1=[5,6,3,7,6];
alert(unique(arr1));
第一种：
function unique(arr) {
var result = [], isRepeated;
for (var i = 0, len = arr.length; i < len; i++) {
isRepeated = false;
for (var j = 0, len = result.length; j < len; j++) {
if (arr[i] == result[j]) {
isRepeated = true;
break;
}
}
if (!isRepeated) {
result.push(arr[i]);
}
}
return result;
}
第二种：
function unique(arr) {
var result = [], hash = {};
for (var i = 0, elem; (elem = arr[i]) != null; i++) {
if (!hash[elem]) {
result.push(elem);
hash[elem] = true;
}
}
return result;
}
需要准备的材料分别是：电脑、html编辑器、浏览器。
1、首先，打开html编辑器，新建html文件，例如：index.html。
2、在index.html的标签中，输入js代码：
var a = [1, 6, 8, 5, 23, 6, 6, 7, 8], b = [], c = [];
for (var i = 0; i < a.length; i++) {
if (c.indexOf(a[i]) === -1) {
c.push(a[i]);
} else {
b.push(a[i]);
}
}
document.body.innerText = b;
3、浏览器运行index.html页面，此时会打印出数组a中重复的数据。