今日学习任务

  • [ ] 1.DOM节点

  • [ ] a.了解节点与元素的区别

  • [ ] b.节点与元素相关操作（常用只有两个：子元素children与父节点parentNode）

  • [ ] 子节点与子元素

  • 兄弟节点与兄弟元素
  • 第一个子节点与第一个子元素
  • 最后一个子节点与最后一个子元素
  • 获取父节点
  • 案例：点击关闭二维码

  • [ ] 2.dom增删改页面元素

  • [ ] a.语法

  • [ ] 创建子元素createElement()

  • 增加子元素appendChild()
  • 插入子元素insertBefore()
  • 替换子元素replaceChild()
  • 移除子元素removeChild()
  • 克隆元素cloneNode()

  • [ ] b.案例

  • [ ] 选择职业技能

  • 模拟百度搜索框

  • [ ] 3.BOM:浏览器对象模型

  • [x] window对象：浏览器窗口

  • location对象：地址栏
  • history对象：网页历史记录
  • navigator对象：浏览器信息
  • screen对象：电脑屏幕信息

01-DOM节点：网页一切内容皆节点

1.1-DOM节点介绍

  • 1.什么是节点：在HTML文档中，一切皆节点（HTML文档本身、标签、属性、注释内容、文本）
  • 2.什么是元素：元素在HTML中叫做标签，在JS的dom对象中称为元素（可以理解为标签的面向对象的叫法）
  • 3.HTML标签属于节点的一种，叫做元素节点

  • 4.节点三要素：

    • 节点类型：标签、属性、注释、文本，nodeType
    • 节点名称：p、div、class（属性名），nodeName
    • 节点的值：one（属性的值），nodeValue

  • 在JavaScript中，document这个对象大家一定很熟悉，哪怕是刚刚开始学习的新人，也会很快接触到这个对象。而document对象不仅仅是一个普通的JavaScript内置对象，它还是一个巨大API的核心对象，这个巨大的API就是DOM（Document Object Model），它将文档的内容呈现在JS面前，并赋予了JS操作文档的能力。

    • DOM树体现着HTML页面的层级结构，学习中经常提到的父元素子元素的说法也是建立在树这种数据结构的基础之上的,而DOM文档树则包含文档中所有内容。

day03 - 图1

  • HTML页面中的所有内容都会体现在DOM文档树中，要理解这种结构，对构成它的每个节点就要先有了解。下面是DOM节点的基本类别，以及各自类别基本属性的值及简单介绍：

day03 - 图2

1.2-元素节点与属性节点

  • 1.元素节点

    • 类型 nodeTypoe:1
    • 名称 nodeName：标签名大写
    • 值 nodeValue ： null

  • 2.属性节点

    • 类型 nodeTypoe:2
    • 名称 nodeName：属性名
    • 值 nodeValue ： 属性值
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  9. <div class="one" id="box">我是一个div</div>
  10. <p class="one" id="p1">我是一个p</p>
  12. </body>
  14. <script>
  15.     /*1.元素节点
  16.         * 类型 nodeTypoe:1
  17.         * 名称 nodeName：标签名大写
  18.         * 值 nodeValue ： null
  19.       2.属性节点
  20.         * 类型 nodeTypoe:2
  21.         * 名称 nodeName：属性名
  22.         * 值 nodeValue ： 属性值
  23.      */
  25.     //1.获取到元素节点
  26.     let box = document.querySelector('#box');
  27.     let p1 = document.querySelector('#p1');
  28.     //2.查看元素节点
  29.     console.log ( box.nodeType );//1
  30.     console.log ( box.nodeName );//DIV
  31.     console.log ( box.nodeValue );//null
  33.     console.log ( p1.nodeType );//1
  34.     console.log ( p1.nodeName );//P
  35.     console.log ( p1.nodeValue );//null
  37.     //3.获取到属性节点
  38.     console.log ( box.getAttribute ( "class" ) );//这个只是单纯的获取class属性的值，不是获取属性节点
  39.     console.log ( box.attributes );//查看box元素的所有属性节点
  41.     //4.查看属性节点
  42.     console.log ( box.attributes[0].nodeType );//2
  43.     console.log ( box.attributes[0].nodeName );//class
  44.     console.log ( box.attributes[0].nodeValue );//one
  45. </script>
  46. </html>

1.3-文本节点与注释节点与文档节点

  • 1.文本节点

    • 类型 nodeTypoe:3
    • 名称 nodeName：#text
    • 值 nodeValue ： 文本内容

  • 2.注释节点

    • 类型 nodeTypoe:8
    • 名称 nodeName：#comment
    • 值 nodeValue ： 注释内容

  • 3.文档节点

    • 类型 nodeTypoe:9
    • 名称 nodeName：#document
    • 值 nodeValue ： null
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8. <ul id="ul1">我是文本内容
  9.     <!--我是注释内容-->
  10.     <li>隔壁老王1</li>
  11.     <li>隔壁老王2</li>
  12.     <li>隔壁老王3</li>
  13.     <li>隔壁老王4</li>
  14.     <li>隔壁老王5</li>
  15. </ul>
  16. </body>
  18. <script>
  19.     /*1.文本节点
  20.         * 类型 nodeTypoe:3
  21.         * 名称 nodeName：#text
  22.         * 值 nodeValue ： 文本内容
  23.         *
  24.       2.注释节点
  25.         * 类型 nodeTypoe:8
  26.         * 名称 nodeName：#comment
  27.         * 值 nodeValue ： 注释内容
  28.         *
  30.        3.文档节点
  31.         * 类型 nodeTypoe:9
  32.         * 名称 nodeName：#document
  33.         * 值 nodeValue ： null
  35.      */
  37.     //获取元素节点
  38.     let ul1 = document.querySelector('#ul1');
  39.     //获取元素节点下的所有子节点（元素之间的空格部分可以看作一个没有内容的文本节点）
  40.     let nodeList = ul1.childNodes;
  41.     console.log ( nodeList );
  43.     //查看文本节点
  44.     console.log ( nodeList[ 0 ].nodeType );//3
  45.     console.log ( nodeList[ 0 ].nodeName );//#text
  46.     console.log ( nodeList[ 0 ].nodeValue );//文本内容
  48.     //查看注释节点
  49.     console.log ( nodeList[ 1 ].nodeType );//8
  50.     console.log ( nodeList[ 1 ].nodeName );//#comment
  51.     console.log ( nodeList[ 1 ].nodeValue );//注释内容
  53.     //查看文档节点（文档节点就是document自己）
  54.     console.log ( document.nodeType );//9
  55.     console.log ( document.nodeName );//#document
  56.     console.log ( document.nodeValue );//null
  58. </script>
  59. </html>

