广告：宝塔服务器面板，一键全能部署及管理，送你10850元礼包，点我领取~~~

本篇文章给大家带来关于JavaScript进阶班之DOM技术的相关知识，希望对大家有帮助。

思维导图、目录总览

1、DOM简介1.1、什么是DOM

文档对象模型（Document Object Model，简称 DOM），是 W3C 组织推荐的处理可扩展标记语言（HTML或者XML）的标准编程接口

W3C 已经定义了一系列的 DOM 接口，通过这些 DOM 接口可以改变网页的内容、结构和样式。

文档：一个页面就是一个文档，DOM中使用doucument来表示元素：页面中的所有标签都是元素，DOM中使用 element 表示节点：网页中的所有内容都是节点（标签，属性，文本，注释等），DOM中使用node表示

DOM 把以上内容都看做是对象

2、获取元素2.1、如何获取页面元素

DOM在我们实际开发中主要用来操作元素。

我们如何来获取页面中的元素呢?

获取页面中的元素可以使用以下几种方式:

根据 ID 获取根据标签名获取通过 HTML5 新增的方法获取特殊元素获取2.2、根据ID获取

使用 getElementByld() 方法可以获取带ID的元素对象

doucument.getElementByld('id名')

登录后复制

使用 console.dir() 可以打印我们获取的元素对象，更好的查看对象里面的属性和方法。

示例

<p id="time">2019-9-9</p><script>    // 1.因为我们文档页面从上往下加载，所以得先有标签，所以script写在标签下面    // 2.get 获得 element 元素 by 通过 驼峰命名法    // 3.参数 id是大小写敏感的字符串    // 4.返回的是一个元素对象    var timer = document.getElementById('time');    console.log(timer);    // 5. console.dir 打印我们的元素对象，更好的查看里面的属性和方法    console.dir(timer);</script>

登录后复制2.3、根据标签名获取

根据标签名获取，使用 getElementByTagName() 方法可以返回带有指定标签名的对象的集合

doucument.getElementsByTagName('标签名');

登录后复制因为得到的是一个对象的集合，所以我们想要操作里面的元素就需要遍历得到元素对象是动态的返回的是获取过来元素对象的集合，以伪数组的形式存储如果获取不到元素，则返回为空的伪数组(因为获取不到对象)

<ul>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li></ul><script>    // 1.返回的是获取过来元素对象的集合 以伪数组的形式存储    var lis = document.getElementsByTagName('li');    console.log(lis);    console.log(lis[0]);    // 2.依次打印,遍历    for (var i = 0; i < lis.length; i++) {        console.log(lis[i]);    }    // 3.如果页面中只有 1 个 li，返回的还是伪数组的形式    // 4.如果页面中没有这个元素，返回的是空伪数组</script>

登录后复制2.4、根据标签名获取

还可以根据标签名获取某个元素（父元素）内部所有指定标签名的子元素,获取的时候不包括父元素自己

element.getElementsByTagName('标签名')ol.getElementsByTagName('li');

登录后复制

注意：父元素必须是单个对象(必须指明是哪一个元素对象)，获取的时候不包括父元素自己

<script>//element.getElementsByTagName('标签名'); 父元素必须是指定的单个元素    var ol = document.getElementById('ol');    console.log(ol.getElementsByTagName('li'));</script>

登录后复制2.5、通过H5新增方法获取①getElementsByClassName

根据类名返回元素对象合集

document.getElementsByClassName('类名')

document.getElementsByClassName('类名');

登录后复制②document.querySelector

根据指定选择器返回第一个元素对象

document.querySelector('选择器');// 切记里面的选择器需要加符号 // 类选择器.box // id选择器 #navvar firstBox = document.querySelector('.box');

登录后复制③document.querySelectorAll

根据指定选择器返回所有元素对象

document.querySelectorAll('选择器');

登录后复制

注意

querySelector 和 querySelectorAll 里面的选择器需要加符号,比如: document.querySelector('#nav');

④例子

<script>    // 1. getElementsByClassName 根据类名获得某些元素集合    var boxs = document.getElementsByClassName('box');    console.log(boxs);    // 2. querySelector 返回指定选择器的第一个元素对象  切记 里面的选择器需要加符号 .box  #nav    var firstBox = document.querySelector('.box');    console.log(firstBox);    var nav = document.querySelector('#nav');    console.log(nav);    var li = document.querySelector('li');    console.log(li);    // 3. querySelectorAll()返回指定选择器的所有元素对象集合    var allBox = document.querySelectorAll('.box');    console.log(allBox);    var lis = document.querySelectorAll('li');    console.log(lis);</script>

登录后复制2.6、获取特殊元素①获取body元素

返回body元素对象

<p id="time">2019-9-9</p><script>    // 1.因为我们文档页面从上往下加载，所以得先有标签，所以script写在标签下面    // 2.get 获得 element 元素 by 通过 驼峰命名法    // 3.参数 id是大小写敏感的字符串    // 4.返回的是一个元素对象    var timer = document.getElementById('time');    console.log(timer);    // 5. console.dir 打印我们的元素对象，更好的查看里面的属性和方法    console.dir(timer);</script>0

登录后复制②获取html元素

返回html元素对象

