二阶段第八天

1 随机验证码

 function rand(min , max) {  
            return parseInt(Math.random() * (max - min) + min)
        }
        function randCode(n) {  
            // 默认4位
            n = n || 4 ;
            var arr2 = [] ;

            var numArr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
            var bigArr = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'] ;
            var smallArr = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'] ;
            var allArr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'] ;

            // 从数字中随机取一个
            arr2.push(numArr[rand(0,numArr.length)]) ;
            // 从大写中去一个
            arr2.push(bigArr[rand(0,bigArr.length)]) ;
            // 从小写中去一个
            arr2.push(smallArr[rand(0,smallArr.length)]) ;
            for(var i = 0 ; i < n - 3 ; i++) {
                arr2.push(allArr[rand(0,allArr.length)])
            }

            // 以上顺序总是一样的
            console.log(arr2);

            // 打乱顺序,随机交换每个位置上的值
            for(var i = 0 ; i < arr2.length ; i++) {
                var j = rand(0 , arr2.length) ;
                var t = arr2[i] ;
                arr2[i] = arr2[j] ;
                arr2[j] = t ;
            }
            
            
            // document.write(join(arr2 , ''))
            return join(arr2 , '') ;
        }

        var res = randCode();
        document.write(res)

1 创建一个随机数的函数，4个包含不同数据类型的数组

2 创建一个空数组，从4个数组中每个取出一个值放入进去，就能得到一个随机验证码，必包含4种不同的类型（缺点是不同数据类型的验证码位置固定）

3 将数组中的4个值随机打乱，每次生成的验证码便不会再固定位置

 2 数组常用的方法

 数组的基本方法  

                      push()       向数组尾部追加值

                      pop()        在数组尾部删除一个值

                      unshift()    向数组的头部追加值

                      shift()      在数组的头部删除一个值

        数组的常用方法

         join()  把数组变成字符串  数组中所有内容怕拼接在一起

         includes()  判断数组中是否存在某个值

         indexOf()  判断数组中是否存在某个值，返回第一次出现的下标,找不到就返回-1

         lastIndexOf()  判断数组中是否存在某个值，返回最后一次出现的下标

         concat()   拼接数组，返回一个新的数组  （常用来将多个数组拼接在一起）

         slice(i,i)  截取数组中的部分值,返回一个新的数组 第一个i是数组角标的起始值（包含），第二个i是数组角标的结束值（不包含）

         splice(i , 删除的个数 ， 新增的值...) 第一个值是需要插入或删除的角标，第二个值是需要删除的个数 不删除则不需要输入，第三个是新增的值，可以同时新增多个，用逗号隔开

  3 判断是否为数组

 

 // 基本数据类型：number  string boolean  null  undefined
        //    基本数据类型可以通过typeof来判断

        // 引用数据类型：function  数组   对象

        //    Array.isArray()  判断是不是数组



        var arr = [1,2,3];

        console.log(typeof arr);   // object 


        console.log(Array.isArray(arr));

1 数组的数据类型同基本的数据类型不同，不能用 typeof 来判断。

2 官方声明了一个判断数组的方法   Array.isArray()  用来判断该变量是否为数组，如果是结果便是true 如果不是，结果便是flase

 4 去掉数组中重复的值

有两种方法

1 创建一个空数组，先遍历需要去重的数组中的所有值，和空数组中的值进行一一对比，假如旧数组的值在新数组中已存在，则跳过，如果旧数组中的值在新数组中不存在，则将旧数组中的值放入新的数组中，代码如下 

var arr = [1,2,3,42,1,3,2,2,1,3,5] ;

        //   方法1：得到新的数组

        var newArr = [] ;
        // 遍历原数组
        for(var i in arr) {
            // 判断原数组中每一个值是否在新数组中存在
            
            var flag = false ;  
            for(var j in newArr) {
                if(newArr[j] === arr[i]) {
                    flag = true ;
                    break ;
                }
            }
            if(!flag) {
                newArr.push(arr[i])
            }

        }

        console.log(newArr);

      2 直接把数组中所有的值一一比较假如遇到重复的值就删除掉一个，最后得出的就是没有重复的数组，代码如下

 //   方法2：直接改变原数组
        //     对比，出现重复的就删掉

        //   拿第一个值出来跟后面所有的值作比较
        var arr = [1,2,3,42,1,3,2,2,1,3,5] ;
        
        // 比较的轮数
        for(var i = 0 ; i < arr.length - 1 ; i++) {
            // 拿第i个数与后面所有的数进行比较
            for(var j = i + 1 ; j < arr.length ; j++) {
                // 只要相同就删除
                if(arr[i] === arr[j]) {
                    // 没删除一个的时候，数组塌陷!!!!!!!!!!
                    arr.splice(j , 1);
                    j--;
                }
            }
        }

        console.log(arr);

注意！！！每删除一个值J的大小就要剪掉一个，因为删除一个值后数组的长度发生了变化，删除值的后面的值角标也发生了变化，J自减是防止漏掉。

  4 统计数组中每一个值出现的次数 

 方法一