1.4-获取子节点与子元素

  • childNodes：获取子节点：（文本节点，注释节点，子元素节点）

    • 细节：属性节点通过attribute来获取，一般用的不多
    • 浏览器兼容问题：IE8及之前不包含非空文本

  • children：获取子元素：（元素节点）

    • 浏览器兼容问题: IE8及之前包含注释节点
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  7.     <title>Document</title>
  8. </head>
  9. <body>
  10.     <ul id="ul1">
  11.         我是班长的小迷妹
  12.         <!-- 我是暗恋班长的班花 -->
  13.         <li>我是班长1</li>
  14.         <li>我是班长2</li>
  15.         <li>我是班长3</li>
  16.         <li>我是班长4</li>
  17.         <li>我是班长5</li>
  18.     </ul>
  20.     <script>
  21.     /*本小节知识点：获取子元素与子节点
  22.         1.获取子元素： 父元素.children
  24.         2.获取子节点： 父元素.childNodes
  25.      */ 
  27.      let ul1 = document.querySelector('#ul1');
  29.      //1.获取子元素： 元素节点
  30.      /* 
  31.      谷歌火狐：元素节点
  32.      IE8：包含注释和元素
  33.      */
  34.      console.log(ul1.children);
  37.      //2.获取子节点: 元素节点  文本节点  注释节点
  38.      /* 
  39.      谷歌火狐：  包含空文本
  40.      IE8：  不包含空文本
  41.      */
  42.      console.log(ul1.childNodes);
  44.     </script>
  45. </body>
  46. </html>

1.5-兄弟节点与兄弟元素

本小节知识点：获取兄弟节点与兄弟元素

  • nextSibling：获取下一个节点 previousSibling：获取上一个节点

    • IE8及之前：文本（不包含非空）、注释、元素
    • 其他浏览器：文本（包含非空）、注释、元素
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  7.     <title>Document</title>
  8. </head>
  9. <body>
  10.     <ul id="ul1">
  12.         我是班长的小迷妹
  13.         <!-- 我是暗恋班长的班花 -->
  14.         <li>我是班长1</li>
  15.         <!-- svkhskvhb -->
  16.         <li id="li2">我是班长2</li>666
  17.         <li>我是班长3</li>
  18.         <li>我是班长4</li>
  19.         <li>我是班长5</li>
  20.     </ul>
  22.     <script>
  23.     /*本小节知识点：获取兄弟元素与兄弟节点
  24.         1.获取兄弟节点
  25.             * 上一个节点： 元素.previousSibling
  26.             * 下一个节点： 元素.nextSibling
  28.         2.获取兄弟元素(常用)
  29.             * 上一个元素：元素.previousElementSibling
  30.             * 下一个元素 元素.nextElementSibling
  31.      */ 
  33.      let ul1 = document.querySelector('#ul1');
  34.      let li2 = document.querySelector('#li2');//班长2
  37.      //1.兄弟节点：  元素、注释、文本
  39.      //1.1 获取上一个节点
  40.      console.log(li2.previousSibling);
  42.      //1.2 获取下一个节点
  43.      console.log(li2.nextSibling);
  46.      //2.兄弟元素:  元素
  47.      //2.1 获取上一个元素
  48.      console.log(li2.previousElementSibling);
  49.      //2.2 获取下一个元素
  50.      console.log(li2.nextElementSibling);
  52.     </script>
  53. </body>
  54. </html>

1.6-第一个子节点与第一个子元素

  • 1.firstChild : 第一个子节点

  • 2.firstElementChild：第一个子元素节点

    • 他们两者的浏览器兼容问题与兄弟节点一致
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  7.     <title>Document</title>
  8. </head>
  9. <body>
  10.     <ul id="ul1">
  11.             我是班长的小迷妹
  12.             <!-- 我是暗恋班长的班花 -->
  13.             <li>我是班长1</li>
  14.             <!-- svkhskvhb -->
  15.             <li id="li2">我是班长2</li>666
  16.             <li>我是班长3</li>
  17.             <li>我是班长4</li>
  18.             <li>我是班长5</li>
  19.     </ul>
  21.     <script>
  22.     /*本小节知识点：获取第一个子元素与第一个子节点
  23.         1.获取第一个子节点： 父元素.firstChild
  24.         2.获取第一个子元素:  父元素.firstElementChild
  25.      */ 
  27.      let ul1 = document.querySelector('#ul1');
  29.      //1.获取第一个子节点 (元素 文本  注释)
  30.      console.log(ul1.firstChild);
  32.      //2.获取第一个子元素: 元素
  33.      console.log(ul1.firstElementChild);
  35.     </script>
  36. </body>
  37. </html>

1.7-最后一个节点与最后一个元素

  • 1.lastChild : 最后一个子节点

  • 2.lastElementChild：最后一个子元素节点

    • 他们两者的浏览器兼容问题与兄弟节点一致
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  7.     <title>Document</title>
  8. </head>
  9. <body>
  10.     <ul id="ul1">
  11.             我是班长的小迷妹
  12.             <li>我是班长1</li>
  13.             <!-- svkhskvhb -->
  14.             <li id="li2">我是班长2</li>666
  15.             <li>我是班长3</li>
  16.             <li>我是班长4</li>
  17.             <li>我是班长5</li>
  18.              <!-- 我是暗恋班长的班花 -->
  19.             </ul>
  21.     <script>
  22.     /*本小节知识点：获取最后一个子元素与最后一个子节点
  23.         1.获取最后一个子节点： 父元素.lastChild
  24.         2.获取最后一个子元素:  父元素.lastElementChild
  25.      */ 
  27.      let ul1 = document.querySelector('#ul1');
  29.      //1.获取最后一个子节点 (元素 文本  注释)
  30.      console.log(ul1.lastChild);
  32.      //2.获取最后一个子元素: 元素
  33.     console.log(ul1.lastElementChild);
  35.     </script>
  36. </body>
  37. </html>

1.8-获取父节点

parentNode:获取元素的父元素节点

  • 细节：一个元素的父节点一定是一个元素，而不是（文本、注释、属性），只有元素才有子节点
  1. <!DOCTYPE html>
  2. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  8.     <title>Document</title>
  9. </head>
  11. <body>
  12.     <ul id="ul1">
  13.         我是班长的小迷妹
  14.         <li>我是班长1</li>
  15.         <!-- svkhskvhb -->
  16.         <li id="li2">我是班长2</li>666
  17.         <li>我是班长3</li>
  18.         <li>我是班长4</li>
  19.         <li>我是班长5</li>
  20.         <!-- 我是暗恋班长的班花 -->
  21.     </ul>
  23.     <script>
  24.         //获取元素的父节点： 子元素.parentNode
  25.         let li2 = document.getElementById('li2');
  26.         //获取元素的父节点一定是元素。  （因为只有元素节点才会有节点）
  27.         console.log(li2.parentNode);//ul1
  29.         console.log(li2.parentNode.parentNode);//body
  30.         console.log(li2.parentNode.parentNode.parentNode);//html
  31.         console.log(li2.parentNode.parentNode.parentNode.parentNode);//document
  32.         console.log(li2.parentNode.parentNode.parentNode.parentNode.parentNode);//null
  33.     </script>
  34. </body>
  35. </html>

1.9-案例：点击关闭二维码

