数组去重的方法,怎样用一个方法去掉一个数组的重复元素

数组去重的方法,怎样用一个方法去掉一个数组的重复元素详细介绍

本文目录一览： 数组去重的5种方法

数组去重的5种方法：
方法一：
双重for循环去重
原理 两两比较如果相等的话就删除第二个
例如: 1 1 1 3 2 1 2 4
先让第一个1 即arr[0]与后面的一个个比较 如果后面的值等于arr[0] 删除后面的值
第一次结束后的结果是 1 3 2 2 4 删除了后面所有的1
同理 第二次 第三会删除与自己相同的元素
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
function noRepeat1(arr){
// 第一层for用来控制循环的次数
for(var i=0; i
<arr.length; i++){
//第二层for 用于控制与第一层比较的元素

for(var j=i+1; j
<arr.length; j++){
//如果相等

if(arr[i] == arr[j]){

//删除后面的 即第 j个位置上的元素 删除个数 1 个

arr.splice(j,1);

// j--很关键的一步 如果删除 程序就会出错

//j--的原因是 每次使用splice删除元素时 返回的是一个新的数组

// 这意味这数组下次遍历是 比较市跳过了一个元素

/*

例如： 第一次删除后 返回的是 1 1 3 2 1 2 4

* 但是第二次遍历是 j的值为2 arr[2] = 3

* 相当于跳过一个元素 因此要 j--

* */

j--;

}

}

}

return arr;

}

方法二：

单层for循环

原理和方法一相似

1

2

3

4

5

6

7

8

9

10

11

12

13

function norepeat(arr){

arr.sort();

//先排序让大概相同的在一个位置，这里为什么说是大概相同 是因为sort排序是把元素当字符串排序的 它和可能排成 1 1 10 11 2 20 3 ... 不是我们想要的从小到大

for(var i = 0; i < arr.length-1;i++){

//还是两两比较 一样删除后面的

if(arr[i]==arr[i+1]){

arr.splice(i,1);

//i-- 和j--同理

i--;

}

}

return arr;

}

方法三：

原理：用一个空数组去存首次出现的元素

利用 indexOf 属性 indexOf是返回某个指定的字符在字符串中出现的位置，如果没有就会返回-1

因此我们可以很好的利用这个属性 当返回的是 -1时 就让其存入数组

1

2

3

4

5

6

7

8

9

function noRepeat2(arr){

var newArr = [];

for(var i = 0; i < arr.length; i++){

if(newArr.indexOf(arr[i]) == -1){

newArr.push(arr[i]);

}

}

return newArr;

}

方法四：

原理：利用对象的思想，如果对象里没有这个属性的话就会返回undefined

利用这个原理当返回的是undefined时让其放入数组然后在给这个属性赋值

1

2

3

4

5

6

7

8

9

10

11

function norepeat3(arr) {

var obj = {};

var newArr = [];

for(var i = 0; i < arr.length; i++) {

if(obj[arr[i]] == undefined) {

newArr.push(arr[i]);

obj[arr[i]] = 1;

}

}

return newArr;

}

方法五：

原理：循环比较如果相等的让后面的元素值为0，最后在输出的时候删除为0的这个前提是你的数据里不能有0，但是凡事可以变通你可以设置任何值替代这个0，这个方法是我当时想到实现的所以没有进行很好的优化。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

var newArr = [];

//控制外循环

for(var i=0; i
<arr.length-1;i++){
//内存循环 只比较后面的

for(j=i+1;j
<arr.length;j++){
//如果相等就让其值等于0

if(arr[i]==arr[j]){

arr[j]=0;

}

}

//去除值为0的

if(arr[i]==0){

continue;

}else{

//放入新的数组

newArr.push(arr[i]);

}

}

推荐教程：《PHP视频教程》

