前端复习之DOM、BOM

 BOM VS DOM：

    BOM：浏览器对象模型（API），专门操作浏览器窗口的API
         没标准！
    DOM：文档对象模型（API），专门操作网页内容的API
         可以对网页中任意对象，做任意修改！
         DOM是标准，90%以上浏览器都严格兼容
    核心DOM：操作所有结构化文档（XML，HTML）的通用API
    HTML DOM：针对HTML文档的简化API
    HTML DOM不能完成所有功能，实际开发中都是核心DOM与HTML DOM配合使用
    HTML DOM：网页中一切都是对象（元素，属性，文字）
        同一网页中所有对象，在内存中父子相连，形成一棵DOM树

2.***DOM树

文档中的元素、属性、文本、注释等都被看成一个节点对象--Node--所有节点对象的父类型
    当网页被加载进内存时，浏览器会为网页创建一个document对象。所有节点对象都是document对象的子节点。
    document(树根)，封装了对网页中所有子节点的增加，删除，查找
    
    Node类型定义了3个公共属性：
    nodeType：节点的类型的数值 
      何时使用：专门用于判断获得的节点类型
         如果是元素节点，返回1
         如果是文本节点，返回3
    nodeName：节点的名称
      何时使用：专门用于判断获得的标签名
         如果是元素节点，返回标签名
           **强调：nodeName返回的都是全大写标签名
          如果是文本节点，返回#text
       
    nodevalue：节点的值：
       元素节点，返回null
       文本节点，返回文本的内容

    childNode：获得当前节点对象下的所有子节点
           类数组对象，[i]   .length

    DOM树6种关系：6个属性：
        父子：4个：parentNode  childNode  firstChild  lastChild
        兄弟：2个：previousSibling  nextSibling

    childNodes：类数组对象，***动态集合***：自己不保存任何实际数据
                        每使用一次都重新查找一遍
    for(var i=0;i<parent.childNodes.length;i++)  X
    for(var i=0;len=parent.childNodes.length;i<len;i++)

 3.****遍历：

  从指定父元素开始，按照深度优先的原则 遍历所有各级子节点
    2步：
    1.定义一个函数，查找任意父节点下的所有直接子节点
    2.以深度优先为原则，递归调用函数本身

    何时使用递归调用：2个
    1.遍历不确定层级深度的树形结构时
       比如：网页中的元素，网盘中的文件夹结构
    2.不确定层级深度的多级管理结构：
    
    元素树：仅由元素节点组成的树结构
       其实有一组和节点树6个属性对应的元素树属性
                       节点树        元素树
          父对象     parentNode    parentElementNode
        所有子对象     childNodes    children
      第一个子对象     firstChild    firstElementChild
        最后子对象     lastChild    LastElementChild

       前一个兄弟     previousSibling   previousElementSibling
       后一个兄弟        nextSibling      nextElementSibling

     何时使用：只要仅希望遍历元素节点时，就用元素树
    问题：IE8不兼容，children可用
    
   DOM level2：遍历API：2个--选学
    1.深度优先遍历：NodeIterator
            节点迭代器
        如何使用：2步：
        1.创建遍历API对象：
        var iterator=document.createNodeIterator(
                开始的父节点对象，
                whatToShow，
                null，false
                )；
        whatToShow:NodeFilter.SHOW_ELEMENT
               NodeFilter.SHOW_ALL
        2.用while循环，反复调用iterator.nextNode()方法
        强调：1.只要nextNode(),就向下移动一次
              2.iterator.previousNode(),后退一次
    
    2.自由遍历：TreeWalker
        使用几乎相同，只不过TreeWalker比Iterator多个别方法

    总结：4种：节点树 元素树
        API（NodeIterator，TreeWalker）

 4.*查找：

