【js】常见公共方法封装

1.加密 解密 Aes

import { Modal } from 'antd';

import * as CryptoJS from 'crypto-js'; // aes加密

import { createHashHistory } from 'history'; // 如果是hash路由

const history = createHashHistory();

let dayFormat = 'YYYY-MM-DD';

let timeFormat = 'HH:mm:ss';

let dateFormat = 'YYYY-MM-DD HH:mm:ss';

let hourFormat = 'HH:mm';

let Aes = {
    /*AES加密*/
    Encrypt(data) {
        let dataStr = data;
        let AuthTokenKey = x + "" + x + "" + kValueC.kValue[2] + "" + kValueD.kValue[3] + "" + kValueE.kValue[4] + "" + kValueF.kValue[5] + "" + kValueG.kValue[6] + "" + kValueH.kValue[7] + "" + kValueA.kValue[8] + "" + kValueB.kValue[9] + "" + kValueC.kValue[10] + "" + kValueD.kValue[11] + "" + kValueE.kValue[12] + "" + kValueF.kValue[13] + "" + kValueG.kValue[14] + "" + kValueH.kValue[15];
        let AuthTokenIv = vValueA.vValue[0] + "" + vValueB.vValue[1] + "" + vValueC.vValue[2] + "" + vValueD.vValue[3] + "" + vValueE.vValue[4] + "" + vValueF.vValue[5] + "" + vValueG.vValue[6] + "" + vValueH.vValue[7] + "" + vValueA.vValue[8] + "" + vValueB.vValue[9] + "" + vValueC.vValue[10] + "" + vValueD.vValue[11] + "" + vValueE.vValue[12] + "" + vValueF.vValue[13] + "" + vValueG.vValue[14] + "" + vValueH.vValue[15];
        let encrypted = CryptoJS.AES.encrypt(dataStr, CryptoJS.enc.Latin1.parse(AuthTokenKey), {
            iv: CryptoJS.enc.Latin1.parse(AuthTokenIv),
            mode: CryptoJS.mode.CBC,
            padding: CryptoJS.pad.Pkcs7
        });
        return encrypted.toString();
    },

    /*AES解密*/
    Decrypt(data) {
        let data2 = data //.replace(/\n/gm, "");
        let AuthTokenKey = kValueA.kValue[0] + "" + kValueB.kValue[1] + "" + kValueC.kValue[2] + "" + kValueD.kValue[3] + "" + kValueE.kValue[4] + "" + kValueF.kValue[5] + "" + kValueG.kValue[6] + "" + kValueH.kValue[7] + "" + kValueA.kValue[8] + "" + kValueB.kValue[9] + "" + kValueC.kValue[10] + "" + kValueD.kValue[11] + "" + kValueE.kValue[12] + "" + kValueF.kValue[13] + "" + kValueG.kValue[14] + "" + kValueH.kValue[15];
        let AuthTokenIv = vValueA.vValue[0] + "" + vValueB.vValue[1] + "" + vValueC.vValue[2] + "" + vValueD.vValue[3] + "" + vValueE.vValue[4] + "" + vValueF.vValue[5] + "" + vValueG.vValue[6] + "" + vValueH.vValue[7] + "" + vValueA.vValue[8] + "" + vValueB.vValue[9] + "" + vValueC.vValue[10] + "" + vValueD.vValue[11] + "" + vValueE.vValue[12] + "" + vValueF.vValue[13] + "" + vValueG.vValue[14] + "" + vValueH.vValue[15];
        let decrypted = CryptoJS.AES.decrypt(data2, CryptoJS.enc.Latin1.parse(AuthTokenKey), {
            iv: CryptoJS.enc.Latin1.parse(AuthTokenIv),
            mode: CryptoJS.mode.CBC,
            padding: CryptoJS.pad.Pkcs7
        });
        return decrypted.toString(CryptoJS.enc.Utf8);
    }
}
let Keup = {
    /*禁用组件tab脚本 UnTab([id1,id2,id3])*/
    UnTab(arr) {
        document.onkeydown = function(e) {
            if (e.keyCode === 9) {
                if (e.target) {
                    if (e.target && e.target.offsetParent) {
                        if (arr.indexOf(e.target.id) !== -1 || arr.indexOf(e.target.offsetParent.id) !== -1) {
                            if (e.preventDefault) { e.preventDefault(); } else { e.returnValue = false; }
                        }
                    }
                }
            }

        }
    },
    /*弹框提示跳转*/
    // Keup.ModalMessage(3, this, 'xxx错误', '跳转到登录页', '/Login','success')
    // time 时间
    // this 当前组件
    // contentTitle 提示内容
    // toTitle 去往哪里
    // toAdree 跳转路由 'destroy'为特殊值 直接关闭
    // type 类型
    ModalMessage(time, dom, contentTitle, toTitle, toAdree, buttonTitle, type) {
        let secondsToGo = time;
        if (window.sessionStorage.getItem("ModalMessage") === 'Y') {
            return false
        }
        window.sessionStorage.setItem("ModalMessage", 'Y');
        const modal = Modal[type]({
            title: contentTitle,
            content: ` ${secondsToGo} 秒后` + toTitle,
            okText: buttonTitle,
            onOk() {
                if (toAdree === 'destroy') {
                    modal.destroy();
                    window.sessionStorage.setItem("ModalMessage", 'N');
                } else {
                    history.push(toAdree);
                }

            },
        });
        const timer = setInterval(() => {
            secondsToGo -= 1;
            modal.update({
                content: ` ${secondsToGo} 秒后` + toTitle,
            });
        }, 1000);
        setTimeout(() => {
            clearInterval(timer);
            if (toAdree === 'destroy') {
                modal.destroy();
                window.sessionStorage.setItem("ModalMessage", 'N');
            } else {
                history.push(toAdree);
            }
            modal.destroy();
            window.sessionStorage.setItem("ModalMessage", 'N');
        }, secondsToGo * 1000);
    },
    // 金额过滤 0.00
    MoneyReplace(val) {
        let newVal

        //先把非数字的都替换掉，除了数字和.

        newVal = val.replace(/[^\d.]/g, "");

        //保证只有出现一个.而没有多个.

        newVal = newVal.replace(/\.{2,}/g, ".");

        //必须保证第一个为数字而不是.

        newVal = newVal.replace(/^\./g, "");

        //保证.只出现一次，而不能出现两次以上

        newVal = newVal.replace(".", "$#$").replace(/\./g, "").replace("$#$", ".");

        //只能输入两个小数

        newVal = newVal.replace(/^(\-)*(\d+)\.(\d\d).*$/, '$1$2.$3');

        return newVal
    },
    // 获取字符串长度
    getBLen(str) {
        if (str == null) return 0;
        if (typeof str != "string") {
            str += "";
        }
        return str.replace(/[^\x00-\xff]/g, "01").length;
    }
}
let ArraySome = {
    // 将重复元素提取出到一个新数组或者单独数组去重
    //  let arr = [1, 2, 3, 1, 5, 7, 9, 8, '哈', '哈', 3, 8, 'a', 'a'];
    //  let a = ArrayWeigh(arr,'remove');
    ArrayWeigh(arrs, type) {
        arrs.sort(); //升排序数组
        let remove = []; //定义一个数组，用于存放数组去重的元素
        let repeat = []; //定义一个数组，用于存放所有重复的元素


        for (var i = 0; i < arrs.length; i++) {
            if (remove.indexOf(arrs[i]) === -1) { //判断在remove数组中是否存在，不存在则push到remove数组中
                remove.push(arrs[i]);
            }
        }

        //遍历数组找出重复元素
        for (var j = 0; j < remove.length; j++) {
            var q = 0; //声明一个变量，记录状态
            for (var k = 0; k < arrs.length; k++) {
                if (remove[j] === arrs[k]) {
                    q++;
                    if (q == 2) { //p为2时,重复元素有两个
                        repeat.push(remove[j], remove[j]);
                    } else if (q > 2) {
                        repeat.push(remove[j]);
                    }
                }
            }
        }

        if (type === 'remove') {
            return remove;
        }

        if (type === 'repeat') {
            return repeat;
        }
    },

    //取出两个数组的不同元素
    getArrDifference(arr1, arr2) {
        return arr1.concat(arr2).filter(function(v, i, arr) {
            return arr.indexOf(v) === arr.lastIndexOf(v);
        })
    },
    // 数字加0
    addPreZero(num, length) {
        for (var len = (num + "").length; len < length; len = num.length) {
            num = "0" + num;
        }
        return num;
    },
    //用于查找指定的元素在数组中的位置，即索引
    indexOfArr(item, val) {
        for (var i = 0; i < item.length; i++) {
            if (item[i] == val) {
                return i
            }
        }
        return -1;
    },
    //使用js数组自己固有的函数去删除这个元素：
    removeArr(item, val) {
        var index = this.indexOfArr(item, val);
        console.log(index)
        if (index > -1) {
            return item.splice(index, 1);
        }
    },
}
let Util = {
    //判断是否是为空
    isEmpty(str) {
        let type = typeof str;
        switch (type) {
            case 'object': //如果是对象用stringify转成str 排除 {} 和 null
                if (str instanceof Array) {
                    return str.length > 0 ? false : true;
                } else {
                    let template = JSON.stringify(str);
                    return template === 'null' || template === '{}' ? true : false;
                }
            default: //其他
                str = str + '';
                if (str.length === 0 || str == 'undefined' || str == 'null') {
                    return true;
                }
        }
        return false;
    },

    //判断空对象
    isNull(obj) {
        if (obj instanceof Object) {
            for (let k in obj) {
                return false
            }
            return true;
        } else {
            throw new Error('不是对象');
        }
    },

    // 处理需要传递的对象当中的数据，有着传没有则不传
    disposeData(data) {
        let obj = {}
        let result = Object.keys(data).filter(item => {
            // if ((data[item] !== null) || (data[item] !== '') || (data[item] !== undefined)) {
            return data[item] !== (null || '' || undefined)
                // }
        })
        result.forEach(item => {
            obj[item] = data[item]
        })
        return obj
    },

    // input框点击回车键切换到下一个选框
    changeEnter(myRef1) {
        var inputs = document.getElementsByClassName('input');

        function init() {
            for (let i = 0; i < inputs.length; i++) {
                inputs[i].onkeydown = focus(i);
            }
        }
        var focus = function handle(i) {
            return function(event) {
                var next = (i + 1) < inputs.length ? i + 1 : 0; // 判断是否为最后一个输入框，是则返回第一个，否则继续下一个
                var eve = event ? event : window.event;
                if (eve.keyCode === 13) {
                    if (inputs[next].tagName === 'INPUT') {
                        inputs[next].focus(); //获取焦点
                    } else {
                        myRef1.current.focus();
                    }
                }
            }
        }
        init()
    },

    // 开关的值修改为Y/N
    replaceTrueFalse(val) {
        if (val) {
            return 'Y'
        } else {
            return 'N'
        }
    },

    //通过日期获取星期
    getWeek(day) {
        var date = new Date();
        var firstDay = new Date(date - (date.getDay() - 1) * 86400000);
        firstDay.setDate(firstDay.getDate() + day);
        var mon = Number(firstDay.getMonth()) + 1;
        return date.getFullYear() + "-" + mon + "-" + firstDay.getDate();
    },

    //处理多个checkbox的公共方法
    commonCheckbox(name, e) {
        this.setState({
            [name]: e.target.checked
        })
    },

    //公共输入框
    commonInputChange(name, e) {
        this.setState({
            [name]: e.target.value
        })
    },

    //获取下拉框所选ID
    handleSelectChange(name, e) {
        this.setState({
            [name]: e
        })
    },
    //表单自定义验证 -- 身份证格式
    vailIdCard(rule, value, callback) {
        var city = { 11: "北京", 12: "天津", 13: "河北", 14: "山西", 15: "内蒙古", 21: "辽宁", 22: "吉林", 23: "黑龙江 ", 31: "上海", 32: "江苏", 33: "浙江", 34: "安徽", 35: "福建", 36: "江西", 37: "山东", 41: "河南", 42: "湖北 ", 43: "湖南", 44: "广东", 45: "广西", 46: "海南", 50: "重庆", 51: "四川", 52: "贵州", 53: "云南", 54: "西藏 ", 61: "陕西", 62: "甘肃", 63: "青海", 64: "宁夏", 65: "新疆", 71: "台湾", 81: "香港", 82: "澳门", 91: "国外 " };
        if (!value || !/^\d{6}(18|19|20)?\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])\d{3}(\d|X)$/i.test(value)) {
            callback('身份证号格式错误'); // 校验未通过
            return;
        } else if (!city[value.substr(0, 2)]) {
            callback('身份证号格式错误'); // 校验未通过
            return;
        } else {
            //18位身份证需要验证最后一位校验位
            if (value.length == 18) {
                value = value.split('');
                //∑(ai×Wi)(mod 11)
                //加权因子
                var factor = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];
                //校验位
                var parity = [1, 0, 'X', 9, 8, 7, 6, 5, 4, 3, 2];
                var sum = 0;
                var ai = 0;
                var wi = 0;
                for (var i = 0; i < 17; i++) {
                    ai = value[i];
                    wi = factor[i];
                    sum += ai * wi;
                }
                var last = parity[sum % 11];
                //最后一位不区分大小写
                if (value[17] == 'x') value[17] = value[17].toUpperCase();
                if (parity[sum % 11] != value[17]) {
                    callback('身份证号格式错误'); // 校验未通过
                    return;
                }
            }
        }
        callback();
    },
    //表单自定义验证 -- 联系方式
    validFContact(rule, value, callback, editId) {
        //数字1开头 网络识别号/地区编码不限  限11位
        if (editId == "1") {
            if (!value || !/^1\d{10}$/.test(value)) {
                callback('手机格式错误'); // 校验未通过
                return;
            }
        }
        //数字 或者 数字 + " - " 组合
        if (editId == "2") {
            if (!value || !/^\d+(\-\d+)?$/.test(value)) {
                callback('办公电话格式错误'); // 校验未通过
                return;
            }
        }
        //只能6—20个字母、数字、下划线和减号，必须以字母开头（不区分大小写），不支持设置中文(支持手机号码添加）
        if (editId == "3") {
            if (!value || !/^[a-zA-Z]([-_a-zA-Z0-9]{5,19})+|^1\d{10}$/.test(value)) {
                callback('微信格式错误'); // 校验未通过
                return;
            }
        }
        //qq4位以上数字
        if (editId == "4") {
            if (!value || !/^[1-9][0-9]{4,}$/.test(value)) {
                callback('QQ格式错误');
                return;
            }
        }
        //开头可以是数字英文加下划线或者"."  @后面也可以是数字英文加下划线
        if (editId == "5" || editId == "7") {
            if (!value || !/^(?:\w+\.?)*\w+@(?:\w+\.)+\w+$/.test(value)) {
                if (editId == "5") {
                    callback('电子邮箱格式错误');
                } else {
                    callback('Facebook邮箱格式错误');
                }
                return;
            }
        }
        //邮箱或者手机号  邮箱开头可以是数字英文加下划线或者"."  @后面也可以是数字英文加下划线
        if (editId == "6") {
            if (!value || !/^(?:\w+\.?)*\w+@(?:\w+\.)+\w+|^1\d{10}$/.test(value)) {
                callback('支付宝格式错误');
                return;
            }
        }
        callback();
    },

    //- 将阿拉伯数字转换中文数字, 只处理到[0 ~ 99] 
    numberConvertToUppercase(num) {
        num = Number(num);
        var upperCaseNumber = ['零', '一', '二', '三', '四', '五', '六', '七', '八', '九', '十', '百', '千', '万', '亿'];
        var length = String(num).length;
        if (length == 1) {
            return upperCaseNumber[num];
        } else if (length == 2) {
            if (num == 10) {
                return upperCaseNumber[num];
            } else if (num > 10 && num < 20) {
                return '十' + upperCaseNumber[String(num).charAt(1)];
            } else {
                return upperCaseNumber[String(num).charAt(0)] + '十' + upperCaseNumber[String(num).charAt(1)].replace('零', '');
            }
        }
    },

    // 判断对象中时候存在属性为空的字段 
    checkAttributeIsEmpty(obj) {
        let arr = [];
        for (let key of Object.keys(obj)) {
            if (obj[key]) {
                arr.push(key)
            }
        }
        return arr && arr.length > 0 ? false : true;
    }
}

