订阅模式初探（2）【复杂应用-命名空间与先发布再订阅】

var Event = (function(){
    var global = this,
    Event,
    _default = 'default';
    Event = function(){
        var _listen,
        _trigger,
        _remove,
        _slice = Array.prototype.slice,
        _shift = Array.prototype.shift,
        _unshift = Array.prototype.unshift,
        namespaceCache = {},
        _create,
        find,
        each = function(ary,fn){
            var ret;
            for(var i = 0,l=ary.length;i<l;i++ ){
                var n = ary[i];
                ret = fn.call(n,i,n)
            }
            return ret
        };
        _listen = function(key,fn,cache){
            if(!cache[key]){
                cache[key] = []
            }
            cache[key].push(fn)
        };
        _remove = function(key,cache,fn){
            if(cache[key]){
                if(fn){
                    for(var i =cache[key].length;i>=0;i--){
                        if(cache[key][i]===fn){
                            cache[key].splice(i,1)
                        }
                    }
                }else{
                    cache[key]=[]
                }
                
            }
        };
        _trigger = function(){
            var cache = _shift.call(arguments),
            key = _shift.call(arguments),
            args = arguments,
            _self = this,
            ret,
            stack = cache[key];
            if(!stack||!stack.length){
                return;
            }
            return each(stack,function(){
                return this.apply(_self,args)
            })
        };
        _create = function(namespace){
            var namespace = namespace||_default;
            var cache ={},
            offlineStack = [], //离线事件
            ret = {
                listen(key,fn,last){
                    _listen(key,fn,cache);
                    if(offlineStack === null){
                        return;
                    }
                    if(last === 'last'){
                        offlineStack.length&&offlineStack.pop()();
                    }else{
                        each(offlineStack,function(){
                            this()
                        })
                    }
                    offlineStack = null;
                },
                one(key,fn,last){
                    _remove(key,cache);
                    this.listen(key,fn,last)
                },
                remove(key,fn){
                    _remove(key,cache,fn)
                },
                trigger(){
                    var fn,
                        args,
                        _self=this;
                    _unshift.call(arguments,cache);
                    args = arguments;
                    fn = function(){
                        return _trigger.apply(_self,args)
                    };
                    if(offlineStack){
                        return offlineStack.push(fn)
                    }
                    return fn()
                }
            }
            return namespace?(namespaceCache[namespace]?namespaceCache[namespace]:namespaceCache[namespace]=ret):ret;
        }
        return {
            create:_create,
            one(key,fn,last){
                var event = this.create();
                event.one(key,fn,last)
            },
            remove(key,fn){
                var event = this.create();
                event.remove(key,fn)
            },
            listen(key,fn,last){
                var event = this.create();
                event.listen(key,fn,last)
            },
            trigger(){
                var event = this.create();
                event.trigger.apply(this,arguments)
            }
        };
    }();
    return Event;
})()

Event.create('namespace1').listen('click',function(a){
    console.log(a)
})
Event.create('namespace1').trigger('click',1)