JavaScript事件流，事件冒泡和事件捕捉

本文主要是介绍JavaScript事件流，事件冒泡和事件捕捉，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

本文是笔者阅读对JS事件流的深入理解之后的学习记录，@谢小飞系原文作者，感谢！

什么是js事件？什么是原生事件和自定义事件？

在JavaScript中有一个Event接口，表示在DOM中出现的事件，一些事件是由用户触发的，例如鼠标或键盘事件；而其他事件常由 API 生成，例如指示动画已经完成运行的事件，视频已被暂停等等。事件也可以通过脚本代码触发，例如对元素调用 HTMLElement.click() 方法，或者定义一些自定义事件，再使用 EventTarget.dispatchEvent() 方法将自定义事件派发往指定的目标（target）。
原生事件（DOM事件）：
原生事件由浏览器的监听器根据原生dom节点对象的状态是否改变来判断是否触发,也可以根据需要手动触发。

<button @click="change">点我</button>

这里的click就是一个鼠标事件（MouseEvent）
自定义事件：
自定义事件句柄指向的操作函数，此事件不在浏览器的监听范围内，换句话说，浏览器的监听器无视自定义事件，所以它的触发完全靠程序员根据需要手动触发。

<my-component @click="myalert">my component</my-component>

        Vue.component('my-component',{
            props:["value"],
            template:`
              <div>
              <slot></slot>
              </div>
            `
        })

myalert:function (){
     alert('myalert')
 }

而这里的click就是一个自定义事件，为什么？
因为my-component是我们自定义的组件，并不是原生元素，此时浏览器会将click认为是我们的自定义事件。
所以，如果我们现在点击my-component，还会触发myalert吗？
并不会，因为my-compenent并没有监听鼠标点击事件，这里监听的只是一个名为click的自定义事件，这个自定义事件需要我们手动触发。

观察以下代码：

        Vue.component('my-component',{
            props:["value"],
            template:`
              <div>
              <button @click="myclick">click here</button>
              <slot></slot>
              </div>
            `,
            methods:{
                myclick(){
                    window.alert('myclick')
                }
            }
        })

这时候点击my-component中的按钮，会触发myclick方法吗？
如何区分这里的<button @click="myclick">click here</button>监听得是自定义事件还是原生事件？button是原生DOM节点，不是我们自定义的，所以，这里监听的click是监听的原生事件，也就是鼠标点击事件。因此，点击button会触发这里的myclick。

js事件流

当一个节点触发了一个事件时，比如在某些写内容上的点击，鼠标的滚动等，该事件会在元素节点与根节点之间按特定的顺序传播，路径所经过的节点都会收到该事件，这个传播过程称为DOM事件流。而自定义事件的冒泡Vue官方并没有提供相应的解决方案，我们可以使用emit达到类似的效果。

事件流描述的就是从页面中接收事件的顺序。而早期的IE和Netscape提出了完全相反的事件流概念，IE事件流是事件冒泡，而Netscape的事件流就是事件捕获。

事件冒泡

IE提出的事件流是事件冒泡，即从下至上，从目标触发的元素逐级向上传播，直到window对象。详情请查看下文的DOM事件处理
在这里插入图片描述

事件捕获

Netscape的事件流就是事件捕获，即从document逐级向下传播到目标元素。由于IE低版本浏览器不支持，所以很少使用事件捕获。
详情请查看下文的DOM事件处理
在这里插入图片描述

DOM事件处理

DOM节点中有了事件，那我们就需要对事件进行处理，而DOM事件处理分为4个级别：DOM0级事件处理，DOM0级事件处理，DOM2级事件处理和DOM3级事件处理。
在这里插入图片描述
其中DOM1级事件处理标准中并没有定义相关的内容，所以没有所谓的DOM1事件处理；DOM3级事件在DOM2级事件的基础上添加了更多的事件类型。

1. DOM 0

DOM0级事件具有极好的跨浏览器优势，会以最快的速度绑定。第一种方式是内联模型（行内绑定），将函数名直接作为html标签中属性的属性值。