day03 - 图3

  • 需求：点击二维码图片右上角的小叉叉，关闭二维码
  • 思路：给子元素添加一个点击事件，点击之后移除父元素
  1. <!DOCTYPE html>
  2. <html>
  4. <head lang="en">
  5.     <meta charset="UTF-8">
  6.     <title>关闭二维码</title>
  7.     <style>
  8.         .box {
  9.             border: 1px solid #D9D9D9;
  10.             margin: 100px auto;
  11.             position: relative;
  12.             width: 107px;
  13.         }
  15.         #x {
  16.             border: 1px solid #D9D9D9;
  17.             width: 14px;
  18.             height: 14px;
  19.             line-height: 14px;
  20.             color: #D6D6D6;
  21.             cursor: pointer;
  22.             position: absolute;
  23.             top: 0;
  24.             left: -15px;
  25.         }
  26.     </style>
  27. </head>
  29. <body>
  31.     <div class="box">
  32.         <img src="images/taobao.jpg" alt="" />
  33.         <span id="x">×</span>
  34.     </div>
  36.     <script>
  38.         //1.获取元素
  39.         let xx = document.querySelector('#x');
  40.         //2.注册事件
  41.         xx.onclick = function () {
  42.             //3.事件处理:隐藏box
  43.             // box1.style.display = 'none';
  44.             //点击xx，就把xx的父元素给隐藏
  45.             this.parentNode.style.display = 'none';
  46.         };
  49.     </script>
  50. </body>
  52. </html>

02-dom增删改页面元素

语法 示例 描述
document.createElement() document.createElement(‘li’) 创建空标签元素
父元素.appendChild(子元素) ul.appendChild(li) 添加子元素
父元素.insertBefore(子元素) ul.insertBefore(元素A，元素B) 将元素A插入到元素B的前面
父元素.replaceChild(子元素) ul.replaceChild(元素A，元素B) 元素A替换元素B
父元素.removeChild(子元素) ul.removeChild(li) 移除子元素

1.1-创建元素三种方式介绍

  • 1.document.write():慎用，可能会覆盖原本内容

    • 解析字符串识别标签

  • 2.innerHTML：创建元素过多时（100以内可以忽略），会损耗性能

    • 解析字符串识别标签
    • 直接赋值 元素.innerHTML 会替换原本内容，如果不想替换使用 += 拼接

  • 3.document.createElement()：dom推荐方式

    • 动态创建一个dom对象（空标签，需要自己设置属性）在内存中
    • 需要使用appendChild来添加到HTML

  • document.write():慎用，因为可能会覆盖原本的内容

    • 覆盖内容的原理了解即可：编译器从上往下解析HTML的时候会形成一个文档流，这个文档流会在文档所有的HTML标签解析后关闭。不会覆盖的情况：如果在关闭这个文档流之前调用document.write()，则不会覆盖会覆盖的情况：如果在关闭文档流之后调用document.write()，会开启一个新的文档流，此时会把上一个文档流中的内容覆盖
  1. <!DOCTYPE html>
  2. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  8.     <title>Document</title>
  9. </head>
  11. <body>
  12.     <div>我是班长</div>
  14.     <button onclick="document.write('<p>我是马云6666</p>');">点我有惊喜</button>
  16.     <script>
  18.         //1.document.write()
  19.         //不常用，因为可能会覆盖网页原先的内容
  20.         /*覆盖原理
  21.         1.当html文件加载的时候，浏览器会生成一个默认文档流，当页面全部加载完毕之后默认文档流会完毕。
  22.         如果此时调用 document.write()浏览器会生成一个新的文档流，重新渲染页面
  23.         2.不会覆盖：  在默认文档流没有关闭之前调用 document.write()
  24.         3.会覆盖：  在默认文档流关闭之后调用 document.write()
  26.          */
  27.         document.write('<p>我是马云</p>');
  29.         //2.innerHTML ： 少用，存在性能问题（100以内忽略不计）
  30.         //直接赋值会替换原有的内容
  31.         // document.body.innerHTML = '<div>黑马程序员</div><a href="#">我是链接</a>';
  32.         //如果希望添加，可以使用字符串连接符
  33.         //  document.body.innerHTML += '<div>黑马程序员</div><a href="#">我是链接</a>';
  35.         //3. dom推荐方式： createElement
  38.         /*
  39.         参数：标签名字符串
  40.         返回值：元素节点
  41.         特点： （1）创建出来的元素只是在内存中，并没有显示到页面中，需要手动添加
  42.                 （2）创建出来的是空标签
  43.          */
  45.         // (1) 创建空元素
  46.         // let box = document.createElement('div');
  47.         // (2) 添加属性
  48.         // box.id = 'box';
  49.         // box.innerText = '我是新来的div';
  50.         // (3) 添加到页面
  51.         // document.body.appendChild(box);
  53.     </script>
  54. </body>
  56. </html>

1.2-练习：点击按钮创建多个标签

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  7.     <title>Document</title>
  8. </head>
  9. <body>
  10.     <button id="btn">点我</button>
  12.     <script>
  13.         //注册事件
  14.         document.querySelector('#btn').onclick = function(){
  16.             //1.innerHTML:1340.5ms
  17.             // console.time()
  18.             // for(let i = 1;i<=1000;i++){
  19.             //     document.body.innerHTML += '<p>我是第' + i + '个p标签</p>'
  20.             // };
  21.             // console.timeEnd()
  23.             //2.createElement : 2ms
  24.             console.time()
  25.             for(let i = 1;i<=1000;i++){
  26.                 //1.创建空标签  (1)空标签  (2)只是在内存创建，需要手动添加
  27.                let p = document.createElement('p');
  28.                //2.添加属性
  29.                p.innerText = '我是第' + i + '个p标签';
  30.                //3.添加到页面: appendChild()
  31.                document.body.appendChild(p);
  32.             };
  33.             console.timeEnd()
  34.         }
  35.     </script>
  36. </body>
  37. </html>

1.3-添加子元素：appendChild()

  • appendChild()添加元素有三种情况

    • （1）如果是一个新的子元素，则默认会添加到最后
    • （2）如果是一个已存在的子元素，相当于移动到最后面
    • （3）如果添加的元素有子元素，子元素也会一起移动到最后面
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  7.     <title>Document</title>
  8. </head>
  9. <body>
  10.     <ul id="ul1">
  11.         <li>隔壁老牛1</li>
  12.         <li>隔壁老牛2</li>
  13.         <li>隔壁老牛3</li>
  14.         <li>隔壁老牛4</li>
  15.         <li>隔壁老牛5</li>
  16.     </ul>
  18.     <ul id="ul2">
  19.         <li>我是马云1</li>
  20.         <li id="li2">我是马云2</li>
  21.         <li>我是马云3</li>
  22.         <li>我是马云4</li>
  23.         <li>我是马云5</li>
  24.     </ul>
  26.     <script>
  27.         /*本小节知识点： 父元素.appendChild(子元素)
  28.         1. 新创建子元素 : 添加到最后面
  29.         2. 已经存在元素 : 移动到最后面
  30.         3. 父元素有子元素: 父元素和子元素一起移动到后面
  31.          */
  32.         let ul1 = document.getElementById('ul1');
  33.         let ul2 = document.getElementById('ul2');
  35.         //1.新创建元素
  36.         let newLi = document.createElement('li');
  37.         // newLi.innerText  = '我是新来的';
  38.         ul1.appendChild(newLi);
  40.         //2.已经存在的元素
  41.         let li2 = document.getElementById('li2');//马云2
  43.         ul1.appendChild(li2);
  45.         //3.元素有子元素
  46.         ul1.appendChild(ul2);
  47.     </script>
  48. </body>
  49. </html>

1.4-插入子元素：inertBefore()

