JS在项目中用到的AOP, 以及函数节流, 防抖, 事件总线

1. 项目中在绑定事件的时候总想在触发前,或者触发后做一些统一的判断或逻辑,在c#后端代码里,可以用Attribute, filter等标签特性实现AOP的效果,可是js中没有这种用法,归根到本质还是不支持类型的拦截和判断,所以没法实现,但是js的灵活就在于可以通过原型链, 高阶函数,闭包等特性来实现类似的效果,这里记录一下便于复习

    //AOP: after
    Function.prototype.after = function (afterFn) {
        var _self = this;
        return function () {
            var ret = _self.apply(this, arguments);
            if (ret === false) {
                return false;
            }
            afterFn.apply(this, arguments);
            return ret;
        }
    }


    //AOP: before
    Function.prototype.before = function (beforeFn) {
        var _self = this;
        return function () {
            var ret = beforeFn.apply(this, arguments);
            if (ret === false) {
                return false;
            }
            return _self.apply(this, arguments);
        }
    }

2. 用法下面的例子是工程中实用, 在tab点击的时候,一般情况没打开一个tab要绑定一个或多个事件做点击,关闭等处理,这里实现的方法就是在父元素统一只绑定一个事件,都通过冒泡来触发,这种好处就是新加tab不用绑定事件,不好的就是可能tab层级复杂,需要做很多元素的判断来决定触发什么事件,比如说下面的关闭事件里面先判断后,要是没有触发,在判断触发点击事件,这样写的逻辑清晰,功能模块可以分开,利于解耦,效果也能很好实现!!!

                _bindEvents: function () {
                    var g = this,
                        p = this.options,
                        container = g.tab.bar.container;

                    // 标签点击事件, 统一只绑定父元素一次
                    container.nav.bind("click.tab.nav", function (e) {
                        if (e.target === e.currentTarget) {
                            e.stopPropagation();
                            return;
                        }
                        g._tabCloseClick.after(g._tabBarClick).call(g, e);
                    });
                    
                  }    

3. 当然还有函数的防抖和节流的实现:

函数防抖就是为了让一个函数在一定的时间只执行一次,即使被多次触发,典型应用就是tab标签打开很多的时候,不停的拖动窗体大小或者改变位置,这样标签会有一些动画效果用来自适应窗体大小,但是要是频发的拖动窗体,这些动画效果就会被触发多次,导致拖完了后一段时间内,这种效果不停在重复,延迟严重,所以用debounce就可以在一定时间后触发一次效果就可以了,性能提升的同时,体验也很好

函数节流 就是规定一个单位时间,在这个单位时间内,只能有一次触发事件的回调函数执行,如果在同一个单位时间内某事件被触发多次,只有一次能生效,在项目中应用的例子就是在手风琴点击展开层级的时候,如果用户在短时间内重复快速点击多次,这样这个层级就会不停的触发多次,展开收起又展开,感觉发疯一样,所以这时候用throttle节流一下, 比如在300ms内就触发一次,不管你点了多少次,这样体验大大提高

    /**
    * 函数防抖, 在事件被触发n秒后再执行回调,如果在这n秒内又被触发,则重新计时
    * @param fn {Function}   实际要执行的函数
    * @param delay {Number}  延迟时间,也就是阈值,单位是毫秒(ms)
    * @return {Function}     返回一个防抖了的函数
    */
    vango.utils.debounce = function (fn, delay) {
        var timer;
        return function () {
            var context = this;
            var args = arguments;
            clearTimeout(timer);
            timer = setTimeout(function () {
                fn.apply(context, args);
            }, delay);
        }
    }

    /**
    * 函数节流,规定一个单位时间,在这个单位时间内,只能有一次触发事件的回调函数执行,如果在同一个单位时间内某事件被触发多次,只有一次能生效
    * @param fn {Function}   实际要执行的函数
    * @param wait {Number}  延迟时间,也就是阈值,单位是毫秒(ms)
    * @return {Function}     返回一个节流了的函数
    */
    vango.utils.throttle = function (func, wait, options) {
        /* options的默认值
         *  表示首次调用返回值方法时,会马上调用func;否则仅会记录当前时刻,当第二次调用的时间间隔超过wait时,才调用func。
         *  options.leading = true;
         * 表示当调用方法时,未到达wait指定的时间间隔,则启动计时器延迟调用func函数,若后续在既未达到wait指定的时间间隔和func函数又未被调用的情况下调用返回值方法,则被调用请求将被丢弃。
         *  options.trailing = true; 
         * 注意:当options.trailing = false时,效果与上面的简单实现效果相同
         */
        var context, args, result;
        var timeout = null;
        var previous = 0;
        if (!options) options = {};
        var later = function () {
            previous = options.leading === false ? 0 : new Date();;
            timeout = null;
            result = func.apply(context, args);
            if (!timeout) context = args = null;
        };
        return function () {
            var now = new Date();;
            if (!previous && options.leading === false) previous = now;
            // 计算剩余时间
            var remaining = wait - (now - previous);
            context = this;
            args = arguments;
            // 当到达wait指定的时间间隔,则调用func函数
            // 精彩之处:按理来说remaining <= 0已经足够证明已经到达wait的时间间隔,但这里还考虑到假如客户端修改了系统时间则马上执行func函数。
            if (remaining <= 0 || remaining > wait) {
                // 由于setTimeout存在最小时间精度问题,因此会存在到达wait的时间间隔,但之前设置的setTimeout操作还没被执行,因此为保险起见,这里先清理setTimeout操作
                if (timeout) {
                    clearTimeout(timeout);
                    timeout = null;
                }
                previous = now;
                result = func.apply(context, args);
                if (!timeout) context = args = null;
            } else if (!timeout && options.trailing !== false) {
                // options.trailing=true时,延时执行func函数
                timeout = setTimeout(later, remaining);
            }
            return result;
        };
    };

 5. 对于一个系统来说事件的设计当然必不可少,平台中简单的实现了一下事件总线的机制,记录一下

    vango.event = (function () {

        var _callbacks = {};

        var on = function (eventName, callback) {
            if (!_callbacks[eventName]) {
                _callbacks[eventName] = [];
            }

            _callbacks[eventName].push(callback);
        };

        var off = function (eventName, callback) {
            var callbacks = _callbacks[eventName];
            if (!callbacks) {
                return;
            }

            var index = -1;
            for (var i = 0; i < callbacks.length; i++) {
                if (callbacks[i] === callback) {
                    index = i;
                    break;
                }
            }

            if (index < 0) {
                return;
            }

            _callbacks[eventName].splice(index, 1);
        };

        var trigger = function (eventName) {
            var callbacks = _callbacks[eventName];
            if (!callbacks || !callbacks.length) {
                return;
            }

            var args = Array.prototype.slice.call(arguments, 1);
            for (var i = 0; i < callbacks.length; i++) {
                callbacks[i].apply(this, args);
            }
        };

        return {
            on: on,
            off: off,
            trigger: trigger
        };
    })();

 

posted @ 2018-08-13 10:31  Jason.Zeng  阅读(574)  评论(0编辑  收藏  举报