前言

  • 因为平时在写代码的过程中，有些算法会经常重复写，比如数组去重、数组抽取随机值等！虽然这些不是很难的逻辑，但是每次刚开始遇到需求的时候，还是需要琢磨一些时间才能想出来，所以此文档把这些常见算法的思想记录下来，以便下次再遇到的时候不会手脚无措了！

  • 这篇文档不考虑es6等语法，也不考虑Array自带的一些过滤方法！

数组去重

  • 我们这里不考虑数组上的一个自带的过滤算法，比如map、filter等方法！数组去重的关键是需要一个中间数组来存数组来帮助实现数组去重！

  • 方法一：

  1.     var arr = [1,2,3,1,1,1,1];
  2.     function toHeavy(array){
  3.         //这是一个缓存对象，用来实现过滤到重复的数据
  4.         var cache = {};
  5.         //定义一个中间数组，用来实现当容器
  6.         var cacheArr = [];
  7.         for(var i = 0,len = array.length;i<len;i++){
  8.             if(!cache[array[i]]){
  9.                 cacheArr.push(array[i]);
  10.                 cache[array[i]] = array[i];
  11.             };
  12.         };
  13.         return cacheArr;
  14.     };
  15.     arr = toHeavy(arr);//arr ==  [1,2,3]
  • 方法二：
  1.     //其实思想跟第一个差不多
  2.     var arr = [1,2,3,1,1,1,1,1,1];
  3.     function toHeavy(array){
  4.         var cache = [];
  5.         for(var i = 0,len = array.length;i<len;i++){
  6.             //用闭包，防止isHeavy向外部暴露，当然如果用es6的话，可以用let对isHeavy进行声明也能达到同样的目的
  7.             //因为js中没有块级作用域
  8.             (function(){
  9.                 var isHeavy = false;
  10.                 for(var j = 0,_len = cache.length;j<_len;j++){
  11.                     if(cache[j] == array[i]){
  12.                         isHeavy = true;
  13.                         break;
  14.                     };
  15.                 };
  16.                 if(!isHeavy){
  17.                     //如果不是重复的，那么就执行把当前值推送的cache里面
  18.                     cache.push(array[i]);
  19.                 };
  20.             })();
  21.         };
  22.         return cache;
  23.     };
  25.     arr = toHeavy(arr);

最后说一句，现实中的数据肯定不会这么简单，可能会是一个稍微复杂的数据，要给这些数组去重你也不要被吓住，其实原理是一样的，只是你被迷惑了而已！

在一个数组中随机抽取一部分值

  • 这个算法的关键要使用Math.random，不说了直接上代码:
  1.     var arr = ['小明','小红','小陈','小于','小兰','小法','小p','小张','小镇','小王','傻逼','怂逼'];
  3.     function getArr(num,array){
  4.         //num表示要去多少个，它不能大于要取的那个数组的最大长度，如果超过了那么就等于它的长度
  5.         var aLength = array.length;
  6.         if(num>=aLength){
  7.             num = aLength;
  8.         };
  9.         var cacheArr = [];
  10.         //我们用一个数组保存原来的数组
  11.         //记住千万能直接赋值，因为数组是一个引用，这样不能保持原来的数组
  12.         //这里也可以用originArr = array.slice()
  13.         // var originArr = (function(){
  14.         //     var arr = [];
  15.         //     for(var i = 0,len = array.length;i<len;i++){
  16.         //         arr.push(array[i]);
  17.         //     };
  18.         //     return arr;
  19.         // })();
  22.         //更新一种获取更简单、更快捷的获取原始数组的方法
  23.         var originArr = array.slice(0);
  24.         for(var i = 0;i<num;i++){
  25.             //array.length不能写成上面的aLength，因为aLength是固定的值，而array.length随着array的改变是自动更新的
  26.             //Math.random() * array.length得到的是一个介于长度和零之间的一个值，包括0但不包含长度值
  27.             //我们算出的是一个浮点值，所以我们必须把它转化成整数
  28.             //因为不能超过最大长度值，所以应该向下取整
  30.             /*更新bug：我们不能在array上操作了，因为这会影响原来的数组，
  31.             所以把这里的array换成originArr
  32.             */
  33.             var _index = Math.floor(Math.random() * originArr.length);
  34.             cacheArr.push(originArr[_index]);
  35.             //记住一定，取出来之后，一定删除原来位置上的数组值
  36.             //要不然数组更新不了
  37.             originArr.splice(_index,1);
  38.         };
  39.         return cacheArr;
  40.     };
  41.     var brr = getArr(5,arr);
  42.     console.log(brr);
  43.     console.log(arr);

得到某个区间的字母组成的数组

  • 这里主要应用两个方法，一个字符串的charCodeAt和String上的一个静态方法fromCharCode。其思想主要是：先得到这个区间开头字母和结束字母的数字表示，然后就可以在这个区间内做一个循环，并且得到这个区间字母的数字表示，最后把数字传唤成字母依次push到数组里面返回。直接上代码：
  1.     function getArrForAlphabet(startLetter,endLetter){
  2.         //var regExp = /^[a-zA-Z]$/gi;
  3.         var regExp = new RegExp("^[a-zA-Z]$");
  4.         if(!regExp.test(startLetter) || !regExp.test(endLetter)){
  5.             //console.log(regExp.test(startLetter));
  6.             //console.log(regExp.test(endLetter));
  7.             console.log('请传入字母！');
  8.             return false;
  9.         };
  10.         //i是得到开始字母的数字表示，j得到结束字母的数字表示
  11.         var i = startLetter.charCodeAt(0),j = endLetter.charCodeAt(0);
  12.         //定义一个数组用于取出将来的字母
  13.         var arr = [];
  14.         //这里取<=符号是因为要取出结束的字母
  15.         for(;i<=j;i++){    
  16.             //fromCharCode是String上的一个静态方法，用于将一个数字转换成对应的字母
  17.             var letter = String.fromCharCode(i);
  18.             arr.push(letter);
  19.         };
  20.         //记得最后返回arr
  21.         return arr;
  22.     };

11. 数组去重、数组随机抽值、循环得到某个区间的字母等算法 - 图1

后续代码待更新……