常用JS工具类

基础的一些校验功能都有，但是如果需要进行校验需要后端联合校验，前端校验只是为了减轻后端压力。否则重写函数return true，所有校验皆为无效！！！ 

/**
 * 别天天想着重写函数跳过判断
 * 后端也有校验，别浪费时间了
 * @param json
 */

// 配置页面
function setPageCfg(json) {
    nicePage.setCfg({
        table: 'table',
        bar: 'pageBar',
        limit: 10,
        color: '#1E9FFF',
        layout: ['count', 'prev', 'page', 'next', 'limit', 'skip']
    });
    layui.use("laypage", function () {
        var a = layui.laypage;
        a.render({
            elem: nicePage.bar,
            limit: nicePage.limit,
            theme: nicePage.color,
            count: json.length,
            layout: nicePage.layout,
            jump: function (b) {
                document.getElementById(nicePage.table).innerHTML = function () {
                    var c = [nicePage.returnHtml(nameList, widthList)],
                        d = nicePage.returnList(json).concat().splice(b.curr * b.limit - b.limit, b.limit);
                    layui.each(d, function (e, g) {
                        var f = nicePage.returnTable(g);
                        c.push(f)
                    });
                    c.push(" </tbody></table></br>");
                    return c.join("")
                }()

            }
        })
    })
}

// 时间格式化
function dateFormat(fmt, date) {
    let ret;
    const opt = {
        "Y+": date.getFullYear().toString(),        // 年
        "m+": (date.getMonth() + 1).toString(),     // 月
        "d+": date.getDate().toString(),            // 日
        "H+": date.getHours().toString(),           // 时
        "M+": date.getMinutes().toString(),         // 分
        "S+": date.getSeconds().toString()          // 秒
        // 有其他格式化字符需求可以继续添加，必须转化成字符串
    };
    for (let k in opt) {
        ret = new RegExp("(" + k + ")").exec(fmt);
        if (ret) {
            fmt = fmt.replace(ret[1], (ret[1].length == 1) ? (opt[k]) : (opt[k].padStart(ret[1].length, "0")))
        }
        ;
    }
    ;
    return fmt;
}

/**
 * ajax post提交
 * @param ajaxdata 提交数据
 * @param ajaxurl 提交路径
 * @param successcallback 成功回调
 * @param errorcallback 失败回调
 */
function ajaxPost(ajaxdata, ajaxurl, successcallback, errorcallback) {
    $.ajax({
        cache: true,
        type: "post",
        dataType: "json",
        url: ajaxurl,
        data: ajaxdata,
        async: true,
        success: function (data) {
            if ($.isFunction(successcallback)) {
                successcallback.call(this, data);
            }
        },
        error: function (data) {
            if ($.isFunction(errorcallback)) {
                errorcallback.call(this, data);
            }
        }
    });
}

/**
 * ajax get
 * @param ajaxdata 提交数据
 * @param ajaxurl 提交路径
 * @param successcallback 成功回调
 * @param errorcallback 失败回调
 */
function ajaxGET(ajaxdata, ajaxurl, successcallback, errorcallback) {
    $.ajax({
        cache: true,
        type: "get",
        dataType: "json",
        url: ajaxurl,
        data: ajaxdata,
        async: true,
        success: function (data) {
            if ($.isFunction(successcallback)) {
                successcallback.call(this, data);
            }
        },
        error: function (data) {
            if ($.isFunction(errorcallback)) {
                errorcallback.call(this, data);
            }
        }
    });
}

/**
 * processData设置为false。因为data值是FormData对象，不需要对数据做处理。
 * <form>标签添加enctype="multipart/form-data"属性。
 * cache设置为false，上传文件不需要缓存。
 * contentType设置为false。因为是由<form>表单构造的FormData对象，且已经声明了属性enctype="multipart/form-data"，所以这里设置为false。
 *
 * ajax FormData post提交
 */