<div onclick="btnClick()">click</div>
<script>
function btnClick(){
    console.log("hello");
}
</script>

内联模型的缺点是不符合w3c中关于内容与行为分离的基本规范。第二种方式是脚本模型（动态绑定），通过在JS中选中某个节点，然后给节点添加onclick属性。

<div id="btn">点击</div>
<script>
var btn=document.getElementById("btn");
btn.onclick=function(){
    console.log("hello");
}
</script>

点击输出hello，没有问题；如果我们给元素添加两个事件

<div id="btn">点击</div>
<script>
var btn=document.getElementById("btn");
btn.onclick=function(){
    console.log("hello");
}
btn.onclick=function(){
    console.log("hello again");
}
</script>

这时候只有输出hello again，很明显，第一个事件函数被第二个事件函数给覆盖掉，所以脚本模型的缺点是同一个节点只能添加一次同类型事件。让我们把div扩展到3个。

<div id="btn3">
    btn3
    <div id="btn2">
        btn2
        <div id="btn1">
            btn1
        </div>
    </div>
</div>
<script>
    let btn1 = document.getElementById("btn1");
    let btn2 = document.getElementById("btn2");
    let btn3 = document.getElementById("btn3");
    btn1.onclick=function(){
        console.log(1)
    }
    btn2.onclick=function(){
        console.log(2)
    }
    btn3.onclick=function(){
        console.log(3)
    }
</script>

在这里插入图片描述
当我们点击btn3的时候输出3，那当我们点击btn1的时候呢？

我们发现最先触发的是最底层btn1的事件，最后才是顶层btn3的事件，因此很明显是事件冒泡。DOM0级只支持冒泡阶段。

2. DOM2

进一步规范之后，有了DOM2级事件处理程序，其中定义了两个方法：

addEventListener() —添加事件侦听器
removeEventListener() —删除事件侦听器

函数均有3个参数，第一个参数是要处理的事件名第二个参数是作为事件处理程序的函数第三个参数是一个boolean值，默认false表示使用冒泡机制，true表示捕获机制。

<div id="btn">点击</div>

<script>
var btn=document.getElementById("btn");
btn.addEventListener("click",hello,false);
btn.addEventListener("click",helloagain,false);
function hello(){
    console.log("hello");
}
function helloagain(){
    console.log("hello again");
}
</script>

这时候两个事件处理程序都能够成功触发，说明可以绑定多个事件处理程序，但是注意，如果定义了一摸一样时监听方法，是会发生覆盖的，即同样的事件和事件流机制下相同方法只会触发一次，

<div id="btn">点击</div>

<script>
var btn=document.getElementById("btn");
btn.addEventListener("click",hello,false);
btn.addEventListener("click",hello,false);
function hello(){
    console.log("hello");
}
</script>

这时候hello只会执行一次；让我们把div扩展到3个。

<div id="btn3">
    btn3
    <div id="btn2">
        btn2
        <div id="btn1">
            btn1
        </div>
    </div>
</div>
<script>
    let btn1 = document.getElementById('btn1');
    let btn2 = document.getElementById('btn2');
    let btn3 = document.getElementById('btn3');
    btn1.addEventListener('click',function(){
        console.log(1)
    }, true)
    btn2.addEventListener('click',function(){
        console.log(2)
    }, true)
    btn3.addEventListener('click',function(){
        console.log(3)
    }, true)
</script>

在这里插入图片描述
这时候看到顺序和DOM0中的顺序反过来了，最外层的btn最先触发，因为addEventListener最后一个参数是true，捕获阶段进行处理。

在这里插入图片描述

那么冒泡和捕获阶段谁先执行呢？我们给每个元素分别绑定了冒泡和捕获两个事件。

btn1.addEventListener('click',function(){
    console.log('btn1捕获')
}, true)
btn1.addEventListener('click',function(){
    console.log('btn1冒泡')
}, false)

btn2.addEventListener('click',function(){
    console.log('btn2捕获')
}, true)
btn2.addEventListener('click',function(){
    console.log('btn2冒泡')
}, false)