5个API：
    1.按ID查找：var elem=document.getElementById("id值")；
    2.按标签名查找：（向下爬树的主要手段）
        var elems=parent.getElementsByTagName("标签名")；
            ***elems也是动态集合***
    3.按name属性查找：（专门用于查找表单中的元素）
        var elems=document.getElementsByName("name属性值")；
            ***elems也是动态集合***
    4.var elems=parent.getElementsByClass  ***elems也是动态集合***
    for(var i=0,len=elems.length;i<len;i++)

    5.Selector API：jQuery的核心
13       var elems=parent.querySelectorAll("任意选择器")
14         elems:包含所有属性和方法的完整对象的集合
15     for(var i=0;i<elems;i++)

5.获取或修改元素内容

 3个属性：
    1.innerHTML：获得/设置元素开始标签和结束标签之间的html原文
        何时使用：只要获得html原文内容时
        固定套路：2个：
          1.删除父元素下所有子元素
             parent.innerHTML="";
          2.批量替换父元素下所有子元素
             parent.innerHTML="所有子元素标签组成的html"
        比如：ul.innerHTML="<li>电影</li><li>剧集</li>"
    2.textContent/innerText:获得开始标签和结束标签之间的纯文本内容，不包含标签
       DOM标准    IE8
    3.文本节点的内容：nodeValue

6.**元素属性：

所有的元素都有attribute属性，[i]访问每个属性--了解
    读取属性：4中方法：
    1.element.attribute[下标].value
    2.var value=element.attribute["属性名"]
    3.element.getAttributeNode("属性名").value
 ***4.var value=element.getAttribute("属性名")
        何时使用：只要获得任意属性的值
    修改属性：2中：
      ***1.element.setAttribute(name,value);
         IE8不支持：
            只能element.attribute["属性名"]=value;
         2.element.setAttributeNode(attrNode);
    移除属性：2种：
      ***1.element.removeAttribute("属性名");
         2.element.removeAttributeNode(attrNode);
    判断属性：2种
      ***1.element.hasAttribute("属性名")；//true/false
         2.element.Attribute(attrNode);

       Property         vs         Attribute
      属性                        特性
对象在内存中存储的属性         元素对象在开始标签中定义的html属性和自定义属性

       访问html标准属性时，二者完全一致
    比如：<a href="http://tmooc.cn"...
        a.href-->属性             -->HTML DOM
        a.getAttribute("href")-->特性 -->核心DOM
       访问自定义属性时，二者不通用！
    <li data-age="29">Eric</li>
    读取自定义属性：li.data-age X错
            li.getAttribute("data-age");
    设置自定义属性：

7.元素样式：？？？

1.内联样式：
    修改: elem.style.css属性名=”值”;
      强调: css属性名必须去横线变驼峰
    问题: elem.style.css属性名 一次只能修改一个属性，要修改的属性多时，代码会很繁琐
    解决: 先将样式定义在class中，再用程序控制class

    获取: elem.style.css属性名 只能获得内联样式
      问题: 今后几乎没人写内联样式，很可能style什么样式也拿不到
      解决: 获取计算后的样式
       计算后的样式: 将最终应用到元素上的所有样式汇总到一起，并将相对单位的值计算为绝对单位值。
       何时: 只要获取元素的样式，都必须用计算后的样式
       如何: 2步:
       1. 获得计算后的样式对象style
         var style=getComputedStyle(elem);
       2. 从style对象中提取想要的css属性值
         var fontSize=style.fontSize;
       强调: 计算后的样式都是只读，不可修改！
    总结: 今后修改元素样式: elem.style… 
          获取元素样式: getComputedStyle()
    2.内部/外部样式表：禁止修改

8.*创建和删除节点、常用的HTML  DOM对象

