event

本文深入解析DOM事件流的三个阶段:捕获阶段、目标阶段和冒泡阶段,阐述了eventPhase属性的作用,并通过实例展示了如何使用addEventListener监听不同阶段的事件。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

事件流动

DOM事件不单单只会在一个Element上触发,它还会流向其他Element。事件的流动通常会经历这么三个阶段:

捕获阶段 -> 目标阶段 -> 冒泡阶段

"eventPhase"

“eventPhase”是“Event”下的一个属性,它指明当前event属于那一个阶段。
“eventPhase”可能是一下其中一个值:

  • Event.NONE,0,没有事件需要处理
  • Event.CAPTURING_PHASE,1,捕获阶段
  • Event.AT_TARGET,2,目标阶段,事件对象到达事件目标上
  • Event.BUBBLING_PHASE,3,冒泡阶段

下面我们详细讨论一下这三个阶段。

捕获阶段(capture phase)

捕获阶段的定义如下(w3c):

The event object propagate through the target's ancestors from the defaultView to the target's parent.
事件对象在事件目标的祖先中上到下顺向传播,从最顶层的defaultView到事件目标的(直系)父元素。

捕获阶段发生在整个事件流动的开始。在这阶段里事件会从父(主干)到子(分支)由上往下传播,被元素一层层地捕获。
文章开头的例子里面,捕获阶段的click事件会依次在document、body、div上触发:

document    1
  v
body    2
  v
div    3
  v
button

一般我们没太大需要监听捕获阶段的事件;如果你确实希望这么做,需要将addEventListener的第三个参数设置为true:

// 第三个参数设置是否为捕获阶段,默认为false
element.addEventListener('click', function() {}, true)

目标阶段(target phase)

目标阶段的定义是(w3c):

The event object arrive at the event object's event target.
事件对象到达事件目标。

例子里面,就是事件在button上触发的。addEventListener可以监听目标阶段的事件:

element.addEventListener('click', function() {})

如果事件是不可冒泡的,那整个事件流动会到此为止,不会发生下面的冒泡阶段。

冒泡阶段(bubble phase)

冒泡阶段的定义如下(w3c):

The event object propagates through the target's ancestors in reverse order, starting with the target's parent and ending with the defaultView.
事件对象会在事件目标的祖先元素里反向传播,由开始的父元素到最后的defaultView(document)。

冒泡阶段发生在最后,这也是我们最为熟悉的一个阶段。在这阶段里事件会从子(分支)到父(主干)逆向传播,看起来像是一个水里的泡泡往上冒。
例子里面,冒泡阶段的click事件会依次在div、body、document上触发:

document    3
  ^
body    2
  ^
div    1
  ^
button

"bubbles"

Event下的bubbles属性标明该事件是否为可冒泡的。一旦该值为false,则说明 evnet不可冒泡,那其流动也会在第二阶段“目标阶段”后就终止。


总结

若一个元素(div)是目标元素(button)的祖先,那事件对象会在该元素上触发两次:一次是捕获阶段(1)的,另一次是冒泡阶段(3)的。当事件对象在事件目标元素(button)上触发时,事件流动进入了目标阶段(2)。

  • 想监听捕获阶段的事件,可以这样:element.addEventListener('click', cb, true),将第三个参数设置为true。
  • 想监听冒泡阶段的事件,可以这样:element.addEventListener('click', cb,),不使用第三个参数或将其设置为false。
  • 而上述的任何一种监听方式都可以监听到目标阶段的事件。

