Utils工具类

最新推荐文章于 2024-07-04 00:59:27 发布
我不爱编程
最新推荐文章于 2024-07-04 00:59:27 发布
阅读量94
点赞数 2
文章标签：前端 javascript 服务器
本文链接：https://blog.csdn.net/weixin_39475476/article/details/138118142
版权
/**
 * 
 * @authors chenshw (chenshw@seaway.net.cn)
 * @date    2017-04-01 11:40:20
 * @version $Id$
 * @description 
 * @update [user] [date] [instruction]
 */
/*
 * 判断obj是否为一个整数
 */
function isInteger(obj) {
    return Math.floor(obj) === obj
}

/*
 * 将一个浮点数转成整数，返回整数和倍数。如 3.14 >> 314，倍数是 100
 * @param floatNum {number} 小数
 * @return {object}
 *   {times:100, num: 314}
 */
function toInteger(floatNum) {
    var ret = { times: 1, num: 0 }
    var isNegative = floatNum < 0
    if (isInteger(floatNum)) {
        ret.num = floatNum
        return ret
    }
    var strfi = floatNum + ''
    var dotPos = strfi.indexOf('.')
    var len = strfi.substr(dotPos + 1).length
    var times = Math.pow(10, len)
    var intNum = parseInt(Math.abs(floatNum) * times + 0.5, 10)
    ret.times = times
    if (isNegative) {
        intNum = -intNum
    }
    ret.num = intNum
    return ret
}

/*
 * 核心方法，实现加减乘除运算，确保不丢失精度
 * 思路：把小数放大为整数（乘），进行算术运算，再缩小为小数（除）
 *
 * @param a {number} 运算数1
 * @param b {number} 运算数2
 * @param digits {number} 精度，保留的小数点数，比如 2, 即保留为两位小数
 * @param op {string} 运算类型，有加减乘除（add/subtract/multiply/divide）
 *
 */
function operation(a, b, digits, op) {
    var o1 = toInteger(a)
    var o2 = toInteger(b)
    var n1 = o1.num
    var n2 = o2.num
    var t1 = o1.times
    var t2 = o2.times
    var max = t1 > t2 ? t1 : t2
    var result = null
    switch (op) {
        case 'add':
            if (t1 === t2) { // 两个小数位数相同
                result = n1 + n2
            } else if (t1 > t2) { // o1 小数位 大于 o2
                result = n1 + n2 * (t1 / t2)
            } else { // o1 小数位 小于 o2
                result = n1 * (t2 / t1) + n2
            }
            return (result / max);
        case 'subtract':
            if (t1 === t2) {
                result = n1 - n2
            } else if (t1 > t2) {
                result = n1 - n2 * (t1 / t2)
            } else {
                result = n1 * (t2 / t1) - n2
            }
            return (result / max);
        case 'multiply':
            result = (n1 * n2) / (t1 * t2)
            return result;
        case 'divide':
            result = (n1 / n2) * (t2 / t1)
            return result;
    }
}

let utils = {}
/**
 * [stringFomat 字符串格式化]
 * @type {Object}
 */
utils.stringFomat = {
    /**
     * [camelcaseToHyphen 驼峰转化成-连接]
     * @param  {[type]} str [驼峰字符串]
     * @return {[type]}     [连接-字符串]
     */
    camelcaseToHyphen(str) {
        return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
    },
    /**
     * [numToCard 转化成卡号]
     * @param  {[type]} string [description]
     * @return {[type]}        [description]
     */
    numToCard(string) {
        return string.replace(/(\d{4})(?=\d)/g, "$1" + " ")
    },
    /**
     * [cardToNum 卡号转化成字符串]
     * @param  {[type]} string [description]
     * @return {[type]}        [description]
     */
    cardToNum(string) {
        return string.replace(/\s/ig, "")
    },
    /**
     * [moneyFormate 金额整数去掉.00]
     * @param  {[type]} string [description]
     * @return {[type]}        [description]
     */
    moneyFormate(string) {
        let oArray = string.split(".");
        if (oArray.length == 2) {
            if (oArray[1] > 0) {
                return string;
            } else {
                return oArray[0];
            }
        }
        return string;
    }

}
/**
 * [dateFormat 时间格式化处理]
 * @type {Object}
 */
