[工具（前端）] 字符串工具函数

[工具（前端）] 时间处理函数

书接上回。这次是字符串的相关处理，包括常用的验证，金额的转换，url参数等…

校验邮箱格式

/**
 * 校验邮箱格式
 * @param email 邮箱
 * @returns {boolean} 邮箱格式是否正确
 */
checkEmail: (email) => {
    return RegExp(/^[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,6}$/)
        .test(email);
},

校验手机

/**
 * 校验手机
 * @param mobile 手机号码
 * @returns {boolean} 手机格式是否正确
 */
checkMobile: (mobile) => {
    return RegExp(/^1[3-9]\d{9}$/).test(mobile);
},

判断密码的强度

/**
 * 判断密码的强度
 * @param password 密码
 * @param limitLength 最小长度
 * @returns {{uppercase: boolean, number: boolean, lowercase: boolean, strength: number, specialChar: boolean, limitLength: boolean}}
 * 返回密码强度对象{uppercase:是否有大写字母,number:是否有数字,lowercase:是否有小写字母,strength:密码强度,specialChar:是否有特殊字符,limitLength:密码长度是否满足要求}
 */
passwordStrength: (password, limitLength = 8) => {
    let strength = 0; //强度
    const minLength = limitLength; //最小长度
    const hasUppercase = /[A-Z]/.test(password); //是否含有大写字母
    const hasLowercase = /[a-z]/.test(password); //是否含有小写字母
    const hasNumber = /\d/.test(password); //是否含有数字
    const hasSpecialChar = /[!@#$%^&*(),.?":{}|<>]/.test(password);//是否含有特殊字符

    if (password.length >= minLength) strength++;
    if (hasUppercase) strength++;
    if (hasLowercase) strength++;
    if (hasNumber) strength++;
    if (hasSpecialChar) strength++;

    return {
        limitLength: password.length >= minLength,
        uppercase: hasUppercase,
        lowercase: hasLowercase,
        number: hasNumber,
        specialChar: hasSpecialChar,
        strength: strength
    }
},

获取随机字符串

/**
 * 获取随机字符串
 * @param len 字符串长度 默认长度为6
 * @returns {string} 随机字符串
 */
randomString: (len = 6) => {
    const possibleChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    let result = '';
    for (let i = 0; i < length; i++) {
        result += possibleChars.charAt(Math.floor(Math.random() * possibleChars.length));
    }
    return result;
},

获取URL参数 new URLSearchParams方式 以http/https开头

/**
 * 获取URL参数 new URLSearchParams方式  以http/https开头
 * @param url url
 * @returns {{}} 参数对象
 */
getURLParameters: (url) => {
    url = new URL(url);
    let params = new URLSearchParams(url.search.slice(1));
    let obj = {};
    for (let [key, value] of params.entries()) {
        obj[key] = value;
    }
    return obj;
},

获取URL参数 切割字符串的方式 url带？号开始切割

/**
 * 获取URL参数 切割字符串的方式  url带？号开始切割
 * @param url  url
 * @returns {{}|*}  参数对象
 */
getUrlParams: (url) => {
    var query = url.split('?')[1];
    if (!query) return {};

    return query.split('&').reduce((params, param) => {
        var keyValue = param.split('=');
        params[keyValue[0]] = decodeURIComponent(keyValue[1]);
        return params;
    }, {});
},

字符串转base64

/**
 * 字符串转base64
 * @param str 字符串
 * @returns {string} base64字符串
 */
stringToBase64:(str)=> {
    return Buffer.from(str, 'utf8').toString('base64');
},

base64转字符串

/**
 * base64转字符串
 * @param base64
 * @returns {*}
 */
base64ToString:(base64)=> {
    return Buffer.from(base64, 'base64').toString('utf8');
},

字符串反转

/**
 * 字符串反转
 * @param str
 * @returns {*}
 */
reverseString:(str)=> {
    return str.split('').reverse().join('');
},

统计字符串中每个字符出现的次数

/**
 * 统计字符串中每个字符出现的次数
 * @param str
 * @returns {{}}
 */
countCharacters:(str)=> {
    let count = {}; // 初始化一个空对象来存储字符计数
    for(let i = 0; i < str.length; i++) {
        let char = str[i];
        if(count[char]) {
            count[char]++; // 如果字符已存在于对象中，则增加计数
        } else {
            count[char] = 1; // 如果字符不存在，则初始化计数为1
        }
    }
    return count;
},

格式化金额

/**
 * 格式化金额
 * @param amount 金额
 * @param decimalPlaces 小数位数
 * @param separator 千分位分隔符
 * @returns {string}
 */
formatMoney:(amount, decimalPlaces = 2, separator = ',')=> {
    // 确保输入是数值类型
    amount = parseFloat(amount);

    // 添加小数位数
    let formattedAmount = amount.toFixed(decimalPlaces);

    // 添加千位分隔符
    formattedAmount = formattedAmount.replace(/\B(?=(\d{3})+(?!\d))/g, separator);

    // 返回格式化后的金额
    return formattedAmount;
},

数字金额转中文大写金额

/**
 * 数字金额转中文大写金额
 * @param num 数字金额
 * @returns {string} 中文字符串
 */
numberToChinese:(num)=> {
    const strs = num.toString().replace(/(?=(\d{4})+$)/g, ",")
        .split(",").filter(Boolean);

    const chinese = ['零','壹','贰','叁','肆','伍','陆','柒','捌','玖']
    const unit = ['','拾','佰','仟']
    //处理四位数
    function _transform(numStr){
        let result = '';
        for (let i = 0; i < numStr.length; i++) {
            const digit = chinese[numStr[i]];
            const c = unit[numStr.length - 1 - i];
            if(digit === '零'){
                if(result[result.length-1] !== chinese[0]){
                    result += digit;
                }

            }else{
                result += digit + c;
            }
        }
        //去除末尾的零
        if(result[result.length-1] === chinese[0]){
            result = result.slice(0, -1);
        }
        return result;
        //console.log(result);
    }
    let res = "";
    const bigUnit = ['','万','亿'];
    for (let i = 0; i < strs.length; i++) {
        const part = strs[i];
        //处理中间四位都是零的情况
        res += _transform(part) ? _transform(part) + bigUnit[strs.length - i - 1] : _transform(part);
    }
    return res;
}