<p id="time">2019-9-9</p><script>    // 1.因为我们文档页面从上往下加载，所以得先有标签，所以script写在标签下面    // 2.get 获得 element 元素 by 通过 驼峰命名法    // 3.参数 id是大小写敏感的字符串    // 4.返回的是一个元素对象    var timer = document.getElementById('time');    console.log(timer);    // 5. console.dir 打印我们的元素对象，更好的查看里面的属性和方法    console.dir(timer);</script>1

登录后复制3、事件基础3.1、事件概述

JavaScript 使我们有能力创建动态页面，而事件是可以被 JavaScript 侦测到的行为。

简单理解： 触发— 响应机制。

网页中的每个元素都可以产生某些可以触发 JavaScript 的事件，例如，我们可以在用户点击某按钮时产生一个事件，然后去执行某些操作。

3.2、事件三要素事件源(谁)事件类型(什么事件)事件处理程序(做啥)

<p id="time">2019-9-9</p><script>    // 1.因为我们文档页面从上往下加载，所以得先有标签，所以script写在标签下面    // 2.get 获得 element 元素 by 通过 驼峰命名法    // 3.参数 id是大小写敏感的字符串    // 4.返回的是一个元素对象    var timer = document.getElementById('time');    console.log(timer);    // 5. console.dir 打印我们的元素对象，更好的查看里面的属性和方法    console.dir(timer);</script>2

登录后复制3.3、执行事件的步骤获取事件源注册事件(绑定事件)添加事件处理程序(采取函数赋值形式)

<p id="time">2019-9-9</p><script>    // 1.因为我们文档页面从上往下加载，所以得先有标签，所以script写在标签下面    // 2.get 获得 element 元素 by 通过 驼峰命名法    // 3.参数 id是大小写敏感的字符串    // 4.返回的是一个元素对象    var timer = document.getElementById('time');    console.log(timer);    // 5. console.dir 打印我们的元素对象，更好的查看里面的属性和方法    console.dir(timer);</script>3

登录后复制3.4、鼠标事件onclick鼠标点击左键触发onmouseover鼠标经过触发onmouseout鼠标离开触发onfocus获得鼠标焦点触发onblur失去鼠标焦点触发onmousemove鼠标移动触发onmouseup鼠标弹起触发onmousedown鼠标按下触发4、操作元素

JavaScript 的 DOM 操作可以改变网页内容、结构和样式，我们可以利用 DOM 操作元素来改变元素里面的内容 、属性等。注意以下都是属性

4.1、改变元素内容

从起始位置到终止位置的内容，但它去除html标签，同时空格和换行也会去掉。

<p id="time">2019-9-9</p><script>    // 1.因为我们文档页面从上往下加载，所以得先有标签，所以script写在标签下面    // 2.get 获得 element 元素 by 通过 驼峰命名法    // 3.参数 id是大小写敏感的字符串    // 4.返回的是一个元素对象    var timer = document.getElementById('time');    console.log(timer);    // 5. console.dir 打印我们的元素对象，更好的查看里面的属性和方法    console.dir(timer);</script>4

登录后复制

起始位置到终止位置的全部内容，包括HTML标签，同时保留空格和换行

<p id="time">2019-9-9</p><script>    // 1.因为我们文档页面从上往下加载，所以得先有标签，所以script写在标签下面    // 2.get 获得 element 元素 by 通过 驼峰命名法    // 3.参数 id是大小写敏感的字符串    // 4.返回的是一个元素对象    var timer = document.getElementById('time');    console.log(timer);    // 5. console.dir 打印我们的元素对象，更好的查看里面的属性和方法    console.dir(timer);</script>5

登录后复制

<p id="time">2019-9-9</p><script>    // 1.因为我们文档页面从上往下加载，所以得先有标签，所以script写在标签下面    // 2.get 获得 element 元素 by 通过 驼峰命名法    // 3.参数 id是大小写敏感的字符串    // 4.返回的是一个元素对象    var timer = document.getElementById('time');    console.log(timer);    // 5. console.dir 打印我们的元素对象，更好的查看里面的属性和方法    console.dir(timer);</script>6

登录后复制

4.2、改变元素属性

<p id="time">2019-9-9</p><script>    // 1.因为我们文档页面从上往下加载，所以得先有标签，所以script写在标签下面    // 2.get 获得 element 元素 by 通过 驼峰命名法    // 3.参数 id是大小写敏感的字符串    // 4.返回的是一个元素对象    var timer = document.getElementById('time');    console.log(timer);    // 5. console.dir 打印我们的元素对象，更好的查看里面的属性和方法    console.dir(timer);</script>7

登录后复制4.3、改变样式属性

我们可以通过 JS 修改元素的大小、颜色、位置等样式。

行内样式操作

<p id="time">2019-9-9</p><script>    // 1.因为我们文档页面从上往下加载，所以得先有标签，所以script写在标签下面    // 2.get 获得 element 元素 by 通过 驼峰命名法    // 3.参数 id是大小写敏感的字符串    // 4.返回的是一个元素对象    var timer = document.getElementById('time');    console.log(timer);    // 5. console.dir 打印我们的元素对象，更好的查看里面的属性和方法    console.dir(timer);</script>8

登录后复制类名样式操作