insertBefore:插入子元素到指定位置

  • 语法： 父元素.insertBefore(要插入的标签，插入到哪一个标签前面)

  • 特点：与appendChildNode一致

    • （1）如果是新元素则插入到指定位置
    • （2）如果是已存在元素则移动到指定位置
    • （3）如果元素有子元素，则子元素随着它一起移动
  • 如果想插入到某元素后面，没有直接的api，可以先获取该元素的下一个元素，然后插入到下一个元素前面即可
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  7.     <title>Document</title>
  8. </head>
  9. <body>
  10.     <ul id="ul1">
  11.         <li>隔壁老牛1</li>
  12.         <li>隔壁老牛2</li>
  13.         <li id="li3">隔壁老牛3</li>
  14.         <li>隔壁老牛4</li>
  15.         <li>隔壁老牛5</li>
  16.     </ul>
  18.     <ul id="ul2">
  19.         <li>我是马云1</li>
  20.         <li id="li2">我是马云2</li>
  21.         <li>我是马云3</li>
  22.         <li>我是马云4</li>
  23.         <li>我是马云5</li>
  24.     </ul>
  26.     <script>
  27.         /*本小节知识点： 父元素.insertBefore(A元素，B元素) : A元素插入B元素的前面
  28.         1. 新创建子元素 :  添加到指定位置
  29.         2. 已经存在元素 :  移动到指定位置
  30.         3. 父元素有子元素:  元素和子元素一起移动到指定位置
  31.          */
  32.         let ul1 = document.getElementById('ul1');
  33.         let ul2 = document.getElementById('ul2');
  34.         let li3 = document.getElementById('li3');//老牛3
  36.         //1.新创建元素
  38.       let newLi =   document.createElement('li');
  39.       newLi.innerText = '我是新来的';
  40.       ul1.insertBefore(newLi,li3);//newLi插入到li3的前面
  43.         //2.已经存在的元素
  44.         let li2 = document.getElementById('li2');//马云2
  45.         ul1.insertBefore(li2,li3);
  47.         //3.元素有子元素
  49.         ul1.insertBefore(ul2,li3);
  51.     </script>
  52. </body>
  53. </html>

1.5-替换子元素：replaceChild()

  • 替换子元素：replaceChild() 语法：父元素.replaceChile(新元素,旧元素)

  • 特点：

    • 1.如果是新创建的元素，则直接替换
    • 2.如果是已存在的元素（不论这个元素是自己的子元素还是别人的）会将新元素移动到旧元素位置，并且旧元素被移除
    • 3.如果已存在的元素有子元素，则子元素会随着父元素一起替换
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  7.     <title>Document</title>
  8. </head>
  9. <body>
  10.     <ul id="ul1">
  11.         <li>隔壁老牛1</li>
  12.         <li>隔壁老牛2</li>
  13.         <li id="li3">隔壁老牛3</li>
  14.         <li>隔壁老牛4</li>
  15.         <li>隔壁老牛5</li>
  16.     </ul>
  18.     <ul id="ul2">
  19.         <li>我是马云1</li>
  20.         <li id="li2">我是马云2</li>
  21.         <li>我是马云3</li>
  22.         <li>我是马云4</li>
  23.         <li>我是马云5</li>
  24.     </ul>
  26.     <script>
  27.         /*本小节知识点： 父元素.replaceChild(A元素,B元素)  A元素替换B元素
  28.         1. 新创建子元素 :   替换元素
  29.         2. 已经存在元素 :   先移动，后替换
  30.         3. 父元素有子元素:   父元素和子元素一起 先移动,后替换
  31.          */
  32.         let ul1 = document.getElementById('ul1');
  33.         let ul2 = document.getElementById('ul2');
  34.         let li3 = document.getElementById('li3');//老牛3
  36.         //1.新创建元素
  38.     //   let newLi =   document.createElement('li');
  39.     //   newLi.innerText = '我是新来的';
  41.     //   ul1.replaceChild(newLi,li3);//newLi替换li3
  44.         //2.已经存在的元素
  45.         // let li2 = document.getElementById('li2');//马云2
  46.         // ul1.replaceChild(li2,li3);//li2替换li3
  48.         //3.元素有子元素
  49.         ul1.replaceChild(ul2,li3);//ul2ti换li3
  51.     </script>
  52. </body>
  53. </html>

1.6-移除子元素：removeChild()

removeChild:移除子元素 语法：

  1. 父元素.removeChild(子元素)
  • 1.不能自己移除自己（只能让爸爸干掉自己）
  • 2.父元素只能移除自己的子元素，不能移除别人的子元素（只有亲爸爸才能干掉自己）
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  7.     <title>Document</title>
  8. </head>
  9. <body>
  10.     <ul id="ul1">
  11.         <li>隔壁老牛1</li>
  12.         <li>隔壁老牛2</li>
  13.         <li id="li3">隔壁老牛3</li>
  14.         <li>隔壁老牛4</li>
  15.         <li>隔壁老牛5</li>
  16.     </ul>
  18.     <ul id="ul2">
  19.         <li>我是马云1</li>
  20.         <li id="li2">我是马云2</li>
  21.         <li>我是马云3</li>
  22.         <li>我是马云4</li>
  23.         <li>我是马云5</li>
  24.     </ul>
  26.     <script>
  27.         /*本小节知识点： 父元素.removeChild(子元素)
  28.         1. 父元素只能移除自己的子元素
  29.         2. 父元素不能移除别人的子元素
  30.         3. 元素不能自己移除自己的
  31.         */ 
  32.         let ul1 = document.getElementById('ul1');
  33.         let ul2 = document.getElementById('ul2');
  34.         let li3 = document.getElementById('li3');//老牛3
  35.         let li2 = document.getElementById('li2');//马云2
  37.         //1.元素自己不能移除自己(不能自杀)
  38.         // li3.removeChild(li3);
  40.         //2.父元素不能移除别人的子元素(不能杀别人的儿子)
  41.         // ul1.removeChild(li2);
  43.         //3.父元素只能移除自己的子元素
  44.         ul2.removeChild(li2);
  45.     </script>
  46. </body>
  47. </html>

1.7-克隆元素：cloneNode()：自主学习

cloneNode：克隆元素 语法：

  1. 元素.cloneNode(布尔)
  2.     false：默认，浅克隆
  3.     true：深克隆
  • 1.克隆目标元素

  • 2.可能分为两种

    • 浅克隆：只克隆元素本身，不包含子节点（文本、元素）
    • 深克隆：克隆元素本身以及其子节点（文本、元素）

03-dom综合案例（尝试练习）

1.1-案例：选择职业技能

效果预览

day03 - 图4