Example

      let divElement = document.querySelector('div')
      let btnElement = document.querySelector('button')
      
      document.body.addEventListener('click', event => {
        console.log('Body Click in Bubble Phase.')
        console.log('Event Phase: ' + event.eventPhase)
      })
      
      document.body.addEventListener('click', event => {
        console.log('Body Click in Capture Phase.')
        console.log('Event Phase: ' + event.eventPhase)
      }, true)

      divElement.addEventListener('click', event => {
        console.log('Div Click in Bubble Phase.')
        console.log('Event Phase: ' + event.eventPhase)
      })
      
      divElement.addEventListener('click', event => {
        console.log('Div Click in Capture Phase.')
        console.log('Event Phase: ' + event.eventPhase)
      }, true)
      
      btnElement.addEventListener('click', event => {
        console.log('Button Click in Target Phase.')
        console.log('Event Phase: ' + event.eventPhase)
      })
      
      btnElement.addEventListener('click', event => {
        console.log('Button Click in Target Phase.')
        console.log('Event Phase: ' + event.eventPhase)
      }, true)
Body Click in Capture Phase.
Event Phase: 1
Div Click in Capture Phase.
Event Phase: 1
Button Click in Target Phase.
Event Phase: 2
Button Click in Target Phase.
Event Phase: 2
Div Click in Bubble Phase.
Event Phase: 3
Body Click in Bubble Phase.
Event Phase: 3

 

Javascript事件:事件监听器

DOM Level 2 Events定义了两个用于分配和删除事件处理程序的方法:addEventListeners()和removeEventListeners()

这些方法存在于所有DOM节点上并接受三个参数:要处理的事件的名称,事件处理函数和用于表示是否调用事件处理程序的布尔值,即truefalse

事件侦听器具有类似于事件处理程序的功能,区别在于将多个功能分配给同一DOM元素和事件时处理程序没有限制。

 

转载于:https://www.cnblogs.com/wwwlinguangcom/p/10003890.html

