2021.12.20周一 二阶段 day_11 js笔记

最新推荐文章于 2022-07-28 21:53:01 发布
最新推荐文章于 2022-07-28 21:53:01 发布
阅读量307 收藏
点赞数
文章标签： javascript 开发语言 ecmascript 前端 html
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WyHHZKA/article/details/122051460
版权

一、知识点回顾

 1. flex : 1   -> flex: 1 1 auto ; ( flex-grow ; flex-shrink ;  flex-basis)

 2. 数组转字符串 join()

 3. 字符串转数组 split()

 4. 获取年            getFullYear()

 5. 月份推到下个月  setDate(32-58)

                                setDate(1-28)   setMonth(getMonth()+1) 

                        存在bug setMonth(getMonth()+1)

                        1.31->2.31->3.3

 6. 月份推到上个月    setDate(0/-1/-2/../-28)

                                 setDate(1-28)    setMonth(getMonth()-1)

     本月的天数           setDate(32)       setDate(0)

                                 先推到下个月 再回到这个月

 7. 定时器的语法        setInterval(fn,time,第一个函数的参数)

 8. 截取字符串的方法       slice(i,i) substr(i,n) substrig(i,i)

 9. 对象的深拷贝

       var obj = {}

       var obj2 = {}

       遍历obj        for in

10. 基本数据类型和引用数据类型的区别

          基本数据类型存储的是值

          引用数据类型存储的是地址

 二、注册验证

