工具【1、计算时间差2、获取当天时间前后七天时间3、根据当前数据的位置，在数组中插入数据4、数组中，某个属性相同的数据放在一块，如把某个日期相同的相连一起】

生成UUID

/**
 * 唯一的随机字符串，用来区分每条数据
 * @returns {string}
 */
export function getUid() {
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
        const r = (Math.random() * 16) | 0;
        const v = c === 'x' ? r : (r & 0x3) | 0x8;
        return v.toString(16);
    });
}

计算时间差

/**
 * 计算时间差
 * @param {String} beginTime ：2022-01-13
 * @param {String} endTime ：2022-01-13
 * @returns {{hours: number, seconds: number, minutes: number, day: number}}
 */
export function dealTime(beginTime, endTime) {
    let dateBegin = beginTime ? new Date(beginTime) : new Date();
    let dateEnd = endTime ? new Date(endTime) : new Date();
    let dateDiff = dateEnd.getTime() - dateBegin.getTime(); //时间差的毫秒数
    let day = Math.floor(dateDiff / (24 * 3600 * 1000)); //计算出相差天数
    let leave1 = dateDiff % (24 * 3600 * 1000); //计算天数后剩余的毫秒数
    let hours = Math.floor(leave1 / (3600 * 1000)); //计算出小时数
    //计算相差分钟数
    let leave2 = leave1 % (3600 * 1000); //计算小时数后剩余的毫秒数
    let minutes = Math.floor(leave2 / (60 * 1000)); //计算相差分钟数

    //计算相差秒数
    let leave3 = leave2 % (60 * 1000); //计算分钟数后剩余的毫秒数
    let seconds = Math.round(leave3 / 1000);
    return {
        day,
        hours,
        minutes,
        seconds
    }
}

获取当天时间

/**
 * 获取当天时间
 * @returns {string}
 */
export function getCurDay() {
    let datetime = new Date();
    let year = datetime.getFullYear();
    let month = datetime.getMonth() + 1 < 10 ? "0" + (datetime.getMonth() + 1) : datetime.getMonth() + 1;
    let date = datetime.getDate() < 10 ? "0" + datetime.getDate() : datetime.getDate();
    return `${year}-${month}-${date}`
}

日期格式处理

/**
 * 日期格式处理
 * @param date
 * @returns {{month: string, year: string, day: string}}
 */
export function formatDate(date) {
    let year = date.getFullYear();
    let months = date.getMonth() + 1;
    let month = (months < 10 ? '0' + months : months).toString();
    let day = (date.getDate() < 10 ? '0' + date.getDate() : date.getDate()).toString();
    return {
        year: year.toString(),
        month,
        day
    }
}

获取当前天时间

/**
 * 获取当前天时间
 * @param {String} target
 * @param {String} param 【Y:年；M:月；D:日；h:小时；m:分钟；s:秒；】 默认精确到秒
 * @returns {string}
 */
export function getCurrentDate(target, param = 's') {
    let now = target ? new Date(target) : new Date();
    let year = now.getFullYear(); //得到年份
    let month = now.getMonth();//得到月份
    let date = now.getDate();//得到日期
    let day = now.getDay();//得到周几
    let hour = now.getHours();//得到小时
    let minu = now.getMinutes();//得到分钟
    let sec = now.getSeconds();//得到秒
    month = month + 1;
    if (month < 10) month = "0" + month;
    if (date < 10) date = "0" + date;
    if (hour < 10) hour = "0" + hour;
    if (minu < 10) minu = "0" + minu;
    if (sec < 10) sec = "0" + sec;

    const arr = {
        'Y': year,
        'M': year + "-" + month,
        'D': year + "-" + month + "-" + date,
        'h': year + "-" + month + "-" + date + " " + hour,
        'm': year + "-" + month + "-" + date + " " + hour + ":" + minu,
        's': year + "-" + month + "-" + date + " " + hour + ":" + minu + ":" + sec
    }
    return arr[param];
}

获取当天时间前后七天时间

/**
 * 获取当天时间前后七天时间
 * @param {number} day day>0 当天时间的后几天 day<0 当天时间前几天
 * @returns {string}
 */
