第一种是比较常规的方法

思路：

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());
$(document).ready(function(){

    var MarYeArr  = ["2017","2016","2015","2017","2019","2012"];

    //调用去重，排序

     MarYeArr = MarYears(MarYeArr).sort().reverse();   

});

//去重

    function MarYears(arr){

        var res = [];

        var json = {};

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

            if(!json[arr[i]]){

               res.push(arr[i]);

               json[arr[i]] = 1;

             }

        }

        return res;

    }

其中第1种和第3种方法都用到了数组的indexOf方法。此方法的目的是寻找存入参数在数组中第一次出现的位置。很显然，js引擎在实现这个方法的时候会遍历数组直到找到目标为止。所以此函数会浪费掉很多时间。 而第2中方法用的是hash表。把已经出现过的通过下标的形式存入一个object内。下标的引用要比用indexOf搜索数组快的多。

为了判断这三种方法的效率如何，我做了一个测试程序，生成一个10000长度的随机数组成的数组，然后分别用几个方法来测试执行时间。 结果表明第二种方法远远快于其他两种方法。 但是内存占用方面应该第二种方法比较多，因为多了一个hash表。这就是所谓的空间换时间。

第四种方法：

Array.prototype.unique4 = function()

{

    this.sort();

    var re=[this[0]];

    for(var i = 1; i < this.length; i++)

    {

        if( this[i] !== re[re.length-1])

        {

            re.push(this[i]);

        }

    }

    return re;

}

这个方法的思路是先把数组排序，然后比较相邻的两个值。 排序的时候用的JS原生的sort方法，JS引擎内部应该是用的快速排序吧。 最终测试的结果是此方法运行时间平均是第二种方法的三倍左右，不过比第一种和第三种方法快了不少。

第五种办法：利用ES6中的Ser()key的集合去重 (确保浏览器支持ES6规范)

Array.prototype.unique5 = function () {

//测试浏览器是否支持ES6

var m = new Map();

var s = new Set();

alert('你的浏览器支持Map和Set！');

//创建2个示例数组

var arr1 = [1,2,3,4,5];

var arr2 = [1,3,5,7,9];

//创建一个空数组 //用于存储去重结果

var arr3 = [];

//将arr1和arr2合并,并且用Set()存储,进行去重;

var s = Set( arr1.concat ( arr2 ) );

//遍历s,并且执行事件;

s.forEach( function (e){

//将s的内容添加到arr3中,即是去重结果;

arr3.push(e);

})

return arr3;

}

第五种方法所用的Set（）是ES6的新内容.

——————————————————————————————————————————————————————————————————————————————

第一：

说明：通常就是把字符串分割成数组，再对数组操作，相对来说数组的方法多些，方便些，最后再join成字符串

关于sort()方法，之所以先对数组元素排序，就是因为可以把相同的字符归到一起，就不用再双层循环，要不然就得拿到每个元素，和剩余的逐个比对，这个sort会按照ASCII 字符顺序进行升序排列

<html>

<head>

<script src="jquery-1.8.1.js"></script>

<SCRIPT LANGUAGE="JavaScript">

$(function(){

 $('#delRepeat').click(function(){

  var str = $('#repeatValue').val();

   var strArr=str.split("");//把字符串分割成一个数组

   strArr.sort();//排序

   var result=new Array();//创建出一个结果数组

   var tempStr="";

   for(var i in strArr)

   {

     if(strArr[i] != tempStr)

     {

      result.push(strArr[i]);

      tempStr=strArr[i];

     }

     else

     {

      continue;

     }

   }

   $('#noRepeat').val(result.join(""))//把数组连成字符串并展示到页面

 })

})

</SCRIPT>

</head>

<body>

原值<input id="repeatValue" type="text" ><input id="delRepeat" type="button" value="去重">

<input type="text" id="noRepeat">

</body>

</html>

第二：

说明，这个unique方法确实方便，但有两个缺陷：

1、只对数组有效（直接字符串不行），并且该数组不能是数字数组,
2、只对相邻的重复元素有效，隔开的不行。

例如：[a,a,b,b,c,c]---unique----》[a,b,c]有效
[a,a,b,b,c,c,a]--unique-->[a,b,c,a]元素a仍然重复，无效

因此调用unique之前必须调用一下sort方法将其重复元素重排一下，挨在一起

但也因为调用了sort方法，顺序给重排了如：[b,b,c,c,a,a]---unique-->[a,b,c]不是[b,c,a]

<html>

<head>

<script src="jquery-1.8.1.js"></script>

<SCRIPT LANGUAGE="JavaScript">

$(function(){

 $('#delRepeat').click(function(){

  var str = $('#repeatValue').val();

   var strArr=str.split("");

   //排序

   strArr.sort();

    var result =$.unique(strArr);

   $('#noRepeat').val(result.join(""));

 })

})

</SCRIPT>

</head>

<body>

原值<input id="repeatValue" type="text" ><input id="delRepeat" type="button" value="去重">

<input type="text" id="noRepeat">

</body>

</html>

第三：

说明：

var reg =/(.)(?=.*\1)/g;
.匹配任意字符，但只能匹配任意字符中的一个
(.)加上()就是将匹配的该字符存储起来供以后引用
(?=)预搜索（也有叫断言的，也有叫预查的），指明某个字符的右侧是什么，但不包含这部分，只取这个‘某个字符'
如：p(?=ing)     匹配字符串ping时匹配成功，但匹配到的字符是p不是ping
(?=.*\1) 这个\1就是指的前面(.)的这个字符，之前说它被加上小括号就是被存储起来了，现在\1就是取存储的第一个（共一个）
*匹配次数，也有人称之为量词，指出现任意次
.*指出现任意次任意字符
(.)(?=.*\1)指第一个匹配字符，如果右侧出现的内容中包含该字符时就匹配上该字符
 g    指globle，全局匹配模式，匹配所有字符串