utils.dateFormat = {  
    /**
     * [format description]
     * @param  {[Date]} date [需要格式的对象]
     * @param  {[String]} fmt  [例子：yyyy-MM-dd hh:mm:ss 连接上做处理]
     * @return {[String]}      [返回fmt的时间]
     */
    format(date, fmt) {
        let 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(fmt)) {
            fmt = fmt.replace(RegExp.$1, (date.getFullYear() + "").substr(4 - RegExp.$1.length));
        }
        for (let k in o) {
            if (new RegExp("(" + k + ")").test(fmt)) {
                fmt = fmt.replace(RegExp.$1, (RegExp.$1.length == 1) ? (o[k]) : (("00" + o[k]).substr(("" + o[k]).length)));
            }
        }
        return fmt;
    },
    millisecondToTime(timestamp) {

        var dateDiff = timestamp;//时间毫秒数
        var dayDiff = Math.floor(dateDiff / (24 * 3600 * 1000));//计算出相差天数
        var leave1=dateDiff%(24*3600*1000)    //计算天数后剩余的毫秒数
        var hours=Math.floor(leave1/(3600*1000))//计算出小时数
        //计算相差分钟数
        var leave2=leave1%(3600*1000)    //计算小时数后剩余的毫秒数
        var minutes=Math.floor(leave2/(60*1000))//计算相差分钟数
        //计算相差秒数
        var leave3=leave2%(60*1000)      //计算分钟数后剩余的毫秒数
        var seconds=Math.round(leave3/1000)

        var timeFn = dayDiff+"天"+hours+"小时"+minutes+"分"+seconds+"秒";
        return timeFn;
    },
    getRecentMonth(){
        //获取最近6个月
        var data=new Date();
        //获取月
        var mon=data.getMonth()+1;
        var arry=new Array();
        for(var i=0;i<6;i++){
            if(mon<=0){
                mon=mon+12;
            }
            if(mon<10){
                mon=mon;
            }
            arry[i]= mon+"月";
            mon=mon-1;
        }
        
        
        return arry.reverse();
    },
    /*日期组件获取今天的日期*/
    getTodayDate() {
        //是否选择今天及其今天以后的日期
        let date = new Date();
        let year = date.getFullYear();
        let month = date.getMonth();
        let day = date.getDate();
        return new Date(year, month, day);
    },
    dateGap30(start, end, day) {
        //日期间隔不超过30天
        var dayTime = day ? day : 30;
        var time = dayTime * 24 * 60 * 60 * 1000,
            gaptime = 0;
        start = start.replace(/-/g, "/");
        end = end.replace(/-/g, "/");
        gaptime = Date.parse(end) - Date.parse(start);
        if (gaptime < 0 || gaptime >= time) {
            return false;
        }
        return true;
    },
    getMonthDate(fmt) {
        let str = "";
        let date = new Date();
        let year = date.getFullYear();
        let month = date.getMonth() + 1;
        let day = date.getDate();
        let startTime = "";
        let endTime = "";
        fmt = fmt ? fmt : "";
        month = month < 10 ? ('0' + month) : month;
        startTime = year + fmt + month + fmt + "01";
        endTime = year + fmt + month + fmt + new Date(year, month, 0).getDate();
        return { "first": startTime, "last": endTime };
    },
    getWeekDate() {
        let startTime = "";
        let Nowdate = new Date();
        let WeekFirstDay = new Date(Nowdate - (Nowdate.getDay() - 1) * 86400000);
        let month = Number(WeekFirstDay.getMonth()) + 1;
        month = month < 10 ? ('0' + month) : month;
        startTime = WeekFirstDay.getFullYear() + "-" + month + "-" + WeekFirstDay.getDate();
        return { "start": startTime, "end": utils.dateFormat.format(Nowdate, "yyyy-MM-dd") };
    },
    /*1417708800000转化成2014-12-05 00:00:00
        date 类型为string*/
    formatDate4(date) {
        return date.substr(0, 4) + "-" + date.substr(4, 2) + "-" + date.substr(6, 2) + " " + date.substr(8, 2) + ":" + date.substr(10, 2) + ":" + date.substr(12, 2);
    },
    /*1417708800000转化成2014-12-05 00:00:00*/
    formatDate3(timestamp, isymd) {
        if (timestamp) {
            var date = new Date(timestamp);
            var y = date.getFullYear();
            var m = date.getMonth() + 1;
            var d = date.getDate();
            var h = date.getHours();
            var mi = date.getMinutes();
            var s = date.getSeconds();
            if (!isymd) { //是否年月日
                return y + '-' + (m < 10 ? ('0' + m) : m) + '-' + (d < 10 ? ('0' + d) : d) + ' ' + (h < 10 ? ('0' + h) : h) + ':' + (mi < 10 ? ('0' + mi) : mi) + ':' + (s < 10 ? ('0' + s) : s);
            } else {
                return y + '-' + (m < 10 ? ('0' + m) : m) + '-' + (d < 10 ? ('0' + d) : d);
            }

        } else
            return;
    },
    //2016-07-22 to Date
    stringToDate(string) {
        var stringObj = string.split("-");
        return new Date(stringObj[0], (parseInt(stringObj[1]) - 1), stringObj[2]);
    },
    /*19201101转换成1970-11-01 或者 19201101121212转换成1970-11-01 12:12:12*/
    dateToString(date) {
        if (date == 0) return "无";
        if (date.indexOf('-') > 0) return date;
        if (date.length == 14) {
            return date.substr(0, 4) + "-" + date.substr(4, 2) + "-" + date.substr(6, 2) + " " + date.substr(8, 2) + ":" + date.substr(10, 2) + ":" + date.substr(12, 2);
        } else {
            return date.substr(0, 4) + "-" + date.substr(4, 2) + "-" + date.substr(6, 2);
        }

    },
    /*19201101转换成1970.11.01 或者 19201101121212转换成1970.11.01 12:12:12*/
    datetimeToString2(date) {
        if (date == 0) return "无";
        if (date.indexOf('-') > 0) return date;
        return date.substr(0, 4) + "." + date.substr(4, 2) + "." + date.substr(6, 2) + " " + date.substr(8, 2) + ":" + date.substr(10, 2);
    },
    datetimeToDay(date,type) {
        if( type == 4){
            if (date) {
                return date.substr(0, 4) + "-" + date.substr(4, 2) + "-" + date.substr(6, 2)+ " " + date.substr(8, 2) + ":" + date.substr(10, 2)+ ":" + date.substr(12, 2);
            }
        }else{
            if (date) {
                return date.substr(0, 4) + "-" + date.substr(4, 2) + "-" + date.substr(6, 2);
            }
        }
        return date;
    },
    datetimeToString(date) {
        date = date + "";
        if (date == 0) return "无";
        if (date.indexOf('-') > 0) return date;
        return date.substr(0, 4) + "." + date.substr(4, 2) + "." + date.substr(6, 2);
    },
    /*192011转换成1970-11*/
    monthToString(date) {
        if (date == 0) return "无";
        if (date.indexOf('-') > 0) return date;
        return date.substr(0, 4) + "-" + date.substr(4, 2);
    },
    /*生成当前的年月*/
    produceDate() {
        let date = new Date();
        let year = date.getFullYear();
        let month = date.getMonth() + 1;
        return year + "年" + month + "月";
    },
    /*192011转换成1970年11月*/
    monthToString2(date) {
        if (date == 0) return "无";
        if (date.indexOf('-') > 0) return date;
        return date.substr(0, 4) + "年" + date.substr(4, 2) + "月";
    },
    /*191441转换成19:14:41*/
    timeToString(time) {
        if (time == 0) return time;
        if (time.indexOf(':') > 0) return time;
        return time.substr(0, 2) + ":" + time.substr(2, 2) + ":" + time.substr(4, 2);
    },
    /*
     *   功能:DateAdd功能.
     *   参数:interval,字符串表达式，表示要添加的时间间隔.
     *   参数:number,数值表达式，表示要添加的时间间隔的个数.
     *   参数:date,时间对象.
     *   返回:新的时间对象.
     *   var now = new Date();
     *   var newDate = DateAdd( "d", 5, now);
     *---------------  DateAdd(interval,number,date)   -----------------
     */
    dateAdd(interval, number, date) {
        switch (interval) {
            case "y":
                {
                    date.setFullYear(date.getFullYear() + number);
                    return date;
                    break;
                }
            case "q":
                {
                    date.setMonth(date.getMonth() + number * 3);
                    return date;
                    break;
                }
            case "M":
                {
                    date.setMonth(date.getMonth() + number);
                    return date;
                    break;
                }
            case "w":
                {
                    date.setDate(date.getDate() + number * 7);
                    return date;
                    break;
                }
            case "d":
                {
                    date.setDate(date.getDate() + number);
                    return date;
                    break;
                }
            case "h":
                {
                    date.setHours(date.getHours() + number);
                    return date;
                    break;
                }
            case "m":
                {
                    date.setMinutes(date.getMinutes() + number);
                    return date;
                    break;
                }
            case "s":
                {
                    date.setSeconds(date.getSeconds() + number);
                    return date;
                    break;
                }
            default:
                {
                    date.setDate(date.getDate() + number);
                    return date;
                    break;
                }
        }
    },
    formatDate6(date) {
        if (date.indexOf('-') < 0) {
            return date.substr(0, 4) + "-" + date.substr(4, 2) + "-" + date.substr(6, 2)
        } else {
            return date
        }
    },
    /**
     * 获取今年到今天
     * @returns 
     */
    getFullYearFirstDay(){
        let today = new Date();
        let year = today.getFullYear();
        let month = today.getMonth() + 1;  // 获取当前月份（注意要加1，月份从0开始）
        let date = today.getDate();  // 获取当前日期
        let todayTime=year + "-" +( month<10?`0${month}`:month )+ "-" + (date<10?`0${date}`:date)
        let firstDay =utils.dateFormat.format(new Date(year + "-01-01"),"yyyy-MM-dd")
        return [firstDay,todayTime]
    }
}
/**
 * [Rmb description 人民币]
 * @type {Object}
 */