export function getRecentDate(day) {
    let date1 = new Date(),
        time1 = date1.getFullYear() + "-" + (date1.getMonth() + 1) + "-" + date1.getDate();//time1表示当前时间
    let date2 = new Date(date1);
    date2.setDate(date1.getDate() + day);
    const y = date2.getFullYear();
    const m = (date2.getMonth() + 1) > 9 ? (date2.getMonth() + 1) : '0' + (date2.getMonth() + 1)
    const d = date2.getDate() > 9 ? date2.getDate() : '0' + date2.getDate()
    return y + "-" + m + "-" + d;
}

数组中，某个属性相同的数据放在一块，如把某个日期相同的相连一起

/**
 * 数组中，某个属性相同的数据放在一块，如把某个日期相同的相连一起
 * @param {Object[]} list 传入的数组
 * @param {String} prop 那个属性相同的数据
 * @returns {*[]}
 */
export function margePropData(list = [], prop) {
    let arr = [], tempArr = {};
    list.forEach(item => {
        if (!tempArr[item[prop]]) {
            tempArr[item[prop]] = [item]
        } else {
            tempArr[item[prop]].push(item)
        }
    })
    for (const tempArrKey in tempArr) {
        arr = [...arr, ...tempArr[tempArrKey]]
    }
    return arr
}

合并行

/**
 * 合并行
 * @param {Object[]} list
 * @param {String} prop
 */
export function mergeRows(list = [], prop) {
    list.forEach(ele => {
        ele.rowspan = 1
    })
    const len = list.length
    for (let i = 0; i < len; i++) {
        for (let j = i + 1; j < len; j++) {
            if (list[i][prop] === list[j][prop]) {
                list[i].rowspan++
                list[j].rowspan--
            }
        }
        // 这里跳过已经重复的数据
        i = i + list[i].rowspan - 1
    }
    return list
}

根据当前数据的位置，在数组中插入数据

/**
 * 根据当前数据的位置，在数组中插入数据
 * 如数组【1，2，4，5】想要在2后面插入3，
 *1：首先获取到2的下标，
 *2：然后获取要插入之前的数据，获取要插入之后的数据，中间就是插入的位置
 *3：最后把这三个按顺序合并就得到在想要的位置插入数据
 * @param {number[]|Object[]} list
 * @param {number} index
 * @param {Object} target
 */
export function insertArrPositionOfIndex(list = [], index = 0, target = {}) {
    //根据index 找出小于index的数据放在左边
    const leftList = list.filter((t, i) => i < index);
    //根据index 找出大于index的数据放在右边
    const rightList = list.filter((t, i) => i >= index);
    // 最终合并数据
    return [...leftList, target, ...rightList]
}

获取元素下标

/**
 * 获取元素下标
 * @param {number} dir 为 1：得到正序遍历方法；为 -1： 得到逆序遍历方法。
 * @returns {(function(*, *, *=): (number|number|number))|*}
 */
export function findArrIndex(dir = 1) {
    return function (array, cb, context) {
        let length = array.length;
        // 控制初始 index，0 或者 length-1
        let index = dir >= 0 ? 0 : length - 1;

        // 条件： 在数组范围内；
        // 递增或递减：递加 1 或者 -1； 妙啊~
        for (; index >= 0 && index <= length - 1; index += dir) {
            if (cb.call(context, array[index], index)) return index
        }
        return -1
    }
}

map转换成数组

/**
 * map转换成数组
 * @param {Object} target
 * @returns {*[]}
 * @constructor
 */
export function MapConvertArr(target = {}) {
    let list = [];
    for (let key in target) {
        list.push(target[key]);
    }
    return list;
}

对象数组去重

/**
 * 对象数组去重
 * @param {Object[]} arr 数组
 * @param {String} prop 根据什么字段去重
 * @returns {any[]}
 */
export function arrayDeduplication(arr, prop) {
    let map = new Map();
    return arr.filter(item => !map.has(item[prop]) && map.set(item[prop], 1));
}

防抖

/**
 * 防抖
 * @param {function} fn
 * @param {number} duration
 * @returns {(function(...[*]): void)|*}
 * @constructor
 */
