jPublic.js

/**
 * @file js工具库
 * @copyright jPublic.js 2020
 * @author https://github.com/smltq/jPublic.git
 */
(function () {
    // 基线开始
    //----------------------
    /**
     * 获得root,兼容web,微信,note等
     */
    var root = (typeof self == 'object' && self.self === self && self) ||
        (typeof global == 'object' && global.global === global && global) || this || {};

    var ArrayProto = Array.prototype, ObjProto = Object.prototype;

    /**
     * 为快速访问核心原型创建快速引用变量
     */
    var push = ArrayProto.push,
        toString = ObjProto.toString,
        hasOwnProperty = ObjProto.hasOwnProperty;

    /**
     * 定义将要实现的 ECMAScript 5 原生方法
     */
    var nativeKeys = Object.keys;

    var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');
    var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString', 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];

    /**
     * 创建全局对象:_
     * @global
     * @module _
     */
    var _ = function (obj) {
        if (obj instanceof _) return obj;
        if (!(this instanceof _)) return new _(obj);
        this._wrapped = obj;
    };

    /**
     * 当前版本号
     * @type {string}
     * @default
     * @readOnly
     * @alias module:_.VERSION
     */
    _.VERSION = '1.8.3';

    if (typeof exports != 'undefined' && !exports.nodeType) {
        if (typeof module != 'undefined' && !module.nodeType && module.exports) {
            exports = module.exports = _;
        }
        exports._ = _;
    } else {
        root._ = _;
    }
    // 基线结束

    //私有成员开始
    //----------------------
    var optimizeCb = function (func, context, argCount) {
        if (context === void 0) return func;
        switch (argCount == null ? 3 : argCount) {
            case 1:
                return function (value) {
                    return func.call(context, value);
                };
            case 3:
                return function (value, index, collection) {
                    return func.call(context, value, index, collection);
                };
            case 4:
                return function (accumulator, value, index, collection) {
                    return func.call(context, accumulator, value, index, collection);
                };
        }
        return function () {
            return func.apply(context, arguments);
        };
    };

    var shallowProperty = function (key) {
        return function (obj) {
            return obj == null ? void 0 : obj[key];
        };
    };

    var has = function (obj, path) {
        return obj != null && hasOwnProperty.call(obj, path);
    }

    var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;
    var getLength = shallowProperty('length');
    var isArrayLike = function (collection) {
        var length = getLength(collection);
        return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;
    };

    var builtinIteratee;
    var cb = function (value, context, argCount) {
        if (_.iteratee !== builtinIteratee) return _.iteratee(value, context);
        if (value == null) return _.identity;
        if (_.isFunction(value)) return optimizeCb(value, context, argCount);
        if (_.isObject(value) && !_.isArray(value)) return _.matcher(value);
        return _.property(value);
    };

    var createAssigner = function (keysFunc, defaults) {
        return function (obj) {
            var length = arguments.length;
            if (defaults) obj = Object(obj);
            if (length < 2 || obj == null) return obj;
            for (var index = 1; index < length; index++) {
                var source = arguments[index],
                    keys = keysFunc(source),
                    l = keys.length;
                for (var i = 0; i < l; i++) {
                    var key = keys[i];
                    if (!defaults || obj[key] === void 0) obj[key] = source[key];
                }
            }
            return obj;
        };
    };

    var collectNonEnumProps = function (obj, keys) {
        var nonEnumIdx = nonEnumerableProps.length;
        var constructor = obj.constructor;
        var proto = _.isFunction(constructor) && constructor.prototype || ObjProto;

        //构造函数是一种特殊情况
        var prop = 'constructor';
        if (has(obj, prop) && !_.contains(keys, prop)) keys.push(prop);

        while (nonEnumIdx--) {
            prop = nonEnumerableProps[nonEnumIdx];
            if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) {
                keys.push(prop);
            }
        }
    };
    //私有成员结束

    //集合函数开始
    //---------------
    /**
     * 生成可应用于集合中的每个元素的回调。<br>
     * _.iteratee支持许多常见回调用例的简写语法。<br>
     * 根据值的类型，_.iteratee 各种结果
     * @param {*}   value   迭代值
     * @param {Object}  context 上下文
     * @alias module:_.iteratee
     * @method
     * @example
     * // 空值
     * _.iteratee();
     * => _.identity()
     * // 函数
     * _.iteratee(function(n) { return n * 2; });
     * => function(n) { return n * 2; }
     * // 对象
     * _.iteratee({firstName: 'Chelsea'});
     * => _.matcher({firstName: 'Chelsea'});
     * // 其它
     * _.iteratee('firstName');
     * => _.property('firstName');
     */
    _.iteratee = builtinIteratee = function (value, context) {
        return cb(value, context, Infinity);
    };

    /**
     * 返回一个断言函数，这个函数会给你一个断言可以用来辨别给定的对象是否匹配attrs指定键/值属性。
     * @param attrs
     * @alias module:_.matcher
     * @example
     * var ready = _.matcher({selected: true, visible: true});
     * var readyToGoList = _.filter(list, ready);
     */
    _.matcher = function (attrs) {
        attrs = _.extendOwn({}, attrs);
        return function (obj) {
            return _.isMatch(obj, attrs);
        };
    };

    /**
     * 类似于 extend, 但只复制自己的属性覆盖到目标对象。（注：不包括继承过来的属性）。
     * @type {Function}
     * @method
     * @alias module:_.extendOwn
     * @example
     * var a = {
     *       foo: false
     *   };
     *
     * var b = {
     *       bar: true
     *   };
     * _.extendOwn(a,b)
     * =>{ foo: false, bar: true };
     */
    _.extendOwn = createAssigner(_.keys);

    /**
     * 判断properties中的键和值是否包含在object中。
     * @param {Object} object   查找目标
     * @param {Object} attrs    查找对象
     * @alias module:_.isMatch
     * @example
     * var stooge = {name: 'moe', age: 32};
     * _.isMatch(stooge, {age: 32});
     * => true
     */
    _.isMatch = function (object, attrs) {
        var keys = _.keys(attrs), length = keys.length;
        if (object == null) return !length;
        var obj = Object(object);
        for (var i = 0; i < length; i++) {
            var key = keys[i];
            if (attrs[key] !== obj[key] || !(key in obj)) return false;
        }
        return true;
    };

    /**
     * 遍历list中的所有元素，按顺序用遍历输出每个元素。<br>
     * 如果传递了context参数，则把iteratee绑定到context对象上。<br>
     * 每次调用iteratee都会传递三个参数：(element, index, list)。<br>
     * 如果list是个JavaScript对象，iteratee的参数是 (value, key, list))。<br>
     * 返回list以方便链式调用。<br>
     * @param {Object} obj   遍历目标
     * @param {Function} iteratee   迭代器
     * @param {Object} context  绑定的目标对象
     * @alias module:_.each
     * @example
     * _.each([1, 2, 3], alert);
     * => 依次提示每个数字...
     * _.each({one: 1, two: 2, three: 3}, alert);
     * => 依次提示每个数字...
     */
    _.each = function (obj, iteratee, context) {
        iteratee = optimizeCb(iteratee, context);
        var i, length;
        if (isArrayLike(obj)) {
            for (i = 0, length = obj.length; i < length; i++) {
                iteratee(obj[i], i, obj);
            }
        } else {
            var keys = _.keys(obj);
            for (i = 0, length = keys.length; i < length; i++) {
                iteratee(obj[keys[i]], keys[i], obj);
            }
        }
        return obj;
    };
    //集合函数结束

    //通用函数开始
    //---------------
    /**
     * 返回一个对象里所有的方法名, 而且是已经排序的 — 也就是说, 对象里每个方法(属性值是一个函数)的名称.
     * @param {Object}  obj 查找对象
     * @returns {this}
     * @alias module:_.functions
     * @example
     * _.functions(_);
     * => ["arrayDiff", "arrayEquals", "arrayIsRepeat", "clone", "debounce", "defineColor" ...
     */
    _.functions = function (obj) {
        var names = [];
        for (var key in obj) {
            if (_.isFunction(obj[key])) names.push(key);
        }
        return names.sort();
    };

    /**
     * 获得当前Url参数值
     * @param {String}  name    参数名
     * @returns {string|null}
     * @alias module:_.getUrlParam
     */
    _.getUrlParam = function (name) {
        var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)", "i");
        var r = window.location.search.substr(1).match(reg);
        if (r != null) {
            return decodeURIComponent(r[2]);
        }
        return null;
    };

    /**
     * 函数去抖,空闲时间大于或等于wait，执行fn
     * @param {Function}    fn          要调用的函数
     * @param {Integer}     wait        延迟时间(单位毫秒)
     * @param {Boolean}     immediate   给immediate参数传递false绑定的函数先执行，而不是wait之后执行
     * @returns 实际调用函数
     * @alias module:_.debounce
     * @example
     * var lazyLayout = _.debounce(calculateLayout, 300);
     * $(window).resize(lazyLayout);
     */
    _.debounce = function (fn, wait, immediate) {
        var timeout;
        return function () {
            var context = this, args = arguments;
            var later = function () {
                timeout = null;
                if (!immediate) fn.apply(context, args);
            };
            var callNow = immediate && !timeout;
            clearTimeout(timeout);
            timeout = setTimeout(later, wait);
            if (callNow) fn.apply(context, args);
        }
    };

    /**
     * 函数节流 每wait时间间隔，执行fn
     * @param {Function}    fn      要调用的函数
     * @param {Integer}     wait    延迟时间，单位毫秒
     * @param {Object}      scope   scope代替fn里this的对象
     * @returns {Function} 实际调用函数
     * @alias module:_.throttle
     * @example
     * var throttled = _.throttle(updatePosition, 100);
     * $(window).scroll(throttled);
     */
    _.throttle = function (fn, wait, scope) {
        wait || (wait = 250);
        var last, deferTimer;
        return function () {
            var context = scope || this;
            var now = _.now(), args = arguments;
            if (last && now < last + wait) {
                clearTimeout(deferTimer);
                deferTimer = setTimeout(function () {
                    last = now;
                    fn.apply(context, args);
                }, wait);
            } else {
                last = now;
                fn.apply(context, args);
            }
        };
    };

    /**
     * 函数只执行一次
     * @param {Function}    fn      要执行的函数
     * @param {Object}      context 上下文
     * @returns {function(): *}
     * @alias module:_.runOnce
     * @example
     * var a = 0;
     * var canOnlyFireOnce = runOnce(function () {
     *      a++;
     *      console.log(a);
     * });
     * canOnlyFireOnce(); =>1
     * canOnlyFireOnce(); => nothing
     * canOnlyFireOnce(); => nothing
     */
    _.runOnce = function (fn, context) {
        var result;
        return function () {
            if (fn) {
                result = fn.apply(context || this, arguments);
                fn = null;
            }
            return result;
        };
    };

    /**
     * 轮询条件函数，根据状态执行相应回调
     * @param {Function}    fn          条件函数
     * @param {Function}    callback    成功回调
     * @param {Function}    errback     失败回调
     * @param {Integer}     timeout     超时间隔(毫秒)
     * @param {Integer}     interval    轮询间隔(毫秒)
     * @alias module:_.poll
     * @example
     * 确保元素可见
     * poll(
     *    function () {
     *       return document.getElementById('lightbox').offsetWidth > 0;
     *    },
     *    function () {
     *       // Done, success callback
     *    },
     *    function () {
     *      // Error, failure callback
     *    }
     * );
     */
    _.poll = function (fn, callback, errback, timeout, interval) {
        var endTime = Number(new Date()) + (timeout || 2000);
        interval = interval || 100;
        (function p() {
            // 如果条件满足，调用回调
            if (fn()) {
                callback();
            }
            //如果在结束时间内，继续进入循环判断
            else if (Number(new Date()) < endTime) {
                setTimeout(p, interval);
            }
            //超时，抛出异常
            else {
                errback(new Error('timed out for ' + fn + ': ' + arguments));
            }
        })();
    };

    /**
     * 返回一个min 和 max之间的随机整数。<br>
     * 如果你只传递一个参数，那么将返回0和这个参数之间的整数
     * @param min 随机数下限,没传默认为0
     * @param max 随机数上限
     * @returns {number}
     * @alias module:_.getRandom
     * @example
     * _.random(0, 100);
     * => 48
     */
    _.getRandom = function (min, max) {
        if (max == null) {
            max = min;
            min = 0;
        }
        return min + Math.floor(Math.random() * (max - min + 1));
    };

    /**
     * 获取表单数据
     * @param {Object}    frm   表单对象
     * @alias module:_.getFormJson
     * @example
     * 获得表单数据，自动拼接成json对象，提交给服务端
     * $.ajax({
     *     type: 'post',
     *     url: 'your url',
     *     data: _.getFormJson($('#formId')),
     *     success: function(data) {
     *       // your code
     *     }
     *   });
     */
    _.getFormJson = function (frm) {
        var o = {};
        var a = frm.serializeArray();
        _.each(a, function () {
            o[this.name] = this.value;
        });
        return o;
    };

    /**
     * 复制文本到剪切板(适用于Chrome、Firefox、Internet Explorer和Edge，以及Safari)
     * @alias module:_.copyToClipboard
     */
    _.copyToClipboard = function (text) {
        if (window.clipboardData && window.clipboardData.setData) {
            return clipboardData.setData("Text", text);
        } else if (document.queryCommandSupported && document.queryCommandSupported("copy")) {
            var textarea = document.createElement("textarea");
            textarea.textContent = text;
            textarea.style.position = "fixed";
            document.body.appendChild(textarea);
            textarea.select();
            try {
                return document.execCommand("copy");
            } catch (ex) {
                console.warn("复制到剪贴板异常:", ex);
                return false;
            } finally {
                document.body.removeChild(textarea);
            }
        }
    };

    /**
     * 定义操作列
     * @param {Array} arr   一个数组
     * @param {Integer} value   对应行的id值
     * @returns {string} 返回html字符串
     * @alias module:_.defineOperate
     *
     * @example
     * var arr = [
     *      { text: "删除", fn: "detailDataGrid.Delete({0})" },
     *      {text: "修改", fn: "detailDataGrid.Edit({0})" }]
     * _.defineOperate(arr,3)
     * =><a style='cursor: pointer;' onclick='detailDataGrid.Delete(3)' href='javascript:;'>删除</a> | <a style='cursor: pointer;' onclick='detailDataGrid.Edit(3)' href='javascript:;'>修改</a>
     */
    _.defineOperate = function (arr, value) {
        var str = "";
        var len = arr.length, i = 0;
        while (i < len) {
            str += _.format("<a style='cursor: pointer;' onclick='{1}' href='javascript:;'>{0}</a>", arr[i].text, _.format(arr[i].fn, value));
            str += (i == len - 1 ? "" : " | ");
            i++;
        }
        return str;
    };

    /**
     * 获取当前网站根路径
     * @returns {string}
     * @alias module:_.getRootPath
     * @example
     * http://localhost:8083/tqlin
     */
    _.getRootPath = function () {
        var curPath = window.document.location.href;
        var pathName = window.document.location.pathname;
        var pos = curPath.indexOf(pathName);
        var localhostPaht = curPath.substring(0, pos);
        var projectName = pathName.substring(0, pathName.substr(1).indexOf('/') + 1);
        return (localhostPaht + projectName);
    };

    /**
     * 格式化字符串
     * @param {String} format   要格式化的字符串
     * @returns {string | void}
     * @returns {string}
     * @alias module:_.format
     * @example
     * _.format("Hello, {0}!","World")=>Hello, World
     * _.format("Hello, {0}, My {1}!","World","Love You")=>Hello, World, My Love You
     */
    _.format = function (format) {
        var args = Array.prototype.slice.call(arguments, 1);
        return format.replace(/{(\d+)}/g, function (match, number) {
            return typeof args[number] != 'undefined' ? args[number] : match;
        });
    };

    /**
     * 去左右空格
     * @param {String} str 字符串
     * @param {String} chars 要移除的字符（默认为空白字符)
     * @returns {string}
     * @alias module:_.trim
     * @example
     * _.trim(" Hello ")=>"Hello"
     * _.trim("_Hello_","_")=>"Hello"
     */
    _.trim = function (str, chars) {
        return this.ltrim(this.rtrim(str, chars), chars);
    };

    /**
     * 去左空格
     * @param {String} str 字符串
     * @param {String} chars 要移除的字符（默认为空白字符)
     * @returns {string}
     * @alias module:_.ltrim
     * @example
     * _.ltrim(" Hello ")=>"Hello "
     * _.ltrim("_Hello_","_")=>"Hello_"
     */
    _.ltrim = function (str, chars) {
        chars = chars || "\\s";
        return str.replace(new RegExp("^[" + chars + "]+", "g"), "");
    };

    /**
     * 去右空格
     * @param str 字符串
     * @param chars 要移除的字符（默认为空白字符)
     * @returns {string}
     * @alias module:_.rtrim
     * @example
     * _.ltrim(" Hello ")=>" Hello"
     * _.ltrim("_Hello_","_")=>"_Hello"
     */
    _.rtrim = function (str, chars) {
        chars = chars || "\\s";
        return str.replace(new RegExp("[" + chars + "]+$", "g"), "");
    };

    /**
     * 如果obj是一个函数（Function），返回true。
     * @param {Object} obj 要检查的对象
     * @returns {boolean}
     * @alias module:_.isFunction
     * @example
     * _.isFunction(alert);
     * => true
     */
    _.isFunction = function (obj) {
        return typeof obj == 'function' || false;
    };

    /**
     * 如果object是一个对象，返回true。需要注意的是JavaScript数组和函数是对象，字符串和数字不是。
     * @param {Object} obj  要检查的对象
     * @returns {boolean}
     * @alias module:_.isObject
     * @example
     * _.isObject({});
     * => true
     * _.isObject(1);
     * => false
     */
    _.isObject = function (obj) {
        var type = typeof obj;
        return type === 'function' || type === 'object' && !!obj;
    };

    /**
     * 是否为日期对象，参数支持Date和String类型
     * @param {Object} date 要检查的对象
     * @returns {boolean}
     * @alias module:_.isValidDate
     * @version 1.8.3
     * @example
     * _.isValidDate("2019-5-5a");
     * =>false
     * _.isValidDate("2019-5-5");
     * =>true
     *_.isValidDate(new Date("2019-5-5a"));
     * =>false
     */
    _.isValidDate = function (date) {
        return !!(Object.prototype.toString.call(date) === "[object Date]" && +date);
    }

    /**
     * 是否为空字符串
     * @param {String} str 要检查的字符串
     * @returns {boolean}
     * @alias module:_.isNullOrEmpty
     * @example
     * _.isNullOrEmpty("   ");
     * =>true
     *
     * .isNullOrEmpty(' ');
     * =>true
     *
     * var student = {className: "测试班", name: "我是张三", age: 18};
     * _.isNullOrEmpty(student.skill);
     * =>true
     *
     * _.isNullOrEmpty(undefined);
     * =>true
     *
     * _.isNullOrEmpty(null);
     * =>true
     *
     * _.isNullOrEmpty("");
     * =>true
     *
     * _.isNullOrEmpty('')
     * =>true
     */
    _.isNullOrEmpty = function (str) {
        if (!str || _.trim(str) === '') {
            return true;
        }
        return false;
    };

    /**
     * 如果object 不包含任何值(没有可枚举的属性)，返回true。
     * 对于字符串和类数组（array-like）对象，如果length属性为 0，那么_.isEmpty检查返回true。
     * @param {Object} obj  要检查的对象
     * @returns {boolean}
     * @example
     * _.isEmpty([1, 2, 3]);
     * => false
     * _.isEmpty({});
     * => true
     */
    _.isEmpty = function (obj) {
        if (obj == null) return true;
        if (isArrayLike(obj) && (_.isArray(obj) || _.isArguments(obj))) return obj.length === 0;
        if (_.isString(obj)) return _.isNullOrEmpty(obj);
        return _.keys(obj).length === 0;
    };

    /**
     * 如果obj是一个数组，返回true。
     * @param {Object}  obj 要检查的对象
     * @returns {boolean}
     * @alias module:_.isArray
     * @example
     * (function(){ return _.isArray(arguments); })();
     * => false
     * _.isArray([1,2,3]);
     * => true
     */
    _.isArray = function (obj) {
        return toString.call(obj) === '[object Array]';
    };

    /**
     * 是否数值
     * @param {Object} value    要检查的对象
     * @returns {boolean}
     * @alias module:_.isNumeric
     * @example
     * // true
     * _.isNumeric( "-10" )
     * _.isNumeric( "0" )
     * _.isNumeric( 0xFF )
     * _.isNumeric( "0xFF" )
     * _.isNumeric( "8e5" )
     * _.isNumeric( "3.1415" )
     * _.isNumeric( +10 )
     * _.isNumeric( 0144 )

     // false
     * _.isNumeric( "-0x42" )
     * _.isNumeric( "7.2acdgs" )
     * _.isNumeric( "" )
     * _.isNumeric( {} )
     * _.isNumeric( NaN )
     * _.isNumeric( null )
     * _.isNumeric( true )
     * _.isNumeric( Infinity )
     * _.isNumeric( undefined )
     */
    _.isNumeric = function (value) {
        return !isNaN(parseFloat(value)) && isFinite(value);
    };

    /**
     * 如果object是一个字符串，返回true。
     * @param {String} value 要检查的值
     * @returns {boolean}
     * @alias module:_.isString
     * @example
     * _.isString("moe");
     * => true
     */
    _.isString = function (value) {
        return typeof value === 'string';
    };

    /**
     * 如果object是一个参数对象，返回true。
     * @param {Object} obj  要检查的对象
     * @example
     * (function(){ return _.isArguments(arguments); })(1, 2, 3);
     * => true
     * _.isArguments([1,2,3]);
     * => false
     * @returns {*}
     */
    _.isArguments = function (obj) {
        return has(obj, 'callee');
    };

    /**
     * 截取字符串
     * @param {String}  str     原始字符串
     * @param {Integer} limit   长度限制(默认限制长度100)
     * @param {String}  suffix  超过替换字符（默认用'...'替代）
     * @returns {string|*}
     * @alias module:_.truncate
     * @example
     * _.truncate('We are doing JS string exercises.')
     * =>We are doing JS string exercises.
     *
     * _.truncate('We are doing JS string exercises.',19)
     * =>We are doing JS ...
     *
     * _.truncate('We are doing JS string exercises.',15,'!!')
     * =>We are doing !!
     */
    _.truncate = function (str, limit, suffix) {
        limit = limit || 100;
        if (_.isString(str)) {
            if (typeof suffix !== 'string') {
                suffix = '...';
            }
            if (str.length > limit) {
                return str.slice(0, limit - suffix.length) + suffix;
            }
            return str;
        }
    };

    /**
     * 金额格式化
     * @param {Number}  value   原始金额数值
     * @param {Integer} digit   保留小数位置(默认2位)
     * @returns {string}
     * @alias module:_.fmoney
     * @example
     * _.fmoney(100000000)
     * =>100,000,000.00
     *
     * _.fmoney(100000000.3434343, 3)
     * =>100,000,000.343
     */
    _.fmoney = function (value, digit) {
        digit = digit > 0 && digit <= 20 ? digit : 2;
        if (typeof (value) == "undefined" || (!value && value != 0)) {
            return '';
        }
        value = parseFloat((value + "").replace(/[^\d\.-]/g, "")).toFixed(digit) + "";
        var ss = value.split(".");
        var r = ss[1];
        ss[0] = ss[0].replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1,")
        return ss[0] + "." + r.substring(0, digit);
    };

    /**
     * 定义文字颜色
     * @param {String}  value   原始文字
     * @param {String}  color   要定义的颜色（默认红色）
     * @returns {string}
     * @alias module:_.defineColor
     * @example
     * _.defineColor(“Hello”)
     * =><span style="color:#FF0000">Hello</span>
     */
    _.defineColor = function (value, color) {
        return '<span style="color:' + (color || "#FF0000") + '">' + value + "</span>";
    };

    /**
     * 字节格式化
     * @param {Number}  bytes       字节值
     * @param {Integer} decimals    小数位数
     * @returns {string}
     * @alias module:_.formatBytes
     * @example
     * formatBytes(1024);
     * =>1 KB
     *
     * formatBytes('1024');
     * =>1 KB
     *
     * formatBytes(1234);
     * =>1.21 KB
     *
     * formatBytes(1234, 3);
     * =>1.205 KB
     */
    _.formatBytes = function (bytes, decimals) {
        if (bytes == 0) return '0 Bytes';
        var k = 1024,
            dm = decimals <= 0 ? 0 : decimals || 2,
            sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'],
            i = Math.floor(Math.log(bytes) / Math.log(k));
        return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
    }

    /**
     * 如果list中的所有元素都通过predicate的真值检测就返回true。<br>
     * （注：如果存在原生的every方法，就使用原生的every。）<br>
     * predicate 通过 iteratee 进行转换，以简化速记语法。
     * @param {Array}       list        要检查的列表
     * @param {Function}    predicate   检测函数
     * @param {Object}      context     上下文
     * @returns {boolean}
     * @alias module:_.every
     * @example
     * _.every([2, 4, 5], function(num) { return num % 2 == 0; });
     * => false
     */
    _.every = function (list, predicate, context) {
        predicate = cb(predicate, context);
        var keys = !isArrayLike(list) && _.keys(list),
            length = (keys || list).length;
        for (var index = 0; index < length; index++) {
            var currentKey = keys ? keys[index] : index;
            if (!predicate(list[currentKey], currentKey, list)) return false;
        }
        return true;
    };

    /**
     * 如果list中有任何一个元素通过 predicate 的真值检测就返回true。<br>
     * 一旦找到了符合条件的元素, 就直接中断对list的遍历。<br>
     * predicate 通过 iteratee 进行转换，以简化速记语法。
     * @param {Array}       list        要检查的列表
     * @param {Function}    predicate   检测函数
     * @param {Object}      context     上下文
     * @returns {boolean}
     * @alias module:_.some
     * @example
     * _.some([null, 0, 'yes', false]);
     * => true
     */
    _.some = function (list, predicate, context) {
        predicate = cb(predicate, context);
        var keys = !isArrayLike(list) && _.keys(list),
            length = (keys || list).length;
        for (var index = 0; index < length; index++) {
            var currentKey = keys ? keys[index] : index;
            if (predicate(list[currentKey], currentKey, list)) return true;
        }
        return false;
    };

    /**
     * 一个用来创建整数灵活编号的列表的函数，便于each 和 map循环。<br>
     * 如果省略start则默认为 0；<br>
     * step 默认为 1.返回一个从start 到stop的整数的列表，用step来增加 （或减少）独占。<br>
     * 值得注意的是，如果stop值在start前面（也就是stop值小于start值），那么值域会被认为是零长度，而不是负增长。-如果你要一个负数的值域 ，请使用负数step.
     * @param {Integer} start   开始位置
     * @param {Integer} stop    结束位置
     * @param {Integer} step    步长
     * @returns {any[]}
     * @alias module:_.range
     * @example
     * _.range(10);
     * => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
     * _.range(1, 11);
     * => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
     * _.range(0, 30, 5);
     * => [0, 5, 10, 15, 20, 25]
     * _.range(0, -10, -1);
     * => [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
     * _.range(0);
     * => []
     */
    _.range = function (start, stop, step) {
        if (stop == null) {
            stop = start || 0;
            start = 0;
        }
        if (!step) {
            step = stop < start ? -1 : 1;
        }
        var length = Math.max(Math.ceil((stop - start) / step), 0);
        var range = Array(length);

        for (var idx = 0; idx < length; idx++, start += step) {
            range[idx] = start;
        }
        return range;
    };

    /**
     * 检索object拥有的所有可枚举属性的名称。
     * @param {Object}  obj 要检索的对象
     * @returns {Array|*}
     * @alias module:_.keys
     * @example
     * _.keys({one: 1, two: 2, three: 3});
     * => ["one", "two", "three"]
     */
    _.keys = function (obj) {
        if (!_.isObject(obj)) return [];
        if (nativeKeys) return nativeKeys(obj);
        var keys = [];
        for (var key in obj) if (has(obj, key)) keys.push(key);
        // Ahem, IE < 9.
        if (hasEnumBug) collectNonEnumProps(obj, keys);
        return keys;
    };

    /**
     * 创建 一个浅复制（浅拷贝）的克隆object。任何嵌套的对象或数组都通过引用拷贝，不会复制。
     * @param {Object}  obj 要克隆的对象
     * @returns {*|_|*}
     * @alias module:_.clone
     * @example
     * _.clone({name: 'moe'});
     * => {name: 'moe'};
     */
    _.clone = function (obj) {
        if (!_.isObject(obj)) return obj;
        return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
    };

    _.templateSettings = {
        evaluate: /<%([\s\S]+?)%>/g,
        interpolate: /<%=([\s\S]+?)%>/g,
        escape: /<%-([\s\S]+?)%>/g
    };

    //通用函数结束

    //日期相关开始
    //-----------------------
    /**
     * 获取当前时间戳，兼容旧环境（毫秒）
     * @method
     * @alias module:_.now
     * @example
     * _.now()
     * =>521557891109615
     */
    _.now = Date.now || function () {
        return new Date().valueOf();
    };

    /**
     * 获取当前服务器时间(Date)
     * @returns {Date}
     * @alias module:_.serverTime
     * @example
     * _.serverTime()
     * =>Wed May 15 2019 11:33:22 GMT+0800 (中国标准时间)
     */
    _.serverTime = function () {
        var xmlHttp = new XMLHttpRequest() || new ActiveXObject("Microsoft.XMLHTTP");
        xmlHttp.open("HEAD", location.href, false);
        xmlHttp.send();
        return new Date(xmlHttp.getResponseHeader("Date"));
    };

    /**
     * 随机获取一个日期
     * @param {Date} begin 开始时间(默认1970-1-1)
     * @param {Date} end   结束时间(默认当前时间)
     * @returns {Date}
     * @version 1.8.3
     * @alias module:_.getRandomDate
     * @example
     * _.dateFormat(_.getRandomDate());
     * =>2019-05-01 12:34:54
     */
    _.getRandomDate = function (begin, end) {
        begin = begin || new Date(1970, 1, 1);
        end = end || new Date();
        return new Date(_.getRandom(begin.getTime(), end.getTime()));
    };

    /**
     * 获取月份第一天
     * @param {Date}    date    日期(默认当前日期)
     * @returns {Date}
     * @alias module:_.firstDay
     * _.dateFormat(_.firstDay());
     * =>2019-05-01 00:00:00
     */
    _.firstDay = function (date) {
        date || (date = new Date());
        return new Date(date.getFullYear(), date.getMonth(), 1);
    };

    /**
     * 获取月份最后一天
     * @param {Date}    date    日期(默认当前日期)
     * @returns {Date}
     * @alias module:_.lastDay
     * @example
     * _.dateFormat(_.lastDay());
     * =>2019-05-31 00:00:00
     */
    _.lastDay = function (date) {
        date || (date = new Date());
        return new Date(date.getFullYear(), date.getMonth() + 1, 0);
    };

    /**
     * 获得本周的开始日期
     * @param {Date}    date    日期(默认当前日期)
     * @returns {Date}
     * @alias module:_.getWeekStartDate
     * @example
     * _.dateFormat(_.getWeekStartDate());
     * =>2019-05-13 00:00:00
     */
    _.getWeekStartDate = function (date) {
        date || (date = new Date());
        return new Date(date.getFullYear(), date.getMonth(), date.getDate() - date.getDay() + 1);
    };

    /**
     * 获得本周的结束日期
     * @param {Date}    date    日期(默认当前日期)
     * @returns {Date}
     * @alias module:_.getWeekEndDate
     * @example
     * _.dateFormat(_.getWeekEndDate());
     * =>2019-05-13 00:00:00
     */
    _.getWeekEndDate = function (date) {
        date || (date = new Date());
        return new Date(date.getFullYear(), date.getMonth(), date.getDate() + 7 - date.getDay());
    };

    /**
     * 将 Date 转化为指定格式的String 月(M)、日(d)、小时(h)、分(m)、秒(s)、季度(q)<br>
     * 可以用 1-2 个占位符 年(y)可以用 1-4 个占位符 毫秒(S)只能用 1 个占位符(是 1-3 位的数字)<br>
     * @param {Date}    date    日期(默认当前时间)
     * @param {String}  format  格式化字符串(默认yyyy-MM-dd hh:mm:ss)
     * @returns {*}
     * @alias module:_.dateFormat
     * @example
     * _.dateFormat(date,"yyyy-MM-dd hh:mm:ss.S") ==> 2016-05-04 08:09:04.423
     * _.dateFormat(date,"yyyy-M-d h:m:s.S") ==>2016-05-04 8:9:4.18
     */
    _.dateFormat = function (date, format) {
        date instanceof Date || (date = new Date(date));
        if (!_.isValidDate(date)) {
            throw "parameter is not a date type!";
        }

        format = format || "yyyy-MM-dd hh:mm:ss";
        var o = {
            "M+": date.getMonth() + 1,
            "d+": date.getDate(),
            "h+": date.getHours(),
            "m+": date.getMinutes(),
            "s+": date.getSeconds(),
            "q+": Math.floor((date.getMonth() + 3) / 3),
            "S": date.getMilliseconds()
        };
        if (/(y+)/.test(format)) {
            format = format.replace(RegExp.$1, (date.getFullYear() + "").substr(4 - RegExp.$1.length));
        }
        for (var k in o) {
            if (new RegExp("(" + k + ")").test(format)) {
                format = format.replace(RegExp.$1, (RegExp.$1.length == 1) ? (o[k]) : (("00" + o[k]).substr(("" + o[k]).length)));
            }
        }
        return format;
    };

    /**
     * 返回日期的yyyy-MM-dd格式
     * @param date 日期
     * @alias module:_.shortDateFormat
     * @example
     * _.shortDateFormat(_.now());
     * =>2019-05-15
     */
    _.shortDateFormat = function (date) {
        if (!date) {
            return "";
        }
        return this.dateFormat(date, 'yyyy-MM-dd');
    };

    /**
     * 将时间格式化为指定格式的String
     * @param {Number}  n   时间(单位秒)
     * @returns {string}
     * @alias module:_.formatTime
     * @example
     * _.formatTime(25);
     * => '0:00:25'
     * _.formatTime(63846);
     * => '17:44:06'
     */
    _.formatTime = function (n) {
        if (n < 0) {
            throw "parameter cannot be less than 0!";
        }
        var hours = Math.floor(n / 60 / 60);
        var minutes = Math.floor((n - (hours * 60 * 60)) / 60);
        var seconds = Math.round(n - (hours * 60 * 60) - (minutes * 60));
        return hours + ':' + ((minutes < 10) ? '0' + minutes : minutes) + ':' + ((seconds < 10) ? '0' + seconds : seconds);
    };

    /**
     * 反格式化,与formatTime函数相反
     * @param {String}  string  要格式化的时间字符串
     * @returns {number}
     * @alias module:_.unformatTime
     * @example
     * _.unformatTime('0:00:25');
     * => 25
     * _.unformatTime('17:44:06');
     * => 63846
     */
    _.unformatTime = function (string) {
        var timeArray = string.split(':'), seconds = 0;
        if (timeArray.length === 3) {
            // hours
            seconds = seconds + (Number(timeArray[0]) * 60 * 60);
            // minutes
            seconds = seconds + (Number(timeArray[1]) * 60);
            // seconds
            seconds = seconds + Number(timeArray[2]);
        } else if (timeArray.length === 2) {
            // minutes
            seconds = seconds + (Number(timeArray[0]) * 60);
            // seconds
            seconds = seconds + Number(timeArray[1]);
        }
        return Number(seconds);
    };
    //日期相关结束

    //数组工具相关开始
    //-------------
    /**
     * 数组差集，以第一个数组为主
     * @param {Array}   a   主数组
     * @param {Array}   b   次数组
     * @returns {*}
     * @alias module:_.difference
     * @example
     * var a = [1,2,3,4,5]
     * var b = [2,4,6,8,10]
     * _.difference(a, b)
     * =>[1,3,5]
     */
    _.difference = function (a, b) {
        var filtered = a.filter(function (e) {
            return b.indexOf(e) === -1;
        });
        return filtered;
    };

    /**
     * 洗牌数组
     * @param {String}  array   要洗牌的数组
     * @returns {Array}
     * @alias module:_.shuffle
     * @example
     * var a = [1,2,3,4,5]
     * _.shuffle(a)
     * => [3, 2, 4, 5, 1]
     */
    _.shuffle = function (array) {
        var copy = [], n = array.length, i;
        while (n) {
            i = Math.floor(Math.random() * n--);
            copy.push(array.splice(i, 1)[0]);
        }
        return copy;
    };

    /**
     * 数组元素是否重复
     * @param {Array}   arr 要检查的数组对象
     * @returns {boolean}
     * @alias module:_.isRepeat
     * @example
     * var a = [1, 2, 3, 4, 5];
     * var b = [1, 2, 3, 5, 5];
     * _.isRepeat(a);
     * =>false
     *
     * _.isRepeat(b);
     * =>true
     */
    _.isRepeat = function (arr) {
        var hash = {};
        for (var i in arr) {
            if (hash[arr[i]]) {
                return true;
            }
            hash[arr[i]] = true;
        }
        return false;
    };

    /**
     * 数组去重
     * @param {Array}   arr 要去重的数组
     * @returns {Array}
     * @alias module:_.unique
     * @example
     * var b = [1, 2, 3, 5, 5];
     * _.unique(b);
     * => [1, 2, 3, 5]
     */
    _.unique = function (arr) {
        var a = [];
        for (var i = 0, l = arr.length; i < l; i++) {
            if (a.indexOf(arr[i]) === -1) {
                a.push(arr[i]);
            }
        }
        return a;
    };

    /**
     * 判断数组是否相等,默认为严格模式比较
     * @param {Array}   a       第一个数组
     * @param {Array}   b       第二个数组
     * @param {Boolean} strict  是否严格比较（默认为true)
     * @returns {boolean}
     * @alias module:_.equals
     * @example
     * var arr1 = [1, 2, 3, 4];
     * var arr2 = [2, 1, 4, 3];
     * var arr3 = [2, 2, 3, 4];
     * var arr4 = [1, 2, 3, 4];
     * _.equals(arr1,arr2);
     * => false
     *
     * _.equals(arr1,arr2, false);
     * =>true
     *
     * _.equals(arr1,arr3);
     * =>false
     *
     * _.equals(arr1,arr3, false);
     * =>false
     *
     * _.equals(arr1,arr4);
     * =>true
     *
     * _.equals(arr1,arr4, false);
     * =>true
     */
    _.equals = function (a, b, strict) {
        if (!b) return false;
        if (arguments.length == 2) strict = true;
        if (a.length != b.length) return false;
        for (var i = 0; i < a.length; i++) {
            if (a[i] instanceof Array && b[i] instanceof Array) {
                if (!a[i].equals(b[i], strict)) return false;
            } else if (strict && a[i] != b[i]) {
                return false;
            } else if (!strict) {
                return _.equals(a.sort(), b.sort(), true);
            }
        }
        return true;
    };
    //数组工具相关结束

    /**
     * 精度范围
     * @readonly
     * @alias module:_.EPSILON
     */
    _.EPSILON = Math.pow(2, -52);

    /**
     * 默认数值保留小数位数
     * @readonly
     * @alias module:_.DEFAULT_SCALE
     */
    _.DEFAULT_SCALE = 2;

    /**
     * 加
     * @param {*}  x   第一个数值
     * @param {*}  y   第二个数组
     * @returns {number}
     * @alias module:_.numAdd
     * @example
     * _.numAdd('3',5);
     * =>8
     */
    _.numAdd = function (x, y) {
        var result = Number(x) + Number(y);
        return result;
    };

    /**
     * 减
     * @param {*}   x   第一个数值
     * @param {*}   y   第二个数值
     * @returns {number}
     * @alias module:_.numSubtract
     * @example
     * _.numSubtract('7',5);
     * =>2
     */
    _.numSubtract = function (x, y) {
        var result = Number(x) - Number(y);
        return result;
    };

    /**
     * 乘
     * @param {*}   x    第一个数值
     * @param {*}   y    第二个数值
     * @returns {number}
     * @alias module:_.numMultiply
     * @example
     * _.numMultiply('2',3);
     * =>6
     */
    _.numMultiply = function (x, y) {
        var result = Number(x) * Number(y);
        return result;
    };

    /**
     * 除
     * @param {*}   x    第一个数值
     * @param {*}   y    第二个数值
     * @returns {number}
     * @alias module:_.numDivide
     * @example
     * _.numDivide(9,'3');
     * =>3
     */
    _.numDivide = function (x, y) {
        var result = Number(x) / Number(y);
        return result;
    };

    /**
     * 精度加法函数，用来得到精确的加法结果
     * javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。
     * @param arg1
     * @param arg2
     * @returns {number}
     */
    _.accAdd = function (arg1, arg2) {
        var r1, r2, m, c;
        try {
            r1 = arg1.toString().split(".")[1].length;
        } catch (e) {
            r1 = 0;
        }
        try {
            r2 = arg2.toString().split(".")[1].length;
        } catch (e) {
            r2 = 0;
        }
        c = Math.abs(r1 - r2);
        m = Math.pow(10, Math.max(r1, r2));
        if (c > 0) {
            var cm = Math.pow(10, c);
            if (r1 > r2) {
                arg1 = Number(arg1.toString().replace(".", ""));
                arg2 = Number(arg2.toString().replace(".", "")) * cm;
            } else {
                arg1 = Number(arg1.toString().replace(".", "")) * cm;
                arg2 = Number(arg2.toString().replace(".", ""));
            }
        } else {
            arg1 = Number(arg1.toString().replace(".", ""));
            arg2 = Number(arg2.toString().replace(".", ""));
        }
        return (arg1 + arg2) / m;
    };

    /**
     * 精度减法函数，用来得到精确的减法结果
     * javascript的减法结果会有误差，在两个浮点数相减的时候会比较明显。这个函数返回较为精确的减法结果。
     * @param arg1
     * @param arg2
     * @returns {string}
     */
    _.accSub = function (arg1, arg2) {
        var r1, r2, m, n;
        try {
            r1 = arg1.toString().split(".")[1].length;
        } catch (e) {
            r1 = 0;
        }
        try {
            r2 = arg2.toString().split(".")[1].length;
        } catch (e) {
            r2 = 0;
        }
        m = Math.pow(10, Math.max(r1, r2)); //动态控制精度长度
        n = (r1 >= r2) ? r1 : r2;
        return ((arg1 * m - arg2 * m) / m).toFixed(n);
    };

    /**
     * 数度乘法函数，用来得到精确的乘法结果
     * javascript的乘法结果会有误差，在两个浮点数相乘的时候会比较明显。这个函数返回较为精确的乘法结果。
     * @param arg1
     * @param arg2
     * @returns {number} arg1乘以 arg2的精确结果
     */
    _.accMul = function (arg1, arg2) {
        var m = 0, s1 = arg1.toString(), s2 = arg2.toString();
        try {
            m += s1.split(".")[1].length;
        } catch (e) {
        }
        try {
            m += s2.split(".")[1].length;
        } catch (e) {
        }
        return Number(s1.replace(".", "")) * Number(s2.replace(".", "")) / Math.pow(10, m);
    };

    /**
     * 除法函数，用来得到精确的除法结果
     * javascript的除法结果会有误差，在两个浮点数相除的时候会比较明显。这个函数返回较为精确的除法结果。
     * @param arg1
     * @param arg2
     * @returns {number} arg1除以arg2的精确结果
     */
    _.accDiv = function (arg1, arg2) {
        var t1 = 0, t2 = 0, r1, r2;
        try {
            t1 = arg1.toString().split(".")[1].length;
        } catch (e) {
        }
        try {
            t2 = arg2.toString().split(".")[1].length;
        } catch (e) {
        }
        r1 = Number(arg1.toString().replace(".", ""));
        r2 = Number(arg2.toString().replace(".", ""));
        return (r1 / r2) * Math.pow(10, t2 - t1);
    };

    /**
     * 固定小数位数
     * @param {Number}  x       要处理的数值
     * @param {Number}  digits  小数位置，默认保留2位
     * @returns {string|*}
     * @alias module:_.toFixed
     * @example
     * _.toFixed(548.6512)
     * =>548.65
     */
    _.toFixed = function (x, digits) {
        if (typeof (x) == "undefined" || x === '') {
            return '';
        } else if (!_.isNumeric(x)) {
            return x;
        }
        digits = digits || this.DEFAULT_SCALE;
        x = (x + '').replace("E", "e");
        if ((x + '').indexOf('e') != -1) {
            return (+(Math.round(+(x)) + 'e' + -digits)).toFixed(digits);
        }
        return (+(Math.round(+(x + 'e' + digits)) + 'e' + -digits)).toFixed(digits);
    };

    /**
     * 移除数值指数表示
     * @param {Number}  x   要处理的数值
     * @returns {string}
     * @alias module:_.toFixed
     * @example
     *         var numbers = [
     *             1.1234567890123456789e+30,
     *             1.1234567890123456789e-30,
     *             -1.1234567890123456789e+30,
     *             -1.1234567890123456789e-30]
     * var i;
     * for (i=0;i<numbers.length;i++) {
     *        console.log(_.removeExponent(numbers[i]));
     *   }
     * =>1123456789012345700000000000000
     * =>0.0000000000000000000000000000011234567890123458
     * =>-1123456789012345700000000000000
     * =>0.00000000000000000000000000000.11234567890123458
     */
    _.removeExponent = function (x) {
        if (Math.abs(x) < 1.0) {
            var e = parseInt(x.toString().split('e-')[1]);
            if (e) {
                x *= Math.pow(10, e - 1);
                x = '0.' + (new Array(e)).join('0') + x.toString().substring(2);
            }
        } else {
            var e = parseInt(x.toString().split('+')[1]);
            if (e > 20) {
                e -= 20;
                x /= Math.pow(10, e);
                x += (new Array(e + 1)).join('0');
            }
        }
        return x;
    };

    /**
     * 判断两个小数数值是否相等
     * @param {Number}  x   第一个数值
     * @param {Number}  y   第二个数值
     * @returns {boolean}
     * @alias module:_.numEqual
     * @example
     * _.numEqual(0.1+0.2, 0.3);
     * =>true
     */
    _.numEqual = function (x, y) {
        return Math.abs(x - y) < this.EPSILON;
    };

    /**
     * 比较两数大小，x>y返回1，x==y返回0，否则返回-1
     * @param {Number}  x   第一个数值
     * @param {Number}  y   第二个数值
     * @returns {number}
     * @alias module:_.numCompare
     * @example
     * _.numCompare(3,5);
     * =>-4
     *
     * -.numCompare('aaa',3);
     * =>抛出异常Parameter is not a number!
     */
    _.numCompare = function (x, y) {
        if (!_.isNumeric(x) || !_.isNumeric(y)) {
            throw "Parameter is not a number!";
        }
        if (_.numEqual(x, y)) return 0;
        else if (x > y) return 1;
        else return -1;
    };

    var REG_NUMBER = /^([+-])?0*(\d+)(\.(\d+))?$/;
    var REG_E = /^([+-])?0*(\d+)(\.(\d+))?e(([+-])?(\d+))$/i;

    /**
     * 分析数字字符串
     *
     * @param {string} num NumberString
     * @returns {object}
     */
    _.getNumbResult = function (num) {
        var result = REG_NUMBER.exec(num.toString());
        if (!result && REG_E.test(num.toString())) {
            result = REG_NUMBER.exec(_.e2ten(num.toString()))
        }
        if (result) {
            return {
                int: result[2],
                decimal: result[4],
                minus: result[1] == "-",
                num: result.slice(1, 3).join('')
            }
        }
    };

    /**
     * 科学计数法转十进制
     *
     * @param {string} num 科学记数法字符串
     * @returns {string}
     */
    _.e2ten = function (num) {
        var result = REG_E.exec(num.toString());
        if (!result) return num;
        var zs = result[2]
            , xs = result[4] || ""
            , e = result[5] ? +result[5] : 0;
        if (e > 0) {
            var _zs = xs.substr(0, e);
            _zs = _zs.length < e ? _zs + new Array(e - _zs.length + 1).join("0") : _zs;
            xs = xs.substr(e);
            zs += _zs;
        } else {
            e = -e;
            var s_start = zs.length - e;
            s_start = s_start < 0 ? 0 : s_start;
            var _xs = zs.substr(s_start, e);
            _xs = _xs.length < e ? new Array(e - _xs.length + 1).join("0") + _xs : _xs;
            zs = zs.substring(0, s_start);
            xs = _xs + xs;
        }
        zs = zs == "" ? "0" : zs;
        return (result[1] == "-" ? "-" : "") + zs + (xs ? "." + xs : "");
    };

    /**
     * 清理多余"零"
     *
     * @param {any} str
     * @param {any} zero "零"字符
     * @param {any} type 清理模式 ^ - 开头, $ - 结尾, nto1 - 多个连续变一个
     * @returns {string}
     */
    _.clearZero = function (str, zero, type) {
        if (str == null) return "";
        var reg0 = ~"*.?+$^[](){}|\\/".indexOf(zero) ? "\\" + zero : zero;
        var arg_s = new RegExp("^" + reg0 + "+")
            , arg_e = new RegExp(reg0 + "+$")
            , arg_d = new RegExp(reg0 + "{2}", "g")
        str = str.toString();
        if (type == "^") {
            str = str.replace(arg_s, "");
        }
        if (!type || type == "$") {
            str = str.replace(arg_e, "");
        }
        if (!type || type == "nto1") {
            str = str.replace(arg_d, zero);
        }
        return str;
    };

    /**
     * 阿拉伯数字转中文数字
     * (源码:https://github.com/cnwhy/nzh.git)
     * @param {String} num 阿拉伯数字/字符串 , 科学记数法字符串
     * @param {Object} opration 转换配置<br>
     *                          {<br>
     *                              ww: {万万化单位 | false}<br>
     *                              tenMin: {十的口语化 | false}<br>
     *                              nzh:{中文语言|简体}<br>
     *                          }<br>
     * @returns {string}
     * @alias module:_.cl
     * @version 1.8.3
     * @example
     * _.cl("100111",{tenMin:true})
     * => "十万零一百一十一"
     *
     * _.cl("100111")
     *=> "一十万零一百一十一"
     *
     * _.cl("13.5",{tenMin:true})
     * => "十三点五"
     *
     * _.cl(1e16)
     * => "一亿亿"
     */
    _.cl = function (num, options) {
        var result = _.getNumbResult(num)
        if (!result) {
            return num;
        }
        options = options ? options : {};

        var nzh = options.nzh || {
            ch: '零一二三四五六七八九'
            , ch_u: '个十百千万亿'
            , ch_f: '负'
            , ch_d: '点'
        };

        var ch = nzh.ch             //数字
            , ch_u = nzh.ch_u       //单位
            , ch_f = nzh.ch_f || "" //负
            , ch_d = nzh.ch_d || "." //点
            , n0 = ch.charAt(0); //零
        var _int = result.int             //整数部分
            , _decimal = result.decimal   //小数部分
            , _minus = result.minus;      //负数标识
        var int = ""
            , dicimal = ""
            , minus = _minus ? ch_f : ''; //符号位
        var encodeInt = function encodeInt(_int, _m, _dg) {
            _int = _.getNumbResult(_int).int;
            var int = ""
                , tenm = arguments.length > 1 ? arguments[1] : options.tenMin
                , _length = _int.length;
            //一位整数
            if (_length == 1) return ch.charAt(+_int);
            if (_length <= 4) { //四位及以下
                for (var i = 0, n = _length; n--;) {
                    var _num = +_int.charAt(i);
                    int += (tenm && _length == 2 && i == 0 && _num == 1) ? "" : ch.charAt(_num);
                    int += (_num && n ? ch_u.charAt(n) : '')
                    i++;
                }
            } else {  //大数递归
                var d = _int.length / 4 >> 0
                    , y = _int.length % 4;
                //"兆","京"等单位处理
                while (y == 0 || !ch_u.charAt(3 + d)) {
                    y += 4;
                    d--;
                }
                var _maxLeft = _int.substr(0, y), //最大单位前的数字
                    _other = _int.substr(y); //剩余数字

                int = encodeInt(_maxLeft, tenm) + ch_u.charAt(3 + d)
                    + (_other.charAt(0) == '0' ? n0 : '') //单位后有0则加零
                    + encodeInt(_other, tenm)
            }
            int = _.clearZero(int, n0); //修整零
            return int;
        }

        //转换小数部分
        if (_decimal) {
            _decimal = _.clearZero(_decimal, "0", "$"); //去除尾部0
            for (var x = 0; x < _decimal.length; x++) {
                dicimal += ch.charAt(+_decimal.charAt(x));
            }
            dicimal = dicimal ? ch_d + dicimal : "";
        }

        //转换整数部分
        int = encodeInt(_int);  //转换整数

        //超级大数的万万化
        if (options.ww && ch_u.length > 5) {
            var dw_w = ch_u.charAt(4)
                , dw_y = ch_u.charAt(5);
            var lasty = int.lastIndexOf(dw_y);
            if (~lasty) {
                int = int.substring(0, lasty).replace(new RegExp(dw_y, 'g'), dw_w + dw_w) + int.substring(lasty);
            }
        }
        return minus + int + dicimal;
    };

    /**
     * 计算地图上两个点的距离
     * @param {float} lng1 经度1
     * @param {float} lat1 纬度1
     * @param {float} lng2 经度2
     * @param {float} lat2 纬度2
     * @returns {float} 返回单位千米
     * @version 1.8.5
     */
    _.getMapDistance = function (lng1, lat1, lng2, lat2) {
        var f = getRad((lat1 + lat2) / 2);
        var g = getRad((lat1 - lat2) / 2);
        var l = getRad((lng1 - lng2) / 2);
        if (g == 0 && l == 0) { //两点重叠，直接返回0
            return g;
        }
        var sg = Math.sin(g);
        var sl = Math.sin(l);
        var sf = Math.sin(f);
        var s, c, w, r, d, h1, h2;
        var a = 6378137.0;
        var fl = 1 / 298.257;
        sg = sg * sg;
        sl = sl * sl;
        sf = sf * sf;
        s = sg * (1 - sl) + (1 - sf) * sl;
        c = (1 - sg) * (1 - sl) + sf * sl;
        w = Math.atan(Math.sqrt(s / c));
        r = Math.sqrt(s * c) / w;
        d = 2 * w * a;
        h1 = (3 * r - 1) / 2 / c;
        h2 = (3 * r + 1) / 2 / s;
        s = d * (1 + fl * (h1 * sf * (1 - sg) - h2 * (1 - sf) * sg));
        s = s / 1000;
        s = s.toFixed(2);
        return s;
    }

    function getRad(d) {
        var PI = Math.PI;
        return d * PI / 180.0;
    }

    /**
     * 判断地图上的点是否在多边形内
     * @param {Object} point 点
     * @param {Array} pts   面
     * @returns {boolean}
     * @version 1.8.5
     */
    _.isMapPointInPolygon = function (point, pts) {
        var N = pts.length;  //pts [{lat:xxx,lng:xxx},{lat:xxx,lng:xxx}]
        var boundOrVertex = true; //如果点位于多边形的顶点或边上，也算做点在多边形内，直接返回true
        var intersectCount = 0;//cross points count of x
        var precision = 2e-10; //浮点类型计算时候与0比较时候的容差
        var p1, p2;//neighbour bound vertices
        var p = point; //point {lat:xxx,lng:xxx}

        p1 = pts[0];//left vertex
        for (var i = 1; i <= N; ++i) {//check all rays
            if ((p.lat == p1.lat) && (p.lng == p1.lng)) {
                return boundOrVertex;//p is an vertex
            }
            p2 = pts[i % N];//right vertex
            if (p.lat < Math.min(p1.lat, p2.lat) || p.lat > Math.max(p1.lat, p2.lat)) {//ray is outside of our interests
                p1 = p2;
                continue;//next ray left point
            }
            if (p.lat > Math.min(p1.lat, p2.lat) && p.lat < Math.max(p1.lat, p2.lat)) {//ray is crossing over by the algorithm (common part of)
                if (p.lng <= Math.max(p1.lng, p2.lng)) {//x is before of ray
                    if (p1.lat == p2.lat && p.lng >= Math.min(p1.lng, p2.lng)) {//overlies on a horizontal ray
                        return boundOrVertex;
                    }
                    if (p1.lng == p2.lng) {//ray is vertical
                        if (p1.lng == p.lng) {//overlies on a vertical ray
                            return boundOrVertex;
                        } else {//before ray
                            ++intersectCount;
                        }
                    } else {//cross point on the left side
                        var xinters = (p.lat - p1.lat) * (p2.lng - p1.lng) / (p2.lat - p1.lat) + p1.lng;//cross point of lng
                        if (Math.abs(p.lng - xinters) < precision) {//overlies on a ray
                            return boundOrVertex;
                        }
                        if (p.lng < xinters) {//before ray
                            ++intersectCount;
                        }
                    }
                }
            } else {//special case when ray is crossing through the vertex
                if (p.lat == p2.lat && p.lng <= p2.lng) {//p crossing over p2
                    var p3 = pts[(i + 1) % N]; //next vertex
                    if (p.lat >= Math.min(p1.lat, p3.lat) && p.lat <= Math.max(p1.lat, p3.lat)) {//p.lat lies between p1.lat & p3.lat
                        ++intersectCount;
                    } else {
                        intersectCount += 2;
                    }
                }
            }
            p1 = p2;//next ray left point
        }
        if (intersectCount % 2 == 0) {//偶数在多边形外
            return false;
        } else { //奇数在多边形内
            return true;
        }
    };

    //这里继续扩展函数
    //示例:_.a1=function(){};

    /**
     * 允许自己的实用程序函数扩展jPublic。传递一个 {name: function}定义的哈希添加到jPublic对象，以及面向对象封装。
     * @param obj
     * @returns {_}
     * @alias module:_.extend
     * @example
     * _.extend({
     *  abc: function(str) {
     *      return str;
     *  }
     * });
     * _.abc("Hello");
     * =>"Hello"
     */
    _.extend = function (obj) {
        _.each(_.functions(obj), function (name) {
            var func = _[name] = obj[name];
            _.prototype[name] = function () {
                var args = [this._wrapped];
                push.apply(args, arguments);
                return chainResult(this, func.apply(_, args));
            };
        });
        return _;
    };
    _.extend(_);
}());