关于dom操作，我们主要针对于元素的操作。主要有创建、增、删、改、查、属性操作、事件操作。

1.创建

1.document.write

2.innerHTML

3.createElement

2.增加

1.appendChild

2.insertBefore

3.删除

1.removeChild

4.改

主要修改dom的元素属性，dom元素的内容、属性、表单的值等

1.修改元素属性：src、herf、title等

2.修改普通元素内容：innerHTML、innerText

3.修改表单元素：value、type、disabled等

4.修改元素样式：style、className

5.查

主要查询dom的元素

1.dom提供的API方法：getElementById、getElementsByTagName

2.H5提供的新方法：querySelector、querySelectorAll

3.利用节点操作获取元素：父（parentNode）、子（children）、兄（previousElementSibling、nextElementsSiling）

6.属性操作

主要针对与自定义属性

1.setAttribute   设置dom的属性值

2.getAttribute   得到dom的属性值

3.removeAttribute   移除属性

7.事件操作

1.注册事件

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

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

传统方式：

• 利用on开头的事件 => onclick
• <button οnclick=  "alert('hi~')"  >  </button>
• btn.onclick = function (){ }
• 特点：注册事件的唯一性
• 同一个元素同一个事件只能设置一个处理函数，最后注册的处理函数将会覆盖前面注册的处理函数

监听事件方式：

• w3c 标准 推荐方式
• addEventListener 它是一个方法
• IE9之前的IE不支持此方法，可使用attachEvent（）代替
• 特点：同一个元素同一个事件可以注册多个监听器
• 按注册顺序依次执行

2.事件监听

addEventListener()事件监听（IE9以后支持）

eventTarget.addEventListener(rype,listener[,useCapture])

eventTarget.addEventListener()方法将指定的监听器注册到 eventTarget（目标对象）上，当该对象触发指定的事件时，就会执行事件处理函数。

该方法接受三个参数：

• type：事件类型，比如click，mouseover，注意这里不要带on
• listener：事件处理函数，事件发生时，会调用该监听事件
• userCapture：可选参数，是一个布尔值，默认为false。

attacheEvent()事件监听（IE678支持）

eventTarget.attachEvent(eventNameWithon,callback)

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

该方法接收两个参数：

• eventNameWithon：事件类型，比如 onclick，onmouseover，这里要带on
• callback：事件处理函数，当目标出发事件时回调函数被调用

注意：IE8及早期版本支持

1. <button>传统注册事件</button>
2. <button>方法监听注册事件</button>
3. <button>ie9 attachEvent</button>
4. <script>
5. var btns = document.querySelectorAll('button');
6. // 1. 传统方式注册事件
7. btns[0].onclick = function() {
8. alert('hi');
9. }
10. btns[0].onclick = function() {
11. alert('hao a u');
12. }
13. // 2. 事件侦听注册事件 addEventListener
14. // (1) 里面的事件类型是字符串 必定加引号 而且不带on
15. // (2) 同一个元素 同一个事件可以添加多个侦听器（事件处理程序）
16. btns[1].addEventListener('click', function() {
17. alert(22);
18. })
19. btns[1].addEventListener('click', function() {
20. alert(33);
21. })
22. // 3. attachEvent ie9以前的版本支持
23. btns[2].attachEvent('onclick', function() {
24. alert(11);
25. })

 

3.删除事件（解绑事件）

1.传统注册方式

eventTarget.onclick = null

2.事件监听注册方式

1. eventTarget.removeEventListener(rype,listener[,useCapture])
3. eventTarget.detachEvent(eventNameWithon,callback)

 

1. <div>1</div>
2. <div>2</div>
3. <div>3</div>
4. <script>
5. var divs = document.querySelectorAll('div');
6. divs[0].onclick = function() {
7. alert(11);
8. // 1. 传统方式删除事件
9. divs[0].onclick = null;
10. }
11. // 2. removeEventListener 删除事件
12. divs[1].addEventListener('click', fn) // 里面的fn 不需要调用加小括号
13. function fn() {
14. alert(22);
15. divs[1].removeEventListener('click', fn);
16. }
17. // 3. detachEvent
18. divs[2].attachEvent('onclick', fn1);
20. function fn1() {
21. alert(33);
22. divs[2].detachEvent('onclick', fn1);
23. }

 

4.DOM事件流

html中的标签都是相互嵌套的，我们可以将元素想象成一个盒子装一个盒子，document是最外面的大盒子。
当你单击一个div时，同时你也单击了div的父元素，甚至整个页面。

那么是先执行父元素的单击事件，还是先执行div的单击事件 ？？？

事件流描述的是从页面接收事件的顺序

事件发生时会在元素节点之间按照特定的顺序传播，这个传播过程即DOM事件流。

比如：我们给页面中的一个div注册了单击事件，当你单击了div时，也就单击了body，单击了html，单击了document。

 

DOM 事件流会经历3个阶段：

1. 捕获阶段
2. 当前目标阶段
3. 冒泡阶段

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

事件冒泡

1. <div class="father">
2. <div class="son">son盒子</div>
3. </div>
4. <script>
5. // onclick 和 attachEvent（ie） 在冒泡阶段触发
6. // 冒泡阶段 如果addEventListener 第三个参数是 false 或者 省略
7. // son -> father ->body -> html -> document
8. var son = document.querySelector('.son');
9. // 给son注册单击事件
10. son.addEventListener('click', function() {
11. alert('son');
12. }, false);
13. // 给father注册单击事件
14. var father = document.querySelector('.father');
15. father.addEventListener('click', function() {
16. alert('father');
17. }, false);
18. // 给document注册单击事件，省略第3个参数
19. document.addEventListener('click', function() {
20. alert('document');
21. })
22. </script>

 