<p id="time">2019-9-9</p><script>    // 1.因为我们文档页面从上往下加载，所以得先有标签，所以script写在标签下面    // 2.get 获得 element 元素 by 通过 驼峰命名法    // 3.参数 id是大小写敏感的字符串    // 4.返回的是一个元素对象    var timer = document.getElementById('time');    console.log(timer);    // 5. console.dir 打印我们的元素对象，更好的查看里面的属性和方法    console.dir(timer);</script>9

登录后复制

注意：

JS里面的样式采取驼峰命名法，比如 fontSize ，backgroundColorJS 修改 style 样式操作 ，产生的是行内样式，CSS权重比较高如果样式修改较多，可以采取操作类名方式更改元素样式class 因为是个保留字，因此使用className来操作元素类名属性className 会直接更改元素的类名，会覆盖原先的类名

doucument.getElementsByTagName('标签名');0

登录后复制4.4、总结

4.5、排他思想

如果有同一组元素，我们相要某一个元素实现某种样式，需要用到循环的排他思想算法：

所有元素全部清除样式（干掉其他人）给当前元素设置样式 （留下我自己）注意顺序不能颠倒，首先干掉其他人，再设置自己

doucument.getElementsByTagName('标签名');1

登录后复制

4.6、自定义属性4.6.1、获取属性值获取内置属性值(元素本身自带的属性)

doucument.getElementsByTagName('标签名');2

登录后复制获取自定义的属性

doucument.getElementsByTagName('标签名');3

登录后复制4.6.2、设置属性值设置内置属性值

doucument.getElementsByTagName('标签名');4

登录后复制主要设置自定义的属性

doucument.getElementsByTagName('标签名');5

登录后复制4.6.3、移除属性

doucument.getElementsByTagName('标签名');6

登录后复制

doucument.getElementsByTagName('标签名');7

登录后复制4.7、H5自定义属性

自定义属性目的：

保存并保存数据，有些数据可以保存到页面中而不用保存到数据库中有些自定义属性很容易引起歧义，不容易判断到底是内置属性还是自定义的，所以H5有了规定2.8.1 设置H5自定义属性

H5规定自定义属性 data-开头作为属性名并赋值

doucument.getElementsByTagName('标签名');8

登录后复制2.8.2 获取H5自定义属性兼容性获取 element.getAttribute('data-index')H5新增的：element.dataset.index 或element.dataset['index'] IE11才开始支持

doucument.getElementsByTagName('标签名');9

登录后复制5、节点操作

获取元素通常使用两种方式：

document.getElementById()利用父子兄节点关系获取元素document.getElementsByTagName()逻辑性强，但是兼容性较差document.querySelector 等逻辑性不强，繁琐

这两种方式都可以获取元素节点，我们后面都会使用，但是节点操作更简单

一般的，节点至少拥有三个基本属性

5.1、节点概述

网页中的所有内容都是节点（标签、属性、文本、注释等），在DOM 中，节点使用 node 来表示。

HTML DOM 树中的所有节点均可通过 JavaScript 进行访问，所有 HTML 元素（节点）均可被修改，也可以创建或删除。

一般的，节点至少拥有nodeType（节点类型）、nodeName（节点名称）和nodeValue（节点值）这三个基本属性。

元素节点：nodeType 为1属性节点：nodeType 为2文本节点：nodeType 为3(文本节点包括文字、空格、换行等)

我们在实际开发中，节点操作主要操作的是元素节点

利用 DOM 树可以把节点划分为不同的层级关系，常见的是父子兄层级关系。

5.2、父级节点

<ul>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li></ul><script>    // 1.返回的是获取过来元素对象的集合 以伪数组的形式存储    var lis = document.getElementsByTagName('li');    console.log(lis);    console.log(lis[0]);    // 2.依次打印,遍历    for (var i = 0; i < lis.length; i++) {        console.log(lis[i]);    }    // 3.如果页面中只有 1 个 li，返回的还是伪数组的形式    // 4.如果页面中没有这个元素，返回的是空伪数组</script>0

登录后复制parentNode属性可以返回某节点的父结点，注意是最近的一个父结点如果指定的节点没有父结点则返回null

<ul>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li></ul><script>    // 1.返回的是获取过来元素对象的集合 以伪数组的形式存储    var lis = document.getElementsByTagName('li');    console.log(lis);    console.log(lis[0]);    // 2.依次打印,遍历    for (var i = 0; i < lis.length; i++) {        console.log(lis[i]);    }    // 3.如果页面中只有 1 个 li，返回的还是伪数组的形式    // 4.如果页面中没有这个元素，返回的是空伪数组</script>1

登录后复制5.3、子结点

<ul>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li></ul><script>    // 1.返回的是获取过来元素对象的集合 以伪数组的形式存储    var lis = document.getElementsByTagName('li');    console.log(lis);    console.log(lis[0]);    // 2.依次打印,遍历    for (var i = 0; i < lis.length; i++) {        console.log(lis[i]);    }    // 3.如果页面中只有 1 个 li，返回的还是伪数组的形式    // 4.如果页面中没有这个元素，返回的是空伪数组</script>2

登录后复制parentNode.childNodes 返回包含指定节点的子节点的集合，该集合为即时更新的集合返回值包含了所有的子结点，包括元素节点，文本节点等如果只想要获得里面的元素节点，则需要专门处理。所以我们一般不提倡使用childNodes