utils.Rmb = {
    /**
     * [upDigit 数字金额大写转换(可以处理整数,小数,负数)]
     * @param  {[type]} n [description]
     * @return {[type]}   [description]
     */
    upDigit(n) {
        var fraction = ['角', '分'];
        var digit = ['零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'];
        var unit = [
            ['元', '万', '亿'],
            ['', '拾', '佰', '仟']
        ];
        var head = n < 0 ? '欠' : '';
        n = Math.abs(n);
        var s = '';
        for (var i = 0; i < fraction.length; i++) {
            s += (digit[Math.floor(n * 10 * Math.pow(10, i)) % 10] + fraction[i]).replace(/零./, '');
        }
        s = s || '整';
        n = Math.floor(n);
        for (var i = 0; i < unit[0].length && n > 0; i++) {
            var p = '';
            for (var j = 0; j < unit[1].length && n > 0; j++) {
                p = digit[n % 10] + unit[1][j] + p;
                n = Math.floor(n / 10);
            }
            s = p.replace(/(零.)*零$/, '').replace(/^$/, '零') + unit[0][i] + s;
        }
        return head + s.replace(/(零.)*零元/, '元').replace(/(零.)+/g, '零').replace(/^整$/, '零元整');
    },
    /**
     * [formatRMB 格式化]
     * @param  {[muber]} money  [传入需要格式化的钱（分为单位）]
     * @param  {[string]} format [thousands：转换千分位,tenthousand:转换万元,空保留小数]
     * @return {[string]}        [返回格式化后的钱]
     */
    formatRMB(money, format) {
        var RMB = null;
        if (isNaN(money)) {
            RMB = 0;
        } else {
            RMB = (Number(money)).toFixed(2); //分转换成元保留两位小数
            switch (format) {
                case "thousands":
                    RMB = (RMB + '').replace(/\d{1,3}(?=(\d{3})+(\.\d*)?$)/g, '$&,');
                    break;
                case "tenthousand":
                    RMB = parseInt(RMB) >= 10000 ? (parseInt(RMB) / 10000) + "万" : parseInt(RMB);
                    break;
                default:
                    RMB = RMB;
            }
        }
        return RMB
    },
    /**
     * [rmbYF 计算元与分]
     * @param  {[muber]} money [传入需要格式化的钱]
     * @return {[object]}   RMB     [存取值]
     */
    rmbYF(money) {
        var RMB = {};
        if (isNaN(money)) {
            RMB.YUAN = 0;
            RMB.FEN = "00";
        } else {
            var money = (Number(money) / 100).toFixed(2); //分转换成元保留两位小数
            RMB.YUAN = money.split(".")[0];
            RMB.FEN = money.split(".")[1];
        }
        return RMB
    },
     /**
     * [changeMoney 分转元]
     * @param  {[muber]} money [传入需要转换的钱 单位:分]
     * @return {[object]}   RMB     [转换后]
     */
    changeMoney(num) {
        var regexp = /(?:\.0*|(\.\d+?)0+)$/
        if (num > 1000000) {
            num = JSON.stringify(num).slice(0, JSON.stringify(num).length - 4) / 100
            return num + '万'
        } else {
            num = (num / 100).toFixed(2)
            num = num.replace(regexp, '$1')
            return num
        }
    },
    
     /**
     * [regYuanToFen 元转分]
     * @param  {[yuan]} yuan [传入需要转换的钱 单位:元]
     * @param  {[digit]} digit [转换倍数]
     * @return {[object]}   RMB     [转换后 单位:分]
     */
     regYuanToFen(yuan,digit){
        var m=0,
            s1=yuan.toString(),
            s2=digit.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)
    }
};

/**
 * [Input 输入替换]
 * @type {Object}
 */
