设置、获取、删除cookie

let _cookie = {
    /**
     * 设置cookie
     * @param {*} key 键名
     * @param {*} value 键值
     * @param {*} time 过期时间（天）（默认30天）
     */
    set: function (key, value, time) {
        let _time = time || 30;
        let _date = new Date();
        _date.setTime(_date.getTime() + (_time * 24 * 60 * 60 * 1000));
        document.cookie = key + '=' + value + '; expires=' + _date;
    },
    /**
     * 获取cookie
     * @param {*} key 键名
     * @returns 键值
     */
    get: function (key) {
        let $cookie = document.cookie;
        let tempCookie = $cookie.split('; ');
        for (let i = 0; i < tempCookie.length; i++) {
            let temp = tempCookie[i].split('=');
            if (temp[0] == key) {
                return temp[1];
            }
        }
    },
    /**
     * 删除cookie
     * @param {*} key 键名
     */
    delete: function (key) {
        document.cookie = key + '=; expries=-1;';
    }
}

获取用户设备

/**
 * 获取用户设备
 * @returns 用户设备（'iOS','Android','Web'）
 */
function getUserDevice() {
    var ua = navigator.userAgent.toLowerCase()
    if (ua.match(/iPhone\sOS/i) === 'iphone os' || ua.match(/iPad/i) === 'ipad') { // ios
        return 'iOS'
    } else if (ua.match(/Android/i) === 'android') {
        return 'Android'
    } else {
        return 'Web'
    }
}

获取数据类型

/**
 * 获取数据类型
 * @param {*} param 数据
 * @returns 类型（字符串）
 */
function getDataType(param) {
    return Object.prototype.toString.call(param).slice(8, -1);
}

1. 字符串

字符串去重

/**
 * 字符串去重
 * @param {*} str 需要去重的字符串
 * @returns 去重后的字符串 
 */
function uniqueStr(str) {
    let newStr = '';
    for (let i = 0; i < str.length; i++) {
        if (newStr.indexOf(str[i]) == -1) {
            newStr += str[i];
        }
    }
    return newStr;
}

获取网络地址中的参数

/**
 * 获取网站地址中的参数
 * @param {*} url 网站地址（可不传，不传默认为当前网址）
 * @returns 参数对象
 */
function getHrefParam(url) {
    let url = url || window.location.href;
    let paramStartIdx = url.indexOf('?');
    let paramStr = url.slice(paramStartIdx + 1, -1);
    let paramStrArr = paramStr.split('&');
    let paramObj = {};
    for (let i = 0; i < paramStrArr.length; i++) {
        let temp = paramStrArr[i].split('=');
        paramObj[temp[0]] = temp[1];
    }
    return paramObj;
}

2. 数字

数字补零

/**
 * 数字补零
 * @param {*} number 需要补零的数字
 * @param {*} len 目标长度
 * @returns 补零后的数字（字符串）
 */
function formatNumberZeroize(number, len) {
    let _currLen = number.toString().length;
    let _zero = '';
    for (let i = 0; i < len - _currLen; i++) {
        _zero += '0';
    }
    return _zero + number;
}

为数字添加分位符

/**
 * 数字添加分位符
 * @param {*} number 需要添加分位符的数字
 * @param {*} separator 分位符（默认为','）
 * @returns 添加分位符后的数字字符串
 */
function splitNumber(number, separator) {
    let _numStr = parseInt(number).toString();
    let _sep = separator || ',';
    let _newNumberStr = '';
    for (let i = _numStr.length - 1; i >= 0; i--) {
        if ((i + 1) % 3 == 0 && i != _numStr.length - 1) {
            _newNumberStr += _sep + _numStr[_numStr.length - i - 1];
        }else {
            _newNumberStr += _numStr[_numStr.length - i - 1];
        }
    }
    return _newNumberStr;
}

3.数组

数组去重

/**
 * 数组去重
 * @param {*} arr 需要去重的数组  
 * @returns 去重后的数组
 */