function ajaxFormDataPost(ajaxdata, ajaxurl, successcallback, errorcallback) {
    $.ajax({
        type: "post",
        url: ajaxurl,
        data: ajaxdata,
        async: true,
        dataType: "json",
        contentType: false,
        processData: false,
        success: function (data) {
            if ($.isFunction(successcallback)) {
                successcallback.call(this, data);
            }
        },
        error: function (data) {
            if ($.isFunction(errorcallback)) {
                errorcallback.call(this, data);
            }
        }
    });
}

/**
 * ajax post提交 以contentType: "application/json"方式，后端使用@RequestBody 接收参数
 * @param ajaxdata 提交数据
 * @param ajaxurl 提交路径
 * @param successcallback 成功回调
 * @param errorcallback 失败回调
 */
function ajaxPostJSON(ajaxdata, ajaxurl, successcallback, errorcallback) {
    $.ajax({
        cache: true,
        type: "post",
        contentType: "application/json",//"application/json;charset=UTF-8"
        dataType: "json",
        url: ajaxurl,
        data: ajaxdata,
        async: true,
        success: function (data) {
            if ($.isFunction(successcallback)) {
                successcallback.call(this, data);
            }
        },
        error: function (data) {
            if ($.isFunction(errorcallback)) {
                errorcallback.call(this, data);
            }
        }
    });
}


/**
 * ajax post提交 （同步）
 * @param ajaxdata 提交数据
 * @param ajaxurl 提交路径
 * @param successcallback 成功回调
 * @param errorcallback 失败回调
 */
function ajaxSyncPost(ajaxdata, ajaxurl, successcallback, errorcallback) {
    $.ajax({
        cache: true,
        type: "post",
        dataType: "json",
        url: ajaxurl,
        data: ajaxdata,
        async: false,
        success: function (data) {
            if ($.isFunction(successcallback)) {
                successcallback.call(this, data);
            }
        },
        error: function (data) {
            if ($.isFunction(errorcallback)) {
                errorcallback.call(this, data);
            }
        }
    });
}

$.ajaxSetup({
    //设置ajax请求结束后的执行动作
    complete: function (XMLHttpRequest, textStatus) {
        // 通过XMLHttpRequest取得响应头，REDIRECT
        var redirect = XMLHttpRequest.getResponseHeader("REDIRECT");//若HEADER中含有REDIRECT说明后端想重定向
        if (redirect == "REDIRECT") {
            var win = window;
            while (win != win.top) {
                win = win.top;
            }
            //将后端重定向的地址取出来,使用win.location.href去实现重定向的要求
            win.location.href = XMLHttpRequest.getResponseHeader('CONTENTPATH');
        }
    }
});

/**
 * 通过正则表达式提取数字/非数字
 * @param str 字符串
 * @param NaN ture非数字，else 数字
 * @returns {XML|void|string|*}
 */
function extractDigits(str, NaN) {
    if (NaN) {
        return str.replace(/[0-9.-]/ig, "");
    }
    return parseInt(str.replace(/[^0-9.-]/ig, ""));
}

/**
 * @description base64编码方法
 * @param val 需要编码的字符串
 * @return 返回编码好的base64字符串
 *    中文进行编码时，需要使用base64Encode(encodeURIComponent(a))
 */