<ul>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li></ul><script>    // 1.返回的是获取过来元素对象的集合 以伪数组的形式存储    var lis = document.getElementsByTagName('li');    console.log(lis);    console.log(lis[0]);    // 2.依次打印,遍历    for (var i = 0; i < lis.length; i++) {        console.log(lis[i]);    }    // 3.如果页面中只有 1 个 li，返回的还是伪数组的形式    // 4.如果页面中没有这个元素，返回的是空伪数组</script>3

登录后复制parentNode.children 是一个只读属性，返回所有的子元素节点它只返回子元素节点，其余节点不返回 （这个是我们重点掌握的）虽然children是一个非标准，但是得到了各个浏览器的支持，因此我们可以放心使用

<ul>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li></ul><script>    // 1.返回的是获取过来元素对象的集合 以伪数组的形式存储    var lis = document.getElementsByTagName('li');    console.log(lis);    console.log(lis[0]);    // 2.依次打印,遍历    for (var i = 0; i < lis.length; i++) {        console.log(lis[i]);    }    // 3.如果页面中只有 1 个 li，返回的还是伪数组的形式    // 4.如果页面中没有这个元素，返回的是空伪数组</script>4

登录后复制5.3.1、第一个子结点

<ul>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li></ul><script>    // 1.返回的是获取过来元素对象的集合 以伪数组的形式存储    var lis = document.getElementsByTagName('li');    console.log(lis);    console.log(lis[0]);    // 2.依次打印,遍历    for (var i = 0; i < lis.length; i++) {        console.log(lis[i]);    }    // 3.如果页面中只有 1 个 li，返回的还是伪数组的形式    // 4.如果页面中没有这个元素，返回的是空伪数组</script>5

登录后复制firstChild 返回第一个子节点，找不到则返回null同样，也是包含所有的节点5.3.2、最后一个子结点

<ul>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li></ul><script>    // 1.返回的是获取过来元素对象的集合 以伪数组的形式存储    var lis = document.getElementsByTagName('li');    console.log(lis);    console.log(lis[0]);    // 2.依次打印,遍历    for (var i = 0; i < lis.length; i++) {        console.log(lis[i]);    }    // 3.如果页面中只有 1 个 li，返回的还是伪数组的形式    // 4.如果页面中没有这个元素，返回的是空伪数组</script>6

登录后复制lastChild 返回最后一个子节点，找不到则返回null同样，也是包含所有的节点

<ul>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li></ul><script>    // 1.返回的是获取过来元素对象的集合 以伪数组的形式存储    var lis = document.getElementsByTagName('li');    console.log(lis);    console.log(lis[0]);    // 2.依次打印,遍历    for (var i = 0; i < lis.length; i++) {        console.log(lis[i]);    }    // 3.如果页面中只有 1 个 li，返回的还是伪数组的形式    // 4.如果页面中没有这个元素，返回的是空伪数组</script>7

登录后复制

5.3.3、第一个子结点(兼容性)

<ul>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li></ul><script>    // 1.返回的是获取过来元素对象的集合 以伪数组的形式存储    var lis = document.getElementsByTagName('li');    console.log(lis);    console.log(lis[0]);    // 2.依次打印,遍历    for (var i = 0; i < lis.length; i++) {        console.log(lis[i]);    }    // 3.如果页面中只有 1 个 li，返回的还是伪数组的形式    // 4.如果页面中没有这个元素，返回的是空伪数组</script>8

登录后复制firstElementChild 返回第一个子节点，找不到则返回null有兼容性问题，IE9以上才支持5.3.4、最后一个子结点(兼容性)

<ul>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li>    <li>知否知否，应是等你好久</li></ul><script>    // 1.返回的是获取过来元素对象的集合 以伪数组的形式存储    var lis = document.getElementsByTagName('li');    console.log(lis);    console.log(lis[0]);    // 2.依次打印,遍历    for (var i = 0; i < lis.length; i++) {        console.log(lis[i]);    }    // 3.如果页面中只有 1 个 li，返回的还是伪数组的形式    // 4.如果页面中没有这个元素，返回的是空伪数组</script>9

登录后复制lastElementChild 返回最后一个子节点，找不到则返回null有兼容性问题，IE9以上才支持5.3.5、解决方案

实际开发中，firstChild 和 lastChild 包含其他节点，操作不方便，而 firstElementChild 和 lastElementChild 又有兼容性问题，那么我们如何获取第一个子元素节点或最后一个子元素节点呢？

解决方案

如果想要第一个子元素节点，可以使用parentNode.chilren[0]

如果想要最后一个子元素节点，可以使用

element.getElementsByTagName('标签名')ol.getElementsByTagName('li');0

登录后复制

示例：

element.getElementsByTagName('标签名')ol.getElementsByTagName('li');1

登录后复制5.4、兄弟节点5.4.1、下一个兄弟节点

element.getElementsByTagName('标签名')ol.getElementsByTagName('li');2

登录后复制nextSibling 返回当前元素的下一个兄弟元素节点，找不到则返回null同样，也是包含所有的节点5.4.2、上一个兄弟节点

element.getElementsByTagName('标签名')ol.getElementsByTagName('li');3