function uniqueArray(arr) {
    return [...new Set(arr)]
}

数组排序

/**
 * 数组排序
 * @param {*} arr 需要排序的数组
 * @param {*} isReverse 排序方式（可不传，默认从小到大排列；传false时，从大到小排列数组）
 * @returns 排序后的数组
 */
function sortArray(arr, isReverse) {
    for (let i = 0; i < arr.length - 1; i++) {
        for (let j = 1; j < arr.length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                let temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    if (isReverse) {
        arr.reverse();
        return arr;
    } else {
        return arr;
    }
}

两个数字范围内生成指定数量的不重复随机数

/**
 * 两个数字范围内生成指定数量的不重复随机数
 * @param {*} min 范围最小值
 * @param {*} max 范围最大值
 * @param {*} count 生成的随机数数量
 * @returns 指定数量长度的随机数数组
 */
function getRandoms(min, max, count) {
    var randomArr = [];
    for (i = 0; i < count; i++) {
        var _random = Math.ceil(Math.random() * (max - min) + min);
        while (checkNumInArr(_random,randomArr)) {
            _random = Math.ceil(Math.random() * (max - min) + min);
        }
        randomArr[i] = _random;
    }
    return randomArr;
}

检查数组中是否包含某元素

function checkNumInArr(ele, arr) {
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] == ele) {
            return true;
        }
    }
    return false;
}

4. 日期时间

格式化日期时间

/**
 * 格式化日期时间
 * @param {*} date 需要格式化的日期时间（可以是字符串或时间戳）
 * @param {*} formatStr 目标格式化日期
 * @returns 
 */
function formatDate(date, formatStr) {
    if (getDataType(date) == 'Number') { 
        if (date.toString().length == 10) {
            date = date * 1000;
        }
    }
    let _date = new Date(date);
    let formatArr = ['Y', 'M', 'D', 'h', 'm', 's'];
    let newArr = [];
    let newFormatStr = '';
    let Y = _date.getFullYear();
    let M = formatNumberZeroize(_date.getMonth() + 1, 2);
    let D = formatNumberZeroize(_date.getDate(), 2);
    let h = formatNumberZeroize(_date.getHours(), 2);
    let m = formatNumberZeroize(_date.getMinutes(), 2);
    let s = formatNumberZeroize(_date.getSeconds(), 2);
    newArr.push(Y, M, D, h, m, s);
    for (let i = 0; i < formatStr.length; i++) {
        let _idx = formatArr.indexOf(formatStr[i]);
        if (_idx != -1) {
            newFormatStr += newArr[_idx];
        } else {
            newFormatStr += formatStr[i];
        }
    }
    return newFormatStr;
}

计算两个日期的时间差

/**
 * 计算两个日期的时间差
 * @param {*} startDate 
 * @param {*} endDate 
 * @returns 时间差对象（例：{d: 1, h: 0, m: 2, s: 33, ms: 0}）
 */
function betweenDate(startDate, endDate) {
    let _start = new Date(startDate).getTime();
    let _end = new Date(endDate).getTime();
    let _between = _start > _end ? _start - _end : _end - _start;
    let _betweenObj = {}
    let d = Math.floor(_between / (24 * 60 * 60 * 1000));// 天
    let h = Math.floor(_between % (24 * 60 * 60 * 1000) / (60 * 60 * 1000));// 小时
    let m = Math.floor(_between % (24 * 60 * 60 * 1000) % (60 * 60 * 1000) / (60 * 1000));// 分
    let s = Math.floor(_between % (24 * 60 * 60 * 1000) % (60 * 60 * 1000) % (60 * 1000) / 1000);// 秒
    let ms = Math.floor(_between % (24 * 60 * 60 * 1000) % (60 * 60 * 1000) % (60 * 1000) % 1000);// 毫秒
    _betweenObj.d = d;
    _betweenObj.h = h;
    _betweenObj.m = m;
    _betweenObj.s = s;
    _betweenObj.ms = ms;
    return _betweenObj;
}