这个去重的结果其实是倒着来排序的，就是说重复字符出现在前面的都被置空了，是按一个字符从后往前出现的顺序排的

<html>

<head>

<script src="jquery-1.8.1.js"></script>

<SCRIPT LANGUAGE="JavaScript">

$(function(){

 $('#delRepeat').click(function(){

  var str = $('#repeatValue').val();

     var reg = /(.)(?=.*\1)/g;//预搜索方式（有的叫断言）

     var result = str.replace(reg, "");

     $('#noRepeat').val(result);

 })

})

</SCRIPT>

</head>

<body>

原值<input id="repeatValue" type="text" value="aca" ><input id="delRepeat" type="button" value="去重">

<input type="text" id="noRepeat">

</body>

</html>

js多种去重的方法总结的更多相关文章

  1. js数组去重的方法（转）

    JS数组去重的几种常见方法 一.简单的去重方法 // 最简单数组去重法 /* * 新建一新数组,遍历传入数组,值不在新数组就push进该新数组中 * IE8以下不支持数组的indexOf方法 * */ ...

  2. js数组去重的方法

    //数组去重 Array.prototype.unique = function() { var newArr = [], hash = {}; for(var i=0, len=this.lengt ...

  3. 两种js数组去重的方法

    方法一: 新建一个数组,遍历原数组,在新数组内用IndexOf查找原数组内的每一项,如果没有找到,则添加到其中 代码如下: function arrayNew(arrs ){ var newArray ...

  4. js数组去重（多种方法）

    // js数组去重 Array.prototype.fun1 = function(){ var arr = this, result = [], i, len = arr.length; for(i ...

  5. js数组去重的4种方法

    js数组去重,老生长谈,今天对其进行一番归纳,总结出来4种方法 贴入代码前 ,先对浏览器Array对象进行支持indexOf和forEach的polyfill Array.prototype.inde ...

  6. js数组去重方法分析与总结

    数组去重经常被人拿来说事,虽然在工作中不常用,但他能够很好的考察js基础知识掌握的深度和广度,下面从js的不同阶段总结一下去重的方法. ES3阶段 该阶段主要通过循环遍历数组从而达到去重的目的 多次循 ...

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

    JS数组去重的几种常见方法 一.简单的去重方法 // 最简单数组去重法 /* * 新建一新数组,遍历传入数组,值不在新数组就push进该新数组中 * IE8以下不支持数组的indexOf方法 * */ ...

  8. js数组去重五种方法

    今天来聊一聊JS数组去重的一些方法,包括一些网上看到的和自己总结的,总共5种方法(ES5). 第一种:遍历数组法 这种方法最简单最直观,也最容易理解,代码如下: var arr = [2, 8, 5, ...

  9. js 数组去重方法汇总

    <!DOCTYPE html> <html lang="zh"> <head> <meta charset="UTF-8&quo ...

随机推荐

  1. xftp实现本地与服务器的文件上传下载（windows）

    背景: Jemter环境搭建,需上传下载服务器文件到aws服务器上,由于secureCRT的局限性它只支持pub格式的密钥,不支持pem格式密钥,xshell是支持pem格式的,所以尝试安装xshel ...

  2. 解决Spring Boot 拦截器注入service为空的问题

    问题:在自定义拦截器中,使用了@Autowaire注解注入了封装JPA方法的Service,结果发现无法注入,注入的service为空 0.原因分析 拦截器加载的时间点在springcontext之前 ...

  3. layui select多选下拉显示 以及回显

    <input type="hidden" id="hiddensheshi" name="hiddensheshi" value=&q ...

  4. Chrome 浏览器中查看 webSocket 连接信息

      1.以下代码实现一个webSocket连接,在文本输入框中输入内容,点击发送,通过服务器,返回相同的内容显示在下方. 1 <!DOCTYPE html> 2 <html lang ...

  5. tecplot不能导入fluent多面体的解决办法

    多面体网格在fluent当中计算完成,如果保存cas和dat文件,如果直接将cas和dat文件导入tecplot进行后处理,tecplot会提示多面体网格在fluent当中计算完成,如果保存cas和d ...

  6. JavaWeb之Tomcat(1) —— Tomcat的目录结构

    1. bin 文件夹 存放Tomcat的可执行文件 (1) startup.bat 文件,启动Tomcat服务的批处理文件. (2) shutdown.bat 文件,结束Tomcat服务的批处理文件. ...

  7. Windows 实例远程桌面报错“没有远程桌面授权服务器可以提供许可证”

    参考阿里云帮助文档: https://help.aliyun.com/knowledge_detail/40859.html?spm=5176.10695662.1996646101.searchcl ...

  8. NoSql数据库Redis系列（1）——Redis简介

    一.redis介绍 (一).Redis 简介 Redis 是完全开源免费的,遵守BSD协议,是一个高性能的key-value数据库. Redis 与其他 key - value 缓存产品有以下三个特点 ...

  9. Visual Studio 2019 使用 Web Deploy 发布远程站点到IIS服务器

    Visual Studio 2019 使用 Web Deploy 发布远程站点到IIS服务器的方式 在开发完项目之后,我们需要把开发的项目发布到指定的服务器上,有两种方式,如下 1.把项目发布成文件系 ...

  10. 清理Windows.edb

    解决Windows.edb文件巨大的windows 10问题的另一个快速解决方法是删除Windows.edb文件. 步骤1:在任务管理器中终止SearchIndexer.exe --按Ctrl + A ...