btn3.addEventListener('click',function(){
    console.log('btn3捕获')
}, true)
btn3.addEventListener('click',function(){
    console.log('btn2冒泡')
}, false)

在这里插入图片描述
我们看到先执行捕获阶段的处理程序，后执行冒泡阶段的处理程序，我们把顺序换一下再看运行结果：

btn1.addEventListener('click',function(){
    console.log('btn1冒泡')
}, false)
btn1.addEventListener('click',function(){
    console.log('btn1捕获')
}, true)

btn2.addEventListener('click',function(){
    console.log('btn2冒泡')
}, false)
btn2.addEventListener('click',function(){
    console.log('btn2捕获')
}, true)

btn3.addEventListener('click',function(){
    console.log('btn3冒泡')
}, false)
btn3.addEventListener('click',function(){
    console.log('btn3捕获')
}, true)

在这里插入图片描述
w3c规定了，任何发生在w3c事件模型中的事件，首是进入捕获阶段，直到达到目标元素，再进入冒泡阶段。绑定在被点击元素的事件是按照代码的顺序发生的。

阻止冒泡

有时候我们需要点击事件不再继续向下捕获或者向上冒泡，我们在btn2上加上stopPropagation函数，阻止程序捕获或者冒泡。

btn1.addEventListener('click',function(){
    console.log('btn1冒泡')
}, false)
btn1.addEventListener('click',function(){
    console.log('btn1捕获')
}, true)

btn2.addEventListener('click',function(){
    console.log('btn2冒泡')
}, false)
btn2.addEventListener('click',function(ev){
    ev.stopPropagation();
    console.log('btn2捕获')
}, true)

btn3.addEventListener('click',function(){
    console.log('btn3冒泡')
}, false)
btn3.addEventListener('click',function(e){
    console.log('btn3捕获')
}, true)

在这里插入图片描述
可以看到btn2捕获阶段执行后不再继续往下执行。

btn1.addEventListener('click',function(ev){
        ev.stopPropagation()
        console.log('btn1冒泡')
    }, false)
    btn1.addEventListener('click',function(){
        console.log('btn1捕获')
    }, true)

    btn2.addEventListener('click',function(){
        console.log('btn2冒泡')
    }, false)
    btn2.addEventListener('click',function(){
        console.log('btn2捕获')
    }, true)

    btn3.addEventListener('click',function(){
        console.log('btn3冒泡')
    }, false)
    btn3.addEventListener('click',function(e){
        console.log('btn3捕获')
    }, true)

在这里插入图片描述
可以看到btn1冒泡阶段执行后不再继续往下执行。

事件委托

如果有多个DOM节点需要监听事件的情况下，给每个DOM绑定监听函数，会极大的影响页面的性能，因为我们通过事件委托来进行优化，事件委托利用的就是冒泡的原理。

<ul>
    <li>1</li>
    <li>2</li>
    <li>3</li>
    <li>4</li>
    <li>5</li>
</ul>
<script>
    var li_list = document.getElementsByTagName('li')
    for(let index = 0;index<li_list.length;index++){
        li_list[index].addEventListener('click', function(ev){
            console.log(ev.currentTarget.innerHTML)
        })
    }
</script>

正常情况我们给每一个li都会绑定一个事件，但是如果这时候li是动态渲染的，数据又特别大的时候，每次渲染后（有新增的情况）我们还需要重新来绑定，又繁琐又耗性能；这时候我们可以将绑定事件委托到li的父级元素，即ul。

var ul_dom = document.getElementsByTagName('ul')
ul_dom[0].addEventListener('click', function(ev){  
    console.log(ev.target.innerHTML)
})

上面代码中我们使用了两种获取目标元素的方式，target和currentTarget，那么他们有什么区别呢：

target返回触发事件的元素，不一定是绑定事件的元素
currentTarget返回的是绑定事件的元素
也就是说，在事件委托之后，ev.target可以得到是哪一个li触发了事件。

这篇关于JavaScript事件流，事件冒泡和事件捕捉的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程