需求分析：

  • 点击 >> ：将左边所有的内容移动到右边
  • 点击 << ：将右边所有的内容移动到左边
  • 点击 > ：将左边选中的内容移动到右边
  • 点击 < ：将右边选中的内容移动到左边
  1. <!DOCTYPE html>
  2. <html>
  4. <head lang="en">
  5.     <meta charset="UTF-8">
  6.     <title></title>
  8.     <style>
  9.         select {
  10.             width: 100px;
  11.             height: 150px;
  12.         }
  13.     </style>
  14. </head>
  16. <body>
  18.     <select name="" id="left" multiple>
  19.         <option value="">web工程师</option>
  20.         <option value="">android工程师</option>
  21.         <option value="">ios工程师</option>
  22.         <option value="">php工程师</option>
  23.         <option value="">nodejs工程师</option>
  24.         <option value="">pyton小白</option>
  25.         <option value="">足疗爱好者</option>
  26.     </select>
  28.     <button id="btn1">&gt;&gt;</button>
  29.     <button id="btn2">&lt;&lt;</button>
  30.     <button id="btn3">&gt;</button>
  31.     <button id="btn4">&lt;</button>
  33.     <select name="" id="right" multiple></select>
  35.     <script>
  36.         /*
  37.         1.分析需求(交互)：
  38.             (1)全部右移：将左边left的children移动到右边right
  39.             (2)全部左移: 将右边right的children移动到左边left
  40.             (3)选中右移: 将左边left的选中的children移动到右边right
  41.             (4)选中坐移：将右边right选中的children移动到左边left
  42.         2.思路分析（事件三要素）
  43.             获取元素：事件源：
  44.             注册事件：事件类型
  45.             事件处理：
  46.         */
  48.         //1.获取元素
  49.         let left = document.querySelector('#left');
  50.         // console.log(left.children);
  51.         let right = document.querySelector('#right');
  53.         let btn1 = document.querySelector('#btn1');//全部右移
  54.         let btn2 = document.querySelector('#btn2');//全部左移
  55.         let btn3 = document.querySelector('#btn3');//选中右移
  56.         let btn4 = document.querySelector('#btn4');//选中左移
  57.         //2.注册事件
  59.         //(2.1)全部右移：将左边left的children移动到右边right
  60.         btn1.onclick = function () {
  61.             /* 
  62.             1.发现问题：左边的所有子元素无法全部添加到右边
  63.             2.分析原因：当数组的元素发生移动的时候，后面所有的元素下标就会前移
  64.             3.解决问题： 只要元素移动，由于下标已经前移，所以循环变量i不能自增
  65.              */
  66.             //3.事件处理
  67.             for(let i = 0;i<left.children.length;i++){
  68.                 right.appendChild(left.children[i]);
  69.                 i--;//抵消本次循环变量自增
  70.             };
  71.         };
  72.         //(2.2)全部左移: 将右边right的children移动到左边left
  73.         btn2.onclick = function () {
  74.             for(let i = 0;i<right.children.length;i++){
  75.                 left.appendChild(right.children[i]);
  76.                 i--;//抵消本次循环变量自增
  77.             };
  78.         };
  79.         //(2.3)选中右移: 将左边left的选中的children移动到右边right
  80.         btn3.onclick = function () {
  81.             for(let i = 0;i<left.children.length;i++){
  82.                 console.log(left.children[i].selected);
  83.                 //如果选中状态是select则移动
  84.                 if(left.children[i].selected){
  85.                      right.appendChild(left.children[i]);
  86.                      //只有元素发生移动，下标才会前移，才需要i--
  87.                      i--;//抵消本次循环变量自增
  88.                 };
  89.             };
  90.         };
  91.         //(2.4)选中坐移：将右边right选中的children移动到左边left
  92.         btn4.onclick = function () {
  93.             for(let i = 0;i<right.children.length;i++){
  94.                 //如果选中状态是select则移动
  95.                 if(right.children[i].selected){
  96.                      left.appendChild(right.children[i]);
  97.                      //只有元素发生移动，下标才会前移，才需要i--
  98.                      i--;//抵消本次循环变量自增
  99.                 };
  100.             };
  101.         };
  102.     </script>
  103. </body>
  105. </html>

1.2-案例：模拟百度搜索框

day03 - 图5

需求分析：
1.键盘松开txt ： 根据搜索内容显示对应搜索列表ul
2.鼠标移入li元素：颜色变红
3.鼠标移出li元素：颜色变原先颜色
4.鼠标点击li元素： （1）搜索框显示点击的li元素文本 （2）情况内容列表ul
思路分析：事件三要素
1 获取元素：
2 注册事件：
3 事件处理：

  1. <!DOCTYPE html>
  2. <html>
  3. <head lang="en">
  4.     <meta charset="UTF-8">
  5.     <title></title>
  6.     <style>
  7.         * {
  8.             margin: 0;
  9.             padding: 0;
  10.         }
  11.         body {
  12.             font-size: 20px;
  13.         }
  14.         .box {
  15.             width: 600px;
  16.             height: 40px;
  17.             margin: 200px auto;
  18.             position: relative;
  19.         }
  20.         #txt {
  21.             width: 498px;
  22.             height: 38px;
  23.             border: 1px solid #ccc;
  24.             font-size: 20px;
  25.         }
  26.         #search {
  27.             width: 100px;
  28.             height: 40px;
  29.         }
  30.         #keywords {
  31.             position: absolute;
  32.             top: 40px;
  33.             left: 0;
  34.             background-color: rgb(12, 255, 24);
  35.             list-style: none;
  36.             width: 500px;;
  37.         }
  38.         li {
  39.             line-height: 24px;
  40.         }
  41.     </style>
  42. </head>
  43. <body>
  44. <div class="box">
  45.     <div class="top">
  46.         <input type="text" id="txt"/><input type="button" value="search" id="search"/>
  47.     </div>
  48.     <ul id="keywords"></ul>
  49. </div>
  50. <script src="common.js"></script>
  51. <script>
  53.       /* 需求分析：
  54.           1.键盘松开txt ： 根据搜索内容显示对应搜索列表ul
  55.           2.鼠标移入li元素：颜色变红
  56.           3.鼠标移出li元素：颜色变原先颜色
  57.           4.鼠标点击li元素： （1）搜索框显示点击的li元素文本  （2）情况内容列表ul
  58.            思路分析：事件三要素
  59.                  1 获取元素：
  60.                  2 注册事件：
  61.                  3 事件处理：
  62.        */
  63.     let keywords = ["小马哥", "小马哥为什么喜欢挖坑", "小马哥有老婆吗", "小马哥是谁", "广东人", "广东人爱吃", "广东人爱吃什么","广东人什么都吃","华为","华为任正非","华为余大嘴","华为被美国封杀","新八国联军封杀中国华为","中国抗议胜利","全世界都在看中国","中国出手了","黑马.中国","Java","王思聪","王健林","社会王","隔壁老王"];
  65.     //1. 获取元素：
  66.     let txt = document.getElementById('txt');
  67.     let ul = document.getElementById('keywords');
  68.     //2.注册事件：
  70.       //2.1 键盘松开
  71.       txt.onkeyup = function (  ) {
  72.         //3.事件处理 : 根据搜索内容显示对应文本
  73.           //3.1 获取搜索文本
  74.           let search = this.value;
  75.           //3.2 每一次输入之前应该把之前的内容清空，以本次输入为准
  76.           ul.innerHTML = '';
  77.           //3.3 如果用户没有输入，则不搜索
  78.           if(search.length == 0){
  79.               return;
  80.           };
  81.           console.log ( search );
  82.           //3.3 根据搜索文本显示对应内容
  83.           searchTxt(search);
  84.       };
  87.       /**
  88.        *
  89.        * @param searchTxt 要搜索的文本
  90.        */
  91.       function searchTxt ( searchTxt ) {
  92.           //将数组中的内容显示到页面
  93.           for(let i = 0;i<keywords.length;i++){
  94.               let str = keywords[i];
  95.               //如果搜索文本searchTxt在str中则显示
  96.               if (str.indexOf(searchTxt) != -1){
  97.                   //1.创建空li元素
  98.                   let li = document.createElement('li');
  99.                   //2.设置文本
  100.                   li.innerText = str;
  101.                   //3.li元素添加到ul
  102.                   ul.appendChild(li);
  104.                   //每一个创建的li元素都有三个事件
  106.                   //鼠标移入：颜色变红
  107.                   li.onmouseover = function (  ) {
  109.                       //(1)先用一个自定义属性存储原先的颜色
  110.                       this.aaa = this.style.backgroundColor;
  111.                       //(2)修改颜色为红色
  112.                       this.style.backgroundColor = 'red';
  113.                   };
  115.                   //鼠标移出：颜色恢复原先的颜色
  116.                   li.onmouseout = function (  ) {
  117.                       this.style.backgroundColor = this.aaa;
  118.                   };
  120.                   //鼠标单击：
  121.                   li.onclick = function (  ) {
  122.                       //(1)搜索框文本变成单击的li元素文本
  123.                       txt.value = this.innerText;
  124.                       //(2)清空内容列表
  125.                       ul.innerHTML = '';
  126.                       // for(let i = 0;i<ul.children.length;i++){
  127.                       //       ul.removeChild(ul.children[i]);
  128.                       // }
  129.                   };
  130.               }
  131.           }
  133.       };
  134. </script>
  135. </body>
  136. </html>

