Verstehen Sie den Event-Bubbling-Mechanismus in JS in einem Artikel

Dieser Artikel befasst sich mit Event-Bubbling und vermittelt Ihnen ein tiefgreifendes Verständnis des Event-Bubbling-Mechanismus in JS. Ich hoffe, er wird Ihnen hilfreich sein!

1. Ereignisse

In der Browser-Client-Anwendungsplattform ist grundsätzlich alles ereignisgesteuert, das heißt, ein Ereignis tritt ein und dann werden entsprechende Aktionen ausgeführt.

                      Browserereignisse stellen Signale dar, dass etwas passiert ist. Die Erklärung des Vorfalls steht nicht im Mittelpunkt dieses Artikels. Freunde, die ihn noch nicht verstanden haben, können ihn auf Baidu erfahren. Dies wird helfen, den folgenden Inhalt besser zu verstehen.

2. Blasenmechanismus

Was ist Blasen?

Sie sollten das Bild unten verstehen. Die Blasen beginnen am Grund des Wassers und steigen von tief nach flach nach oben. Auf dem Weg nach oben durchqueren die Blasen unterschiedliche Wassertiefen.应 对

Dementsprechend: Diese Blase entspricht unserem Vorfall, und Wasser entspricht unserem gesamten DOM-Baum. Der Vorfall wird von der untersten Ebene des DOM-Baums bis zum Pass zum Pass weitergegeben zum Wurzelknoten von dom.

Einfache Fallanalyse

Das Folgende ist ein einfaches Beispiel, um das Prinzip des Sprudelns zu veranschaulichen:

Definieren Sie einen HTML-Code mit drei einfachen Dom-Elementen: div1, div2, span, div2 enthält span, div1 enthält div2; und sie befinden sich alle unter dem Körper:

	<div>
		<div>
			<span>This is a span.</span>
		</div>
	</div>

Der Schnittstellenprototyp lautet wie folgt:

a. Klickereignisüberwachung zum Körper hinzufügen. Wenn der Körper das Ereignisereignis erfasst, wird die Zeit ausgedruckt, zu der das Ereignis auftritt Das aufgetretene Ereignis und die Knoteninformationen, die das Ereignis ausgelöst haben:

<script>
	window.onload = function() {
		document.getElementById("body").addEventListener("click",eventHandler);
	}
	function eventHandler(event) {
		console.log("时间："+new Date(event.timeStamp)+" 产生事件的节点：" + event.target.id +"  当前节点："+event.currentTarget.id);
	}
</script>

Wenn wir nacheinander auf „Dies ist span“, div2, div1 und body klicken, werden die folgenden Informationen ausgegeben:

​​​​​​​ ： Analyse der obigen Ergebnisse: 以 Ob es sich um Body, Bodys Unterelement DIV1 oder DIVs Unterelement DIV2 und SPAN handelt, wenn auf diese Elemente geklickt wird, wird der entsprechende Ereignishandler aufgerufen Funktion. So wie Blasen im Wasser von unten nach oben steigen, so steigen auch Ereignisse auf.

Das schematische Diagramm der Ereigniszustellung sieht wie folgt aus:

Im Allgemeinen verfügt ein Ereignis während des Zustellungsprozesses über einige Informationen, die die Bestandteile des Ereignisses sind:

Der Zeitpunkt, zu dem das Ereignis stattfand + der Ort wo das Ereignis aufgetreten ist + der Ereignistyp + der aktuelle Handler des Ereignisses + andere Informationen ,

Der vollständige HTML-Code lautet wie folgt:

nbsp;html>



<script></script>


 
<script>
	window.onload = function() {
		document.getElementById("body").addEventListener("click",eventHandler);
	}
	function eventHandler(event) {
		console.log("时间："+new Date(event.timeStamp)+" 产生事件的节点：" + event.target.id +"  当前节点："+event.currentTarget.id);
	}
</script>
 


	<div>
		<div>
			<span>This is a span.</span>
		</div>
	</div>

b, beende das Sprudeln des Ereignisses

Wir möchten jetzt eine solche Funktion implementieren. Wenn auf div1 geklickt wird, wird „Hallo, ich bin das äußerste Div“ angezeigt. Wenn auf div2 geklickt wird, wird „Hallo, ich bin das Div der zweiten Ebene“ angezeigt Wenn Sie darauf klicken, wird „Hallo, ich bin das zweite Div“ angezeigt. Daraus erhalten wir das folgende Javascript-Snippet:

<script>
	window.onload = function() {
		document.getElementById("box1").addEventListener("click",function(event){
			alert("您好，我是最外层div。");
		});
		document.getElementById("box2").addEventListener("click",function(event){
			alert("您好，我是第二层div。");
		});
		document.getElementById("span").addEventListener("click",function(event){
			alert("您好，我是span。");
		});
	}
</script>

预期上述代码会单击span 的时候，会出来一个弹出框 "您好，我是span。" 是的，确实弹出了这样的对话框：

然而，不仅仅会产生这个对话框，当点击确定后，会依次弹出下列对话框：

     