utils.Input = {

    clearNoPriceMax6(obj) {

        obj.value = obj.value.replace(/^[0][0-9]/g, "") //清楚以0开始的非小数的字符
        obj.value = obj.value.replace(/[^\d.]/g, ""); //清除"数字"和"."以外的字符
        obj.value = obj.value.replace(/^\./g, ""); //验证第一个字符是数字而不是
        obj.value = obj.value.replace(/\.{2,}/g, "."); //只保留第一个. 清除多余的
        obj.value = obj.value.replace(".", "$#$").replace(/\./g, "").replace("$#$", ".");
        obj.value = obj.value.replace(/^(\d+)\.(\d\d).*$/, '$1.$2'); //保留两位小数

        var _reg = /^(.){0,6}$/;
        if (!_reg.test(obj.value)) {
            obj.value = obj.value.substr(0, 6);
            return;
        }
    },
    faceDecimal: function(str) {
        str = str.replace(/^[0][0-9]/g, "") //清楚以0开始的非小数的字符
        str = str.replace(/[^\d.]/g, ""); //清除"数字"和"."以外的字符
        str = str.replace(/^\./g, ""); //验证第一个字符是数字而不是
        str = str.replace(/^(\d\d\d\d)(\d+).*$/, '$1');
        str = str.replace(/\.{2,}/g, "."); //只保留第一个. 清除多余的
        str = str.replace(".", "$#$").replace(/\./g, "").replace("$#$", ".");
        str = str.replace(/^(\d{1,4})\.(\d\d).*$/, '$1.$2');
        return str;
    },
    clearNoPriceMax11(obj) {

        obj.value = obj.value.replace(/^[0][0-9]/g, "") //清楚以0开始的非小数的字符
        obj.value = obj.value.replace(/[^\d.]/g, ""); //清除"数字"和"."以外的字符
        obj.value = obj.value.replace(/^\./g, ""); //验证第一个字符是数字而不是
        obj.value = obj.value.replace(/\.{2,}/g, "."); //只保留第一个. 清除多余的
        obj.value = obj.value.replace(".", "$#$").replace(/\./g, "").replace("$#$", ".");
        obj.value = obj.value.replace(/^(\d+)\.(\d\d).*$/, '$1.$2'); //保留两位小数

        var _reg = /^(.){0,11}$/;
        if (!_reg.test(obj.value)) {
            obj.value = obj.value.substr(0, 11);
            return;
        }
    },
    clearNoPriceMax10(obj) {
        // console.log(obj.validity.badInput);
        // if(!obj.value){
        //     return;
        // }
        // console.log(obj.value);
        obj.value = obj.value.replace(/^[0][0-9]/g, "") //清楚以0开始的非小数的字符
        obj.value = obj.value.replace(/[^\d.]/g, ""); //清除"数字"和"."以外的字符
        obj.value = obj.value.replace(/^\./g, ""); //验证第一个字符是数字而不是
        obj.value = obj.value.replace(/\.{2,}/g, "."); //只保留第一个. 清除多余的
        obj.value = obj.value.replace(".", "$#$").replace(/\./g, "").replace("$#$", ".");
        obj.value = obj.value.replace(/^(\d+)\.(\d\d).*$/, '$1.$2'); //保留两位小数

        var _reg = /^(.){0,10}$/;
        if (!_reg.test(obj.value)) {
            obj.value = obj.value.substr(0, 10);
            return;
        }
    },
    /**
      * [clearNoPrice 整数可9位,小数点可6位]
     * @param  {[Object]} obj [输入对象]
     * @return {[type]}     [description]
     */
    clearNoPrice2(str) {
        str = str.replace(/^[0][0-9]/g, "") //清楚以0开始的非小数的字符
        str = str.replace(/[^\d.]/g, ""); //清除"数字"和"."以外的字符
        str = str.replace(/^\./g, ""); //验证第一个字符是数字而不是
        str = str.replace(/^(\d\d\d\d\d\d\d\d\d)(\d+).*$/, '$1');
        str = str.replace(/\.{2,}/g, "."); //只保留第一个. 清除多余的
        str = str.replace(".", "$#$").replace(/\./g, "").replace("$#$", ".");
        str = str.replace(/^(\d+)\.(\d\d\d\d\d\d).*$/, '$1.$2');//保留后6位小数
        return str;
    },
     
    /**
     * [clearNoPrice 小数点两位]
     * @param  {[Object]} obj [输入对象]
     * @return {[type]}     [description]
     */
    clearNoPrice(str) {
        str = str.replace(/^[0][0-9]/g, "") //清楚以0开始的非小数的字符
        str = str.replace(/[^\d.]/g, ""); //清除"数字"和"."以外的字符
        str = str.replace(/^\./g, ""); //验证第一个字符是数字而不是
        str = str.replace(/\.{2,}/g, "."); //只保留第一个. 清除多余的
        str = str.replace(".", "$#$").replace(/\./g, "").replace("$#$", ".");
        str = str.replace(/^(\d+)\.(\d\d).*$/, '$1.$2'); //保留两位小数 
        return str;
    },
    /**
     * [clearNoPrice 小数点后n位]
     * @param  {[Object]} obj [输入对象]
     * @return {[type]}     [description]
     */
    clearPrice(str, n,len) {
        str = str.replace(/^[0][0-9]/g, "") //清楚以0开始的非小数的字符
        str = str.replace(/[^\d.]/g, ""); //清除"数字"和"."以外的字符
        str = str.replace(/^\./g, ""); //验证第一个字符是数字而不是
        str = str.replace(/\.{2,}/g, "."); //只保留第一个. 清除多余的
        str = str.replace(".", "$#$").replace(/\./g, "").replace("$#$", ".");
        if (len && str.length==9  && str.substr(str.length - 1, 1)=='.') {
            str=str.substr(0, str.length - 1)
        }
        if (n == 1) {
            str = str.replace(/^(\d+)\.(\d).*$/, '$1.$2'); //保留一个位小数 
        } else if (n == 2) {
            str = str.replace(/^(\d+)\.(\d\d).*$/, '$1.$2'); //保留两位小数 
        } else if (n == 3) {
            str = str.replace(/^(\d+)\.(\d\d\d).*$/, '$1.$2'); //保留三位小数 
        }

        return str;
    },
    /**
     * [clearSpace description]
     * @param  {[type]} obj [description]
     * @return {[type]}     [description]
     */
    clearSpace(obj) {
        obj.value = obj.value.replace(/\s/g, "") //清楚空格
    },
    /**
     * [clearNoInt 非0整数]
     * @param  {[Object]} obj [输入对象]
     * @return {[type]}     [description]
     */
    clearNoInt(str) {
        str = str.replace(/^[0][0-9]/g, "") //清楚以0开始的非小数的字符
        str = str.replace(/\D/g, '');
        return str;
    },
    /**
     * [clearNoChinese 只能输入英文字母和数字,不能输入中文]
     * @param  {[Object]} obj [输入对象]
     * @return {[type]}     [description]
     */
    clearNoChinese(obj) {
        obj.value = obj.value.replace(/[^\w\.\/]/ig, '')
    },
    /**
     * [clearNoInt 整数]
     * @param  {[Object]} obj [输入对象]
     * @return {[type]}     [description]
     */
    clearNoInteger(str,num) {
        str = str.replace(/\D/g, '');
        if (num && str.length>6) {
            str=str.substring(0, 6);
        }
        return str;
    },
    /**
     * [clearNoInt 整数]
     * @param  {[Object]} obj [输入对象]
     * @return {[type]}     [description]
     */
    clearNoInteger2(str) {
        str = str.replace(/[0]/g, '');
        str = str.replace(/\D/g, '');
        return str;
    },
    /**
     * [clearNoInt 只能输入字母和汉字]
     */
    clearNoLetterChinese(str) {
        str = str.replace(/[^\a-\z\A-\Z\u4E00-\u9FA5]/g, '');
        return str;
    },
    /**
     * [clearNoInt 只能输入字母和汉字和·]
     */
    clearNoLetterChineseDot(str) {
        str = str.replace(/[^\a-\z\A-\Z\u4E00-\u9FA5\·]/g, '');
        return str;
    },
    /**
     * [clearNoInt 只能输入字母,汉字和数字]
     */
    clearNoLetterChineseNumber(str) {
        str = str.replace(/[^\a-\z\A-\Z0-9\u4E00-\u9FA5]/g, '');
        return str;
    },
    /**
     * [clearNoInt 只能输入字母和数字]
     */
    clearNOEN(str) {
        str = str.replace(/[^\a-\z\A-\Z0-9]/g, '');
        return str;
    },
    // /**
    //  * [clearNoInt 只能输入字母,汉字和数字]
    //  */
    // clearNoLetterChineseNumber(obj) {
    //     obj.value = obj.value.replace(/[^\a-\z\A-\Z0-9\u4E00-\u9FA5]/g, '')
    // },
    /**
     * [clearNoInt 不能输入汉字]
     */
    clearChinese(obj) {
        obj = obj.replace(/[\u4E00-\u9FA5]/g, '')
        return obj;
    },
    /**
     * [clearDiscount 只能输入0.1~9.9]
     */
    clearDiscount(str) {
        //折扣：只能输入0.1~9.9
        str = str.replace(/^[0][0-9]/g, "") //清楚以0开始的非小数的字符
        str = str.replace(/[^\d.]/g, ""); //清除"数字"和"."以外的字符
        str = str.replace(/^\./g, ""); //验证第一个字符是数字而不是
        str = str.replace(/^(\d\d)(\d+).*$/, '$1');
        str = str.replace(/\.{1,}/g, "."); //只保留第一个. 清除多余的
        str = str.replace(".", "$#$").replace(/\./g, "").replace("$#$", ".");
        str = str.replace(/^(\d{1,2})\.(\d\d).*$/, '$1.$2');
        if (parseFloat(str) > 10 && str.indexOf(".") == -1) {
            str = str.substring(0, 1);
        } else if (parseFloat(str) > 10 && str.indexOf(".") != -1) {
            str = str.substring(0, 3);
        }
        return str;
    },
    /**
     * [clearNoDiscount 只能输入0.1~99.999]
     */
    clearNoDiscount2(str) {
        //折扣：只能输入0.1~99.999
        str = str.replace(/^[0][0-9]/g, "") //清楚以0开始的非小数的字符
        str = str.replace(/[^\d.]/g, ""); //清除"数字"和"."以外的字符
        str = str.replace(/^\./g, ""); //验证第一个字符是数字而不是
        str = str.replace(/^(\d\d)(\d+).*$/, '$1');
        str = str.replace(/\.{1,}/g, "."); //只保留第一个. 清除多余的
        str = str.replace(".", "$#$").replace(/\./g, "").replace("$#$", ".");
        str = str.replace(/^(\d{1,2})\.(\d{3}).*$/, '$1.$2');
        if (parseFloat(str) >= 100 && str.indexOf(".") == -1) {
            str = str.substring(0, 2);
        } else if (parseFloat(str) >= 100 && str.indexOf(".") != -1) {
            str = str.substring(0, 4);
        } else if (str == '0.000') {
            str = str.substring(0, 3);
        }
        return str;
    },
      /**
    * [clearNoDiscount 只能输入0.1~9.9]
    */
   clearNoDiscount(str) {
    //折扣：只能输入0.1~9.9
    str = str.replace(/^[0][0-9]/g, "") //清楚以0开始的非小数的字符
    str = str.replace(/[^\d.]/g, ""); //清除"数字"和"."以外的字符
    str = str.replace(/^\./g, ""); //验证第一个字符是数字而不是
    str = str.replace(/^(\d\d)(\d+).*$/, '$1');
    str = str.replace(/\.{1,}/g, "."); //只保留第一个. 清除多余的
    str = str.replace(".", "$#$").replace(/\./g, "").replace("$#$", ".");
    str = str.replace(/^(\d{1,2})\.(\d{2}).*$/, '$1.$2');
    if (parseFloat(str) >= 1 && str.indexOf(".") == -1) {
        str = str.substring(0, 1);
    } else if (parseFloat(str) >= 1 && str.indexOf(".") != -1) {
        str = str.substring(0, 4);
    } else if (str == '0.0') {
        str = str.substring(0, 2);
    }
    return str;
    },
    /**
    * [clearNoDiscount 只能输入0~0.99]
    */
   clearNoDiscount3(str) {
        console.log(str);
       str = str.replace(/^[0][0-9]/g, "") //清楚以0开始的非小数的字符
       str = str.replace(/^[1-9]/g, ""); //清除1-9开始的非小数的字符
       str = str.replace(/[^\d.]/g, ""); //清除"数字"和"."以外的字符
       str = str.replace(/^\./g, ""); //验证第一个字符是数字而不是
       str = str.replace(/^(\d\d)(\d+).*$/, '$1');
       str = str.replace(/\.{1,}/g, "."); //只保留第一个. 清除多余的
       str = str.replace(".", "$#$").replace(/\./g, "").replace("$#$", ".");
       str = str.replace(/^(\d{1,2})\.(\d{2}).*$/, '$1.$2');
       if (parseFloat(str) >= 1 && str.indexOf(".") == -1) {
           str = str.substring(0, 1);
       } else if (parseFloat(str) >= 1 && str.indexOf(".") != -1) {
           str = str.substring(0, 4);
       } else if (str == '0.00') {
           str = str.substring(0, 3);
       }
       return str;
   },
    clearAmount: function(str) {
        str = str.replace(/^[0][0-9]/g, "") //清楚以0开始的非小数的字符
        str = str.replace(/[^\d.]/g, ""); //清除"数字"和"."以外的字符
        str = str.replace(/^\./g, ""); //验证第一个字符是数字而不是
        str = str.replace(/^(\d\d\d\d\d\d)(\d+).*$/, '$1');
        str = str.replace(/\.{2,}/g, "."); //只保留第一个. 清除多余的
        str = str.replace(".", "$#$").replace(/\./g, "").replace("$#$", ".");
        str = str.replace(/^(\d{1,6})\.(\d\d).*$/, '$1.$2');
        return str;
    },
    /**
     * 清除非数字 9整数 6位小数
     * @param {*} str 
     * @returns 
     */
    clearNotNum: function(str) {
        str = str.replace(/^[0][0-9]/g, "") //清楚以0开始的非小数的字符
        str = str.replace(/[^\d.]/g, ""); //清除"数字"和"."以外的字符
        str = str.replace(/^\./g, ""); //验证第一个字符是数字而不是
        str = str.replace(/^(\d{9,})(\d+).*$/, '$1');   //保留9位整数
        str = str.replace(".", "$#$").replace(/\./g, "").replace("$#$", ".");//只保留第一个. 清除多余的
        str = str.replace(/^(\d+)\.(\d{1,6}).*$/, '$1.$2');  //9整数 6位小数
        return str;
    },
    /**
    * [clearNoPrice 整数前面最多6位,小数点两位]
    * @param  {[Object]} obj [输入对象]
    * @return {[type]}     [description]
    */
   clearFourAmount: function(str) {
       str = str.replace(/^[0][0-9]/g, "") //清楚以0开始的非小数的字符
       str = str.replace(/[^\d.]/g, ""); //清除"数字"和"."以外的字符
       str = str.replace(/^\./g, ""); //验证第一个字符是数字而不是
       str = str.replace(/^(\d\d\d\d\d\d)(\d+).*$/, '$1');
       str = str.replace(/\.{2,}/g, "."); //只保留第一个. 清除多余的
       str = str.replace(".", "$#$").replace(/\./g, "").replace("$#$", ".");
       str = str.replace(/^(\d{1,6})\.(\d\d).*$/, '$1.$2');
       return str;
   },
    /**
     * [clearMatchIdNo 数字和Xx]
     * @param  {[Object]} obj [输入对象]
     * @return {[type]}     [description]
     */
    clearMatchIdNo(str) {
        str = str.replace(/[^0-9xX]/g, '');
        return str;
    },
    /*
        输入包含中文的字符串，进行长度为 maxlength 的限制
    */
    clearTextMaxlength({
        str,
        maxLength
    }){
        if(!str || !maxLength) {
            console.log("clearTextMaxlength， 数据有误，停止执行")
            return
        }
        let split = str.split("");
        let res = str;
        const map = split.map((s, i) => (str.charCodeAt(i) >= 0 && str.charCodeAt(i) <= 128) ? 1 : 2);
        // 这里设置想要限制的长度 
        let n = 0;
        const charLength = map.length > 0 && map.reduce((accumulator, currentValue, index) => {
            if (accumulator === maxLength || accumulator === maxLength - 1) {
                n = index;
            }
            return accumulator + currentValue;
        });
        if (charLength > maxLength) {
            res = split.slice(0, n).join('');
        }
        console.log("res ==========", res)
        return res;
    }
}
/**
 * [valid 验证类]
 * @type {Object}
 */