事件捕获

1. <div class="father">
2. <div class="son">son盒子</div>
3. </div>
4. <script>
5. // 如果addEventListener() 第三个参数是 true 那么在捕获阶段触发
6. // document -> html -> body -> father -> son
7. var son = document.querySelector('.son');
8. // 给son注册单击事件，第3个参数为true
9. son.addEventListener('click', function() {
10. alert('son');
11. }, true);
12. var father = document.querySelector('.father');
13. // 给father注册单击事件，第3个参数为true
14. father.addEventListener('click', function() {
15. alert('father');
16. }, true);
17. // 给document注册单击事件，第3个参数为true
18. document.addEventListener('click', function() {
19. alert('document');
20. }, true)
21. </script>

 

5. 事件对象

事件发生后，跟事件相关的一系列信息数据的集合都放到这个对象里面，这个对象就是事件对象。

 

比如：

1. 谁绑定了这个事件。
2. 鼠标触发事件的话，会得到鼠标的相关信息，如鼠标位置。
3. 键盘触发事件的话，会得到键盘的相关信息，如按了哪个键。

事件对象的使用

事件触发发生时就会产生事件对象，并且系统会以实参的形式传给事件处理函数。

所以，在事件处理函数中声明1个形参用来接收事件对象。

 

事件对象的属性和方法

 

e.target 和 this 的区别

• this 是事件绑定的元素（绑定这个事件处理函数的元素） 。
• e.target 是事件触发的元素。

通常情况下terget 和 this是一致的，
但有一种情况不同，那就是在事件冒泡时（父子元素有相同事件，单击子元素，父元素的事件处理函数也会被触发执行），
这时候this指向的是父元素，因为它是绑定事件的元素对象，
而target指向的是子元素，因为他是触发事件的那个具体元素对象。

1. <div>123</div>
2. <script>
3. var div = document.querySelector('div');
4. div.addEventListener('click', function(e) {
5. // e.target 和 this指向的都是div
6. console.log(e.target);
7. console.log(this);
9. });
10. </script>

 

事件冒泡下的e.target和this

1. <ul>
2. <li>abc</li>
3. <li>abc</li>
4. <li>abc</li>
5. </ul>
6. <script>
7. var ul = document.querySelector('ul');
8. ul.addEventListener('click', function(e) {
9. // 我们给ul 绑定了事件 那么this 就指向ul
10. console.log(this); // ul
12. // e.target 触发了事件的对象 我们点击的是li e.target 指向的就是li
13. console.log(e.target); // li
14. });
15. </script>

 

6 阻止默认行为

html中一些标签有默认行为，例如a标签被单击后，默认会进行页面跳转。

1. <a href="http://www.baidu.com">百度</a>
2. <script>
3. // 2. 阻止默认行为 让链接不跳转
4. var a = document.querySelector('a');
5. a.addEventListener('click', function(e) {
6. e.preventDefault(); // dom 标准写法
7. });
8. // 3. 传统的注册方式
9. a.onclick = function(e) {
10. // 普通浏览器 e.preventDefault(); 方法
11. e.preventDefault();
12. // 低版本浏览器 ie678 returnValue 属性
13. e.returnValue = false;
14. // 我们可以利用return false 也能阻止默认行为 没有兼容性问题
15. return false;
16. }
17. </script>

 

7 阻止事件冒泡

事件冒泡本身的特性，会带来的坏处，也会带来的好处。

• 标准写法：利用事件对象里面的stopPropagation（）方法

e.stopPropagation（）

• 非标准写法：IE6-8 利用时间对象 cancelBubble属性

e.cancelBubble = true

1. <div class="father">
2. <div class="son">son儿子</div>
3. </div>
4. <script>
5. var son = document.querySelector('.son');
6. // 给son注册单击事件
7. son.addEventListener('click', function(e) {
8. alert('son');
9. e.stopPropagation(); // stop 停止 Propagation 传播
10. window.event.cancelBubble = true; // 非标准 cancel 取消 bubble 泡泡
11. }, false);
13. var father = document.querySelector('.father');
14. // 给father注册单击事件
15. father.addEventListener('click', function() {
16. alert('father');
17. }, false);
18. // 给document注册单击事件
19. document.addEventListener('click', function() {
20. alert('document');
21. })
22. </script>

 

8 事件委托

把事情委托给别人，代为处理。

事件委托也称为事件代理，在 jQuery 里面称为事件委派。

说白了就是，不给子元素注册事件，给父元素注册事件，把处理代码在父元素的事件中执行。

事件委托的原理

给父元素注册事件，利用事件冒泡，当子元素的事件触发，会冒泡到父元素，然后去控制相应的子元素。

事件委托的作用

• 我们只操作了一次 DOM ，提高了程序的性能。
• 动态新创建的子元素，也拥有事件。

1. <ul>
2. <li>知否知否，点我应有弹框在手！</li>
3. <li>知否知否，点我应有弹框在手！</li>
4. <li>知否知否，点我应有弹框在手！</li>
5. <li>知否知否，点我应有弹框在手！</li>
6. <li>知否知否，点我应有弹框在手！</li>
7. </ul>
8. <script>
9. // 事件委托的核心原理：给父节点添加侦听器， 利用事件冒泡影响每一个子节点
10. var ul = document.querySelector('ul');
11. ul.addEventListener('click', function(e) {
12. // e.target 这个可以得到我们点击的对象
13. e.target.style.backgroundColor = 'pink';
14. })
15. </script>