export function MyDebounce(fn, duration = 100) {
    let timer = null
    return (...args) => {
        clearTimeout(timer)
        timer = setTimeout(() => {
            fn(...args);
        }, duration)

    }
}

节流

/**
 * 节流
 * @param fn
 * @param {number} duration
 * @returns {(function(...[*]): (boolean|undefined))|*}
 * @constructor
 */
export function MyThrottle(fn, duration = 100) {
    let target = true;
    return (...arg) => {
        if (!target) {
            return false;
        }
        target = false;
        setTimeout(() => {
            fn(...arg);
            target = true
        }, duration)
    }
}

单例模式

/**
 * 单例模式
 * @param {Object} className
 * @returns {*}
 */
export function singleton(className) {
    let ins;
    return new Proxy(className, {
        construct(target, args) {
            if (!ins) {
                ins = new target(...args)
            }
            return ins;
        }
    })
}

校验规则 表单提交校验

/**
 * 校验规则
 * @param {Object[]} list
 * @param {Object[]} require
 * @returns {null}
 */
export function verifyRules(list = [], require = []) {
    let message = null
    for (const key of require) {
        const isEmpty = list.every(it => !it[key.prop])
        if (isEmpty) {
            message = key.message
            break;
        }
    }
    return message
}

输入框校验

• 校验输入最大数字长度
• 校验保留几位小数
• 校验手机号
• 校验邮箱
• 校验身份证

/**
 *
 * @param target {*} 传入的值
 * @param rule {String} 需要检验的类型 num_2:输入数字范围，1表示可输入最大值9，2：表示可输入最大值为99，以此类推，；decimal_2：保留小数位，1表示留一位，2表示留两位小数 ；phone校验手机 ；email：校验邮箱 ；IDCard：校验身份证
 * @param reg {RegExp} 正则
 * @returns {*|boolean}
 */
export function regInput(target, rule = 'num_5', reg) {
    //校验输入最大数字长度
    if (rule.includes('num_')) {
        const endNum = rule.split("_")[1];
        target = target.replace(/[^\d.]/g, "").replace(".", "");
        if (endNum < 1) {
            throw new Error(`规则：${rule}最小为1`)
        }
        reg = reg || new RegExp(`^[1-9]\\d{0,${(+endNum - 1)}}$`);
        if (reg.test(target)) {
            return target;
        }
        return target.slice(0, endNum);
    }
    //校验保留几位小数
    else if (rule.includes('decimal_')) {
        //清除非数字和小数点的字符
        target = target.replace(/[^\d.]/g, "");
        //只保留第一个小数点，清除多余的小数点
        target = target.replace(/\.{2,}/g, "").replace(".", "$#$").replace(/\./g, "").replace("$#$", ".");
        const endDecimal = rule.split("_")[1];
        //只保留几位小数
        let regStr = ''
        for (let i = 0; i < endDecimal; i++) {
            regStr += '\\d';
        }
        reg = reg || new RegExp(`^(\\-)*(\\d+)\\.(${regStr}).*$`)
        if (endDecimal > 0) {
            return target.replace(reg, '$1$2.$3')
        } else {
            return target.replace(/^(\-)*(\d+).*$/, '$1$2');
        }
    }
    //校验手机号
    else if (rule.includes('phone')) {
        reg = reg || /^1[3456789]\d{9}$/;
        return reg.test(target);
    }
    //校验邮箱
    else if (rule.includes('email')) {
        reg = reg || /^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+(.[a-zA-Z0-9_-])+/;
        return reg.test(target);
    }
    //校验身份证
    else if (rule.includes('IDCard')) {
        reg = reg || /^[1-9]\d{5}(19\d{2}|20\d{2})(0[1-9]|1[0-2])(0[1-9]|[1-2]\d|3[0-1])\d{3}(\d|x|X)$/;
        if (reg.test(target)) {
            // 校验码校验
            let idCard_array = target.split("");
            let factor = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];
            let checkCode = ["1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2"];
            let checkSum = 0;
            for (let i = 0; i < factor.length; i++) {
                checkSum += factor[i] * parseInt(idCard_array[i]);
            }
            let mod = checkSum % 11;
            return checkCode[mod] === idCard_array[17].toLowerCase();
        }
        return false;

    }
    return target;

}