登录后复制

previousSibling 返回当前元素上一个兄弟元素节点，找不到则返回null

同样，也是包含所有的节点

5.4.3、下一个兄弟节点(兼容性)

element.getElementsByTagName('标签名')ol.getElementsByTagName('li');4

登录后复制nextElementSibling 返回当前元素下一个兄弟元素节点，找不到则返回null有兼容性问题，IE9才支持5.4.4、上一个兄弟节点(兼容性)

element.getElementsByTagName('标签名')ol.getElementsByTagName('li');5

登录后复制previousElementSibling 返回当前元素上一个兄弟元素节点，找不到则返回null有兼容性问题，IE9才支持

示例

element.getElementsByTagName('标签名')ol.getElementsByTagName('li');6

登录后复制

如何解决兼容性问题 ？

答：自己封装一个兼容性的函数

element.getElementsByTagName('标签名')ol.getElementsByTagName('li');7

登录后复制5.5、创建节点

element.getElementsByTagName('标签名')ol.getElementsByTagName('li');8

登录后复制document.createElement() 方法创建由 tagName 指定的HTML 元素因为这些元素原先不存在，是根据我们的需求动态生成的，所以我们也称为动态创建元素节点5.5.1、添加节点

element.getElementsByTagName('标签名')ol.getElementsByTagName('li');9

登录后复制node.appendChild() 方法将一个节点添加到指定父节点的子节点列表末尾。类似于 CSS 里面的 after 伪元素。

<script>//element.getElementsByTagName('标签名'); 父元素必须是指定的单个元素    var ol = document.getElementById('ol');    console.log(ol.getElementsByTagName('li'));</script>0

登录后复制node.insertBefore() 方法将一个节点添加到父节点的指定子节点前面。类似于 CSS 里面的 before 伪元素。

示例

<body>    <ul>        <li>123</li>    </ul>    <script>        // 1. 创建节点元素节点        var li = document.createElement('li');        // 2. 添加节点 element.getElementsByTagName('标签名')ol.getElementsByTagName('li');9  node 父级  child 是子级 后面追加元素  类似于数组中的push        // 先获取父亲ul        var ul = document.querySelector('ul');        ul.appendChild(li);        // 3. 添加节点 node.insertBefore(child, 指定元素);        var lili = document.createElement('li');        ul.insertBefore(lili, ul.children[0]);        // 4. 我们想要页面添加一个新的元素分两步: 1. 创建元素 2. 添加元素    </script></body>

登录后复制5.5.2、删除节点

<script>//element.getElementsByTagName('标签名'); 父元素必须是指定的单个元素    var ol = document.getElementById('ol');    console.log(ol.getElementsByTagName('li'));</script>2

登录后复制node.removeChild()方法从 DOM 中删除一个子节点，返回删除的节点5.5.3、复制节点(克隆节点)

<script>//element.getElementsByTagName('标签名'); 父元素必须是指定的单个元素    var ol = document.getElementById('ol');    console.log(ol.getElementsByTagName('li'));</script>3

登录后复制<script>//element.getElementsByTagName('标签名'); 父元素必须是指定的单个元素    var ol = document.getElementById('ol');    console.log(ol.getElementsByTagName('li'));</script>3方法返回调用该方法的节点的一个副本。 也称为克隆节点/拷贝节点如果括号参数为空或者为 false ，则是浅拷贝，即只克隆复制节点本身，不克隆里面的子节点如果括号参数为 true ，则是深度拷贝，会复制节点本身以及里面所有的子节点

示例

<body>    <ul>        <li>1111</li>        <li>2</li>        <li>3</li>    </ul>    <script>        var ul = document.querySelector('ul');        // 1. <script>//element.getElementsByTagName('标签名'); 父元素必须是指定的单个元素    var ol = document.getElementById('ol');    console.log(ol.getElementsByTagName('li'));</script>3; 括号为空或者里面是false 浅拷贝 只复制标签不复制里面的内容        // 2. node.cloneNode(true); 括号为true 深拷贝 复制标签复制里面的内容        var lili = ul.children[0].cloneNode(true);        ul.appendChild(lili);    </script></body>

登录后复制

5.5.4、面试题

三种动态创建元素的区别

doucument.write()<p id="time">2019-9-9</p><script>    // 1.因为我们文档页面从上往下加载，所以得先有标签，所以script写在标签下面    // 2.get 获得 element 元素 by 通过 驼峰命名法    // 3.参数 id是大小写敏感的字符串    // 4.返回的是一个元素对象    var timer = document.getElementById('time');    console.log(timer);    // 5. console.dir 打印我们的元素对象，更好的查看里面的属性和方法    console.dir(timer);</script>5document.createElement()

区别：

document.write() 是直接将内容写入页面的内容流，但是文档流执行完毕，则它会导致页面全部重绘innerHTML 是将内容写入某个 DOM 节点，不会导致页面全部重绘innerHTML 创建多个元素效率更高（不要拼接字符串，采取数组形式拼接），结构稍微复杂

<script>//element.getElementsByTagName('标签名'); 父元素必须是指定的单个元素    var ol = document.getElementById('ol');    console.log(ol.getElementsByTagName('li'));</script>5

