【备忘】一些方法(TS)

    /**判断是否整数 */
    static isInteger(num: number): boolean {
        return typeof (num) == "number" && Math.floor(num) === num;
    }

    /**能否被4整除 
     * @param target 传个整数
    */
    static isDivideBy4(target: number): boolean {
        //若一个整数的末尾两位数能被4整除，则这个数能被4整除
        if (this.isInteger(target)) {//是整数
            let str_tar = target.toString();
            let len = str_tar.length;
            let end2num = Number(str_tar);
            if (len > 2) {//大于2位数，才取后2位
                end2num = Number(str_tar.substr(len - 2, 2));
            }
            //能被4整除 
            if (end2num % 4 == 0) {
                return true;
            }
        }
        return false;
    }
   /**能被4整除的数，传入的不是就最近的
     * @param target 传个整数
     * @returns 能被4整除的整数
    */
    static canDivideBy4(target: number): number {
        let result = 0;
        let str_tar = target.toString();
        let len = str_tar.length;

        //若一个整数的末尾两位数能被4整除，则这个数能被4整除
        if (this.isInteger(target)) {//是整数
            let end2num = Number(str_tar);
            if (len > 2) {//大于2位数，才取后2位
                end2num = Number(str_tar.substr(len - 2, 2));
            }

            if (end2num % 4 == 0) {
                result = target;
            } else {
                let t_num = end2num / 4;
                if (len >= 3) {//整数，不用区分
                    //2位数前
                    let left2num = Number(str_tar.substr(0, len - 2)) * 100;
                    result = left2num + Math.ceil(t_num) * 4;
                } else {
                    result = Math.ceil(t_num) * 4;
                }
            }
        } else {//有小数
            let len1 = str_tar.split('.')[0];

            let end2num = Number(len1);
            if (len1.length > 2) {//大于2位数，才取后2位
                end2num = Number(len1.substr(len1.length - 2, 2));
            }
            //小数，要区分
            let len2 = len1.length;

            if (end2num % 4 == 0) {
                result = Number(len1);
            } else {
                let t_num = end2num / 4;

                if (len2 >= 3) {//整数，不用区分
                    //2位数前
                    let left2num = Number(str_tar.substr(0, len2 - 2)) * 100;
                    result = left2num + Math.ceil(t_num) * 4;
                } else {
                    result = Math.ceil(t_num) * 4;
                }
            }
        }
        return result;
    }

    /**
     * 检查是否为移动电话
     * @param content 
     */
    static IsCheckPhone(content: string): boolean {
        if (!(/^1\d{10}$/.test(content))) {
            return false;
        }
        return true;
    }
    /**
   * 字符串是否为空字符串
   * @param obj 
   */
    static isEmptyString(obj: string): boolean {
        if (typeof obj == "undefined" || obj == null || obj == "") {
            return true;
        } else {
            return false;
        }
    }

    static isChinese(temp): boolean {
        var re = new RegExp("/^[\u{4e00}-\u{9fa5}]+$/u");
        if (re.test(temp)) return false;
        return true;
    }



    /**判断2个时间戳相差几天(返回值是整数)
     * @param start 距今较远的天数
     * @param end 距今较近的天数
     * @returns 整数的天数
     */
    static DayDiff(start: number, end: number): number {
        let s_date = new Date(start);
        let e_date = new Date(end);

        let days = e_date.getTime() - s_date.getTime();
        let diff = Math.floor(days / 86400000); //简化计算 直接输一天的毫秒数 86400000 = (1000 * 60 * 60 * 24)

        if (diff < 0) {
            diff = 0;
        }
        return diff;
    }



   /**返回间隔天数的时间戳,从大到小排序 (不包括判断的这2天)
     * @param start 距今较远的天数
     * @param end 距今较近的天数
     * @param is_includeEnd 是否包括判断的end这天
     */
    static DaysDiffArr(start: number, end: number, is_includeEnd: boolean = false): Array<number> {
        let days = [];
        let day_num = this.DayDiff(start, end);
        if (day_num > 0 && is_includeEnd) {//补上end 这天的
            days.push(end);
        }
        //加2者之间间隔的日期
        for (let i = 1; i < day_num + 1; i++) {
            let day = (end - (i * 86400000)); //刚好也是从大到小排序
            //不是和最开始同一天，就加入,差距在一天内，算同一天
            if (!this.isSameDay(start, day) && (this.DayDiff(start, day) > 0)) {
                days.push(day);
            }
        }
        return days;
    }

    /**
     * 返回目标的参数字段
     * @param s_str 修改的字符串
     * @param sub_str 目标字符串
     */
    static getUrlParam(s_str: string, sub_str: string = 'from'): string {
        if (this.isEmptyString(s_str)) {
            return "";
        }
        let targetStr: string = "";
        s_str = decodeURIComponent(s_str);
        if (s_str.indexOf("?") != -1) {
            let str = s_str.substr(1);
            let strs = str.split("&");
            for (let i = 0; i < strs.length; i++) {
                if (sub_str == strs[i].split("=")[0]) {
                    targetStr = unescape(strs[i].split("=")[1]);
                    break;
                }
            }
        }
        return targetStr;
    }

    /**
     * 目标字符串中是否包含数组中的元素
     * @param str 目标字符串
     * @param arr 包含条件的字符串数组
     */
    static isTarInArr(str: string, arr: Array<string>): boolean {
        if (arr.toString().indexOf(str) > -1) {
            return true;
        }
        return false;
    }

    static versionCompare(versionA, versionB): number {
        var vA = versionA.split('.')
        var vB = versionB.split('.')
        for (var i = 0; i < vA.length; ++i) {
            var a = parseInt(vA[i])
            var b = parseInt(vB[i] || "0")
            if (a === b) {
                continue;
            }
            else if (a > b) {
                return 1;
            } else {
                return -1;
            }
        }
        return 0;
    }

    /**返回能被10整除的数字：末位是0的整数 */
    private divisionTen(num: number): number {
        let str = Math.floor(num).toString();
        let last_num = Number(str.charAt(str.length - 1));//取最后一位
        if (last_num == 0) {
            return num;
        }
        let t = 10;
        t -= last_num;
        return t + num; //加起来是最靠近下个能被10整除的数字
    }

    /**根据对象某属性去重,替换新的 */
    private uniqueFunc(arr: Item[], flag?: any) {
        let paramlen = arr.length;

        if (paramlen == 1) {
            return arr;
        } else {
            // let t_res = new Map();
            // return arr.filter(item =>!t_res.has(item[flag]) && t_res.set(item[flag], item));

            //object.assgin()怕出问题
            let t_res = {};
            for (let i = 0; i < arr.length; i++) {
                let item = arr[i];
                t_res[item.userId] = item;
            }
            let res = [];
            for (const key in t_res) {
                if (Object.prototype.hasOwnProperty.call(t_res, key)) {
                    let element = t_res[key];
                    res.push(element);
                }
            }
            //排列数量最大值到小值
            res.sort((a: Item, b: Item) => {
                return b.day - a.day;
            })

            return res;
        }

    }

//var reChinese = /[^\u4e00-\u9fa5￥]/;//汉字的正则￥