promiseEvent Class

基于事件和promise的回调管理，类似于jquery的callbacks，但具有结果传递，优先级，事件参数，promise控制等功能； 默认注册的事件都是按照优先级，依次执行，无论同步还是异步；但在非阻塞模式下，则事件不会等待上一个执行完毕（异步）， 直接回依次执行，只是在最后的结果中会等待所有的事件执行完毕之后才返回

Methods

Properties

Events

Defined in: src\base\aop.js:67
Module: AOP

Constructor

promiseEvent

promiseEvent
(
  • [mode]
)

Defined in src\base\aop.js:67

Parameters:

nametypeflagdescription
[mode] String optional

promiseEvent的模式，可以混用；

1. 默认；event模式，所有的注册的事件，执行时，第一个事件参数为e（详细说明见promiseEvent-EventArg）
2. 'callback' : 回调模式; 与event模式对立，执行时不会添加事件参数e
2. 'once' : 全部事件执行一次，即有执行动作就销毁
3. 'noBlock' : 非阻塞模式；

Example:

            //标准模式
            var events = st.promiseEvent(),
                result = [];

            //注册事件
            events.add('call1', function(e, text) {
                result.push('call1');
            });

            //自定义priority注册事件
            events.add('call2', function(e, text) {
                result.push('call2');
            },100);

            //单once模式注册
            events.add('call3', function(e, text) {
                result.push('call3');
            },'once');

            //所有设置
            events.add('call4', function(e, text) {
                result.push('call4');
            },50,'once');

            //返回promise
            events.add("promiseCall", function(e, text) {
                //异步的方法
                setTimeout(function() {
                    result.push('promiseCall');
                    e.resolve();
                },0);
                return e.promise();
            },20);

            //回调中如果存在promise需要,st.when来获取结果
            st.when(events.fire('test')).done(function(){
                expect(result.join('-')).toBe('call2-call4-promiseCall-call1-call3');

            });
            //已once模式创建事件管理
            var onceCalls = st.promiseEvent("once"),
                result = [];

            onceCalls.add("c1", function {
                result.push("c1");
            });
            //执行之后即销毁
            onceCalls.fire
            expect(onceCalls.has('c1')).toBe(false);
            var result = [],obj2 = st.attachTrigger({
                test: function(name) {
                    result.push(name);
                }
            }, "callback");

            obj2.onBefore("test", "addBefore", function(name) {
                result.push('before-' + name);
            }).on("test", "addAfter", function(name) {
                result.push('after-' + name)
            });
            obj2.test('bind');
            expect(result.join(',')).toBe("before-bind,bind,after-bind");
            var pCalls = st.promiseEvent(),
                result = [];

            pCalls.add("c1", function(e, name) {
                //延迟100ms
                setTimeout(function() {
                    //完成promise,并返回结果
                    e.resolve(name + ',resolve!');
                }, 100);

                //返回promise
                return e.promise();
            });

            //使用when来监控promiseEvent的执行，使用done来处理执行完毕的方法
            $.when(pCalls.fire("call")).done(function(data) {
                expect(data).toBe('call,resolve!');

            });
            //创建一个noBlock模式的promiseEvents;
            var noBlockCalls = st.promiseEvent("noBlock"),
                result = [];

            //第一个回调延迟100
            noBlockCalls.add("c1", function(e) {
                setTimeout(function() {
                    result.push('c1');
                    e.resolve();
                }, 100);
                return e.promise();
            });

            //第二个正常执行
            noBlockCalls.add("c2", function(e) {
                result.push('c2');
            });

            //第三个回调延迟50
            noBlockCalls.add("c3", function(e) {
                setTimeout(function() {
                    result.push('c3');
                    e.resolve();
                }, 50);
                return e.promise();
            });

            $.when(noBlockCalls.fire()).done(function(data) {
                //最终执行顺序是c2-c3-c1
                expect(result + '').toBe('c2,c3,c1');

            });
            var resultCalls = st.promiseEvent
            resultCalls.add("c1", function(e) {
                return "c1";
            }).add("c2", function(e) {
                return e.result + ",c2";
            });
            expect(resultCalls.fire).toBe('c1,c2');