1.3-案例：综合表格处理

day03 - 图6

  1. <!DOCTYPE html>
  2. <html>
  4. <head lang="en">
  5.     <meta charset="UTF-8">
  6.     <title></title>
  7.     <style>
  8.         .main,
  9.         table {
  10.             width: 800px;
  11.             margin: 0 auto;
  12.         }
  14.         .main {
  15.             height: 40px;
  16.             line-height: 40px;
  17.         }
  19.         table,
  20.         th,
  21.         td {
  22.             border: 1px solid black;
  23.             border-collapse: collapse;
  24.         }
  26.         .optd {
  27.             width: 200px;
  28.         }
  30.         .addTable {
  31.             width: 780px;
  32.             padding: 10px;
  33.             border: 1px solid green;
  34.             /* 固定位置 */
  35.             position: fixed;
  36.             top: 200px;
  37.             left: 50%;
  38.             margin-left: -400px;
  39.             /* 标准流 */
  40.             /* margin: 0 auto; */
  41.             background-color: #fff;
  42.             display: none;
  43.         }
  45.         .addTable table {
  46.             width: 100%;
  47.             text-align: center;
  48.             margin-bottom: 10px;
  49.         }
  50.     </style>
  51. </head>
  53. <body>
  54.     <div class="main">
  55.         <input type="button" value="新增一行" id="add" />
  56.     </div>
  57.     <table id="table">
  59.     </table>
  60.     <!--用于新增表格获取数据的模块-->
  61.     <div class="addTable" id="addRow">
  62.         <table>
  63.             <tr>
  64.                 <th>学号</th>
  65.                 <th>姓名</th>
  66.                 <th>性别</th>
  67.                 <th>年龄</th>
  68.             </tr>
  69.             <tr>
  70.                 <td><input type="text" id="number" /></td>
  71.                 <td><input type="text" id="name" /></td>
  72.                 <td>
  73.                     <select id="gender">
  74.                         <option>男</option>
  75.                         <option>女</option>
  76.                     </select>
  77.                 </td>
  78.                 <td><input type="text" id="age" /></td>
  79.             </tr>
  80.         </table>
  82.         <div>
  83.             <input type="button" value="确定" id="sure" />
  84.             <input type="button" value="取消" id="cancle" />
  85.         </div>
  86.     </div>
  87.     <script>
  88.         /*思路分析
  89.             1.根据json数据生成页面结构
  90.                 1.1-动态创建表头
  91.                 1.2-根据json对象动态创建tr
  92.                 1.3-动态创建tr中的三个操作按钮
  93.                 函数封装：
  94.                     a.将创建tr封装到函数中：因为新增一行也会用到
  95.                     b.将根据id获取元素封装到函数中：因为页面多个地方会用到
  96.             2.注册页面事件
  97.                 2.1-点击新增一行
  98.                 2.2-新增确定
  99.                 2.3-新增取消
  100.                 2.4-向上移动
  101.                 2.5-向下移动
  102.                 2.6-删除
  103.             3.处理事件 
  105.         */
  106.         let head = ["学号", "姓名", "性别", "年龄", "操作"];
  107.         let data = [
  108.             { "number": "001", "name": "李狗蛋", "gender": "男", "age": 16 },
  109.             { "number": "002", "name": "王大柱", "gender": "女", "age": 17 },
  110.             { "number": "003", "name": "李葫芦", "gender": "男", "age": 15 },
  111.             { "number": "004", "name": "小明", "gender": "男", "age": 18 },
  112.             { "number": "005", "name": "小红", "gender": "女", "age": 16 }
  113.         ];
  115.         //1.根据数组内容：生成tableb表格结构
  117.         let table = document.querySelector('#table');
  119.         //1.1 生成表头
  121.         //(1)创建空标签
  122.         let headTr = document.createElement('tr');
  123.         //(2)设置内容
  124.         for (let i = 0; i < head.length; i++) {
  125.             //1.创建空标签
  126.             let th = document.createElement('th');
  127.             //2.设置内容
  128.             th.innerText = head[i];
  129.             //3.添加到页面
  130.             headTr.appendChild(th);
  131.         };
  132.         //(3)添加到页面
  133.         table.appendChild(headTr);
  135.         //1.2 生成表格内容
  136.         for (let i = 0; i < data.length; i++) {
  137.             let obj = data[i];
  138.             console.log(obj);
  139.             createRow(obj);
  140.         };
  142.         function createRow(obj) {
  143.             //(1)创建空标签
  144.             let tr = document.createElement('tr');
  145.             //(2)设置内容 : 遍历对象的属性，生成td
  146.             for (let key in obj) {
  147.                 console.log(obj[key]);
  148.                 //1.创建空td
  149.                 let td = document.createElement('td');
  150.                 //2.设置内容
  151.                 td.innerText = obj[key];
  152.                 //3.添加到tr
  153.                 tr.appendChild(td);
  155.             };
  156.             //(3)最后一个td里面有三个按钮
  157.             let buttonTd = document.createElement('td');
  159.             //(3.1)创建元素 ：createElement 三行
  160.             let buttonUp = document.createElement('button');
  161.             //(3.2)设置内容
  162.             buttonUp.innerText = '向上移动';
  163.             buttonUp.onclick = moveUp;
  164.             buttonTd.appendChild(buttonUp);
  166.             let buttonDown = document.createElement('button');
  167.             buttonDown.innerText = '向下移动';
  168.             buttonDown.onclick = moveDown;
  169.             buttonTd.appendChild(buttonDown);
  171.             let buttonDelete = document.createElement('button');
  172.             buttonDelete.innerText = '删除';
  173.             buttonDelete.onclick = moveDelete;
  174.             buttonTd.appendChild(buttonDelete);
  176.             tr.appendChild(buttonTd);
  177.             //(3)添加到table
  178.             table.appendChild(tr);
  179.         }
  182.         //2.1 点击新增一行 add ： 显示addRow
  183.         let add = document.getElementById('add');
  184.         let addRow = document.getElementById('addRow');
  185.         add.onclick = function () {
  186.             addRow.style.display = 'block';
  187.         };
  189.         //2.2 取消 ： 隐藏addRow
  190.         let cancle = document.getElementById('cancle');
  191.         cancle.onclick = function () {
  192.             addRow.style.display = 'none';
  193.         };
  195.         //2.3 确定： sure
  196.         let sure = document.getElementById('sure');
  197.         sure.onclick = function () {
  198.             //3.1 获取输入数据
  199.             let obj = {};
  200.             obj.number = document.getElementById('number').value;
  201.             obj.name = document.getElementById('name').value;
  202.             obj.gender = document.getElementById('gender').children[0].selected ? '男' : '女';
  203.             obj.age = document.getElementById('age').value;
  204.             console.log(obj);
  206.             //3.2 将数据添加到表格
  207.             createRow(obj);
  208.             //3.3 隐藏addRow
  209.             addRow.style.display = 'none';
  210.         };
  213.         //向上移动
  214.         function moveUp() {
  215.             console.log(this);//button
  216.             console.log(this.parentNode);//td
  217.             console.log(this.parentNode.parentNode);//tr
  218.             //需求： 爷爷插入到  爷爷的哥哥的前面
  219.             if (this.parentNode.parentNode == table.children[1]) {// 下标0是表头，内容从下标1开始
  220.                 alert('不能移动');
  221.             } else {
  222.                 let yeye = this.parentNode.parentNode;
  223.                 let yeGe = this.parentNode.parentNode.previousElementSibling;
  224.                 table.insertBefore(yeye, yeGe);
  225.             }
  226.         };
  228.         //向下移动
  229.         function moveDown() {
  230.             if (this.parentNode.parentNode == table.lastElementChild) {
  231.                 alert('已经是最后一个');
  232.             } else {
  233.                 let yeye = this.parentNode.parentNode;
  234.                 let yeDiDi = this.parentNode.parentNode.nextElementSibling.nextElementSibling;
  235.                 table.insertBefore(yeye, yeDiDi);
  236.             }
  237.         };
  239.         //删除
  240.         function moveDelete() {
  241.             if (confirm('你确定要移除我的爷爷吗？')) {
  242.                 table.removeChild(this.parentNode.parentNode);
  243.             };
  244.         };
  245.     </script>
  246. </body>
  248. </html>