思路：1. 封装rand get 验证码函数

           2. 通过get方法拿到需要的对象  例如：var oUser = get('user');

           3. 创建四个数组

           4. 绑定点击事件->验证码刷新

           5. 第一次打开时网页就有显示  get('code').innerHTML = randCode()

           6. 绑定点击事件->验证

                   6.1 用户名验证

                         6.11 去掉首尾空格 var username = oUser.value.trim（）

                         6.12 判断为空    

                         6.13 验证长度 （长度必须在3-6位之内）

                         6.14 验证数字（不能以数字开头） if(numArr.includes(username.charAt(0)))

                         6.15 验证非法字符（不能包含非法字符）if(! allArr.includes(username[i])）

                         6.16 用户名验证成功   oUserSpan.innerHTML = '√'

                    6.2 密码验证 

                          6.21 去掉首尾空格 var password = oPwd.value.trim()

                          6.22 判断为空

                          6.23 验证长度（长度必须在3-6位之内）

                          6.24 验证非法字符（不能包含非法字符）

                          6.25 强度验证 纯数字，字母，则弱；任意两种，则中；大写字母合小写

                                  字母结合数字，则强

                          6.26 密码验证成功     oPwdSpan.innerHTML = '√'

                     6.3 验证码验证

                          6.31 获取输入框的值 获取验证码的值

                          6.32 判断两值是否相等（验证码不分大小写）

                                        相等    -> 验证通过

                                        不相等 -> 验证码重新刷新 输入框清空

                                                        验证失败

             7.用户名 密码 验证码 三者全部成功，则注册成功

 



    <script>
            function rand(max,min) {
                min = min || 0
                return parseInt(Math.random()*(max - min)+ min )
            }

            function get(id) {  
                return document.getElementById(id)
            }       
           

            // 拿对象
            var oUser = get('user');
            var oUserSpan = get('userSpan');
            var oPwd = get('pwd')
            var oPwdSpan = get('pwdSpan')
            var oCode = get('code')
            var oCodeSpan = get('codeSpan')
            var oMsg = get('msg')
            var oBtn = get('btn')
            var oStrong = get('strong')

            var numArr = [];
            for(var i = 0 ; i < 10 ; i++){
                numArr.push(i + '')
            }

            var smallArr = [];
            for(var i = 97 ; i<= 122 ; i++){
                smallArr.push(String.fromCharCode(i))
            } 

            var bigArr = [];
            for(var i = 65 ; i <= 90 ; i++){
                bigArr.push(String.fromCharCode(i))

            }
            var allArr = numArr.concat(smallArr , bigArr);

            function randCode(n) {
                n =  n || 4 ; 

                var res = '' ;

                res += numArr[rand(numArr.length)];

                res += smallArr[rand(smallArr.length)];

                res += bigArr[rand(bigArr.length)];

                for(var i = 0 ; i < n - 3 ; i++){
                    res += allArr[rand(allArr.length)];
                }

                // 把字符串转数组
                var arr = res.split('')

                // 交换位置
                for(var i in arr ){
                    var index = rand(arr.length)
                    var t = arr[i] ;
                    arr[i] = arr[index]
                    arr[index] = t ;
                }

                res = arr.join('')
                return res 
            }

            oCodeSpan.innerHTML = randCode()

            oCodeSpan.onclick = function () {
                oCodeSpan.innerHTML = randCode()
            }



            function tips(obj , msg , color) {
                obj.innerHTML = msg ; 
                obj.style.color = color ; 
            }

            // 验证
            oBtn.onclick = function () {
                // 去掉用户名首尾空格
                var username = oUser.value.trim() ; 
                // 判断为空
                if(username === ''){
                    tips(oUserSpan,"输入不能为空",'red');
                    return 
                }
                // 判断长度 
                if(username.length < 3 || username.length > 6){
                    tips(oUserSpan,'长度必须在3-6位之间',"red")
                    return
                }
                // 判断是否数字开头
                if(numArr.includes(username[0])){
                    tips(oUserSpan,'不能用数字开头','red');
                    return
                }
                // 必须是字母,数字组成
                for(var i in username){
                    if(!allArr.includes(username[0])){
                        tips(oUserSpan,'用户名只能是字母和数字','red');
                        return
                    }
                }
                tips(oUserSpan,'√','green')

                // 判断密码
                // 去掉密码首尾空格
                var password = oPwd.value.trim();
                // 判断为空
                if(password === ''){
                    tips(oPwdSpan,'输入不能为空','red');
                    return
                }
                // 判断长度
                if(password.length < 3 || password.length > 6){
                    tips(oPwdSpan,'长度必须在3-6位之内','red')
                    return
                }
                // 必须是字母，数字组成
                for(var i in password){
                    if(!allArr.includes(password[0])){
                        tips(oPwdSpan,'密码必须在3-6位之间','red')
                        return
                    }
                }
                // 强度验证
                var count1 = 0 ;   // 数字
                var count2 = 0 ;  // 小写
                var count3 = 0 ;  // 大写
                for(var i in password){
                    if(numArr.includes(password[i])){
                        count1 = 1
                    }
                    if(smallArr.includes(password[i])){
                        count2 = 1
                    }
                    if(bigArr.includes(password[i])){
                        count3 = 1
                    }
                }

                var count = count1 + count2 + count3
                if(count === 1){
                    tips(oStrong,'弱','red')
                }
                if(count === 2){
                    tips(oStrong,'中','yellow')
                }
                if(count === 3){
                    tips(oStrong,'强','green')
                }

                tips(oPwdSpan,'√','green')

                //验证码
                var str = oCode.value 
                var str2 = oCodeSpan.innerHTML 
                if(str.toLowerCase() === str2.toLowerCase()){
                    oMsg.innerHTML = '验证通过'
                    oMsg.style.color = 'green'
                }else{
                    oCodeSpan.innerHTML = randCode();
                    oCode.value = '' ;
                    oMsg.innerHTML = '验证失败'
                    oMsg.style.color = 'red'
                }
                alert('注册成功')

                
            }

        
        
    </script>



</body>

三、定时器 

定时器

    语法 ： setInterval(fn,time)

    变量存储的是一个数字（页面中的第几个定时器）

    定时器是异步的

    清除定时器   clearInterval(第几个定时器)

js   单线程的语言

      代码正常从上往下执行

但是有一些特殊的功能：异步

       图片的请求，数据的请求    -- 需要服务器响应（需要时间的）

       定时器和延时器以及点击事件 -- 不是立即执行的（需要时间的，或者需要用户）

       js 的所有代码都在主线程上执行

           同步先执行

           异步存放在任务队列中（任务队列不能执行任务，而是任务到时间了之后去主线程上执行）

        var t = setInterval(function(){
            console.log(666);
        },1000)
        console.log(1);


        // clearInterval(t) 清空计时器

 四、倒计时

    <h1 id="h"></h1>

    <script>
        var oH1 = document.getElementById('h');

        var count = 10 ;
        oH1.innerHTML = count + 's';
        var t = setInterval(function(){
            count--
            oH1.innerHTML = count + 's';
            if(count === 0){
                clearInterval(t)
            }

        },1000)



    </script>

 五、按钮倒计时

 思路：

    一、1个按钮控制开和关

        1. 首先获取元素 

        2. 绑定点击事件

                2.1 if判断，若按钮开启，则定时器开始运行，按钮变成暂停

                2.2 否则清空定时器，按钮回到开始

    二、1个按钮控制开和暂停

         1. 绑定点击事件

                1.1 按钮点击时，计时器清空，计时器开始 。 （这样能实现每次点击是暂停，第 

            二次点击是继续的效果）

     三、3个按钮分别控制开，暂停，结束

         1. 绑定开始按钮点击事件

                1.1 一旦点击开始按钮，开始按钮禁用，暂停和结束按钮开启 计时器开启

         2. 绑定暂停按钮点击事件

                2.1 一旦点击暂停按钮，清空计时器，暂停按钮禁用，开始按钮开启。

         3. 绑定结束按钮点击事件

                3.1 一旦点击结束按钮，清空计时器，页面上清回0，结束按钮禁用，暂停按钮禁

                      用，开始按钮打开


        var oBtn = document.getElementById('btn');
        var oPause = document.getElementById('pause');
        var oEnd = document.getElementById('end')
        var oSpan = document.getElementById('span')

        // 每次点击的时候都会重新调用这个函数

        // 存储定时器的变量必须在点击事件外面声明 -> 也就是说他必须是一个全局变量

        // Version 1.0 , 1个按钮控制开关

        // var t 
        // oBtn.onclick = function(){
            
        //     if(oBtn.innerHTML === '开始'){
        //         oBtn.innerHTML = '暂停'
        //         t = setInterval(function(){
        //             oSpan.innerHTML++;
        //         },1000)
        //     }
        //     else{
        //         clearInterval(t)
        //         oBtn.innerHTML = '开始'
        //     }
        // }



        // Version 2.0 , 1个按钮控制开/暂停

        // var t ;
        // oBtn.onclick = function(){
        //     clearInterval(t)
        //     t = setInterval(function(){
        //         oSpan.innerHTML++
        //     },1000)
        // }




        // Version 3.0 , 3个按钮控制开关暂停
        var t 
        oBtn.onclick = function(){
            oBtn.disabled = true
            oPause.disabled = false
            oEnd.disabled = false
            t = setInterval(function(){
                oSpan.innerHTML++;
            },1000)
        }

        oPause.onclick = function(){
            clearInterval(t)
            oPause.disabled = true
            oBtn.disabled = false ;
        }

        oEnd.onclick = function(){
            clearInterval(t)
            oSpan.innerHTML = 0
            oEnd.disabled = true 
            oPause.disabled = true
            oBtn.disabled = false ;
        }

 六、小广告

 思路：右下角出现弹窗小广告

         1. get方法获取元素

         2. 10s倒计时后关闭

                2.1 设置定时器 倒计时在减小 oTime.innerHTML--

                2.2 判断时间<0 ，则关闭 -> display:none,随后清空计时器

         3. 点X关闭

                3.1 绑定点击事件 点击，则关闭 -> display.none,随后清空计时器

 <script>

        // 右下角出现弹窗

        var oAd = document.getElementById('ad')
        var oClose = document.getElementById('close')
        var oTime = document.getElementById('time')

        // 10s 倒计时后关
        var t = setInterval(function(){
            oTime.innerHTML--;
            if(oTime.innerHTML < 0 ){
                oAd.style.display = 'none';
                clearInterval(t);
            }
        },500)

        // 点X关

        oClose.onclick = function(){
            oAd.style.display = 'none';
            clearInterval(t);
        }

    </script>

 七、延时器

 定时器：重复的闹钟

 延时器：一次性的闹钟

 setTimeout(fn,time)

 变量存储的是第几个闹钟（不分定时器和延时器）

 setTimeout也是异步

 

 clearInterval  可以清除定时器，也可以清除延时器

 clearTimeout 可以清除延时器，也可以清除定时器

  var t1 = setInterval(function(){

            console.log(777);

        },1000)

        var t2 = setTimeout(function(){
            console.log(666);
        },0)

        console.log(t1 , t2);

        // clearInterval(t1)
        // // clearTimeout(t2)

        
        // clearTimeout(t1)
        // clearInterval(t2)

 八、关于异步

 异步：

          在点击事件里面，绑定是同步的，事件处理函数是异步的

          在定时器里面，要做的事情是异步的

    var t = setTimeout(function(){},1000)
                                                        
        clearInterval(t)

                                                        
        var oH1 = document.getElementById('h');
        oH1.onclick = function(){
            console.log(666);
        }

 九、延时器改定时器

延时器：只会执行一次

死递归：短时间内内存溢出（递归一定要有结束的条件）

  // 延时器：只会执行一次

        // setTimeout(function(){
        //         console.log(666);
        // },1000)


        // 死递归：短时间内内存溢出(递归一定要有结束的条件) 

         // 每隔1s调用函数

            function fn(){
                setTimeout(function(){
                    console.log(666);
                    fn()
                },1000)
            }

            fn()

            // 递归

 十、流氓小广告

 思路：用延时器 倒计时结束后，广告再出现在页面中；关闭广告后，广告再出现在页面中；

      1. get方法获取元素的值

      2. 封装showAd函数

                2.1 设置延时器  3s后，打开广告（广告默认是关闭的 display:none）

                2.2  10s后自动关闭

                        2.21 设置定时器

                        2.22 时间-- 时间<0 则关闭，清空定时器，时间回到10，调用一次showAd()

                2.3    点X关闭

                        2.31 绑定点击事件 点击X关闭 ,计时器清空，时间回到10，调用一次

                                showAd()

        var oAd = document.getElementById('ad')

        var oClose = document.getElementById('close')

        var oTime = document.getElementById('time')

        function showAd(){
            setTimeout(function(){
                oAd.style.display = 'block'
                // 10s 倒计时后关
                var t = setInterval(function(){
                    oTime.innerHTML--;
                    if(oTime.innerHTML < 0 ){
                        oAd.style.display = 'none';
                        clearInterval(t);
                        oTime.innerHTML = 10;
                        showAd()
                    }},500)                          
                // 点X关
                oClose.onclick = function(){
                    oAd.style.display = 'none';
                    clearInterval(t);
                    oTime.innerHTML = 10;
                    showAd()
                    }
            },3000)
        }

        showAd()

 十一、日历

日历分析：

                上个月 + 本月 + 下个月 = 42 

                上个月  显示几天是由本月的第一天是星期几来决定的

                本月      所有的天数

                下个月  下个月 42 - 上个月的天数 - 本月的天数

 思路：

        1.实现封装函数

                1.1 封装本月的天数

                        1.10 先创建当前时间     var date = new Date(time)

                        1.11 把日期推到下个月 date.setDate(32)

                        1.12 把日期推到这个月 date.setDate(0)

                        1.13 设置 var maxDay = date.getDate()

                        1.14 把数据放入数组中  for(i = 1 ; i <= maxDay ; i++)  list.push(i)

                1.2 封装上个月的天数

                      // 注意：观察日历得知：本月的第一天是星期几能决定上个月显示几天

                        1.20 先创建当前时间     var date = new Date(time)

                        1.21 获取本月的第一天是星期几 date.setDate(1)   var week = date.getDay()

                        1.22 if(week === 0){week = 7}

                        1.23 把日期推到第0天  date.setDate(0) 

                        1.24 设置 var maxDay = date.getDate()

                        1.25 把数据放入数组中  for(i = maxDay - week + 2 ; i <= maxDay ; i++)

                                list.push(i)

                1.3 拼接上个月的天数   

                        1.31  var prevDays = getPrevDays(date);

                        1.32  prevDays.forEach(function(v) {  res += `<li style = 'color:#666;'>${v}</li>`   })

                1.4 拼接本月的天数

                        1.41  var nowDays = getNowDays(date);

                        1.42  nowDays.forEach(function(v) {  res += `<li >${v}</li>`  })

                1.5 拼接下个月的天数

                        1.51  for(var i = 1 ; i <= 42 - prevDays.length - nowDays.length ; i++)

                        1.52  {  res += `<li style = 'color:#666;'>${i}</li>` })

        2.下翻页：日期推到下个月

                        2.1 date.setDate(32);          getList()

        3.上翻页：日期推到上个月

                        3.1 date.setDate(0);             getList()

        var oList = document.getElementById('list');
        var oPrev = document.getElementById('prev');
        var oNext = document.getElementById('next');

        var date = new Date()
        getList()


        // 下翻页：日期推到下个月
        oNext.onclick = function () {
            date.setDate(32);
            getList()
        }

        // 上翻页：日期推到上个月
        oPrev.onclick = function () {
            date.setDate(0);
            getList()
        }



        function getList() {
            var res = '';

            // 拼接上个月的天数
            var prevDays = getPrevDays(date);

            prevDays.forEach(function(v) {
                res += `<li style = 'color:#666;'>${v}</li>`
            })
            // for(var i = 0 ; i < prevDays.length ; i++){
            //     res += `<li>${prevDays[i]}</li>`
            // }


            // 拼接本月的天数
            var nowDays = getNowDays(date);
            nowDays.forEach(function (v) {
                res += `<li>${v}</li>`
            })
            // for(var i = 0 ; i < nowDays.length ; i++){
            //     res += `<li>${nowDays[i]}</li>`
            // }

            // 拼接下一个月的天数
            for(var i = 1 ; i <= 42 - prevDays.length - nowDays.length ; i++){
                res +=`<li style = 'color:#666;'>${i}</li>`
            }
            

            oList.innerHTML = res
       }


        // 获取本月的天数
        function getNowDays(time) {
            var date = new Date(time);
            // 把日期推到下个月
            date.setDate(32);
            // 把日期推动本月
            date.setDate(0);

            var maxDay = date.getDate();

            var list = []
            for(i = 1 ; i <= maxDay ; i++){
                list.push(i)
            }
  
            return list 
        }


         // 获取上个月的天数
         // 注意：观察日历得知：本月的第一天是星期几能决定上个月显示几天
        function getPrevDays(time) {
            var date = new Date(time);

            // 先获取本月的第一天是星期几
            date.setDate(1)
            var week = date.getDay();

            if(week === 0) {
                week = 7
            }

            // 把日期推到第0天
            date.setDate(0);
            var maxDay = date.getDate();

            var list = []
            for(i = maxDay - week + 2 ; i <= maxDay ; i++){
                list.push(i)
            }

            return list
        }

