事件订阅广播组件

export default class {
    // 事件栈
    eventStacks = [{
        eventType: '',
        handlers: []
    }];
    /**
     * 获取事件对应栈的索引
     *
     * @param {string} eventType 事件类型
     * @return {number} stackIndex 对应栈的索引 不存在为-1
     */
    indexOf(eventType) {
        const eventStacks = this.eventStacks;
        // 已有事件类型处理栈
        let stackIndex = -1;
        for (let i = 0; i < eventStacks.length; i++) {
            const eventStack = eventStacks[i];
            if (eventStack.eventType === eventType) {
                stackIndex = i;
                break;
            }
        }
        return stackIndex;
    };
    /**
     * 监听事件
     *
     * @param {string} eventType 自定义事件类型
     * @param {Function} handler 事件处理函数
     */
    on(eventType, handler) {
        const index = this.indexOf(eventType);
        if (index >= 0) {
            // 已存在事件类型处理 直接把相应的处理函数入栈
            this.eventStacks[index].handlers.push(handler);
        }
        else {
            // 不存在事件，把对应的事件处理入栈
            const newEventStack = {
                eventType,
                handlers: [handler]
            };
            this.eventStacks.push(newEventStack);
        }
    };
    /**
     * 触发对应的事件
     *
     * @param {string} eventType 自定义事件类型
     * @param {Object} params 参数对象
     */
    emit(eventType, params = {}) {
        this.execEvent(eventType, params);
    };
    /**
     * 执行对应的事件
     *
     * @param {string} eventType 自定义事件类型
     * @param {Object} params 参数对象
     */
    execEvent(eventType, params = {}) {
        const index = this.indexOf(eventType);
        if (index < 0) {
            return;
        }
        const handlers = this.eventStacks[index].handlers;
        for (let i = 0; i < handlers.length; i++) {
            const currentHandler = handlers[i];
            if (currentHandler && typeof currentHandler === 'function') {
                currentHandler(params);
            }
        }
    };
    /**
     * 解除对应的事件
     *
     * @param {string} eventType 事件类型
     * @param {Function} handler 事件处理器 必须是引用传进来 使用对象引用相等判断
     */
    offHandler(eventType, handler) {
        const index = this.indexOf(eventType);
        if (index >= 0 && this.eventStacks[index].handlers.length) {
            // 存在，并且已经入栈
            const handlers = this.eventStacks[index].handlers;
            this.eventStacks[index].handlers = handlers.filter(currentHandler => {
                return currentHandler !== handler
            });
        }
    }
}