登录后复制createElement()创建多个元素效率稍低一点点，但是结构更清晰

总结：不同浏览器下， innerHTML 效率要比 createElement 高

6、DOM核心

对于DOM操作，我们主要针对子元素的操作，主要有

创建增删改查属性操作时间操作6.1、创建document.writeinnerHTMLcreateElement6.2、增appendChildinsertBefore6.3、删removeChild6.4、改主要修改dom的元素属性，dom元素的内容、属性、表单的值等修改元素属性：src、href、title 等修改普通元素内容：innerHTML、innerText修改表单元素：value、type、disabled修改元素样式：style、className6.5、查主要获取查询dom的元素DOM提供的API方法：getElementById、getElementsByTagName (古老用法，不推荐)H5提供的新方法：querySelector、querySelectorAll (提倡)利用节点操作获取元素：父(parentNode)、子(children)、兄(previousElementSibling、nextElementSibling) 提倡6.6、属性操作主要针对于自定义属性setAttribute：设置dom的属性值getAttribute：得到dom的属性值removeAttribute：移除属性7、事件高级7.1、注册事件(绑定事件)

给元素添加事件，称为注册事件或者绑定事件。

注册事件有两种方式：传统方式和方法监听注册方式

利用 on 开头的事件 onclickw3c 标准推荐方式<button onclick = "alert("hi")"></button>addEventListener() 它是一个方法btn.onclick = function() {}IE9 之前的 IE 不支持此方法，可使用 attachEvent() 代替特点：注册事件的唯一性特点：同一个元素同一个事件可以注册多个监听器同一个元素同一个事件只能设置一个处理函数，最后注册的处理函数将会覆盖前面注册的处理函数按注册顺序依次执行addEventListener事件监听方式eventTarget.addEventListener()方法将指定的监听器注册到 eventTarget（目标对象）上当该对象触发指定的事件时，就会执行事件处理函数

<script>//element.getElementsByTagName('标签名'); 父元素必须是指定的单个元素    var ol = document.getElementById('ol');    console.log(ol.getElementsByTagName('li'));</script>6

登录后复制

该方法接收三个参数：

type:事件类型字符串，比如click,mouseover,注意这里不要带onlistener：事件处理函数，事件发生时，会调用该监听函数useCapture：可选参数，是一个布尔值，默认是 false。学完 DOM 事件流后，我们再进一步学习

<script>//element.getElementsByTagName('标签名'); 父元素必须是指定的单个元素    var ol = document.getElementById('ol');    console.log(ol.getElementsByTagName('li'));</script>7

登录后复制②attachEvent事件监听方式(兼容)eventTarget.attachEvent()方法将指定的监听器注册到 eventTarget（目标对象） 上当该对象触发指定的事件时，指定的回调函数就会被执行

<script>//element.getElementsByTagName('标签名'); 父元素必须是指定的单个元素    var ol = document.getElementById('ol');    console.log(ol.getElementsByTagName('li'));</script>8

登录后复制

该方法接收两个参数：

eventNameWithOn：事件类型字符串，比如 onclick 、onmouseover ，这里要带 oncallback： 事件处理函数，当目标触发事件时回调函数被调用ie9以前的版本支持③注册事件兼容性解决方案

兼容性处理的原则：首先照顾大多数浏览器，再处理特殊浏览器

<script>//element.getElementsByTagName('标签名'); 父元素必须是指定的单个元素    var ol = document.getElementById('ol');    console.log(ol.getElementsByTagName('li'));</script>9

登录后复制7.2、删除事件(解绑事件)7.2.1、removeEventListener删除事件方式

document.getElementsByClassName('类名');0

登录后复制

该方法接收三个参数：

type:事件类型字符串，比如click,mouseover,注意这里不要带onlistener：事件处理函数，事件发生时，会调用该监听函数useCapture：可选参数，是一个布尔值，默认是 false。学完 DOM 事件流后，我们再进一步学习7.2.2、detachEvent删除事件方式(兼容)

document.getElementsByClassName('类名');1

登录后复制

该方法接收两个参数：

eventNameWithOn：事件类型字符串，比如 onclick 、onmouseover ，这里要带 oncallback： 事件处理函数，当目标触发事件时回调函数被调用ie9以前的版本支持7.2.3、传统事件删除方式

document.getElementsByClassName('类名');2

登录后复制

事件删除示例：

document.getElementsByClassName('类名');3

登录后复制7.2.4、删除事件兼容性解决方案

document.getElementsByClassName('类名');4

登录后复制7.3、DOM事件流事件流描述的是从页面中接收事件的顺序事件发生时会在元素节点之间按照特定的顺序传播，这个传播过程即DOM事件流

事件冒泡： IE 最早提出，事件开始时由最具体的元素接收，然后逐级向上传播到到 DOM 最顶层节点的过程。

事件捕获： 网景最早提出，由 DOM 最顶层节点开始，然后逐级向下传播到到最具体的元素接收的过程。

加深理解：

我们向水里面扔一块石头，首先它会有一个下降的过程，这个过程就可以理解为从最顶层向事件发生的最具体元素（目标点）的捕获过程；之后会产生泡泡，会在最低点（ 最具体元素）之后漂浮到水面上，这个过程相当于事件冒泡。