这显然不是我们想要的！ 我们希望的是点谁显示谁的信息而已。为什么会出现上述的情况呢？ 原因就在于事件的冒泡，点击span的时候，span 会把产生的事件往上冒泡，作为父节点的div2 和 祖父节点的div1也会收到此事件，于是会做出事件响应，执行响应函数。现在问题是发现了，但是怎么解决呢？

方法一：我们来考虑一个形象一点的情况：水中的一个气泡正在从底部往上冒，而你现在在水中，不想让这个气泡往上冒，怎么办呢？——把它扎破！没了气泡，自然不会往上冒了。类似地，对某一个节点而言，如果不想它现在处理的事件继续往上冒泡的话，我们可以终止冒泡：

在相应的处理函数内，加入  event.stopPropagation()   ,终止事件的广播分发，这样事件停留在本节点，不会再往外传播了。修改上述的script片段：

<script>
	window.onload = function() {
		document.getElementById("box1").addEventListener("click",function(event){
			alert("您好，我是最外层div。");
			event.stopPropagation();
		});
		document.getElementById("box2").addEventListener("click",function(event){
			alert("您好，我是第二层div。");
			event.stopPropagation();
		});
		document.getElementById("span").addEventListener("click",function(event){
			alert("您好，我是span。");
			event.stopPropagation();
		});
	}
</script>

经过这样一段代码，点击不同元素会有不同的提示，不会出现弹出多个框的情况了。

方法二：事件包含最初触发事件的节点引用 和 当前处理事件节点的引用，那如果节点只处理自己触发的事件即可,不是自己产生的事件不处理。event.target 引用了产生此event对象的dom 节点，而event.currrentTarget 则引用了当前处理节点，我们可以通过这 两个target 是否相等。

            比如span 点击事件，产生一个event 事件对象，event.target 指向了span元素，span处理此事件时，event.currentTarget 指向的也是span元素，这时判断两者相等，则执行相应的处理函数。而事件传递给 div2 的时候，event.currentTarget变成 div2，这时候判断二者不相等，即事件不是div2 本身产生的，就不作响应处理逻辑。               

<script>
	window.onload = function() {
		document.getElementById("box1").addEventListener("click",function(event){
			if(event.target == event.currentTarget)
			{
			    alert("您好，我是最外层div。");
			}
		});
		document.getElementById("box2").addEventListener("click",function(event){
			if(event.target == event.currentTarget)
			{
				alert("您好，我是第二层div。");
			}
		});
		document.getElementById("span").addEventListener("click",function(event){
			if(event.target == event.currentTarget)
			{
			    alert("您好，我是span。");
				
			}
		});
	}
</script>

比较：

从事件传递上看：

• 方法一在于取消事件冒泡，即当某些节点取消冒泡后，事件不会再传递；

• 方法二在于不阻止冒泡，过滤需要处理的事件，事件处理后还会继续传递；

优缺点：

• 方法一缺点：为了实现点击特定的元素显示对应的信息，方法一要求每个元素的子元素也必须终止事件的冒泡传递，即跟别的元素功能上强关联，这样的方法会很脆弱。比如，如果span 元素的处理函数没有执行冒泡终止，则事件会传到p2 上，这样会造成p2 的提示信息；
  

• 方法二缺点：方法二为每一个元素都增加了事件监听处理函数，事件的处理逻辑都很相似，即都有判断 if(event.target == event.currentTarget)，这样存在了很大的代码冗余，现在是三个元素还好，当有10几个，上百个又该怎么办呢？

还有就是为每一个元素都有处理函数，在一定程度上增加逻辑和代码的复杂度。

        我们再来分析一下方法二：方法二的原理是 元素收到事件后，判断事件是否符合要求，然后做相应的处理，然后事件继续冒泡往上传递；

既然事件是冒泡传递的，那可不可以让某个父节点统一处理事件，通过判断事件的发生地（即事件产生的节点），然后做出相应的处理呢？答案是可以的，下面通过给body 元素添加事件监听，然后通过判断event.target 然后对不同的target产生不同的行为。

        将方法二的代码重构一下：

<script>
	window.onload = function() {
		document.getElementById("body").addEventListener("click",eventPerformed);
	}
	function eventPerformed(event) {
		var target = event.target;
		switch (target.id) {
		case "span": 
			alert("您好，我是span。");
			break;
		case "div1":
			alert("您好，我是第二层div。");
			break;
		case "div2":
			alert("您好，我是最外层div。");
			break;
		}
	}
</script>

结果会是点击不同的元素，只弹出相符合的提示，不会有多余的提示。

Mit der obigen Methode haben wir die Verarbeitungsfunktionen übergeben, die jedes Element an sein Großelternknoten -Körperelement ausführen sollte, mit anderen Worten, Span, P2 und P1 delegieren Sie ihre Antwortlogik an den Körper, lassen Sie es vervollständigen. die entsprechende Logik und implementieren nicht die entsprechende Logik selbst. Dieser Modus ist die sogenannte Ereignisdelegation. Das Folgende ist ein schematisches Diagramm:

[Verwandte Empfehlungen: Javascript-Lern-Tutorial

]

Das obige ist der detaillierte Inhalt vonVerstehen Sie den Event-Bubbling-Mechanismus in JS in einem Artikel. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!