let Reg = {
    number: /^\d+$/,
}

let MD5 = {
    md5(string){
        function md5_RotateLeft(lValue, iShiftBits) {
            return (lValue<<iShiftBits) | (lValue>>>(32-iShiftBits));
        }
        function md5_AddUnsigned(lX,lY){
            var lX4,lY4,lX8,lY8,lResult;
            lX8 = (lX & 0x80000000);
            lY8 = (lY & 0x80000000);
            lX4 = (lX & 0x40000000);
            lY4 = (lY & 0x40000000);
            lResult = (lX & 0x3FFFFFFF)+(lY & 0x3FFFFFFF);
            if (lX4 & lY4) {
                return (lResult ^ 0x80000000 ^ lX8 ^ lY8);
            }
            if (lX4 | lY4) {
                if (lResult & 0x40000000) {
                    return (lResult ^ 0xC0000000 ^ lX8 ^ lY8);
                } else {
                    return (lResult ^ 0x40000000 ^ lX8 ^ lY8);
                }
            } else {
                return (lResult ^ lX8 ^ lY8);
            }
        }
        function md5_F(x,y,z){
            return (x & y) | ((~x) & z);
        }
        function md5_G(x,y,z){
            return (x & z) | (y & (~z));
        }
        function md5_H(x,y,z){
            return (x ^ y ^ z);
        }
        function md5_I(x,y,z){
            return (y ^ (x | (~z)));
        }
        function md5_FF(a,b,c,d,x,s,ac){
            a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_F(b, c, d), x), ac));
            return md5_AddUnsigned(md5_RotateLeft(a, s), b);
        };
        function md5_GG(a,b,c,d,x,s,ac){
            a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_G(b, c, d), x), ac));
            return md5_AddUnsigned(md5_RotateLeft(a, s), b);
        };
        function md5_HH(a,b,c,d,x,s,ac){
            a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_H(b, c, d), x), ac));
            return md5_AddUnsigned(md5_RotateLeft(a, s), b);
        };
        function md5_II(a,b,c,d,x,s,ac){
            a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_I(b, c, d), x), ac));
            return md5_AddUnsigned(md5_RotateLeft(a, s), b);
        };
        function md5_ConvertToWordArray(string) {
            var lWordCount;
            var lMessageLength = string.length;
            var lNumberOfWords_temp1=lMessageLength + 8;
            var lNumberOfWords_temp2=(lNumberOfWords_temp1-(lNumberOfWords_temp1 % 64))/64;
            var lNumberOfWords = (lNumberOfWords_temp2+1)*16;
            var lWordArray=Array(lNumberOfWords-1);
            var lBytePosition = 0;
            var lByteCount = 0;
            while ( lByteCount < lMessageLength ) {
                lWordCount = (lByteCount-(lByteCount % 4))/4;
                lBytePosition = (lByteCount % 4)*8;
                lWordArray[lWordCount] = (lWordArray[lWordCount] | (string.charCodeAt(lByteCount)<<lBytePosition));
                lByteCount++;
            }
            lWordCount = (lByteCount-(lByteCount % 4))/4;
            lBytePosition = (lByteCount % 4)*8;
            lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80<<lBytePosition);
            lWordArray[lNumberOfWords-2] = lMessageLength<<3;
            lWordArray[lNumberOfWords-1] = lMessageLength>>>29;
            return lWordArray;
        };
        function md5_WordToHex(lValue){
            var WordToHexValue="",WordToHexValue_temp="",lByte,lCount;
            for(lCount = 0;lCount<=3;lCount++){
                lByte = (lValue>>>(lCount*8)) & 255;
                WordToHexValue_temp = "0" + lByte.toString(16);
                WordToHexValue = WordToHexValue + WordToHexValue_temp.substr(WordToHexValue_temp.length-2,2);
            }
            return WordToHexValue;
        };
        function md5_Utf8Encode(string){
            string = string.replace(/\r\n/g,"\n");
            var utftext = "";
            for (var n = 0; n < string.length; n++) {
                var c = string.charCodeAt(n);
                if (c < 128) {
                    utftext += String.fromCharCode(c);
                }else if((c > 127) && (c < 2048)) {
                    utftext += String.fromCharCode((c >> 6) | 192);
                    utftext += String.fromCharCode((c & 63) | 128);
                } else {
                    utftext += String.fromCharCode((c >> 12) | 224);
                    utftext += String.fromCharCode(((c >> 6) & 63) | 128);
                    utftext += String.fromCharCode((c & 63) | 128);
                }
            }
            return utftext;
        };
        var x=Array();
        var k,AA,BB,CC,DD,a,b,c,d;
        var S11=7, S12=12, S13=17, S14=22;
        var S21=5, S22=9 , S23=14, S24=20;
        var S31=4, S32=11, S33=16, S34=23;
        var S41=6, S42=10, S43=15, S44=21;
        string = md5_Utf8Encode(string);
        x = md5_ConvertToWordArray(string);
        a = 0x67452301; b = 0xEFCDAB89; c = 0x98BADCFE; d = 0x10325476;
        for (k=0;k<x.length;k+=16) {
            AA=a; BB=b; CC=c; DD=d;
            a=md5_FF(a,b,c,d,x[k+0], S11,0xD76AA478);
            d=md5_FF(d,a,b,c,x[k+1], S12,0xE8C7B756);
            c=md5_FF(c,d,a,b,x[k+2], S13,0x242070DB);
            b=md5_FF(b,c,d,a,x[k+3], S14,0xC1BDCEEE);
            a=md5_FF(a,b,c,d,x[k+4], S11,0xF57C0FAF);
            d=md5_FF(d,a,b,c,x[k+5], S12,0x4787C62A);
            c=md5_FF(c,d,a,b,x[k+6], S13,0xA8304613);
            b=md5_FF(b,c,d,a,x[k+7], S14,0xFD469501);
            a=md5_FF(a,b,c,d,x[k+8], S11,0x698098D8);
            d=md5_FF(d,a,b,c,x[k+9], S12,0x8B44F7AF);
            c=md5_FF(c,d,a,b,x[k+10],S13,0xFFFF5BB1);
            b=md5_FF(b,c,d,a,x[k+11],S14,0x895CD7BE);
            a=md5_FF(a,b,c,d,x[k+12],S11,0x6B901122);
            d=md5_FF(d,a,b,c,x[k+13],S12,0xFD987193);
            c=md5_FF(c,d,a,b,x[k+14],S13,0xA679438E);
            b=md5_FF(b,c,d,a,x[k+15],S14,0x49B40821);
            a=md5_GG(a,b,c,d,x[k+1], S21,0xF61E2562);
            d=md5_GG(d,a,b,c,x[k+6], S22,0xC040B340);
            c=md5_GG(c,d,a,b,x[k+11],S23,0x265E5A51);
            b=md5_GG(b,c,d,a,x[k+0], S24,0xE9B6C7AA);
            a=md5_GG(a,b,c,d,x[k+5], S21,0xD62F105D);
            d=md5_GG(d,a,b,c,x[k+10],S22,0x2441453);
            c=md5_GG(c,d,a,b,x[k+15],S23,0xD8A1E681);
            b=md5_GG(b,c,d,a,x[k+4], S24,0xE7D3FBC8);
            a=md5_GG(a,b,c,d,x[k+9], S21,0x21E1CDE6);
            d=md5_GG(d,a,b,c,x[k+14],S22,0xC33707D6);
            c=md5_GG(c,d,a,b,x[k+3], S23,0xF4D50D87);
            b=md5_GG(b,c,d,a,x[k+8], S24,0x455A14ED);
            a=md5_GG(a,b,c,d,x[k+13],S21,0xA9E3E905);
            d=md5_GG(d,a,b,c,x[k+2], S22,0xFCEFA3F8);
            c=md5_GG(c,d,a,b,x[k+7], S23,0x676F02D9);
            b=md5_GG(b,c,d,a,x[k+12],S24,0x8D2A4C8A);
            a=md5_HH(a,b,c,d,x[k+5], S31,0xFFFA3942);
            d=md5_HH(d,a,b,c,x[k+8], S32,0x8771F681);
            c=md5_HH(c,d,a,b,x[k+11],S33,0x6D9D6122);
            b=md5_HH(b,c,d,a,x[k+14],S34,0xFDE5380C);
            a=md5_HH(a,b,c,d,x[k+1], S31,0xA4BEEA44);
            d=md5_HH(d,a,b,c,x[k+4], S32,0x4BDECFA9);
            c=md5_HH(c,d,a,b,x[k+7], S33,0xF6BB4B60);
            b=md5_HH(b,c,d,a,x[k+10],S34,0xBEBFBC70);
            a=md5_HH(a,b,c,d,x[k+13],S31,0x289B7EC6);
            d=md5_HH(d,a,b,c,x[k+0], S32,0xEAA127FA);
            c=md5_HH(c,d,a,b,x[k+3], S33,0xD4EF3085);
            b=md5_HH(b,c,d,a,x[k+6], S34,0x4881D05);
            a=md5_HH(a,b,c,d,x[k+9], S31,0xD9D4D039);
            d=md5_HH(d,a,b,c,x[k+12],S32,0xE6DB99E5);
            c=md5_HH(c,d,a,b,x[k+15],S33,0x1FA27CF8);
            b=md5_HH(b,c,d,a,x[k+2], S34,0xC4AC5665);
            a=md5_II(a,b,c,d,x[k+0], S41,0xF4292244);
            d=md5_II(d,a,b,c,x[k+7], S42,0x432AFF97);
            c=md5_II(c,d,a,b,x[k+14],S43,0xAB9423A7);
            b=md5_II(b,c,d,a,x[k+5], S44,0xFC93A039);
            a=md5_II(a,b,c,d,x[k+12],S41,0x655B59C3);
            d=md5_II(d,a,b,c,x[k+3], S42,0x8F0CCC92);
            c=md5_II(c,d,a,b,x[k+10],S43,0xFFEFF47D);
            b=md5_II(b,c,d,a,x[k+1], S44,0x85845DD1);
            a=md5_II(a,b,c,d,x[k+8], S41,0x6FA87E4F);
            d=md5_II(d,a,b,c,x[k+15],S42,0xFE2CE6E0);
            c=md5_II(c,d,a,b,x[k+6], S43,0xA3014314);
            b=md5_II(b,c,d,a,x[k+13],S44,0x4E0811A1);
            a=md5_II(a,b,c,d,x[k+4], S41,0xF7537E82);
            d=md5_II(d,a,b,c,x[k+11],S42,0xBD3AF235);
            c=md5_II(c,d,a,b,x[k+2], S43,0x2AD7D2BB);
            b=md5_II(b,c,d,a,x[k+9], S44,0xEB86D391);
            a=md5_AddUnsigned(a,AA);
            b=md5_AddUnsigned(b,BB);
            c=md5_AddUnsigned(c,CC);
            d=md5_AddUnsigned(d,DD);
        }
        return (md5_WordToHex(a)+md5_WordToHex(b)+md5_WordToHex(c)+md5_WordToHex(d)).toUpperCase();
    }
}
let DES = {
    //DES加密
    encryptByDES(message, key){
        var keyHex = CryptoJS.enc.Utf8.parse(key);
        var encrypted = CryptoJS.DES.encrypt(message, keyHex, {
            mode: CryptoJS.mode.ECB,
            padding: CryptoJS.pad.Pkcs7
        });
        return encrypted.ciphertext.toString();
    },
    //DES解密
    decryptByDES(ciphertext, key){
        var keyHex = CryptoJS.enc.Utf8.parse(key);
        var decrypted = CryptoJS.DES.decrypt({
            ciphertext: CryptoJS.enc.Hex.parse(ciphertext)
        }, keyHex, {
            mode: CryptoJS.mode.ECB,
            padding: CryptoJS.pad.Pkcs7
        });
        var result_value = decrypted.toString(CryptoJS.enc.Utf8);
        return result_value;
    }
}
module.exports = { Util, ArraySome, Aes, Keup, dayFormat, timeFormat, dateFormat, hourFormat, Reg,MD5, DES};