1
class EventBus {
2
  constructor() {
3
    // 使用Map存储事件类型和回调函数
4
    this.events = new Map();
5
    // 通配符事件存储
6
    this.wildcardEvents = [];
7
    // 事件统计
8
    this.stats = new Map();
9
    // 异步队列
10
    this.queue = Promise.resolve();
11
  }
12

13
  // 订阅事件
14
  on(eventName, callback, scope = 'global') {
15
    const eventKey = `${scope}:${eventName}`;
16

17
    if (!this.events.has(eventKey)) {
18
      this.events.set(eventKey, []);
19
    }
20

21
    // 添加回调函数
22
    this.events.get(eventKey).push(callback);
23

24
    // 通配符处理
25
    if (eventName === '*') {
26
      this.wildcardEvents.push({ callback, scope });
27
    }
28

29
    return this;
30
  }
31

32
  // 一次性订阅
33
  once(eventName, callback, scope = 'global') {
34
    const onceCallback = (...args) => {
35
      this.off(eventName, onceCallback, scope);
36
      callback(...args);
37
    };
38
    return this.on(eventName, onceCallback, scope);
39
  }
40

41
  // 发布事件
42
  emit(eventName, data, scope = 'global') {
43
    const eventKey = `${scope}:${eventName}`;
44
    const startTime = performance.now();
45

46
    // 创建异步任务
47
    this.queue = this.queue.then(async () => {
48
      try {
49
        // 执行通配符事件
50
        for (const { callback } of this.wildcardEvents) {
51
          await callback(eventName, data);
52
        }
53

54
        // 执行匹配事件
55
        if (this.events.has(eventKey)) {
56
          const callbacks = [...this.events.get(eventKey)];
57
          for (const callback of callbacks) {
58
            await callback(data);
59
          }
60
        }
61

62
        // 收集统计信息
63
        const duration = performance.now() - startTime;
64
        this.recordStats(eventName, duration);
65
      } catch (error) {
66
        console.error(`EventBus error in ${eventName}:`, error);
67
        this.emit('error', error, 'system');
68
      }
69
    });
70

71
    return this;
72
  }
73

74
  // 取消订阅
75
  off(eventName, callbackToRemove, scope = 'global') {
76
    const eventKey = `${scope}:${eventName}`;
77

78
    if (eventName === '*') {
79
      this.wildcardEvents = this.wildcardEvents.filter(
80
        ({ callback }) => callback !== callbackToRemove
81
      );
82
      return this;
83
    }
84

85
    if (!this.events.has(eventKey)) return this;
86

87
    if (callbackToRemove) {
88
      const filteredCallbacks = this.events
89
        .get(eventKey)
90
        .filter(callback => callback !== callbackToRemove);
91

92
      if (filteredCallbacks.length === 0) {
93
        this.events.delete(eventKey);
94
      } else {
95
        this.events.set(eventKey, filteredCallbacks);
96
      }
97
    } else {
98
      this.events.delete(eventKey);
99
    }
100

101
    return this;
102
  }
103

104
  // 创建作用域
105
  createScopedBus(scopeName) {
106
    return {
107
      on: (event, callback) => this.on(event, callback, scopeName),
108
      once: (event, callback) => this.once(event, callback, scopeName),
109
      emit: (event, data) => this.emit(event, data, scopeName),
110
      off: (event, callback) => this.off(event, callback, scopeName)
111
    };
112
  }
113

114
  // 清除所有事件
115
  clear() {
116
    this.events.clear();
117
    this.wildcardEvents = [];
118
    return this;
119
  }
120

121
  // 事件统计
122
  recordStats(eventName, duration) {
123
    const stats = this.stats.get(eventName) || {
124
      count: 0,
125
      totalDuration: 0,
126
      avgDuration: 0
127
    };
128

129
    stats.count++;
130
    stats.totalDuration += duration;
131
    stats.avgDuration = stats.totalDuration / stats.count;
132

133
    this.stats.set(eventName, stats);
134
  }
135

136
  // 获取事件统计
137
  getStats(eventName) {
138
    return this.stats.get(eventName) || null;
139
  }
140
}

1
// 创建事件总线
2
const bus = new EventBus();
3

4
// 订阅全局事件
5
bus.on('user.login', user = >{
6
    console.log('User logged in:', user.name);
7
});
8

9
// 订阅一次性事件
10
bus.once('app.initialized', () = >{
11
    console.log('App initialized!');
12
});
13

14
// 通配符订阅所有事件
15
bus.on('*', (event, data) = >{
16
    console.log(` [$ {
17
        event
18
    }] triggered with: `, data);
19
});
20

21
// 创建作用域事件总线
22
const cartBus = bus.createScopedBus('cart');
23
cartBus.on('item.added', item = >{
24
    console.log('Item added to cart:', item.name);
25
});
26

27
// 发布事件
28
bus.emit('user.login', {
29
    name: 'Alice',
30
    id: 123
31
});
32
/*
33
输出:
34
[user.login] triggered with: {name: 'Alice', id: 123}
35
User logged in: Alice
36
*/
37

38
bus.emit('app.initialized');
39
/*
40
输出:
41
[app.initialized] triggered with: undefined
42
App initialized!
43
*/
44

45
cartBus.emit('item.added', {
46
    name: 'Laptop',
47
    price: 999
48
});
49
/*
50
输出:
51
[cart:item.added] triggered with: {name: 'Laptop', price: 999}
52
Item added to cart: Laptop
53
*/
54

55
// 获取事件统计
56
console.log(bus.getStats('user.login'));
57
// { count: 1, totalDuration: 0.24, avgDuration: 0.24 }
58
// 取消订阅
59
bus.off('user.login');