有用代码段

不能发布隐藏文章吗？，公开就公开了吧

{
    //  -------------------------------------------------------------
    //生成上下150年的年份列表
    yearList:
    new Array(150+1).fill(0).map((e,i,a)=>new Date().getFullYear()-((a.length/2)>>0)+i+"年"),

    //  -------------------------------------------------------------
    //生成月份列表
    monthList:new Array(12).fill(0).map((e,i)=>i+1+"月")
    /**
     *  -------------------------------------------------------------
     * 错误信息提取
     * @param err
     * @returns {*|string|string}
     */
      trimErrorMessage(err){
        if(!err) {
            return "未知错误"
        }
        if(err.data) {
            err = err.data;
            try{
                err = JSON.parse(err);
            }catch(e){/*console.log();*/}
        }
        var text = ""
            || err.error        || err.errorText
            || err.message      || err.msg
            || err.statusText   || err
        ;
        return text;
    },


    /**
     * 描述太难，看例子
     * let retryAjax = retry({times:10,duration:1000});
     * retryAjax($.get,["/user",{id:1053256}])
     *      .then(resp={
     *          //10次内，有一次成功就会进入成功
     *      })
     *      .catch(resp=>{
     *          //重试10次，显示第10次的错误
     *      })
     * ;
     * @param genOptions
     * @returns {Function}
     */
    retry(genOptions){
        const defaultOptions = {
            scope:null,
            times:5,
            duration:1000,
            retryCallback(error, times){}
        }

        /**
         * function(thenable,options)
         * function(thenable,options,args)
         * function(thenable,args)
         */
        return function(thenable,options,args){
            if(Array.isArray(options)) {
                args = options;
                options = undefined;
            }
            options = Object.assign({},defaultOptions,genOptions,options);
            let counter = 0;
            return new Promise((resolve,reject)=>{
                function retry(){
                    thenable.apply(options.scope,args||[])
                        .then(resolve)
                        .catch(resp=>{
                            counter++;
                            options.retryCallback(resp,counter);
                            if(counter0时，times表示重复执行最大时间毫秒数,时间耗尽停止重复
     *      3. times<0,times表示重复执行的最大次数,次数耗尽停止
     * @param interval  重复执行setp的间隔，默认90ms
     * @param times     重复执行最大次数的定义，避免一直重复下去
     *        times>0   表示重复执行多久时间。单位毫秒
     *        times<0   表示重复执最大多少次，单位 次
     * @param stepHandler      被重复执行的函数，如果该函数返回true停止重复
     *        function(flag){} //flag如果flag为true，
     *        表示为重复执行时间已经到，或者重复执行的次数已到
     */
    runUntil(interval,times,stepHandler){
        var time_mode = false;
        if(typeof interval == "function") {
            times = 0;
            stepHandler = interval;
            interval = 90;
        }else if(typeof interval == "number" && typeof times == "function"){
            stepHandler = times;
            times = 0;
        }
        var interval = setInterval(function () {
            if(stepHandler()){
                clearInterval(interval);
            }
            if(judge()){
                clearInterval(interval);
                stepHandler(true);
            }
        }, interval);
        var now = new Date().getTime();
        function judge(){
            if(times<0){
                times ++ ;
                if(times === 0){
                    return true;
                }
            }else if(times>0){
                if(new Date().getTime() - now > times ){
                    return true;
                }
            }
        }
    }


    
    
    //-------------------------------------------------------------
    // 独立的除抖函数
    // Returns a function, that, as long as it continues to be invoked, will not
    // be triggered. The function will be called after it stops being called for
    // N milliseconds. If `immediate` is passed, trigger the function on the
    // leading edge, instead of the trailing.
    debounce(func, wait, immediate) {
        var timeout;
        return function() {
            var context = this, args = arguments;
            var later = function() {
                timeout = null;
                if (!immediate) func.apply(context, args);
            };
            var callNow = immediate && !timeout;
            clearTimeout(timeout);
            timeout = setTimeout(later, wait);
            if (callNow) func.apply(context, args);
        };
    },
   
    //-------------------------------------------------------------
    // 独立的节流函数
    // Returns a function, that, when invoked, will only be triggered at most once
    // during a given window of time. Normally, the throttled function will run
    // as much as it can, without ever going more than once per `wait` duration;
    // but if you'd like to disable the execution on the leading edge, pass
    // `{leading: false}`. To disable execution on the trailing edge, ditto.
    throttle(func, wait, options) {
        var context, args, result;
        var timeout = null;
        var previous = 0;
        if (!options) options = {};
        var later = function() {
            previous = options.leading === false ? 0 : Date.now();
            timeout = null;
            result = func.apply(context, args);
            if (!timeout) context = args = null;
        };
        return function() {
            var now = Date.now();
            if (!previous && options.leading === false) previous = now;
            var remaining = wait - (now - previous);
            context = this;
            args = arguments;
            if (remaining <= 0 || remaining > wait) {
                if (timeout) {
                    clearTimeout(timeout);
                    timeout = null;
                }
                previous = now;
                result = func.apply(context, args);
                if (!timeout) context = args = null;
            } else if (!timeout && options.trailing !== false) {
                timeout = setTimeout(later, remaining);
            }
            return result;
        };
    },



}