Methods

add

add
(
  • name
  • fn
  • [priority=0]
  • [mode]
)
chainable

Defined in src\base\aop.js:114

添加事件回调方法

Parameters:

nametypeflagdescription
name String

事件回调名

fn String

事件回调方法

[priority=0] Number optional

权重;预设为0，可以通过配置调整

[mode] String optional

回调模式："once":执行一次

Example:

            //标准模式
            var events = st.promiseEvent(),
                result = [];

            //注册事件
            events.add('call1', function(e, text) {
                result.push('call1');
            });

            //自定义priority注册事件
            events.add('call2', function(e, text) {
                result.push('call2');
            },100);

            //单once模式注册
            events.add('call3', function(e, text) {
                result.push('call3');
            },'once');

            //所有设置
            events.add('call4', function(e, text) {
                result.push('call4');
            },50,'once');

            //返回promise
            events.add("promiseCall", function(e, text) {
                //异步的方法
                setTimeout(function() {
                    result.push('promiseCall');
                    e.resolve();
                },0);
                return e.promise();
            },20);

            //回调中如果存在promise需要,st.when来获取结果
            st.when(events.fire('test')).done(function(){
                expect(result.join('-')).toBe('call2-call4-promiseCall-call1-call3');

            });

clear

clear () chainable

Defined in src\base\aop.js:103

清空所有事件回调

Example:

            var events = st.promiseEvent

            //添加回调
            events.add('call1', function(e, text) {});
            events.add('call2', function(e, text) {});

            //回调事件总数为2
            expect(events.len).toBe(2);

            //清除events下面注册的事件
            events.clear();

            //回调事件总数为0
            expect(events.len()).toBe(0);

fire

fire
(
  • args
  • [argHandle]
)
Object

Defined in src\base\aop.js:320

执行回调

Parameters:

nametypeflagdescription
args Array

执行参数

[argHandle] Function optional

参数处理方法，可以对eventarg进行修改；例如：argHandle(e)

Returns:

[Object]

返回执行结果

fireWith

fireWith
(
  • context
  • args
  • [argHandle]
)
Object | Promise

Defined in src\base\aop.js:156

根据上下文对象执行回调;fire方法的增强

Parameters:

nametypeflagdescription
context Object

上下文对象

args Array

执行参数

[argHandle] Function optional

参数处理方法，可以对eventarg进行修改；例如：argHandle(e)

Returns:

[Object | Promise]

返回执行结果

Example:

            var events = st.promiseEvent,
                target = {
                    name: 'target'
                };

            //注册事件
            events.add('call1', function(e, text) {
                return this.name + '-' + text + '-' + e.extend
            });

            //使用fireWith执行
            var result = events.fireWith(target, ['test'], function(e) {
                //扩展事件参数；只会在这一次的fire中生效
                e.extend = function() {
                    return 'extend';
                }
            })

            expect(result).toBe('target-test-extend');

has

has
(
  • name
)
Boolean

Defined in src\base\aop.js:287

判断是否存在事件回调

Parameters:

nametypeflagdescription
name String

事件回调名

Returns:

[Boolean]

是否存在

Example:

            var calls = st.promiseEvent

            calls.add("call1", function(e) {});

            //判断是否注册了"call1"的event
            expect(calls.has("call1")).toBeTruthy;

len

len () Number

Defined in src\base\aop.js:311

获取注册的事件长度/数

Returns:

[Number]

注册的事件长度/数

remove

remove
(
  • name
)
chainable

Defined in src\base\aop.js:142

删除事件回调方法

Parameters:

nametypeflagdescription
name String

事件回调名

Example:

            var events = st.promiseEvent

            //注册事件
            events.add('call1', function(e, text) {});

            //删除事件
            events.remove('call1');

            expect(events.len).toBe(0);
Top