1.*创建的删除节点
    1.创建节点：
       创建元素节点：3步
       1.创建空元素对象:
        var newElem=document.createElement("标签名")；
        比如：var a=document.createElement("a");
       2.设置必要属性：
        newElem.属性名="值"；
        newELem.innerHTML="文本"；
        比如：a.href="http://tmooc.cn";
             a.innerHTML="go to tmooc";
        <a href="http://tmooc.cn">go to tmooc</a>
       3.将元素对象挂载到指定父元素下：2种：
        追加：parent.appendChild(newElem);
        强调：只有向已经在页面中的父元素追加新节点，才导致渲染
        比如：div.appendChild(a);
        <div>
           ……
             <a href="http://tmooc.cn">go to tmooc</a>
        </div>
   2.创建文档片段：var frag=document.createDocumentfragment();
        DOM优化之一:尽量少的操作DOM树
         页面加载过程: 
         html -> DOM Tree
                  ↓
                 Render Tree -> *** layout *** -> paint
                  ↑             计算每个元素
         css -> CSS Model      的精确布局位置
         在页面加载过程中，layout是复杂度最高，最耗时的操作。
        只要出发页面样式的改变，都需要重新layout
       所以，要尽量减少操作DOM树的次数!
         如何: 
         1.如果同时添加父元素和子元素时，应该先在内存中将子元素拼都父元素中，
              最后再整体一次性将父元素添加到页面——只出发一次layout
         2.如果同时添加多个平级子元素时，用文档片段
           文档片段: 内存中临时存储多个平级子元素的虚拟父元素
      文档片段：内存中，临时存储多个子节点的存储空间
      何时使用文档片段？反复追加多个平级元素
      解决：先将所有平级元素追加到文档片段中
        frag.appendChild(child)
        将文档片段一次性追加到父元素下
        parent.appendChild(frag)
          *文档片段不参与追加*frag将子元素添加到页面后自动释放，不占页面内存

  3.  插入新元素：
        parent.insertBefore(newElem,oldElem);
      删除节点：parent.removeChild(oldElem);
        oldElem.parentNode.removeChild(oldElem);//自删
      替换节点：parent.replaceChild(newElem,oldElem);

  4.常用HTML DOM对象：
     Table对象：
       属性：
        tHead tFoot tBodies
        rows:获得表中所有行对象
        rows[i]：获得表中小标为i的一个元素
       方法：
        var newRow=insertRow(rowIndex):
                    rowIndex写-1，表示在末尾追加
        比如：insertRow(-1);
        核心DOM：var newRow=document.createElement("tr");
            table.appendChild(newRow)
        deleteRow(rowIndex):
        比如:currRow.parentNode.removeChild(currRow);
                table.deleteRow(currRow.rowIndex);

     TableRow对象：代表table对象中的某一个tr对象
        table.rows集合，就是一组TableRow对象的集合
        属性：
           cells：当前行中所有td对象
           cells[i]：获得当前行中下标为i的td
           rowIndex：当前行下标位置，专用于删除行
        方法：
           var newCell=insertCell(index)
           比如：insertCell(3)
             核心DOM：var td=document.createElement("td");
                  tr.appendChild(td);
           deleteCell(index)
    Select对象：
       属性：
        options：获得当前select下所有option
        options[i]：获得当前select下i位置的option
        selectedIndex：获得当前选中的option

        select.value 当前选中项的value，没有value，就返回选中项的内容
              select.options 保存select下所有option元素对象
                相当于: select.getElementsByTagName("option")
            select.options.length 保存select下option的个数
                清空select下所有option: select.options.length=0;
              select.length 等效于select.options.length
            清空select下所有option: select.length=0;
                                           select.innerHTML="";
              select.selectedIndex 当前选中项的下标