修改:File "C:\Users\Administrator\Desktop\project\core\event_center.py", line 114 def subscribe(self, event_type, callback): """订阅事件""" if event_type not in self.subscribers: self.subscribers[event_type] = [] 已重新声明上文定义的无用法的 'subscribe'未使用局部函数 '__init__',从外部作用域隐藏名称 'self'函数中的变量应小写,从外部作用域隐藏名称 'event'代码#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ 优化后的事件中心模块 (最终稳定版) """ import logging import threading import uuid import time from enum import Enum, auto from typing import Tuple, Dict, List, Callable, Optional, Any, Set, DefaultDict, Union from collections import defaultdict from dataclasses import dataclass, field from concurrent.futures import ThreadPoolExecutor # 初始化日志 logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) class EventType(Enum): """完整事件类型枚举""" # 基础事件类型 MODULE_RUN = auto() ANALYSIS_RESULT = auto() MODULE_ERROR = auto() REGISTER_UI = auto() GET_RESULTS = auto() # 系统事件 SYSTEM_STARTUP = auto() SYSTEM_SHUTDOWN = auto() MODULE_READY = auto() ERROR = auto() # 模块特定事件 INPUT_ANALYSIS_START = auto() INPUT_ANALYSIS_END = auto() COMBINATION_ANALYSIS_START = auto() COMBINATION_ANALYSIS_END = auto() FOLLOW_ANALYSIS_START = auto() FOLLOW_ANALYSIS_UPDATE = auto() TREND_ANALYSIS_REQUEST = auto() TREND_ANALYSIS_REPORT = auto() NUMBER_GENERATION_START = auto() NUMBER_GENERATION_FINISH = auto() # 测试事件 TEST_EVENT = auto() @dataclass class Event: """事件数据类""" type: Union[str, EventType] # 必须放在非默认参数位置 source: str # 必须放在非默认参数位置 target: Optional[str] = None event_id: str = field(default_factory=lambda: str(uuid.uuid4())) token: Optional[str] = None data: Optional[Dict[str, Any]] = field(default_factory=dict) timestamp: float = field(default_factory=time.time) def __post_init__(self): """数据验证和类型转换""" if isinstance(self.type, EventType): self.type = self.type.name if not isinstance(self.type, str) or not self.type: raise ValueError("type 必须是非空字符串或EventType枚举") if not isinstance(self.source, str) or not self.source: raise ValueError("source 必须是非空字符串") class EventCenter: """线程安全的事件中心(最终优化版)""" _instance = None _lock = threading.Lock() _executor = ThreadPoolExecutor(max_workers=10, thread_name_prefix="EventWorker") def __new__(cls): with cls._lock: if cls._instance is None: cls._instance = super().__new__(cls) cls._instance.__initialized = False return cls._instance def __init__(self): """初始化事件中心(单例模式)""" def __init__(self): self.subscribers = {} if getattr(self, '__initialized', False): return self.__initialized = True self._subscribers: DefaultDict[str, List[Tuple[Callable[[Event], None], Optional[str]]]] = defaultdict(list) self._event_history: Dict[str, Event] = {} self._pending_acks: Set[str] = set() self._ack_timeout = 5.0 self._stats = { 'total_events': 0, 'failed_events': 0, 'delivered_events': 0 } def subscribe(self, event_type: Union[str, EventType], handler: Callable[[Event], None], token: Optional[str] = None) -> None: """订阅事件(支持token过滤)""" event_type_str = event_type.name if isinstance(event_type, EventType) else str(event_type) with self._lock: self._subscribers[event_type_str].append((handler, token)) logger.debug(f"已订阅事件: {event_type_str}, token: {token}") def subscribe(self, event_type, callback): """订阅事件""" if event_type not in self.subscribers: self.subscribers[event_type] = [] self.subscribers[event_type].append(callback) def publish(self, event_type, data): """发布事件""" if event_type in self.subscribers: for callback in self.subscribers[event_type]: callback(data) def unsubscribe(self, event_type: Union[str, EventType], handler: Callable[[Event], None]) -> bool: """取消订阅事件""" event_type_str = event_type.name if isinstance(event_type, EventType) else str(event_type) with self._lock: if event_type_str not in self._subscribers: return False before = len(self._subscribers[event_type_str]) self._subscribers[event_type_str] = [ (h, t) for h, t in self._subscribers[event_type_str] if h != handler ] removed = before != len(self._subscribers[event_type_str]) if removed: logger.debug(f"已取消订阅: {event_type_str}") return removed def publish(self, event, require_ack=False, async_handle=True) -> bool: """发布事件(支持同步/异步处理)""" # 增强事件验证 try: # 确保事件有必要的属性 if not hasattr(event, 'type') or not hasattr(event, 'source'): raise AttributeError("事件缺少必要属性: type或source") # 自动生成事件ID(如果缺失) if not hasattr(event, 'event_id') or not event.event_id: event.event_id = str(uuid.uuid4()) # 执行事件验证 if hasattr(event, '__post_init__'): event.__post_init__() else: # 手动验证基本属性 if not isinstance(event.type, (str, EventType)): raise TypeError("type必须是字符串或EventType") if not isinstance(event.source, str) or not event.source: raise ValueError("source必须是非空字符串") except (ValueError, TypeError, AttributeError) as e: # 处理预期的验证错误 logger.error(f"事件验证失败: {e}") with self._lock: self._stats['failed_events'] += 1 return False except Exception as e: # 记录所有其他异常 logger.exception(f"事件验证过程中发生意外错误: {e}") with self._lock: self._stats['failed_events'] += 1 return False # 主事件处理逻辑 try: with self._lock: if event.event_id in self._event_history: logger.warning(f"重复事件ID: {event.event_id}") return False self._event_history[event.event_id] = event self._stats['total_events'] += 1 if require_ack: self._pending_acks.add(event.event_id) handlers = self._get_matching_handlers(event) if not handlers: logger.debug(f"没有处理器订阅: {event.type}") return True if async_handle: self._executor.submit(self._dispatch_event, event, handlers, require_ack) else: self._dispatch_event(event, handlers, require_ack) return True except (KeyError, AttributeError) as e: # 处理内部数据结构错误 logger.error(f"内部数据结构错误: {e}") with self._lock: self._stats['failed_events'] += 1 return False except Exception as e: # 捕获所有其他异常 logger.exception(f"发布事件时发生未预期错误: {e}") with self._lock: self._stats['failed_events'] += 1 return False def _get_matching_handlers(self, event: Event) -> List[Callable[[Event], None]]: """获取匹配的事件处理器""" with self._lock: return [ h for h, t in self._subscribers.get(event.type, []) if t is None or t == event.token ] def _dispatch_event(self, event: Event, handlers: List[Callable[[Event], None]], require_ack: bool) -> None: """分发事件到处理器""" for handler in handlers: try: handler(event) with self._lock: self._stats['delivered_events'] += 1 logger.debug(f"事件处理成功: {event.event_id[:8]}") except Exception as e: logger.exception(f"处理器异常: {e}") if require_ack and event.target: self._wait_for_ack(event) def _wait_for_ack(self, event: Event) -> None: """等待事件确认""" start = time.time() while time.time() - start < self._ack_timeout: with self._lock: if event.event_id not in self._pending_acks: return time.sleep(0.05) logger.warning(f"事件确认超时: {event.event_id[:8]}") def get_stats(self) -> Dict[str, int]: """获取事件中心统计信息""" with self._lock: return self._stats.copy() def clear(self): """重置事件中心状态(测试专用)""" with self._lock: self._subscribers.clear() self._event_history.clear() self._pending_acks.clear() self._stats = { 'total_events': 0, 'failed_events': 0, 'delivered_events': 0 } # 全局单例实例 event_center = EventCenter() # ======================== 完整测试套件 ======================== import pytest from dataclasses import make_dataclass @pytest.fixture def event_center_instance(): """创建独立的EventCenter实例用于测试""" center = EventCenter() center.clear() return center def test_event_subscription(event_center_instance): """测试事件订阅机制""" handled_events = [] def handler(event: Event): handled_events.append(event) # 订阅并发布测试事件 event_center_instance.subscribe(EventType.TEST_EVENT, handler) test_event = Event( type=EventType.TEST_EVENT, source="pytest", data={"test": "subscription"} ) assert event_center_instance.publish(test_event) is True time.sleep(0.1) # 等待异步处理完成 assert len(handled_events) == 1 assert handled_events[0].data["test"] == "subscription" stats = event_center_instance.get_stats() assert stats["total_events"] == 1 assert stats["delivered_events"] == 1 assert stats["failed_events"] == 0 def test_event_validation_failure(event_center_instance): """测试无效事件处理""" # 用例1:完全无效的事件对象 class InvalidEvent: pass # 用例2:缺少必要属性的事件 PartialEvent = make_dataclass('PartialEvent', [('type', str)], namespace={'source': None}) partial_event = PartialEvent(type="TEST") # 用例3:属性类型错误的事件 @dataclass class WrongTypeEvent: type: int = 123 # 应该是字符串或EventType source: str = "test" # 用例4:空source属性的事件 @dataclass class EmptySourceEvent: type: str = "TEST" source: str = "" # 空字符串 for invalid_event in [InvalidEvent(), partial_event, WrongTypeEvent(), EmptySourceEvent()]: assert event_center_instance.publish(invalid_event) is False # 验证统计计数 stats = event_center_instance.get_stats() assert stats["total_events"] == 0 assert stats["failed_events"] == 4 assert stats["delivered_events"] == 0 def test_duplicate_event_id(event_center_instance): """测试重复事件ID检测""" event = Event( type=EventType.TEST_EVENT, source="pytest", event_id="fixed-id-123" ) # 首次发布应成功 assert event_center_instance.publish(event) is True # 重复发布应失败 assert event_center_instance.publish(event) is False stats = event_center_instance.get_stats() assert stats["total_events"] == 1 assert stats["failed_events"] == 0 # 重复事件不算验证失败 assert stats["delivered_events"] == 0 # 没有订阅者 def test_token_filtering(event_center_instance): """测试基于token的事件过滤""" handled_events = [] def handler(event: Event): handled_events.append(event) # 订阅特定token的事件 event_center_instance.subscribe(EventType.TEST_EVENT, handler, token="secret") # 发布不带token的事件(不应被处理) event1 = Event( type=EventType.TEST_EVENT, source="pytest", data={"test": "no token"} ) # 发布带错误token的事件(不应被处理) event2 = Event( type=EventType.TEST_EVENT, source="pytest", token="wrong", data={"test": "wrong token"} ) # 发布正确token的事件(应被处理) event3 = Event( type=EventType.TEST_EVENT, source="pytest", token="secret", data={"test": "correct token"} ) assert event_center_instance.publish(event1) is True assert event_center_instance.publish(event2) is True assert event_center_instance.publish(event3) is True time.sleep(0.1) # 等待异步处理完成 assert len(handled_events) == 1 assert handled_events[0].data["test"] == "correct token" stats = event_center_instance.get_stats() assert stats["total_events"] == 3 assert stats["delivered_events"] == 1 assert stats["failed_events"] == 0 def test_async_handling(event_center_instance): """测试异步事件处理""" handled_events = [] def slow_handler(event: Event): time.sleep(0.2) handled_events.append(event) event_center_instance.subscribe(EventType.TEST_EVENT, slow_handler) # 发布两个事件 event1 = Event(type=EventType.TEST_EVENT, source="pytest", data={"id": 1}) event2 = Event(type=EventType.TEST_EVENT, source="pytest", data={"id": 2}) # 异步发布 assert event_center_instance.publish(event1) is True assert event_center_instance.publish(event2) is True # 立即检查(应尚未处理) assert len(handled_events) == 0 # 等待足够时间 time.sleep(0.3) assert len(handled_events) == 2 assert {e.data['id'] for e in handled_events} == {1, 2} def test_ack_mechanism(event_center_instance): """测试事件确认机制""" ack_received = False def ack_handler(event: Event): nonlocal ack_received # 模拟目标模块发送ACK if event.type == "ACK": ack_received = True # 从待确认集合中移除 with event_center_instance._lock: if event.data.get("ack_for") in event_center_instance._pending_acks: event_center_instance._pending_acks.remove(event.data["ack_for"]) # 订阅ACK事件(模拟) event_center_instance.subscribe("ACK", ack_handler) # 发布需要ACK的事件 event = Event( type=EventType.TEST_EVENT, source="pytest", target="test_target", data={"require_ack": True} ) # 发布测试事件(要求ACK) assert event_center_instance.publish(event, require_ack=True) is True # 检查事件是否在待确认集合中 with event_center_instance._lock: assert event.event_id in event_center_instance._pending_acks # 发布ACK事件(模拟目标模块的响应) ack_event = Event( type="ACK", source="test_target", data={"ack_for": event.event_id} ) event_center_instance.publish(ack_event) # 等待ACK处理 time.sleep(0.1) assert ack_received is True # 检查pending_acks应被移除 with event_center_instance._lock: assert event.event_id not in event_center_instance._pending_acks def test_event_auto_id_generation(event_center_instance): """测试自动生成事件ID""" # 创建没有event_id的事件 event = Event( type=EventType.TEST_EVENT, source="pytest", data={"auto_id": True} ) del event.event_id # 移除自动生成的ID assert event_center_instance.publish(event) is True assert hasattr(event, 'event_id') and event.event_id assert len(event.event_id) == 36 # UUID长度验证 def test_concurrent_publishing(event_center_instance): """测试并发事件发布""" from concurrent.futures import ThreadPoolExecutor handled_events = [] event_count = 50 def handler(event: Event): handled_events.append(event) event_center_instance.subscribe(EventType.TEST_EVENT, handler) def publish_event(i): event = Event( type=EventType.TEST_EVENT, source=f"thread-{i}", data={"index": i} ) event_center_instance.publish(event) # 使用线程池并发发布事件 with ThreadPoolExecutor(max_workers=10) as executor: executor.map(publish_event, range(event_count)) # 等待所有事件处理完成 time.sleep(0.5) assert len(handled_events) == event_count assert len({e.data['index'] for e in handled_events}) == event_count
最新发布
08-21
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值