04-BOM浏览器对象模型

1.1-BOM与DOM介绍

  • JavaScript语言由三部分组成

    • ECMAJavaScript：定义了js的语法规范

    • Dom：document object model文档对象模型：一个HTML文档中所有的一切都是dom对象

      1. * Dom定义了一套操作HTML文档的API（节点的增删改查）
  • Bom：Browser object model浏览器对象模型 例如：一个浏览器的窗口就是一个window对象
    1. * Bom定义了一套操作浏览器窗口的API

  • Bom主要由五大对象组成：

    • window：浏览器核心对象
    • location：包含当前页面的URL信息
    • history：history对象主要用于记录你当前窗口的历史记录
    • navigator：包含当前浏览器的信息，例如用的什么浏览器，操作系统版本等

    • screen：获取用户电脑的屏幕分辨率

      • 这个一般不用，因为对开发者没啥作用

day03 - 图7

1.2-window对象

  • 1.window对象：指的是当前浏览器窗口，它是JS中的顶级对象

    • (1).所有的全局变量（var声明的）都是window对象的属性：最顶级的对象

      • document对象
      • bom对象
      • 全局的方法：alert(),setInterval()………..

    • (2).只要是window的属性和方法，在使用的时候都可以省略window

      • 例如：window.alert() 可以省略window写成alert()
      • 例如：window.document 可以省略window写成document

    • (3).window对象有一个特殊属性叫做name

      • 它永远都是一个字符串，无论给他赋什么值

  • 2.window对象有两个常用的方法：open()与close()

    • open():打开一个窗口
    • close():关闭一个窗口
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  9. <input type="button" value="点我打开一个新窗口" id="open">
  10. <input type="button" value="点我有惊喜" id="close">
  12. </body>
  14. <script>
  15.     /*1.window对象：指的是当前浏览器窗口，它是JS中的顶级对象
  16.         * (1).所有的全局变量都是window对象的属性：最顶级的对象
  17.             * document对象
  18.             * bom对象
  19.             * 全局的方法：alert(),setInterval()...........
  20.          * (2).只要是window的属性和方法，在使用的时候都可以省略window
  21.             * 例如：window.alert()  可以省略window写成alert()
  22.             * 例如：window.document 可以省略window写成document
  23.          * (3).window对象有一个特殊属性叫做name
  24.             * 它永远都是一个字符串，无论给他赋什么值
  25.             *
  26.        2.window对象有两个常用的方法：open()与close()
  27.             * open():打开一个窗口
  28.             * close():关闭一个窗口
  30.      */
  32.     //1.window是顶级对象，所有的全局变量都是window对象的属性
  33.     let age = 18;
  34.     console.log ( window.age );
  36.     //2.只要是window对象的属性和方法，window可以省略
  37.     console.log ( window.document === document );true
  39.     //3.window有一个特殊的属性叫做name，它永远都是一个字符串
  40.     console.log ( window.name );//默认是一个空字符串
  41.     window.name = 123456;
  42.     console.log ( name );//永远都是一个字符串
  43.     //就算你重新声明一个变量叫做name，也无法覆盖它
  44.     let name = [123];
  45.     console.log ( name );
  47.     //打开新窗口
  48.     document.getElementById('open').onclick = function (  ) {
  49.         /**
  50.         * @param 第一个参数：URL  要打开的窗口网址
  51.          * @param 第二个参数：类似于a标签的target属性，是替换当前窗口还是新开一个窗口
  52.          * @param 第三个参数：新窗口特征：大小和位置等(新窗口才有效_blank)
  53.          * @param 第四个参数：布尔类型  true/false:把新开的窗口加入/不加入到浏览器历史记录
  54.          * @return 新打开的window对象
  55.         */
  56.        let newWindow = window.open('https://www.baidu.com', '_blank', 'top=100,left=100,width=500,height=300', true );
  57.     }
  59.     //关闭窗口
  60.     document.getElementById('close').onclick = function (  ) {
  61.         //参数就是你想要关闭的窗口对象，如果不写，默认就是关闭自己
  62.         //1.这样写如果关闭的是顶级窗口谷歌和火狐会失效，如果失效可以使用下面这种写法
  63.         //window.close( );
  65.         /*2.谷歌火狐为了安全起见会拦截我们的代码，js代码只能关闭用js代码打开的界面，
  66.         所以我们用js先假装在当前窗口打开自己，然后再关闭自己*/
  67.         //这里的url不是空字符串""，而是一个空格字符串  " "
  68.         window.open(" ","_self").close();
  69.     }
  70. </script>
  71. </html>

1.3-window对象三个事件