utils.Valid = {
    /**
     *  经纬度
     * @param {*} val 
     * @returns 
     */
    isLongitude(val) { 
        return /^(\-|\+)?(((\d|[1-9]\d|1[0-7]\d|0{1,3})\.\d{0,6})|(\d|[1-9]\d|1[0-7]\d|0{1,3})|180\.0{0,6}|180)$/.test(val);
    },
    /**
     * 经纬度
     * @param {*} val 
     * @returns 
     */
    isLatitude(val) { 
        return /^(\-|\+)?([0-8]?\d{1}\.\d{0,6}|90\.0{0,6}|[0-8]?\d{1}|90)$/.test(val);
    },
    /**
     * [isNum 是否位数字]
     * @param  {[string]}  num [description]
     * @return {Boolean}     [description]
     */
    isNum(num) { //# 是否为数
        return !isNaN(num);
    },
    /**
     * [isEmail description]
     * @param  {[type]}  mail [description]
     * @return {Boolean}      [description]
     */
    isEmail(mail) { //# 是否为 邮箱
        return /^([a-z0-9]+[_\-\.]?)*[a-z0-9]+@([a-z0-9]+[_\-\.]?)*[a-z0-9]+\.[a-z]{2,5}$/i.test(mail);
    },
    /**
     * [isFloat 浮点数]
     * @param  {[type]}  num [description]
     * @return {Boolean}     [description]
     */
    isFloat(num) { //# 是否为 浮点数
        return /^(([1-9]\d*)|(\d+\.\d+)|0)$/.test(num);
    },
    /**
     * [isInt 正整数]
     * @param  {[type]}  num [description]
     * @return {Boolean}     [description]
     */
    isInt(num) { //# 是否为 正整数
        return /^[1-9]\d*$/.test(num);
    },
    /**
     * [isLicitDeciaml 是否是合法的数字]
     * @param  {[type]}  num [description]
     * @return {Boolean}     [description]
     */
    isLicitDeciaml(amount) {
        if (amount > 0 && /^\d+(\.\d{1,2})?$/.test(amount)) {
            return true;
        } else {
            return false;
        }
    },
    /**
     * [isChinese 是否全为汉字]
     * @param  {[type]}  str [description]
     * @return {Boolean}     [description]
     */
    isChinese(str) { //# 是否全为 汉字
        return /^([\u4E00-\u9FA5]|[\uFE30-\uFFA0])+$/gi.test(str);
    },
    /**
     * [isChinese 是含有汉字]
     * @param  {[type]}  str [description]
     * @return {Boolean}     [description]
     */
    isIncludeChinese(str) { //# 是含有汉字
        return /([\u4e00-\u9fa5]|[\ufe30-\uffa0])/.test(str);
    },
    /**
     * [isChinese 是否金额]
     * @param  {[type]}  str [description]
     * @return {Boolean}     [description]
     */
    isAmount(str) {
        if (str == "0" || str == "0." || str == "0.0" || str == "0.00") {
            return false;
        }
        return /^([1-9][\d]{0,}|0)(\.[\d]{1,2})?$/gi.test(str);
    },
    /**
     * [isChinese 是否金额]
     * @param  {[type]}  str [description]
     * @return {Boolean}     [description]
     */
    isAmount3(str) {
        if (str == "0." || str == "0.0" || str == "0.00") {
            return false;
        }
        return /^([1-9][\d]{0,}|0)(\.[\d]{1,3})?$/gi.test(str);
    },
    
    /**
     * [isChinese 是否金额]
     * @param  {[type]}  str [//按% 1位小数点; ]
     * @return {Boolean}     [description]
     */
    isAmount2(str) {
        if (str == "0" || str == "0." || str == "0.0" || str == "0.00") {
            return false;
        }
        return /^([1-9][\d]{0,}|0)(\.[\d]{0,1})?$/.test(str);
    },
    isTimeSpinner(start, end) {
        var t1 = parseInt(start.replace(/:/g, ""));
        var t2 = parseInt(end.replace(/:/g, ""));
        return t1 >= t2;
    },
    isLateDay(start, end) {
        //晚一天比较字符串
        start = utils.dateFormat.dateAdd("d", 1, new Date(start));
        return start <= new Date(end);
    },
    /**
     * [isChinese 是否为中文名称]
     * @param  {[type]}  str [description]
     * @return {Boolean}     [description]
     */
    isChineseName(str) {
        return /^([\u4E00-\u9FA5]|[\uFE30-\uFFA0]{2,5})+([·|•]([\u4E00-\u9FA5]|[\uFE30-\uFFA0]){2,5})*$/gi.test(str);
    },
    /**
     * [isBankAccount 是否为银行账号]
     * @param  {[type]}  str [description]
     * @return {Boolean}     [description]
     */
    isBankAccount(str) {
        return /^\d{8,32}$/gi.test(str);
    },
    /**
     * [isCEN  是否为中文数字英文符号]
     * @param  {[type]}  str [description]
     * @return {Boolean}     [description]
     */
    isCENP(str) {
        return /^[\，\。\！\？\：\,\.\!\?\:\·\¥\%\u4E00-\u9FA5A-Za-z0-9_]+$/gi.test(str);
    },
    /**
     * [isCEN  是否为中文数字英文]
     * @param  {[type]}  str [description]
     * @return {Boolean}     [description]
     */
    isCEN(str) {
        return /^[\u4E00-\u9FA5A-Za-z0-9_]+$/gi.test(str);
    },
    /**
     * [isCEN  是否为数字英文]
     * @param  {[type]}  str [description]
     * @return {Boolean}     [description]
     */
    isEN(str) {
        return /^[A-Za-z0-9]+$/gi.test(str);
    },
    /**
     * [isCEN  是否为中文英文]
     * @param  {[type]}  str [description]
     * @return {Boolean}     [description]
     */
    isCE(str) {
        return /^[\u4E00-\u9FA5A-Za-z_]+$/gi.test(str);
    },
       //
    /**
     * [isIdCard 身份证验证]
     * @param {[type]} gets [description]  string 类型传递
     * @return {Boolean}     [description]
     */
     isIdCard(gets) {
        if (typeof gets == 'number') {
            gets=gets.toString();
        }
        var Wi = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2, 1]; // 加权因子;
        var ValideCode = [1, 0, 10, 9, 8, 7, 6, 5, 4, 3, 2]; // 身份证验证位值，10代表X;
        if (gets.length == 15) {
            return isValidityBrithBy15IdCard(gets);
        } else if (gets.length == 18) {
            var a_idCard = gets.split(""); // 得到身份证数组
            if (isValidityBrithBy18IdCard(gets) && isTrueValidateCodeBy18IdCard(a_idCard)) {
                return true;
            }
            return false;
        }
        return false;

        function isTrueValidateCodeBy18IdCard(a_idCard) {
            var sum = 0; // 声明加权求和变量
            if (a_idCard[17].toLowerCase() == 'x') {
                a_idCard[17] = 10; // 将最后位为x的验证码替换为10方便后续操作
            }
            for (var i = 0; i < 17; i++) {
                sum += Wi[i] * a_idCard[i]; // 加权求和
            }
            var valCodePosition = sum % 11; // 得到验证码所位置
            if (a_idCard[17] == ValideCode[valCodePosition]) {
                return true;
            }
            return false;
        }

        function isValidityBrithBy18IdCard(idCard18) {
            var year = idCard18.substring(6, 10);
            var month = idCard18.substring(10, 12);
            var day = idCard18.substring(12, 14);
            var temp_date = new Date(year, parseFloat(month) - 1, parseFloat(day));
            // 这里用getFullYear()获取年份，避免千年虫问题
            if (temp_date.getFullYear() != parseFloat(year) || temp_date.getMonth() != parseFloat(month) - 1 || temp_date.getDate() != parseFloat(day)) {
                return false;
            }
            return true;
        }

        function isValidityBrithBy15IdCard(idCard15) {
            var year = idCard15.substring(6, 8);
            var month = idCard15.substring(8, 10);
            var day = idCard15.substring(10, 12);
            var temp_date = new Date(year, parseFloat(month) - 1, parseFloat(day));
            // 对于老身份证中的你年龄则不需考虑千年虫问题而使用getYear()方法
            if (temp_date.getYear() != parseFloat(year) || temp_date.getMonth() != parseFloat(month) - 1 || temp_date.getDate() != parseFloat(day)) {
                return false;
            }
            return true;
        }
    },
    /**
     * [isMobile  手机验证]
     * @param  {[type]} gets [description]
     * @return {[type]}      [description]
     */
    isMobile(gets) {
        return /^1[3-9][0-9]{9}$/.test(gets);
    },
    
    /**
     * [httpUrl  网址]
     * @param  {[type]} gets [description]
     * @return {[type]}      [description]
     */
     httpUrl(gets) {
        return /^(?:http(s)?:\/\/)?[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~:/?#[\]@!\$&'\*\+,;=.]+$/.test(gets);
    },
    /**
     * [isTel 验证座机]
     * @param  {[type]}  tel [description]
     * @return {Boolean}     [description]
     */
    isTel(tel) { //# 是否为 验证座机
        return /^\d{3,4}-\d{7,8}(-\d{1,6})?$/.test(tel);
    },
    //   /**
    //  * [isMobile  手机验证]
    //  * @param  {[type]} gets [description]
    //  * @return {[type]}      [description]
    //  */
    // isMobile(gets) {
    //     return /^(13[0-9]|14[01456879]|15[0-35-9]|16[2567]|17[0-8]|18[0-9]|19[0-35-9])\d{8}$/.test(gets);
    // },
    /**
     * [isCustomerTel 验证客服电话]
     * @param  {[type]}  tel [description]
     * @return {Boolean}     [description]
     */
    isCustomerTel(tel) { //# 是否为 客服电话
        return /^[0-9\-]+$/.test(tel);
    },
    /**
     * [merchantCredentialNumber  商户资质证件类型（营业执照编码;统一社会信用代码;组织机构代码证;经营许可证;税务登记证;其他）
     * @param  {[val]}  val [description] 传递值
     * @return {type}   类型  [description] 营业执照编码;统一社会信用代码;组织机构代码证;经营许可证;税务登记证;其他
     */
    isCredentialNumber(val,type) { 
        if (type=='营业执照编码') {//营业执照15位数字 或18位(由18数字或大写英文字母（不使用I、O、Z、S、V）组成，（同 统一社会信用代码)
           
            //注:标准的18位营业执照应为()/^([0-9A-HJ-NPQRTUWXY]{2}\d{6}[0-9A-HJ-NPQRTUWXY]{10}|[1-9]\d{14})$/
            //此地此需求为产品要求(?![0-9]+$)(?![A-HJ-NPQRTUWXY]+$)
            return /^([0-9A-HJ-NPQRTUWXY]{18}|[0-9]{15})$/.test(val);

        }else  if(type=='统一社会信用代码'){
            //统一社会信用代码为由18位数字或大写英文字母（不使用I、O、Z、S、V）组成 => 20240416弃用
            // return /^([0-9A-HJ-NPQRTUWXY]{18})$/.test(val);
            return /^(([0-9A-Za-z]{15})|([0-9A-Za-z]{18})|([0-9A-Za-z]{20}))$/.test(val);

        }else  if(type=='组织机构代码证'){//组织机构代码证为9位长度 数字与大写英文字母

            return /^(([0-9A-Z-]{9})|([0-9A-Z-]{10}))$/.test(val);

        }else  if(type=='经营许可证'){//经营许可证为16位、以JY标识后加14位数字

            return /^([JY]{2}\d{14})$/.test(val);

        }else  if(type=='税务登记证'){//税务登记证为15位数字和大写的英文字母

            return /^([0-9A-Z]{15})$/.test(val);
        }else{  //其他
            return true;
        }
    },

    /**
     * [isDiscount 验证折扣金额]
     * @param  {[type]}  text [description]
     * @return {Boolean}     [description]
     */
    isDiscount(price) { //# 是否为 折扣金额
        if (price == "0" || price == "0." || price == "0.0" || price == "0.00" || /^[1-9]\d?\.$/.test(price)) {
            return false;
        }
        if (parseFloat(price) > 10.00) {
            return false;
        }
        return true;
    },
    /**
     * [isPrice校验价格和金额的方法]
     * @param  {[type]}  price [description]
     * @return {Boolean}       [description]
     */
    isPrice(price) {
        if (price == "0" || price == "0." || price == "0.0" || price == "0.00") {
            price = "0";
            return true;
        } else {
            var index = price.indexOf("0");
            var length = price.length;
            if (index == 0 && length > 1) { /*0开头的数字串*/
                var reg = /^[0]{1}[.]{1}[0-9]{1,2}$/;
                if (!reg.test(price)) {
                    return false;
                } else {
                    return true;
                }
            } else { /*非0开头的数字*/
                var reg = /^[1-9]{1}[0-9]{0,10}[.]{0,1}[0-9]{0,2}$/;
                if (!reg.test(price)) {
                    return false;
                } else {
                    return true;
                }
            }
            return false;
        }
    },
    /**
     * [isPlateNumber 车牌号验证]
     * @param  {[type]} gets [description]
     * @return {[Boolean]}      [description]
     */
    isPlateNumber(gets) {
        var re = /^[\u4e00-\u9fa5]{1}[a-zA-Z]{1}[a-zA-Z_0-9]{5}$/; //车牌号
        if (gets.search(re) == -1) {
            return false;
        } else {
            return true;
        }
    },
    /**
     * [isName 姓名验证]
     * @param  {[type]} gets [description]
     * @return {[Boolean]}      [description]
     */
    isName(gets) {
        return /[\u4E00-\u9FA5]{2,5}(?:·[\u4E00-\u9FA5]{2,5})*/.test(gets);
    },
    /**
     * [passCheck 密码验证]
     * @param  {[type]} gets [description]
     * @return {[Boolean]}      [description]
     */
    passCheck(gets) {
        var number = 0,
            letter = 0,
            other = 0,
            regs = /^([a-zA-Z0-9!\$&'\(\)\*\+,.;:}{\/\=-@%^#~]){8,20}$/;
        for (var i = gets.length - 1; i >= 0; i--) {
            var charater = gets.charCodeAt(i);
            if (charater >= 48 && charater <= 57) {
                //统计数字
                number++;
            } else if ((charater >= 65 && charater <= 90) || (charater >= 97 && charater <= 122)) {
                //统计字母
                letter++;
            } else {
                other++;
            }
        }
        console.log(11)
        if (number >= 1 && letter >= 1 && regs.test(gets)) {
            //密码格式为8-20位数字和字母组合
            return true;
        }
        return false;
        //return /^\d[a-zA-Z][!\$&'\(\)\*\+,.;:}{\/\=-@#~]$/; 
    },
    /**
     * [contrastDate 时间对比]
     * @param  {["YYYY--MM-DD"]} a [第一个日期]
     * @param  {["YYYY--MM-DD"]} b [第二个日期]
     * @param  {[int]} number [间隔日期天]
     * @return {[Boolean]}   [如果第一个大于第二 false  反之 true]
     */
    contrastDate(a, b, number) {
        var num = number ? number : 0;
        var arr = a.split("-");
        var startTime = new Date(arr[0], arr[1] - 1, arr[2]);
        var startTimes = startTime.getTime();
        var arrs = b.split("-");
        var endTime = new Date(arrs[0], arrs[1] - 1, arrs[2]);
        var endTimes = endTime.getTime();
        if (num != 0) {
            var datenum = num * 24 * 60 * 60 * 1000;
            if (startTimes + datenum >= endTimes) {
                return true;
            } else {
                return false;
            }
        } else {
            if (startTimes <= endTimes) {
                return true;
            } else {
                return false;
            }
        }
    },
    /**
     * [contrastDate 时间对比大小,起始时间不得小于结束时间]
     * @param  {["YYYY--MM-DD"]} a [第一个日期]
     * @param  {["YYYY--MM-DD"]} b [第二个日期]
     * @return {[Boolean]}   [如果第一个大于第二 false  反之 true]
     */
    contrastDateSize(a, b) {
        var arr = a.split("-");
        var startTime = new Date(arr[0], arr[1] - 1, arr[2]);
        var startTimes = startTime.getTime();
        var arrs = b.split("-");
        var endTime = new Date(arrs[0], arrs[1] - 1, arrs[2]);
        var endTimes = endTime.getTime();
        if (startTimes <= endTimes) {
            return true;
        } else {
            return false;
        }
    },
};
/**
 * [Desensitize 脱敏类]
 * @type {Object}
 */
utils.Desensitize = {
    /**
     * [手机号]
     * @param  {[string]}  val [description]
     * @return {Boolean}     [description]
     */
    desensitizationPhone(val) { 
        if (val) {
            return val.replace(/^(.{3})(?:\d+)(.{4})$/, "$1 **** $2");
        }
        return val;
    },
   
    /**
     * [desensitizationID 身份证]
     * @param  {[type]} gets [description]
     * @return {[Boolean]}      [description]
     */
     desensitizationID(val) { 
        if (val) {
            return  val.replace(/^(.{6})(?:\d+)(.{2})$/, "$1 **** $2"); 
        }
        return val;
    },
    /**
     * [desensitizationCard 卡号脱敏]
     * @param  {[type]} gets [description]
     * @return {[Boolean]}      [description]
     */
     desensitizationCard(val,len) { 
        if (val) {
            if (len) {  
                let valStr=val.toString()
                return  '*'+valStr.substring(valStr.length-4,valStr.length) //只留后四位
            }else{
                return  val.replace(/^(.{4})(?:\d+)(.{4})$/, "$1 *********** $2"); 
            }
        }
        return val;
    },
    /**
     * [姓名]
     * @param  {[string]}  val [description]
     * @return {Boolean}     [description]
     */
     desensitizationName(val) { 
        if (val) {
            return '*'+val.substring(val.length-1,val.length) //截取name 字符串截取最后一个字符，
        }
        return val;
    },
}
// deepCopy
utils.deepCopyArray = function(data) {
    let o = [];
    for (let i = 0; i < data.length; i++) {
        o.push(data[i]);
    }
    return o;
}

// deepCopy
utils.deepCopyArray2 = function(data) {
    let o = [];
    for (let i = 0; i < data.length; i++) {
        let newobj = {};
        for (var j in data[i]) {
            newobj[j] = data[i][j];
        }
        o.push(newobj);
    }
    return o;
}

// deepCopy
utils.deepCopyArray3 = function(odata) {
    var o = {};
    for (var key in odata) {
        o[key] = [];
        for (let m = 0; m < odata[key].length; m++) {
            let item = {};
            for (let n in odata[key][m]) {
                item[n] = odata[key][m][n];
            }
            o[key].push(item);
        }
    }
    return o;
}

// deepCopyParam-过滤没有值的参数
utils.deepCopyParam = function(data) {
    let o = [];
    for (let i = 0; i < data.length; i++) {
        data[i] && o.push(data[i]);
    }
    return o;
}

// shallowCopyObject
utils.shallowCopyObject = function(option) {
    let o = {};
    for (var i in option) {
        o[i] = option[i];
    }
    return o;
}

// shallowCopyObject
utils.shallowCopyObject2 = function(data, option) {
    let o = {};
    for (var i in data) {
        o[i] = option[i];
    }
    return o;
}


// deepCopy
utils.deepCopyObject = function(option, data) {
    for (var i in option) {
        if (data[i]) {
            if (i == 'areaId') {
                option[i] = data['publicAreaId'];
            } else if (i == 'cityId') {
                option[i] = data['publicCityId'];
            } else {
                option[i] = data[i];
            }
        }
    }
    return option;
}
// deepCopy-简单赋值对象
utils.simpleCopyObject = function(data) {
    var option = {};
    for (var i in data) {
        if (i == 'sellerInvoiceClientList' || i == 'sellerTaxItemsList') {
            option[i] = [];
            for (let m = 0; m < data[i].length; m++) {
                let item = {};
                for (let n in data[i][m]) {
                    item[n] = data[i][m][n];
                }
                option[i].push(item);
            }
        } else {
            option[i] = data[i];
        }
    }
    return option;
}
// 增值业务判断
utils.addServices = function(datas) {
    var result = {
            errors: "",
            msg: "",
        },
        todayTime = "";

    if (datas.state == 0) {
        todayTime = utils.dateFormat.format(new Date(), "hh:mm");
        if (datas.specialStartTime && datas.specialEndTime) {
            if (datas.specialStartTime <= todayTime && todayTime <= datas.specialEndTime) {
                //通过
                result.errors = 'VAS000';
                result.msg = "通过";

            } else {
                //不在服务时间
                result.errors = 'VAS002';
                result.msg = "抱歉，服务时间为" + datas.specialStartTime + "—" + datas.specialEndTime;
            }
        } else {
            //通过
            result.errors = 'VAS000';
            result.msg = "通过";
        }
    } else if (datas.state == 1) {
        //维护中
        result.errors = 'VAS003';
        result.msg = '系统维护中，给您带来不便，请谅解';
    }
    return result;
}
// 加减乘除的四个接口
utils.floatObj = {
    add: function(a, b, digits) {
        return operation(a, b, digits, 'add')
    },
    subtract: function(a, b, digits) {
        return operation(a, b, digits, 'subtract')
    },
    multiply: function(a, b, digits) {
        return operation(a, b, digits, 'multiply')
    },
    divide: function(a, b, digits) {
        return operation(a, b, digits, 'divide')
    }
}


//计算距离(进行经纬度转换为距离的计算)，参数分别为第一点的纬度，经度；第二点的纬度，经度
utils.getDistance = function(lat1, lng1, lat2, lng2) {
    function Rad(d) {
        return d * Math.PI / 180.0; //经纬度转换成三角函数中度分表形式。
    }
    var radLat1 = Rad(lat1);
    var radLat2 = Rad(lat2);
    var a = radLat1 - radLat2;
    var b = Rad(lng1) - Rad(lng2);
    var s = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a / 2), 2) +
        Math.cos(radLat1) * Math.cos(radLat2) * Math.pow(Math.sin(b / 2), 2)));
    s = s * 6378.137; // EARTH_RADIUS;
    //s = Math.round(s * 1000); //输出为米
    // s = Math.round(s * 1000) / 1000; //输出为千米
    s = s * 1000;
    return s;
}