效果图：

 

火火射射
关注
JavaScript学习笔记--进阶之路
JackieDYH的博客
03-16 1566
了解js特性&事件使用 20200316 1、JavaScript简介 历史： 第一个浏览器 就是文本和图片 网景公司 增强用户的使用体验 急需一门语言 实现用户和网页之间的交互 诞生：为了实现用户和网页的交互而出现 1、开发一门新语言 2、使用已经成熟的语言（java<sun> python c ------） ​ 这个时候使用的是java ---...
js 清除已运行的定时器clearTimeout() 和clearInterval()
最新发布
qq_45094682的博客
11-22 5070
清除已运行的定时器clearTimeout() 和clearInterval() 在做demo时很容易不给定时器设置一个变量存储，而是直接用定时器了，如果数据量大的话就会在控制台一直输出，这时候你应该静下心来把定时器清除就是了 假设我们有100,000条消息，根据视频播放的进度展示对应的消息，不展示历史消息。
clearInterval只终止定时器不终止函数
Hey firefly
07-23 6014
用return解决
JavaScript的异步操作
前端路上坎坎坷坷，总有一天站在顶峰仰望世界！！！
12-15 371
JavaScript的代码一般都是同步执行的，但是在一些情况下是异步执行的，在需要耗费时间的代码上他会持续等待，完成之后再继续往下执行，异步就是把代码放到另一个地方执行，执行完成后再把结果返回同步代码中，剩下的代码继续执行 setTimeout 把代码推迟执行 //一秒后执行 他会返回一个id，可以把id存储成一个变量 var timer=setTimeout(()=>{},1000) //停止setTimeout clearTimeout(timer) setinterval 每隔一段.
宏任务和微任务
liuhongboke的博客
04-25 589
执行顺序： js 是单线程执行的，js中的任务按顺序一个一个的执行，但是一个任务耗时太长； 那么后面的任务就需要等待，为了解决这种情况，将任务分为了同步任务和异步任务； 而异步任务又可以分为微任务和宏任务： 先是执行所有的同步任务，会在任务队列中取出可执行的异步任务，先将所有微任务执行完成后，才会执行宏任务，再去执行所有的微任务 ，直到循环完所有事件。 宏任务一般是：由宿主环境发起的称为宏观任务 包括整体代码script， setTimeout（定时器：setTimeout() 只执行 code 一次。如果
clearInterval不起作用？肯定是用法不对
Fly的博客
12-03 1万+
clearInterval不起作用？肯定是用法不对 1.场景 当一个定时器可能会被多次调用的时候，只清理一次肯定会出现没有清理完全的情况，这时候给你的错觉就是“clearInterval不起作用”。 2.用法 var timer = null; var timerList = []; function intervalStart() { intervalEnd(); timer =...
【2022.4.20修改】Vue_day02_模板语法_指令_表单数据绑定_DevTools使用
pre_eminent的JAVA学习园地
04-22 433
Vue.js 四天课程学习笔记_第2天课程内容概要:1. 介绍Vue中模板语法及数据绑定 主要是概述了el、data、 methods语法的作用及注意事项2. 介绍Vue指令 主要是v-html、v-once、v-if(渲染与否)、v-show(显示与否)、v-for(循环)、v-on(绑定事件,简写是@)、v-bind(单向绑定,简写是:)、v-model(双向绑定)3. 介绍表...
2021-02-26~27~28 大数据课程笔记 day37day38day39
qq_44745905的博客
02-28 3620
@R星校长 音乐数据中心平台 1.1 数据库与ER建模 1.1.1 数据库（DataBase） 数据库是按照数据结构来组织、存储和管理数据的仓库，是一个长期存储在计算机内的、有组织的、可共享的、统一管理的大量数据的集合。 数据库是以一定方式储存在一起、能与多个用户共享、具有尽可能小的冗余度、与应用程序彼此独立的数据集合，可视为电子化的文件柜，存储电子文件的处所，用户可以对文件中的数据进行新增、查询、更新、删除等操作，数据组织主要是面向事务处理任务。 1.1.2 数据库三范式 关系型数据库设计时，遵照一定的.
原js笔记
Pwsifeng的博客
01-10 2619
s原生JS笔记 电话：17339853876（微信同号） 二阶段学习内容 1、B/S架构（web结构） [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4LYi0Arv-1641803458638)(img1628929434621.png)] 2、前端工程师的工作 人机交互 前后端交互 3、HTML、CSS、JS的作用和关系 一个网页由三部分组成：HTML、CSS、Javascript HTML： 结构（静态） [外链图片转存失败,源站可能有防盗链
信息安全工程师第二版考试总结+笔记
热门推荐
IT技术
11-29 2万+
信息安全工程师第二版考试总结+笔记
【 javascript】异步定时器机制
weixin_55846296的博客
02-21 1178
同步异步 1. JS是单线程同步代码机制 => 当你写一个死循环的时候，后面的代码就全都不执行了 2. WEBAPI 给我们提供了一个队伍的机制 => 不会立即执行的代码 => 准备一个队列 => 我们叫做单线程异步 3. 异步： ==> 不会立即执行的代码 ==> 当代码从上到下的执行，遇到异步代码的时候 ==> 会把他放到队列里边，先不执行 ==> 等到所有同步代码执行完毕，再从队列里边拿代码里来执行 JS提供了两个异步定时器机制 1. setTimeou
【JavaScript 教程】异步操作——定时器
油墨香^-^的博客
06-08 1208
作者 | 阮一峰 JavaScript 提供定时执行代码的功能，叫做定时器（timer），主要由setTimeout()和setInterval()这两个函数来完成。它们向任务队列添加定时任务。 setTimeout() setTimeout函数用来指定某个函数或某段代码，在多少毫秒之后执行。它返回一个整数，表示定时器的编号，以后可以用来取消这个定时器。 var timerId = setTimeout(func|code, delay); 上面代码中，setTimeout函数接受两个参数，
JS 定时器setInterval clearInterval 延时器setTimeOut 异步 动画
HandsomeDanielWu的博客
07-28 203
JS 定时器setInterval clearInterval 延时器setTimeOut 异步 动画
setinterval是同步还是异步的问题
萧逸才的博客
06-02 1万+
虽然经常使用setInterval定时器方法，但没有注意过它是否是异步或同步的问题，因为以前写的关于setInterval的代码，基本模式是这样的：setInterval(function(){//do something...},1000);，所以在这种情况下是观察不到异步和同步的问题的，直到有一次我写了这样的代码：setInterval(function(){//do something...}
setInterval、clearInterval的回调函数，实现函数间调用的先后顺序
weixin_30314631的博客
05-10 1145
定义: var waitUnitil=function (untillCallBack, nextStepCallBack, count) { if (count == null) { count = 0; } var timer = setInterval(function (u...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值