week总结3

99 阅读6分钟
BOM常用对象:
    history对象:保存了当前窗口的历史纪录(过去的url)
        前进:history.go(正数)
        后退:history.go(负数)
        刷新:history.go(0)
    location对象:保存了当前窗口的正在打开的url(现在的url)
    
    url的组成:
        协议
        主机号
        端口号
        文件的相对路劲
        查询字符串/请求消息
        
        属性:获取5个部分内容,查看直接输出location
            协议:location.protocol
            域名:location.hostname
            端口号:location.port
            路由:locatio.pathname
            请求消息:lacation.search
        方法:
            跳转:location="新的url"
            跳转后,禁止后退:location.replace("新的url")
            刷新:location.reloda()
    DOM:3分布:
        核心DOM
        HTMLDOM
        XMLDOM
        建议:优先使用HTMLDOM,实现不了的再使用核心DOM
        
        查找元素:2方面:
            关系:至少找到一个父元素,才可以调用关系网
        直接查找:2大类:
            var elems=document.ElementsByXXXX();返回一个动态集合
            
            
            var elems=document.querySelector("任意css选择器")
            找到了返回第一个,没找到返回一个null
            var elems=document.querySelectorAll(”任意css选择器)
            返回一个静态集合
       操作样式:
           内联样式:
               获取:elem.style.css属性名;--只能获取内联样式
               设置:elem.style.css属性名="css属性值"
               
               
       操作属性:
           获取属性值:
               核心DOM:elem.getAttribute("属性名")
               HTMLDOM:elem.属性名
               
           设置属性值:
               核心DOM:elem.setAttribute(""属性名)
               HTMLDOM:elem.属性名="属性值"
           删除属性:
               核心DOM:elem.removeAttribute("属性名")
               HTMLDOM:elem.属性名=""
               
           操作内容:innerHTML/innerText/value
           上树:
               创建空标签:
                   var elem.document.CreareElement("标签名")
               为其设置必要的属性和事件
                   elem.属性名="属性值"
                   elem.on事件名=function(){}
               上树:
                   父元素.appendChild(elem)
                   父元素.insertBefore(elem.已有子元素)
                   父元素.replaceChild(elem.已有子元素)
           删除元素:elem.remove()
       扩展:
           input/textarea的两个专属事件:onfocus(获取焦点)和noblur(失去焦点)
           创建变量的新方式:
               let 变量名=值;
           类数组对象变为普通数组:
               接住=Array.from(类数组)