//组合省市区的数据
utils.combineAddress = function(odata) {
    let provinceList = [],
        cityObj = {},
        areaObj = {};

    for (let i = 0; i < odata.length; i++) {
        let nCity = [];
        provinceList.push({ "text": odata[i].name, "value": odata[i].code });
        if (odata[i].areaList) {
            for (let m = 0; m < odata[i].areaList.length; m++) {
                let nArea = [];
                nCity.push({ "text": odata[i].areaList[m].name, "value": odata[i].areaList[m].code });
                if (odata[i].areaList[m].areaList) {
                    for (let n = 0; n < odata[i].areaList[m].areaList.length; n++) {
                        nArea.push({ "text": odata[i].areaList[m].areaList[n].name, "value": odata[i].areaList[m].areaList[n].code });
                    }
                }
                areaObj[odata[i].areaList[m].code] = nArea;
            }
        }
        cityObj[odata[i].code] = nCity;
    }
    return { "province": provinceList, "city": cityObj, "district": areaObj, };
}

//类别数据组装
utils.categoryCombite = function(odata) {
    let newList = [];
    if(odata && odata.length){
        for(let i = 0,len = odata.length;i<len;i++){
            newList.push({'value':odata[i].cateName,'id':odata[i].cateId});
        }
    }
    return  newList;
}