事件       事件: onchange 当选中项发生改变时

       方法：
        select.add(薪option对象)
        比如：select.appendChild(newOpt);
            select.add(newOpt);
        select.remove(index)

    Option对象：指代select下的一个option元素
       创建：
        var newOpt=new Option(innerHTML,value);
        创建option对象的同时，设置对象的innerHTML和value属性
        相当于：var newOpt=document.createElement("option");
            newOpt.innerHTML="内容"；
            newOpt.value="值"
        一句话：创建，设置，追加
        select.add(new Option(innerHTML,value))

        属性：index：获取当前option的下标位置，专用于删除
              selected：可当做bool用
            如果当前option被选中，返回true，否则false
    From对象：
       如何找到一个form对象
       var form=document.forms[i/name];
       如何知道到form中的一个数据采集元素：
        var elem=document.form.elements[i/name]

       事件：onsubmit:在正式提交表单前自动触发
        对整个表单执行验证
        form.onsubmit=function(){
            只要任意一个验证为通过，就*取消事件*：2步
            1.获得event对象e"
            var e=window.event||arguments[0];
            if(e.preventDefault){;//DOM
                e.preventDefault();
            }else{
            e.returnValue=false; //IE8
                }
    
       让元素获得或失去焦点：elem.focus()
                elem.blur()
       获得、失去焦点的事件：onfocus/onblurs;
       获得当前正在获得焦点的元素：document.activeElement

       表单提交：2种：直接点submit按钮
            如果当前form种任意元素获得焦点，按回车自动提交
            只要自动表单提交前，先触发onsubmit

9.BOM

1.*BOM：
        window对象：
    ****定时器--动画
 2.常用BOM对象：
    ***Navigator 

    1.BOM：专门操作浏览器窗口的对象
    window对象：
       1.充当全局对象！
       2.包含bom常用对象
    属性：
       大小于位置：
       1.window.innerHeight/innerWidth:文档显示区的大小
       outerHeight/outerWidth：      窗口的大小
       pageXOffset/pafeYOffset：     文档左上角到文档显示区左上角的距离

       2.screen.height/          桌面完整分辨率宽高
       screen.availHeight/availWidth:去掉任务栏后剩余的宽高
    
       3.调整大小：window.resizeTo(width,height)
            调整到
                 resizeBy(变化的width,变化的height)
       位置：
       1.左上角x坐标：window.screenLeft||window.screenX;
           y坐标：window.screenTop||window.screenY;
       2.将窗口移动到指定坐标：window.moveTo(x,y)
       3.事件发生时，鼠标的坐标(相对于整个屏幕)：event.screenX|screenY

    打开新连接：4种效果
       1.在当前窗口打开新连接，可后退
        html: <a href="url" target="_self"></a>
        js:[window].open("url","_self");
       2.在当前窗口打开新连接，禁止后退
        js: location.replace("url");
                   用新url代替history中当前url，结果: 无法后退

       3.在新窗口打开新连接，可同时打开多个
        html: <a href="url" target="_blank"></a>
            js: open("url","_blank")

       4.在新窗口打开新连接，只能打开一个    
        target-->目标窗口的名称
        _self:自动获得当前窗口名称
        _blank:创建一个新窗口，随机生成一个不重复的名字
        *窗口名：内存中打开新窗口会替换之前的窗口
    
        html：<a href="xxx" target="自定义窗口名"></a>
                window.name="自定义窗口名"
        js:  open("url","自定义name属性值")


     2.*定时器：让浏览器按指定时间间隔反复执行同一函数任务
    2种：
    周期性定时器：让浏览器按指定时间间隔反复执行同一任务，如果不手动停止，。。    
       一次性定时器：让浏览器等待一段时间间隔，执行一次任务自动停止。
        在一次性定时器的结尾，每次重新启动一个一次性定时器
    建议：尽量使用一次性代替周期性
    如何使用：周期性和一次性用法完全相同
    周期性：3件事：
    1.动画的每一步要执行的任务（函数对象）
      function step(){
        每一步要做的事情
    }
    2.将一步的任务放入定时器，反复调用
      setInterval(step,间隔毫秒数)
    3.必须用全局变量，临时存储定时器的编号
      clearInterval（timer）；timer=null;
   一次性：3件事：
    1.动画的每一步要执行的任务（函数对象）
      function step(){
        每一步要做的事情
        //根据条件判断是否有必要继续注册
    }
    2.讲一步的任务放入定时器，反复调用
      timer=setTimeout(step,间隔毫秒数|等待毫秒数)
    3.必须用全局变量，临时存储定时器的编号
      clearTimeout（timer）；timer=null;

10.常用BOM对象：navigator history location screen

1.navigator：保存浏览器配置信息的对象
        cookieEnabled：判断当前浏览器是否启用cookie
        plugins:保存所以插件对象的集合
        userAgent：保存了浏览器名称，版本好的字符串

    2.window常用子对象：history location screen
    history：window对象中保存当前窗体访问过的URL历史记录栈
       history.go(1):前进1次
          -1：后退1次
           2：前进2次
           0：刷新

    3.location：
      location.search:获得URL中的查询字符串
              如果进一步获得参数名和参数值？
                先按&分割，再按=号分离
      location.replace("新URL")：在当前窗口打开新连接，不可后退
                （history中旧的URL被新的替换了）
      使用location在当前窗口打开新连接：2中：
          location.href="新URL"；
          location.assign("新URL");
      刷新：
          location.reload();

    4.screen:封装当前屏幕的显示信息
      screen.height/完全屏幕宽高
      availHeight/Width:去掉任务栏后的宽高

 .***事件：

***事件：
        浏览器自动触发的或用户手动触发的对象状态的改变
       DOM level2 Event标准
       IE8：自成体系！
       事件处理函数：当事件触发时，自动执行的函数
        比如：<button onclick="函数/js语句"></button>

    事件处理：
       1.事件定义（绑定事件处理函数）3种：
         html:<标签 onxxx=""函数调用/js语句>
         js：elem.onxxx=函数对象；
        一个元素的事件处理函数，只能绑定一个函数对象
         DOM标准：elem.addEventListener("事件名",函数对象,是否在捕获阶段触发
)        一个元素的一个事件处理函数，可add多个不同函数对象
         IE8：elem.attachEvent("on事件名",函数对象)
       2.***事件周期：从浏览器捕获到事件后，一直到最后一个事件触发完，经历的过程。
        DOM标准：3个阶段
           1.（由外向内）捕获：从最外层html原素开始，向内逐层
              记录每层原素绑定的事件处理函数。到目标元素为止
           2.目标触发：自动执行目标元素上绑定的事件处理函数
           3.（由内向外）事件冒泡：从目标元素的父级元素开始，
              逐层向上执行每层的事件处理函数，到最外层html结束。
        IE8的事件周期：2个阶段：没有捕获
       3.event对象：
          当事件发生时，自动创建，封装了事件信息（eg：keyCode screenX）
        获得event对象：
          html：onclick="fun(event)"
        实际调用时：event会自动获得当前事件对象
        fun(e){
            e中获得的就是事件对象
        }
         js：elem.onxxx=fun;
        fun(){
            //DOM标准：自动创建event对象，默认以第一个参数传入
            //IE8：window全局的event属性，当事件发生时，
                也会自动创建event对象，但会保存在window.event中
        }
        event对象中包含：
        1.目标元素对象：var src=e.srcElement||e.target;
        2.***取消/利用冒泡：
          取消：DOM标准：e.stopPropagation()
                IE8：e.cancelBubble=true;
          一般用在当前事件处理结尾
        ***优化：如果多个子元素中定义了相同的事件处理函数
             其实，只需要在父元素上绑定一次，所有子元素即可共用
             1. 获得目标元素:
                不能用this, 因为this指父元素
                    应该用e.target，保存实际点击的目标元素
             2. 鉴别目标元素: 
                先判断目标元素的nodeName或className...
                只有目标元素符合要求时，才执行事件操作

             3.*取消事件：
              if(e.preventDefault){
                 e.preventDefault();//DOM
               }else{
                 e.returnValue=false;
              }
           何时取消：比如：表单提交前，如果验证未通过，则取消
         页面滚动: 
           事件: window.onscroll
          获得页面滚动位置: document.body.scrollTop
              页面超出文档显示区顶部的距离

        事件坐标: 3对儿: 
            1. 相对于整个屏幕左上角的坐标: e.screenX|screenY
          2. 相对于文档显示区左上角的坐标: e.clientX|clientY
          3. 相对于当前元素左上角的坐标: e.offsetX|offsetY