stringUtils

序列化为字符串

// 将基本数据类型、对象等序列化为字符串
function serialize(value, parents = []) {
    // 处理基本类型和特殊值
    if (value === null) return 'null';
    if (value === undefined) return 'undefined';
    
    const type = typeof value;
    
    // 基本类型快速处理
    if (type === 'string') {
        // 转义双引号和反斜杠等字符
        return '"' + value.replace(/[\\"]/g, '\\$&').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\t/g, '\\t') + '"';
    }
    if (type === 'number') {
        if (isNaN(value)) return 'NaN';
        if (value === Infinity) return 'Infinity';
        if (value === -Infinity) return '-Infinity';
        return String(value);
    }
    if (type === 'boolean') return value ? 'true' : 'false';
    if (type === 'bigint') return value.toString() + 'n';
    if (type === 'symbol') {
        const desc = value.description ? value.description : '';
        return `Symbol(${desc})`;
    }
    if (type === 'function') {
        const name = value.name || 'anonymous';
        return `[Function: ${name}]`;
    }
    
    // 对象类型
    if (value && typeof value === 'object') {
        // 检测循环引用
        if (parents.includes(value)) {
            return '[Circular]';
        }
        
        // 处理支持 toJSON 方法的对象
        if (typeof value.toJSON === 'function') {
            return serialize(value.toJSON(), parents);
        }
        
        // 获取具体对象类型
        const objType = Object.prototype.toString.call(value);
        
        // Date
        if (objType === '[object Date]') {
            try {
                return `Date("${value.toISOString()}")`;
            } catch(e) {
                return `Date("${value.toString()}")`;
            }
        }
        
        // RegExp
        if (objType === '[object RegExp]') {
            return value.toString();
        }
        
        // Error
        if (objType === '[object Error]') {
            return `Error("${value.message}")`;
        }
        
        // Map
        if (objType === '[object Map]') {
            const newParents = [...parents, value];
            const entries = [];
            for (const [k, v] of value.entries()) {
                entries.push(`${serialize(k, newParents)} => ${serialize(v, newParents)}`);
            }
            return `Map{${entries.join(', ')}}`;
        }
        
        // Set
        if (objType === '[object Set]') {
            const newParents = [...parents, value];
            const items = [];
            for (const item of value) {
                items.push(serialize(item, newParents));
            }
            return `Set{${items.join(', ')}}`;
        }
        
        // Array
        if (Array.isArray(value)) {
            const newParents = [...parents, value];
            const items = [];
            // 处理稀疏数组
            for (let i = 0; i < value.length; i++) {
                if (i in value) {
                    items.push(serialize(value[i], newParents));
                } else {
                    items.push('empty');
                }
            }
            return `[${items.join(', ')}]`;
        }
        
        // 普通对象
        const newParents = [...parents, value];
        const keys = Object.keys(value);
        const props = [];
        for (const key of keys) {
            const propValue = value[key];
            // 避免输出过长或递归，直接序列化值
            props.push(`"${key}": ${serialize(propValue, newParents)}`);
        }
        // 可选：处理 Symbol 属性（默认不处理，若要启用取消注释）
        // const syms = Object.getOwnPropertySymbols(value);
        // for (const sym of syms) {
        //     const symKey = `Symbol(${sym.description || ''})`;
        //     props.push(`${symKey}: ${serialize(value[sym], newParents)}`);
        // }
        return `{${props.join(', ')}}`;
    }
    
    // 兜底处理（极少出现的情况）
    return String(value);
}


// 调用方法
serialize(各种类型的变量)

删除最后一个后缀

/**
 * 2021年7月4日 23:05:58
 * chanchaw
 * raw：传入原始字符串
 * suffix：字符串最后一个字符符合则删除后返回
 */
function removeSuffix(raw,suffix) {
  let str = raw.toString();
  if(str.substr(str.length-1,1)==suffix)
    str = str.substr(0,str.length-1)
  return str;
}

移除前后不可见字符

删除字符串首尾的不可见字符，保留中间的

// 移除字符串前后不可见字符，保留中间的任何字符
function trimInvisible(str) {
    // 匹配所有常见的空白字符（包括零宽空格等）
    return str.replace(/^[\s\uFEFF\u200B\u200C\u200D\u2028\u2029\u00A0]+|[\s\uFEFF\u200B\u200C\u200D\u2028\u2029\u00A0]+$/gu, '');
}

移除字符保留数字

const str = 'xieyezi 123123 to hao ffff22222';
const numbers = str.replace(/\D/g,'');

反转字符串

const sentence='abc 112233';
const reverseSentence=reverseBySeparator(sentence, "");
console.log(reverseSentence);// 332211 cba

const reverseEachWord = reverseBySeparator(sentence, " ");
console.log(reverseEachWord);// cba 332211

function reverseBySeparator(string, separator){
    return string.split(separator).reverse().join(separator);
}

填充到指定长度

/**
* 2021年7月4日 21:27:27
* chanchaw
* raw：原始字符串
* len： 要填充到的目标长度
* filler： 填充物
*/
function fillPrefix(raw,len,filler) {
  let tmp = raw.toString()
  tmp = tmp.padStart(len,filler)
  return tmp
}

英文首字母大写

const capitalize = str => str.charAt(0).toUpperCase() + str.slice(1)
    
capitalize("follow for more")
// Result: Follow for more

将下划线表名转换为小驼峰

// 将带有下划线的表名转换为小驼峰返回。传入：bill_code，返回 billCode
function smallCamel(tableName){
    const capitalize = (str)=> str.charAt(0).toUpperCase() + str.slice(1)
    const strArray = tableName.split('_')
    let ret = strArray[0]
    if(strArray.length>1){
        for(let i=1;i<strArray.length;i++){
            ret = ret + capitalize(strArray[i])
        }
    }
    return ret
}

取指定长度的随机字符串

const randomString13 = Math.random().toString(16).substring(2)// 13位
const randomString11 = Math.random().toString(36).substring(2) // 11位