utils.fileType = function(fileUrl){ // 通过返回的地址路径判断文件类型
    if(!fileUrl){ // 无地址
        console.log("utils.fileType ================= 无地址");
        return;
    }
    let fileType = "";
    let regImg = /\.(png|jpe?g|gif)(\?.*)?$/;
    let regDoc = /\.(docx?)(\?.*)?$/;
    let regPdf = /\.pdf(\?.*)?$/;
    if(regImg.test(fileUrl)){
        fileType = "image"
    }
    if(regDoc.test(fileUrl)){
        fileType = "word"
    }
    if(regPdf.test(fileUrl)){
        fileType = "pdf"
    }
    return fileType;
}

utils.pxToRem =function({value, basicFontSize = 100}) { // 项目里 1rem = 100px,
    return value/window.devicePixelRatio/basicFontSize
}

// 将版本号转成整数位用于判断版本号大小；
// 先替换去除.在转成8位字符串，不够位数的时候在字符串前面补0，parserint去除前面的0的整数
utils.versionToEightNum = function(vers) {
    console.log("vers ===========", vers);
    let lent = 8;
    let versNum = parseInt(vers.replace(/\./g, ""));
    return parseInt((Array(lent).join("0") + versNum).slice(-lent));
}


//合并对象
utils.mergeObject = function (...options) {
    let obj={}
    for (let i = 0; i < options.length; i++) {
        let sObj = options[i]
        for (let key in sObj) {
            if(obj[key]){
                console.log(sObj)
                console.log(key)
               throw("对象名称相同的了")
            }else{
                obj[key]=sObj[key]
            }

        }
    }
    return obj
}

//合并数组
utils.mergeArray = function (...options) {
    let newArray = [];
    for (let i = 0; i < options.length; i++) {
        let sArray = options[i]
        for (let j = 0; j < sArray.length; j++) {
            newArray.push(sArray[j]);
        }
    }
    return newArray
}
//合并固定参数
utils.mergeFixedParams = (targetVal, newObj) => {
    if (newObj) {
        let c = {}
        Object.keys(targetVal).forEach(key => {
            c[key] = newObj[key]
        })
        return c;
    }
    return targetVal;
}

export default utils