以上就是数组去重的5种方法有哪些？的详细内容，更多请关注php中文网其它相关文章！
</arr.length;j++){
</arr.length-1;i++){

数组的常用方法有哪些，如何给数组去重（附代码）

数组是JavaScript的重要组成部分，不管是工作还是求职面试都会涉及数组，比如经典问题：怎么给数组去重。今天就和大家聊聊，数组的常用方法有哪些，以及多种方式给数组去重。一、数组常用方法slice() 用于提取目标数组的一部分，返回一个新数组，原数组不变。concat() 用于多个数组的合并。它将新数组的成员，添加到原数组成员的后部，然后返回一个新数组，原数组不变。reverse() 用于颠倒排列数组元素，返回改变后的数组。注意，该方法将改变原数组。sort() 对数组成员进行排序，默认是按照字典顺序排序。排序后，原数组将被改变。push() 用于在数组的末端添加一个或多个元素，并返回添加新元素后的数组长度。注意，该方法会改变原数组。pop() 用于删除数组的最后一个元素，并返回该元素。注意，该方法会改变原数组。unshift() 用于在数组的第一个位置添加元素，并返回添加新元素后的数组长度。注意，该方法会改变原数组。shift() 用于删除数组的第一个元素，并返回该元素。注意，该方法会改变原数组。splice() 用于删除原数组的一部分成员，并可以在删除的位置添加新的数组成员，返回值是被删除的元素。注意，该方法会改变原数组。map() 将数组的所有成员依次传入参数函数，然后把每一次的执行结果组成一个新数组返回。forEach() 与map方法很相似，也是对数组的所有成员依次执行参数函数。但是，forEach方法不返回值，只用来操作数据。filter() 用于过滤数组成员，满足条件的成员组成一个新数组返回。join() 以指定参数作为分隔符，将所有数组成员连接为一个字符串返回。如果不提供参数，默认用逗号分隔。indexOf() 返回给定元素在数组中第一次出现的位置，如果没有出现则返回-1。lastIndexOf() 返回给定元素在数组中最后一次出现的位置，如果没有出现则返回-1。二、多种方式给数组去重1、利用对象function unique(arr) { var uniqueArr = [], len = arr.length for (var i = 0; i < len; i++) { if (uniqueArr.indexOf(arr[i]) == -1) { uniqueArr.push(arr[i]) } } return uniqueArr } var arr = [1, 2, 3, 1, 5, "1"] var uniqueArr = unique(arr) console.log(arr) //[1, 2, 3, 1, 5, "1"] c onsole.log(uniqueArr) //[ 1, 2, 3, 5, '1' ]2、排序后去重function unique(arr) { var uniqueArr = [], sortArr = arr.concat().sort(), len = sortArr.length, prev for (var i = 0; i < len; i++) { if (!i || prev !== sortArr[i]) { uniqueArr.push(sortArr[i]) } prev = sortArr[i] } return uniqueArr } var arr = [1, 2, 3, 1, 5, "1"] var uniqueArr = unique(arr) console.log(arr) //[ 1, 2, 3, 1, 5, '1' ] console.log(uniqueArr) //[ 1, '1', 2, 3, 5 ]3、for循环+indexOf function unique(arr) { var uniqueArr = [], obj = {}, len = arr.length for (var i = 0; i < len; i++) { obj[typeof arr[i] + arr[i]] = arr[i] } for (var i in obj) { uniqueArr.push(obj[i]) } console.log(obj) //{ number1: 1, number2: 2, number3: 3, number5: 5, string1: '1' } return uniqueArr } var arr = [1, 2, 3, 1, 5, "1"] var uniqueArr = unique(arr) console.log(arr) // [1, 2, 3, 1, 5, "1"] console.log(uniqueArr) //[ 1, 2, 3, 5, '1' ]4、es6实现方法function unique(arr) { return Array.from(new Set(arr)) } var arr = [1, 2, 3, 1, 5, "1"] var uniqueArr = unique(arr) console.log(arr) //[ 1, 2, 3, 1, 5, '1' ] console.log(uniqueArr) //[ 1, 2, 3, 5, '1' ]

怎样用一个方法去掉一个数组的重复元素

思路：首先想到的一个方法是遍历，将整个数组遍历一遍，如果之前没有出现过，将其放到一个新的数组中，最后返回这个数组。
function unique(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;

var 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;

}

}

可以使用双重循环，逐一对比元素，如有重复，则删除的方法去重。

其思路为

1、依次遍历循环中的每一个元素。

2、对于任意一个元素，依次与之前的元素进行对比，如果有重复则删除。

3、删除操作可以采用将后续元素逐个前移，达到覆盖当前元素的效果。

在此基础上可以进行一点优化，即，不需要每次删除元素均前移所有元素，而是把需要保留的元素放到"应该"放的位置即可，这样可以提高效率。

以整型数组为例，参考代码如下：

int remove_repeat(int *a, int l)//对起始地址为a，长度为l的数组进行去重，新的长度以返回值形式返回。

{

int i,j, r=0; //i,j为循环下标，r为去重后元素总数，初始值为0

for(i = 0; i < l; i ++)

{

for(j = 0; j < r; j ++)//检查是否重复

if(a[j] == a[i]) break;

if(j == r) //没有重复元素

a[r++] = a[i]; //将当前元素放置与去重后数组的尾部，并增加去重后的总数。

}

return r; //返回新的长度。

}

数组去重