先创造一个空数组，将旧数组中去掉重复的值后导入新数组中，再统计新数组中的值在旧数组中出现了几次，

 方法1：先去重再统计
        var arr2 = [] ;
        for(var i = 0 ; i < arr.length ; i++) {
            if(!arr2.includes(arr[i])) {
                arr2.push(arr[i])
            }
        } 
        console.log(arr2);

     //   以上代码为取出重复的值
        
        // 拿新数组中的每一个值与原数组进行比较
        for(var i = 0 ; i < arr2.length ; i++) {

            var count = 0 ;     //哇一个count作为计数，同时在输出后清零
            for(var j = 0 ; j < arr.length ; j++) {
                if(arr2[i] === arr[j]) {
               // 每出现一次 count 自增一次，方便计数
                    count++
                }
            }
               // 遍历完成后输出
            console.log(arr2[i] + '出现了' + count + '次');
        }

方法二

类似选择排序，声明一个初始为1的count，再拿第一个值和后面所有的值做对比，遇到相同的就删除掉那个值，并count自增，遍历完成后 count的值便是这个值出现的次数，同时输出结果后将count清零，再继续拿第二个值做对比...

   var arr = [1,2,1,3,2,3]

        // 方法2：一边删除一边统计
        for(var i = 0 ; i < arr.length ; i++) {
            // 拿第一个值与后面的值进行比较
            var count = 1 ;
            for(var j = i + 1 ; j < arr.length ; j++) {
                找到相同的值以后删除这个值，并count自增，同时J自减防止漏掉
                if(arr[i] === arr[j]) {
                    count++ ;
                    arr.splice(j , 1) ;
                    j-- ;
                }
            }
            console.log(arr[i] + '出现了' + count + '次');
        }
        console.log(arr);

方法三

  先将 数组中所有的值排序在一起，排序完成后相同的值会连续显示，再拿第一个值和后面的值对比，遇到相同的count自增一次，遇到不同的就停止循环，并输出count的值，同时下一次对比的起点就是上一次对比不相同的那个值。

// 方法3：先排序，再统计
        var arr = [1,1,1,1,2,2,2,3,4,4];

        for(var i = 0 ; i < arr.length ;  ) {
            var count = 1 ;
            for(var j = i + 1 ; j < arr.length ; j++) {
                if(arr[i] === arr[j]) {
                    count++ ;
                }
                else {
                    // 只要不相等说明后面没有相同 的了
                    break ;
                }
            }
            console.log(arr[i] + '出现了' + count + '次');
            i += count
        }

 5 回调函数

        回调函数的作用是为了解决函数作用单一性，主要使用方法是将一个函数作为实际参数传达到另一个函数里面，从而使此函数的应用范围更广，功能更强大。

 // callback:回调函数
        //    把一个函数当做另一个函数的参数


        function xunHuan(n , fn) {  
            for(var i = 0 ; i < n ; i++) {
                fn()
            }
        }

        xunHuan(5 , function(){
            document.write(1 + '<br>')
        })

如上所示 函数 xunhun（）中其中一个参数是fn（）后面调用这个函数时给的实参便是一个函数，这是一个最基本的回调函数，回调函数中注明了 xunhun（）的输出方式，当调用xunhuan（）时，两个函数便被一起调用了。

 
//设置一个函数 形参为 arr 和cb
function forEach(arr , cb) {  
                    遍历整个数组
            for(var i = 0 ; i < arr.length ; i++) {
                cb作为一个参数，没有设置功能，但是输出了两个实参
                cb(arr[i] , i)
            }
        }


            调用forEach这个函数，第一个实参输入的一个数组，第二个实参
            为一个回调函数，设置了两个行参用于接收收 cb 输出的两个实参
        forEach([1,2,3] ,function (v , i) {  
            // console.log(666);
        将接收的两个实参控制台打印出来。
            console.log(v);
            console.log(i);
        })

回调函数同样有参数，使用回调函数时使用的实参来自于调用他的那个函数输出的，我们可以利用这个参数达到自己想要的效果。

         6 数组的迭代方法（数组自带的回调函数）

 

sort()   ASCII升序

        sort(function(a,b){return a - b})  升序

        sort(function(a,b){return b - a})  降序

        forEach(function(v,i,arr){})  遍历数组

        map(function(v,i,arr){})  改变数组中的值，返回一个新的数组  必须return

        filter(function(v,i,arr){})  过滤器，找到满足条件的值，返回一个新的数组

        every(function(v,i){})  判断数组中是不是每一个值都满足条件

        some(function(v,i){})  判断数组中有没有满足条件的值

 

 var arr = [1,2,3] ;
        var res = arr.map(function (v) {  
            return v + 3
        })
        console.log(res);

设置一个数组，利用map函数把函数中的每个值加3，并成立一个新数组

  var arr = [1,4,7,3,2] ;
        var res = arr.filter(function (v) {  
            return v > 2
        })
        console.log(res);

设置一个数组，利用filter函数设置一个条件，将数组中大于2的数筛选出来，并放入一个新的数组。

var arr = [10,40,70,38,26] ;
        var res = arr.every(function (v) {  
            return v > 60
        })
        console.log(res);

设置一个函数，用every函数判断数组中是不是每个值都大于60，返回值是布尔值，如果全部满足返回值就是true，否则返回值就是flase，

some函数同理，但是some函数只要有一个值满足条件，返回值就是true。

var arr = [5,3,22,1,7] ;
        var res = arr.sort(function (a , b) {  
            return b - a
        })
        console.log(res);

设置一个函数，用sort函数来对数组排序，输出a-b则是升序排列，输出b-a则是降序排列