7.3.1、捕获阶段document -> html -> body -> father -> son

两个盒子嵌套，一个父盒子一个子盒子，我们的需求是当点击父盒子时弹出 father ，当点击子盒子时弹出 son

document.getElementsByClassName('类名');5

登录后复制

但是因为DOM流的影响，我们点击子盒子，会先弹出 father，之后再弹出 son

这是因为捕获阶段由 DOM 最顶层节点开始，然后逐级向下传播到到最具体的元素接收

document -> html -> body -> father -> son

先看 document 的事件，没有；再看 html 的事件，没有；再看 body 的事件，没有；再看 father 的事件，有就先执行；再看 son 的事件，再执行。

7.3.2、冒泡阶段son -> father ->body -> html -> document

document.getElementsByClassName('类名');6

登录后复制

我们点击子盒子，会弹出 son、father、document

这是因为冒泡阶段开始时由最具体的元素接收，然后逐级向上传播到到 DOM 最顶层节点

son -> father ->body -> html -> document7.3.3、小结

JS 代码中只能执行捕获或者冒泡其中的一个阶段

onclick 和 attachEvent只能得到冒泡阶段

addEventListener(type,listener[,useCapture])第三个参数如果是 true，表示在事件捕获阶段调用事件处理程序；如果是 false (不写默认就是false),表示在事件冒泡阶段调用事件处理程序

实际开发中我们很少使用事件捕获，我们更关注事件冒泡。

有些事件是没有冒泡的，比如 onblur、onfocus、onmouseenter、onmouseleave

7.4、事件对象

document.getElementsByClassName('类名');7

登录后复制官方解释：event 对象代表事件的状态，比如键盘按键的状态、鼠标的位置、鼠标按钮的状态简单理解：事件发生后，跟事件相关的一系列信息数据的集合都放到这个对象里面这个对象就是事件对象 event，它有很多属性和方法，比如“谁绑定了这个事件鼠标触发事件的话，会得到鼠标的相关信息，如鼠标位置键盘触发事件的话，会得到键盘的相关信息，如按了哪个键这个 event 是个形参，系统帮我们设定为事件对象，不需要传递实参过去当我们注册事件时， event 对象就会被系统自动创建，并依次传递给事件监听器（事件处理函数）

document.getElementsByClassName('类名');8

登录后复制7.4.1、事件对象的兼容性方案

事件对象本身的获取存在兼容问题：

标准浏览器中是浏览器给方法传递的参数，只需要定义形参 e 就可以获取到。在 IE6~8 中，浏览器不会给方法传递参数，如果需要的话，需要到 window.event 中获取查找

解决：

document.getElementsByClassName('类名');9

登录后复制7.4.2、事件对象的常见属性和方法e.target返回触发事件的对象 标准e.srcElement返回触发事件的对象 非标准 ie6-8使用e.type返回事件的类型 比如clickmouseover不带one.cancelBubble该属性阻止冒泡，非标准，ie6-8使用e.returnValue该属性阻止默认行为 非标准，ie6-8使用e.preventDefault()该方法阻止默认行为 标准 比如不让链接跳转e.stopPropagation()阻止冒泡 标准

e.target和this的区别：

this 是事件绑定的元素， 这个函数的调用者（绑定这个事件的元素）e.target 是事件触发的元素。7.5、事件对象阻止默认行为

document.querySelector('选择器');// 切记里面的选择器需要加符号 // 类选择器.box // id选择器 #navvar firstBox = document.querySelector('.box');0

登录后复制7.6、阻止事件冒泡

事件冒泡：开始时由最具体的元素接收，然后逐级向上传播到到 DOM 最顶层节点

事件冒泡本身的特性，会带来的坏处，也会带来的好处，需要我们灵活掌握。

标准写法

document.querySelector('选择器');// 切记里面的选择器需要加符号 // 类选择器.box // id选择器 #navvar firstBox = document.querySelector('.box');1

登录后复制非标准写法： IE6-8 利用对象事件 cancelBubble属性

document.querySelector('选择器');// 切记里面的选择器需要加符号 // 类选择器.box // id选择器 #navvar firstBox = document.querySelector('.box');2

登录后复制

<body>    <p class="father">        <p class="son">son儿子</p>    </p>    <script>        // 常见事件对象的属性和方法        // 阻止冒泡  dom 推荐的标准 stopPropagation()         var son = document.querySelector('.son');        son.addEventListener('click', function(e) {            alert('son');            document.querySelector('选择器');// 切记里面的选择器需要加符号 // 类选择器.box // id选择器 #navvar firstBox = document.querySelector('.box');1 // stop 停止  Propagation 传播            document.querySelector('选择器');// 切记里面的选择器需要加符号 // 类选择器.box // id选择器 #navvar firstBox = document.querySelector('.box');2 // 非标准 cancel 取消 bubble 泡泡        }, false);        var father = document.querySelector('.father');        father.addEventListener('click', function() {            alert('father');        }, false);        document.addEventListener('click', function() {            alert('document');        })    </script></body>

登录后复制7.6.1、阻止事件冒泡的兼容性解决方案