数组去重是一个经常会用到的方法，我写了一个测试模板，测试一下常见的数据去重的方法的性能
测试模板
1、Array.filter() + indexOf 方法思路：将两个数组拼接为一个数组，然后使用 ES6 中的 Array.filter() 遍历数组，并结合 indexOf 来排除重复项
2、双重 for 循环 方法思路：外层循环遍历元素，内层循环检查是否重复，当有重复值的时候，可以使用 push()，也可以使用 splice()
3、for...of + includes() 方法思路：双重for循环的升级版，外层用 for...of 语句替换 for 循环，把内层循环改为 includes()。先创建一个空数组，当 includes() 返回 false 的时候，就将该元素 push 到空数组中 。类似的，还可以用 indexOf() 来替代 includes()
4、Array.sort() 方法思路：首先使用 sort() 将数组进行排序，然后比较相邻元素是否相等，从而排除重复项
5、new Set() ES6 新增了 Set 这一数据结构，类似于数组，但Set 的成员具有唯一性
6、for...of + Object 方法思路：首先创建一个空对象，然后用 for 循环遍历，利用对象的属性不会重复这一特性，校验数组元素是否重复
测试结果一目了然，几种方法的性能 6>5>4>3>1>2

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实现数组去重

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

去重的方法（数组、字符串）

数组去重
(1)
思路：利用一个函数中for遍历查找出重复元素，有则返回turn，如果全部备遍历完后没则返回false
利用另一个函数判断上一个返回的值
方法：
//去重
//遍历一遍找出重复元素
//方法是：将新数组与原数组进行对比，第一次出现就添加到新数组里，否则就不进行操作。
function has(arra,val){//是否有重复的数值，存在返回turn，否则false
for(let i=0,len=arra.length;i
<len;i++){
if(arra[i]===val)//存在

return true;

}

return false;

}

function strOne(array){

var newArray = [];

for(var i in array){

if(!has(newArray,array[i]))

newArray.push(array[i]);

}

return newArray;

}

console.log(strOne(arr));

(2)（es6新增）

方法：

function dedupe(array){

return Array.from(new Set(array));

}

console.log(dedupe(arr));

(3)

方法：

function de_weight (array){

var newArray = [];

for(let i=0,len=array.length;i
<len;i++){
for(let j=i+1;j
<len;j++){
if(array[i]===array[j])

j=++i;

}

newArray.push(array[i]);

}

return newArray;

}

（4）

方法：

//利用对象来给数组去重

var arr = [12,1,1,12,45,2,3,45,5,6,7,89,9,9,89,1,1,1];

var conet = {};

for(let i=0,len=arr.length;i
<len;i++){
conet[arr[i]] = arr[i];

}

console.log(Object.values(conet));

字符串去重：

（1）

var str = "dwqewdfsafdfwqewdsadsa";

var strArray = [],newArray=[];

console.log(str.charAt(4));

console.log(str.length);

for(let i=0,len=str.length;i
<len;i++){
strArray[i] = str.charAt(i);

}

console.log(strArray);

for(let i=0,len=strArray.length;i
<len;i++){
for(let j=i+1;j
<len;j++){
if(strArray[i]===strArray[j]){

j=++i;

}

}

newArray.push(strArray[i]);

}

console.log(newArray);

str = "";

for(let i=0,len=newArray.length;i
<len;i++){
str += newArray[i];

}

console.log(str);

(2)

/**

*思路：对象不会获取相同的属性，从而将属性与属性值对应，拿出属性值，组成新的数组

*/

var str = "dwqewdfsafdfwqewdsadsa";

var conet ={};

for(let i=0,len=str.length;i
<len;i++){
conet[str.charAt(i)] = str.charAt(i);

}

let string = Object.values(conet);//获取对象里的对应的值

console.log(typeof string);

console.log(string);

string = string.join("");//将数组对象转换变成字符串

console.log(string);
</len;i++){
</len;i++){
</len;j++){
</len;i++){
</len;i++){
</len;i++){
</len;j++){
</len;i++){
</len;i++){

数组去重方法 js

js数组去重的方法可以利用数组排序，通过相邻元素比较,去除重复元素。
去重，一般都是在面试的时候才会碰到，一般是要求手写数组去重方法的代码。在真实的项目中碰到的数组去重，一般都是后台去处理，很少让前端处理数组去重。虽然日常项目用到的概率比较低，但还是需要了解一下，以防面试的时候可能回被问到。
利用for嵌套for，然后splice去重（ES5中最常用）。双层循环，外层循环元素，内层循环时比较值。值相同时，则删去这个值。想快速学习更多常用的ES6语法，可以看一些相关的文章如《学习ES6笔记──工作中常用到的ES6语法》。
js数组去重的几种方法
利用数组排序，通过相邻元素比较，去除重复元素，可以严格匹配以区分数据类型。
借用对象属性方法，将数组中的元素添加为对象的属性。遍历数组元素的时候查询对象是否已经有该属性，如果有则不重复添加。
借用正则匹配的方法，将新数组转换为字符串。原数组中的每个元素与在字符串中查找，如果匹配到，则不添加。
使用js新特性的Map对象，使用键值对的方式修改第二种方法。或者利用Set对象，自动过滤掉重复项，而且可以判断数据类型。

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的数据传递与数据分发步骤详解