js工具函数

export default {
    /**
     * 删除或增加对应元素的类名
     * @param {Object} obj  原生js对象
     * @param {String} Class  类名
     * nlTogetherClass(obj, "active", "active")
     */
    nlTogetherClass(obj, Class = '') {
        const objClass = obj.className;
        if (objClass == '') {
            obj.className = Class;
            return;
        }
        let classArr = objClass.split(' ');
        const index = classArr.findIndex((items) => {
            return items == Class;
        });
        if (index == -1) {
            //没有就新增
            obj.className = obj.className + ` ${Class}`;
        } else {
            classArr.splice(index, 1);
            obj.className = classArr.join(' ');
        }
        return;
    },

    /**
     * 获取指定时区的时间戳；因为目前还无法直接修改date对象的时区，所以使用时间戳方式返回
     * @param {时间对象} date
     * @param {时差} zone   比如东八区与格林尼治时间（GMT）差8小时就传 8
     * @returns
     */
    getZoneTime(date, zone) {
        var offset_GMT = date.getTimezoneOffset();
        var current = date.getTime();
        var targetDate = new Date(current + offset_GMT * 60 * 1000 + zone * 60 * 60 * 1000);
        return targetDate.getTime();
    },
    /**
     * 格式化日期
     * @param {要格式化的日期格式} type   YYYY-MM-DD hh:mm:ss.S
     * @param {时间对象} date
     * @returns
     */
    getFormatTime(type, date) {
        let formatTime = type
            .replace('YYYY', date.getFullYear())
            .replace('MM', date.getMonth() < 9 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1)
            .replace('DD', date.getDate() < 10 ? '0' + date.getDate() : date.getDate()); //年月日
        formatTime = formatTime.replace(
            'hh',
            date.getHours() < 10 ? '0' + date.getHours() : date.getHours()
        ); //时
        formatTime = formatTime.replace(
            'mm',
            date.getMinutes() < 10 ? '0' + date.getMinutes() : date.getMinutes()
        ); //分
        formatTime = formatTime.replace(
            'ss',
            date.getSeconds() < 10 ? '0' + date.getSeconds() : date.getSeconds()
        ); //秒
        formatTime = formatTime.replace('S', date.getMilliseconds()); //毫秒
        return formatTime;
    },
    /**
     * 获取昨天的日期
     * @param {要格式化的日期格式} type   YYYY-MM-DD hh:mm:ss.S
     * @returns
     */
    getYesterday(type) {
        const date = new Date();
        date.setDate(date.getDate() - 1);
        const formatTime = getFormatTime(type, date);
        return formatTime;
    },
    /**
     * 防抖函数
     * func 执行函数
     * wait 等待时间  毫秒
     * imMe false 动作完毕之后延迟执行  true  立即执行一次，后续不执行
     */
    debounce(func, wait, imMe = false) {
        let timer = null;
        return function () {
            if (timer != null) {
                clearTimeout(timer);
            }
            if (imMe) {
                const state = !timer;
                timer = setTimeout(function () {
                    timer = null;
                }, wait);
                if (state) {
                    func();
                }
            } else {
                timer = setTimeout(func, wait);
            }
        };
    },
    /**
     * 节流
     * fn  执行函数
     * wait 间隔时间  毫秒
     */
    throttle(fn, wait) {
        let timer = null;
        return function () {
            if (!timer) {
                fn();
                timer = setTimeout(() => {
                    timer = null;
                }, wait);
            }
        };
    },

    // 对象深克隆
    deepClone(obj) {
        let rtn = '';
        // 先判断数组，数组也是对象的一种
        if (obj instanceof Array) {
            rtn = cloneArray(obj);
        } else if (obj instanceof Object) {
            rtn = cloneObject(obj);
        } else {
            rtn = obj;
        }
        return rtn;
    },
    //对象克隆
    cloneObject(object) {
        let rtn = {};
        for (const key in object) {
            if (Object.hasOwnProperty.call(object, key)) {
                rtn[key] = deepClone(object[key]);
            }
        }
        return rtn;
    },
    //数组克隆
    cloneArray(array) {
        let rtn = [];
        array.forEach(function (element) {
            rtn.push(deepClone(element));
        });
        return rtn;
    },
    /**
     * 将字符串格式化为数值
     */
    formatNum(str) {
        let rtn = '';
        if (String(+str) == 'NaN') {
            rtn = parseInt(str);
        } else {
            rtn = +str;
        }
        return rtn;
    },

    // 获取每毫米的像素值
    getOneMmsPx() {
        // 创建一个1mm宽的元素插入到页面，然后坐等出结果
        let div = document.createElement('div');
        div.id = 'mm';
        div.style.width = '1mm';
        document.querySelector('body').appendChild(div);
        // 原生方法获取浏览器对元素的计算值
        let mm1 = document.getElementById('mm').getBoundingClientRect();
        console.log(mm1);
        div.remove();
        return mm1.width;
    },
    /**
     * 获取网址的传参，直接传入的location.search 原始值
     * str  location.search 原始值
     * return: 对象
     */
    getUrlParse(str) {
        let rtn = {};
        str = str.slice(1);
        let strInfo = decodeURIComponent(str);
        let keyValueArr = strInfo.split('&');
        keyValueArr.forEach(function (Str) {
            let arrKV = Str.split('=');
            let key = arrKV[0];
            let value = arrKV[1];
            if (rtn[key] == undefined) {
                rtn[key] = value;
            } else {
                //多个值便存为数组
                let arrValue = rtn[key];
                rtn[key] = [].concat(arrValue, value);
            }
        });
        return rtn;
    },
    /**
     * 将对象值转为网址传参格式，将返回值直接拼入网址后即可
     * str  location.search 原始值
     * return: 网址传参 ?username=&password=&hobby=book&hobby=dance
     */
    doUrlIfy(obj) {
        let rtn = '?';
        for (const key in obj) {
            if (Object.hasOwnProperty.call(obj, key)) {
                // Object.hasOwnProperty.call(obj, key) 判断key是否在obj存在
                const element = obj[key];
                if (typeof element == 'object') {
                    //数组的时候
                    for (let i = 0; i < element.length; i++) {
                        const arrValue = element[i];

                        rtn += `${key}=${arrValue}&`;
                    }
                } else {
                    rtn += `${key}=${element}&`;
                }
            }
        }
        let lastIndex = rtn.lastIndexOf('&');
        rtn = rtn.substr(0, lastIndex);
        return rtn;
    },
    // 追加本地存储
    saveLocal(key, jsonObj) {
        let arr = JSON.parse(localStorage.getItem(key) || '[]');
        let id = arr[arr.length - 1] ? arr[arr.length - 1].id + 1 : 0;
        jsonObj.id = id;
        arr.push(jsonObj);
        localStorage.setItem(key, JSON.stringify(arr));
    },
    // 修改本地存储 ，其实就是覆盖，
    updateLocal(key, str) {
        localStorage.setItem(key, str);
        return 1;
    },
    // 获取本地存储
    getLocal(key) {
        let str = localStorage.getItem(key) || '{}';
        return str;
    },

    // 利用本地存储存储参数
    saveParma(params) {
        params = { ...JSON.parse(getLocal('params')), ...params };
        updateLocal('params', JSON.stringify(params));
    },
    // 获取参数 return 对象
    getParma(params) {
        return JSON.parse(getLocal('params'));
    },

    // q清除本地存储存储参数
    clearParma() {
        localStorage.removeItem('params');
    },

    /**
     * 根据出生日期计算岁数
     * @param {} birthday  日期格式字符串，可以被 Date对象创建实例
     * @returns 年龄
     */
    getAge(birthday) {
        //出生时间 毫秒
        var birthDayTime = new Date(birthday).getTime();
        //当前时间 毫秒
        var nowTime = new Date().getTime();
        //一年毫秒数(365 * 86400000 = 31536000000)
        let age = Math.ceil((nowTime - birthDayTime) / 31536000000);
        if (isNaN(age)) {
            age = 0;
        }
        return age + '岁';
    },
};