function base64Encode(val) {
    var base64hash = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
    val = encodeURIComponent(val);
    //把字符串转换为字符数组
    var strArr = val.split('');

    //装入结果的数组
    var result = [];
    //每个字符的ascii码
    var asciiCode;
    //上一个字符的ascii码
    var prevAsciiCode;

    var mod;
    //未填充之前的数组与3的模
    var preMod = strArr.length % 3;

    //使字符数组组成三个一组
    if (preMod == 1) {
        strArr.push(null);
        strArr.push(null);
    }
    if (preMod == 2) strArr.push(null);
    //遍历整个数组，寻找每个字符的ascii码
    for (var index in strArr) {
        if (!strArr[index]) {
            asciiCode = 0;
        } else {
            asciiCode = strArr[index].charCodeAt();
        }
        //位于一组当中的第几个字符
        mod = index % 3;
        switch (mod) {
            case 0:
                //往右移2位
                result.push(base64hash[asciiCode >> 2]);
                break;
            case 1:
                //上一个ascii码往左移4位与现在的ascii码往右移四位做或操作
                result.push(base64hash[(prevAsciiCode & 3) << 4 | asciiCode >> 4]);
                break;
            case 2:
                //假设当前组的ascii为：01000111,00000011,00000000
                //2表示当前索引位于第三个，第二个ascii码和15相与，获得低四位的值，右移两位后再从第三个ascii获取高二位作为新6位数的低二位
                result.push(base64hash[(prevAsciiCode & 15) << 2 | asciiCode >> 6]);
                //与2的6次方减1相与，获得低6位的值
                result.push(base64hash[asciiCode & 63]);
                break
        }

        prevAsciiCode = asciiCode
    }

    //处理异常
    if (preMod == 1) {
        result.splice(result.length - 2, 2);
        result.push('==');
    } else if (preMod == 2) {
        result.pop();
        result.push('=');
    }

    return result.join('');
}

/**
 * Base64译码
 * @param val base编码后的字符串
 * @returns {string} 原字符串
 */
function base64Decode(val) {
    var base64hash = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';

    //把字符串转换为字符数组
    var strArr = val.split('');

    //装入结果的数组
    var result = [];
    var preCode;
    var code;
    //余数，1-3
    var n;
    for (var i in strArr) {
        n = i % 4;
        code = base64hash.indexOf(strArr[i]);
        switch (n) {
            case 0:
                preCode = base64hash.indexOf(strArr[i]);
                break;
            case 1:
                result.push(String.fromCharCode(preCode << 2 | (code & 48) >> 4));
                break;
            case 2:
                result.push(String.fromCharCode((preCode & 15) << 4 | (code & 60) >> 2));
                break;
            case 3:
                result.push(String.fromCharCode(((preCode & 3) << 6) | code));
                break;

        }
        preCode = code;

    }

    return decodeURIComponent(result.join(''));
}

/**
 * 通过正则来判断是否是手机号，1开头 34578第2位，结尾为0-9的9个整数
 * @param phoneInput
 * @returns {boolean}
 */
function isPhoneAvailable(phoneInput) {
    var myreg = /^[1][3,4,5,7,8][0-9]{9}$/;
    if (!myreg.test(phoneInput)) {
        return false;
    } else {
        return true;
    }
}

/**
 * 邮箱正则
 * @param emailInput
 * @returns {boolean}
 */
function isEmailAvailable(emailInput) {
    var myreg = /^([a-zA-Z0-9]+[_|\_|\.]?)*[a-zA-Z0-9]+@([a-zA-Z0-9]+[_|\_|\.]?)*[a-zA-Z0-9]+\.[a-zA-Z]{2,3}$/;
    if (!myreg.test(emailInput)) {
        return false;
    } else {
        return true;
    }
}

function StringIsEmpty(str) {
    if (result == null || result == "" || result == 'undefined')
        return true;
    else
        return false

}

function IsURL(strUrl) {
    var regular = /^\b(((https?|ftp):\/\/)?[-a-z0-9]+(\.[-a-z0-9]+)*\.(?:com|edu|gov|int|mil|net|org|biz|info|name|museum|asia|coop|aero|[a-z][a-z]|((25[0-5])|(2[0-4]\d)|(1\d\d)|([1-9]\d)|\d))\b(\/[-a-z0-9_:\@&?=+,.!\/~%\$]*)?)$/i
    if (regular.test(strUrl)) {
        return true;
    }
    else {
        return false;
    }
}