递归:简单来说就是在函数中再一次条用户了函数自己,但是迟早有一天要让他停下来
        何时使用:专门用于【遍历层级不明确】的情况-DOM树和【数据】
        如何使用:
                function 函数名(){
                        root第一层要做什么直接做
                        判断有没有下一层,如果有下一层再次调用此方法,但是传入的实参是自己的下一层
                        }
                函数名(实际的根元素)
                
        算法:深度优先算法
        缺陷:不要过多使用,性能相对较差
        
        
        绑定事件:
            在HTML页面上书写事件属性:
                <elem on事件名="函数名()"> </elem>
            在js中使用事件处理函数属性:
                elem.on事件名=function(){操作}
            在JS中使用事件API:
                主流:elem.addEventListener("事件名",callback)
                老IE:elem.addachEvent("on事件名",callback)
                兼容:
                    解决if(elem.addEventListener){
                        elem.addEventListener("事件名",callback)
                    }eles{
                        elem.addachEvent("on事件名",callback)
                    }
                        
        扩展:
            select&option只有他们可以简化创建和上树!
                select.add(new Option("innerHTML","value"))
            
        
        事件周期:从事件发生,到所有事件处理函数执行完毕的全过程
            3个阶段:
                捕获阶段
                目标优先触发
                冒泡触发
        ******获取事件对象event:
            主流:会自动作为事件处理函数的第一个形参传入e
            老IE:event;
            兼容:event;
            
            事件对象event可以做什么?
                ***获取鼠标的坐标/位置:
                    获取鼠标相对于屏幕的坐标:e.screenX/Y;
                    获取鼠标相对于浏览器窗口/客户端/文档显示区域的坐标:e.clientX/Y;
                    获取鼠标相对于网页的坐标:e.pageX/Y;
            阻止冒泡:
                主流:e.stopPropagation()
                老IE:e.cancelBubble=true;
                兼容:e.cancelBubble=true;
            事件委托:
                主流:e.targetIE:e.srcElement
                兼容:e.srcElement
            阻止浏览器的默认行为:
                主流:e.preventDefault()
                老IE:e.returnValue=false
                兼容:e.returnValue=false
            新学事件:
                右键事件:window.oncontextmenu
                键盘事件:一般用于游戏开发比较多+都要搭配上键盘的键码
                    window.onkeydown-按下和按住都会触发,而且任何按键都会触发
                    window.onkeypress-按下和按住都会触发,但是只有数字,字母,回车,空格可以触发,其他都不行
                    window.onkeyup-松开的时候才会触发,而且任何按键都会触发
            获取键盘的键码:
                e.keyCode-可以获取到按了那个键,每个键都有自己对应的键码,不要记忆要么输出看,要么百度看e.keyCode表
            
            扩展:
                脱掉字符串的衣服:eval(str)-会悄悄的脱掉字符串的衣服再运算!
                判断标签名字:elem.nodeName-注意返回的标签名是大写组成的
            事件的取消绑定:
                如果用的elem.on事件名=()=>{} 取消绑定:elem.on事件名=null
                如果用的elem.addEventListener("事件名",f1)
                    取消绑定:
                        elem.removeEventListener("事件名",f1)事件名和回调函数【必须和添加时一模一样,是同一个】
            this的指向:
                单个元素绑定事件:this->这个元素
                多个元素绑定事件:this->当前触发事件的元素
                箭头回调函数中的this->外部对象
                ***函数中的this->当前正在调用函数的这个人
                定时器的this->window
            *****Es5强制改变this的指向:
                call/apply:临时的替换了函数之中的this--借用
                语法:
                    函数名.call(借用的对象,实参,....)--单独传入每个实参
                    函数名.apply(借用的对象,arr)--只能传入一个实参,要求必须是一个数组:apply会悄悄的将数组打散
                    强调:call/apply,相当于立刻调用函数,是会立刻执行的,而且会还给别人,才叫借用
                bind:永久的替换了函数中的this--买
                    语法:
                        var 新函数=函数名.bind(指定对象,永久的固定的实参)
                     3件事:
                         创建了一个和原函数功能完全相同的新函数
                         将新函数中的this永久绑定了为指定对象,别人都借不走
                         将新函数的部分参数永久固定的
                      强调:
                          bind绑定的新函数没有办法被call/apply再次借走!
                          买是不会立刻调用的需要自己手动调用一下
                          
                三个固定套路:
                          Math.max/min.apply(Math,arr)
                          类数组转为普通数组:
                              老方法:接住=Array.prototype.slice.call/apply(类数组)
                              新方法:接住=Array.from(类数组)
                Es5-严格模式:"use strict"
                
                Es6:大版本-导致语法变化很大;
                            模板字符串:可以直接识别变量,不需要用+运算再拼接出拼接了,而且实现了一个简单的JS的环境,甚至支持在里面使用API做操作
                                `我的名字叫${name}`
                            *****解构赋值
                                顾名思义:解析结构再进行赋值--赋值的新方式并且得到了增强
                                如果赋值符号,左右两边的结构是一样的,他就会悄悄的解开/脱掉结构再一一进行赋值
                                如何使用:
                                    类数组的解构赋值
                                    类似对象的解构赋值
                                    调用函数时,传递实参的顺序无所谓了--往往很多框架之中!都会用到这个结构赋值
                                    函数的返回结果,可以有多个了
                             
                            新的循环:for...of
                            
                            SetMapSet有点用【去重数组然后再转回数组】 [...new Set(arr)]
                            ...--扩展运算符,咳哟脱掉数组/对象的衣服