if(e && e.stopPropagation){      document.querySelector('选择器');// 切记里面的选择器需要加符号 // 类选择器.box // id选择器 #navvar firstBox = document.querySelector('.box');1  }else{      window.event.cancelBubble = true;  }

登录后复制4.4.4 e.target 与 this

e.target 与 this 的区别

this是事件绑定的元素，这个函数的调用者(绑定这个事件的元素)e.target是事件触发的元素

<body>    <p>123</p>    <ul>        <li>abc</li>        <li>abc</li>        <li>abc</li>    </ul>    <script>        // 常见事件对象的属性和方法        // 1. e.target 返回的是触发事件的对象（元素）  this 返回的是绑定事件的对象（元素）        // 区别 ： e.target 点击了那个元素，就返回那个元素 this 那个元素绑定了这个点击事件，那么就返回谁        var p = document.querySelector('p');        p.addEventListener('click', function(e) {            console.log(e.target);            console.log(this);        })        var ul = document.querySelector('ul');        ul.addEventListener('click', function(e) {                // 我们给ul 绑定了事件  那么this 就指向ul                  console.log(this);                console.log(e.currentTarget);                // e.target 指向我们点击的那个对象 谁触发了这个事件 我们点击的是li e.target 指向的就是li                console.log(e.target);            })            // 了解兼容性            // p.onclick = function(e) {            //     document.getElementsByClassName('类名');9            //     var target = e.target || e.srcElement;            //     console.log(target);        // }        // 2. 了解 跟 this 有个非常相似的属性 currentTarget  ie678不认识    </script></body>

登录后复制4.4.5 事件对象的兼容性

事件对象本身的获取存在兼容问题：

标准浏览器中浏览器是给方法传递的参数，只需定义形参e就可以获取到在 IE6 -> 8 中，浏览器不会给方法传递参数，如果需要的话，需要到window.event中获取查找

解决方案

e = e || window.event

<body>    <p>123</p>    <script>        // 事件对象        var p = document.querySelector('p');        p.onclick = function(e) {                // document.getElementsByClassName('类名');9                console.log(e);// 事件对象也有兼容性问题 ie678 通过 window.event 兼容性的写法  document.getElementsByClassName('类名');9            }</body>

登录后复制7.7、事件委托事件委托也称为事件代理，在 jQuery 里面称为事件委派事件委托的原理不是每个子节点单独设置事件监听器，而是事件监听器设置在其父节点上，然后利用冒泡原理影响设置每个子节点

document.querySelector('选择器');// 切记里面的选择器需要加符号 // 类选择器.box // id选择器 #navvar firstBox = document.querySelector('.box');7

登录后复制

以上案例：给 ul 注册点击事件，然后利用事件对象的 target 来找到当前点击的 li，因为点击 li，事件会冒泡到 ul 上， ul 有注册事件，就会触发事件监听器。

7.8、常见的鼠标事件onclick鼠标点击左键触发onmouseover鼠标经过触发onmouseout鼠标离开触发onfocus获得鼠标焦点触发onblur失去鼠标焦点触发onmousemove鼠标移动触发onmouseup鼠标弹起触发onmousedown鼠标按下触发7.8.1、禁止鼠标右键与鼠标选中contextmenu主要控制应该何时显示上下文菜单，主要用于程序员取消默认的上下文菜单selectstart 禁止鼠标选中

document.querySelector('选择器');// 切记里面的选择器需要加符号 // 类选择器.box // id选择器 #navvar firstBox = document.querySelector('.box');8

登录后复制7.8.2、鼠标事件对象event对象代表事件的状态，跟事件相关的一系列信息的集合现阶段我们主要是用鼠标事件对象 MouseEvent 和键盘事件对象 KeyboardEvent。e.clientX返回鼠标相对于浏览器窗口可视区的X坐标e.clientY返回鼠标相对于浏览器窗口可视区的Y坐标e.pageX（重点）返回鼠标相对于文档页面的X坐标 IE9+ 支持e.pageY（重点）返回鼠标相对于文档页面的Y坐标 IE9+ 支持e.screenX返回鼠标相对于电脑屏幕的X坐标e.screenY返回鼠标相对于电脑屏幕的Y坐标

document.querySelector('选择器');// 切记里面的选择器需要加符号 // 类选择器.box // id选择器 #navvar firstBox = document.querySelector('.box');9

登录后复制7.9、常用的键盘事件onkeyup某个键盘按键被松开时触发onkeydown某个键盘按键被按下时触发onkeypress某个键盘按键被按下时触发，但是它不识别功能键，比如 ctrl shift 箭头等如果使用addEventListener 不需要加 ononkeypress 和前面2个的区别是，它不识别功能键，比如左右箭头，shift 等三个事件的执行顺序是： keydown – keypress — keyup

document.querySelectorAll('选择器');0

登录后复制7.9.1、键盘对象属性keyCode返回该键值的ASCII值onkeydown和 onkeyup 不区分字母大小写，onkeypress 区分字母大小写。在我们实际开发中，我们更多的使用keydown和keyup， 它能识别所有的键（包括功能键）Keypress 不识别功能键，但是keyCode属性能区分大小写，返回不同的ASCII值

document.querySelectorAll('选择器');1

登录后复制

相关推荐：javascript学习教程

以上就是超详细的JavaScript进阶学习之DOM技术（整理分享）的详细内容，更多请关注9543建站博客其它相关文章！