window对象有三个事件，记录了浏览器窗口从打开到关闭的三个过程

  • 1.window.onload:界面上所有的内容加载完毕之后才触发这个事件
  • 2.window.onbeforeunload:界面在关闭之前会触发这个事件

  • 3.window.onunload:界面在关闭的那一瞬间会触发这个事件

    • 点击某个离开页面的链接
    • 在地址栏中键入了新的 URL
    • 使用前进或后退按钮
    • 关闭浏览器窗口
    • 重新加载页面
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  8. <script>
  9.     /*window对象有三个事件，记录了浏览器窗口从打开到关闭的三个过程
  11.     1.window.onload:界面上所有的内容加载完毕之后才触发这个事件
  13.     2.window.onbeforeunload:界面在关闭之前会触发这个事件
  15.         3.window.onunload:界面在关闭的那一瞬间会触发这个事件
  17.      */
  19.     //由于我们script标签写在了body标签的上面，这行代码会在body内容还未加载的时候就执行
  20.     console.log ( document.getElementById ( "p1" ) );//null  此时编译器还未解析p标签
  22.     //1.window.onload：界面上所有内容加载完毕后会触发
  23.     window.onload = function ( ) {
  25.         // 由于编译器是从上往下解析html文件的，如果我们的js代码写在body前面，就有可能无法获取dom对象
  26.         console.log ( "当前界面全部加载完毕" );
  27.         //window.onload无论写在界面什么位置都是等整个界面加载完毕之后才会执行
  28.         console.log ( document.getElementById ( "p1" ) );
  29.     }
  31.     //2.window.onbeforeunload:界面在关闭前触发
  32.     window.onbeforeunload = function (  ) {
  33.         /* 
  34.         *  1.这个方法主要用于在界面关闭之前保存一些重要数据
  35.         *  2.也可以弹出一个提示框挽留一下用户
  36.         * */
  38.         //return 内容：浏览器会自动弹出一个挽留窗口
  39.         //谷歌和火狐都会拦截这种恶心事，只有IE支持
  40.         return '你真的要狠心抛弃我吗';
  41.     }
  43.     //3 window.onunload:界面关闭时触发
  44.     window.onunload = function (  ) {
  46.         console.log('界面正在关闭');
  48.     }
  50.     // 注意：如果打开的页面没有任何操作，那么关闭系统也会忽略onbeforeunload、onunload事件（里面的log会执行，但是不会有弹出框提示）
  51.     // 另外，弹出窗口的内容chrome和ff已经不可更改
  52. </script>
  54. <body>
  56. <p id="p1">我是p标签</p>
  57. </body>
  60. </html>

1.4-location对象

  • 1.location对象：包含当前页面的URL信息

    • url：全球统一资源定位符
    • url = 协议名（http） + ip地址（域名） + 端口号 + 资源路径
    • 暂时只需要知道location对象包含一个网页的网络url信息即可，具体的含义将在后面阶段学习网络的时候详细讲解

  • 2.location对象有三个常用的方法

    • （1）打开新网页：location.assign(‘你要打开的新网页的url’)
    • （2）替换当前网页：location.replace(‘要替换的网页url’)
    • (3) 刷新当前网页: location.reload()
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  9. <input type="button" id="assign" value="assign打开新网页">
  10. <br>
  11. <input type="button" id="replace" value="replace替换当前网页">
  12. <br>
  13. <input type="button" id="reload" value="reload刷新当前网页">
  14. <br>
  16. </body>
  18. <script>
  19.     /*1.location对象：包含当前页面的URL信息
  20.         * url：全球统一资源定位符
  21.         * url = 协议名（http） + ip地址（域名） + 端口号 + 资源路径
  22.         * 暂时只需要知道location对象包含一个网页的网络url信息即可，具体的含义将在后面阶段学习网络的时候详细讲解
  24.       2.location对象有三个常用的方法
  25.             * （1）打开新网页：location.assign('你要打开的新网页的url')
  26.             * （2）替换当前网页：location.replace('要替换的网页url')
  27.             *   (3)  刷新当前网页: location.reload()
  28.      */
  30.     //1.location对象信息查看
  31.     console.log ( window.location );        //location对象
  32.     console.log(location.hash);                //资源定位符（锚点定位）
  33.     console.log(location.host);                //主机   host = hostname + port
  34.     console.log(location.hostname);            //主机名（ip地址）
  35.     console.log(location.port);                //端口号
  36.     console.log(location.href);                //完整的url路径
  37.     console.log(location.pathname);            //资源路径
  38.     console.log(location.protocol);            //url的协议
  39.     console.log(location.search);            //url请求的参数
  41.     //2.assign：打开新网页
  42.     document.getElementById('assign').onclick = function (  ) {
  43.         //会留下历史记录（可以回退）
  44.         window.location.assign('http://www.itheima.com');
  45.         //上面这行代码等价于下面这行代码
  46.         //window.location.href = 'http://www.itheima.com';
  47.     }
  49.     //3.replace:替换当前网页
  50.     document.getElementById('replace').onclick = function (  ) {
  51.         //不会留下历史记录（不能回退）
  52.         window.location.replace('http://www.itcast.com');
  53.     }
  55.     //4.刷新当前网页
  56.     document.getElementById('reload').onclick = function (  ) {
  57.         //相当于按了F5刷新当前网页
  58.         window.location.reload();
  59.     }
  61. </script>
  62. </html>

1.5-history对象

history对象主要用于记录你当前窗口的历史记录

  • 主要作用就是前进和后退网页（相当于浏览器的左上角前进后退按钮功能）
  • history.forward():前进
  • history.back():后退
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8. <a href="09-history测试页.html">点我跳转</a>
  9. <input type="button" value="前进" id="forword">
  10. </body>
  12. <script>
  13.     /*history对象主要用于记录你当前窗口的历史记录
  14.         * 主要作用就是前进和后退网页（相当于浏览器的左上角前进后退按钮功能）
  15.         * history.forward():前进
  16.         * history.back():后退
  17.      */
  19.     document.getElementById('forword').onclick = function (  ) {
  20.         //跳转到当前网页历史记录的下一页，如果没有下一页的历史记录，则不跳转
  21.         history.forward();
  22.     }
  23. </script>
  24. </html>

1.6-navigator对象

navigator对象：包含当前浏览器的信息

  • 工作中应用场景：用户信息统计（统计我这个网站平台的用户群体分布，什么浏览器，windows什么版本等）
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  9. </body>
  11. <script>
  12.     /*navigator对象：包含当前浏览器的信息
  13.         工作中应用场景：用户信息统计（统计我这个网站平台的用户群体分布，什么浏览器，windows什么版本等）
  15.      */
  17.     console.log ( navigator );//navigator对象
  18.     console.log ( navigator.appVersion );        //当前浏览器版本信息
  19.     console.log ( navigator.platform );            //当前浏览器的硬件平台
  20.     console.log ( navigator.userAgent );        //当前浏览器信息
  22.     //使用场景1：判断当前用户的操作系统是32位还是64位
  23.     //谷歌和IE  64位显示WOW64    火狐显示Win64
  24.     if(navigator.userAgent.indexOf('WOW64') != -1 || navigator.userAgent.indexOf('Win64') != -1){
  25.         console.log ( "64位" );
  26.     }else{
  27.         console.log ( "32位" );
  28.     }
  30.     //使用场景2：判断用户当前使用哪种浏览器
  31.     if(navigator.userAgent.indexOf('Chrome') != -1){
  32.         console.log ( "谷歌浏览器" );
  33.     }else if(navigator.userAgent.indexOf('Firefox') != -1){
  34.         console.log ( "火狐浏览器" );
  35.     }else{
  36.         console.log ( "IE浏览器" );            //也有可能是其他小众浏览器，可以忽略不计
  37.     }
  39. </script>
  40. </html>