正则:
        正则表达式:定义字符串中字符出现规则的表达式
            何时使用:切割,替换,【验证】
            如何使用:语法:/正则表达式/
                最简单的正则就是关键字原文:"no"->/no/后缀
                           后缀:g:找全部  i:忽略大小写
                备选字符集:/[备选字符集]/
                        强调:
                            一个中括号,只管一位字符
                            问题:正则表达式默认只要满足了就不管后续了,而我们做验证的人希望的是用户从头到尾完全按照我们的要求来,希望完全匹配
                                解决:前加^后加$两者同时使用,代表要求从头到尾【完全匹配】--/^[备选字符集]$/
                                
        特殊:如果备选字符集中ASCLL码是连续的,那么可用-省略掉中间部分
            比如:
                一位数字:[0-9]
                一位字母;[A-Za-z]
                一位数字、字母、下划线:[0-9A-Za-z_]
                一位汉字:[\u4e00-\u9fa5]
                一位数字、字母、下划线、波浪号、汉字:[0-9A-Za-z_~\u4e00-\u9fa5]
                除了xxx之外的:[^0-9]--很少使用,范围太广了
         预定义字符集:
                 一位数字:\d
                 一位数字、字母、下划线:\w
                 一位空白字符:\s -- 什么叫空白字符:空格、制表符、换行
                 一位除了换行外的任意字符: .  --  很少使用,范围太广了
          建议:优先使用预定义字符集,满足不了再用备选字符集补充
          
          问题:不管是备选字符集,还是预定义字符集,一个都只管一位
          量词:规定一个字符集出现的次数
              有明确数量:
                  字符集{n,m}:前边相邻的字符集最少出现n个,最多出现m个
                  字符集{n,}:前边相邻的字符集最少出现n个,多了不限
                  字符集{n}:铅笔相邻的字符集,必须出现几个
              无明确数量:
                  字符集?:前边相邻的字符集,可有可无,最多一个
                  字符集*:前边相邻的字符集,可有可无,多了不限
                  字符集+:前边相邻的字符集,至少一个,多了不限
          选择和分组:
              选择:在多个规则中选一个,选择往往都要和分组进行搭配
                      规则1|规则2
              分组:将多个字符集临时组成一组子规则
                      (规则1|规则2)
           密码验证强度:
               预判公式:
                   (?![0-9]+$)
                   (?![0-9a-z]+$)
                   (?![0-9A-Za-z]+$)
支持正则的字符串API:
        *切割:var arr=str.split("固定切割符"/RegExp)
        *****替换:很有可能出现在笔试中
            基础替换法:
                var newStr=str.replace(RegExp);
            高级替换法:
                var newStr=str.replace(/[][]/+g,function(key,i,str){
                        console.log(key);//关键字
                        console.log(i);//关键字的下标
                        console.log(str);//原文本身
                        return a.length==2?"**":"***";
                })
             格式化:
                 var idCard="500236200207183791"
                 var reg=/(\d{6})(\d{4})(\d{2})(\d{2})(\d{4})/;
                 var newStr=idCard.replace(reg,function(a,b,c,d,e,f,g,h){
                    //在replace的时候,如果正则中出现了分组,那我们会得到更多的形参
                    //在形参key的后面就会出现n个形参,具体有多少个,看你有多少个分组
                    //第1个分组获得的内容会保存到第2个形参之中
                    //第2个分组获得的内容会保存到第3个形参之中
                    //第3个分组获得的内容会保存到第4个形参之中
                    //.....
                    //倒数第二个形参是下标
                    //倒数第一个是原文
                    return `${c}${d}${e}日`
                 })
              正则对象:
                  创建:
                      直接量:var reg=/正则表达式/后缀
                      构造函数:var reg=new RegExp("正则表达式","后缀")
                  API:
                      验证:var bool=reg.test(str);
                      true->验证成功  false->验证失败
              
              扩展:
                  边输入边判断:input.oninput--每次内容改变就会触发
                  鼠标按下:onmousedown
                  鼠标松开:onmouseup