mingyang_text/text.js

a collection of string related functions

/**
author:王甫君
create time:2018-03-24
wang.fu.jun@qq.com
wx/qq:96211
***************************************
*/






/**
 * 对【数字】或【字符】进行【左侧补齐】操作
 * @param {"数字或字符"} args_Input
 * @param {"目标长度"} args_Length
 * @param {"占位符"} args_PlaceHolder
 */
function func_StringFormat(args_Input, args_Length, args_PlaceHolder) {
    let temp_TXT = args_Input.toString();
    if (args_Length > temp_TXT.length) {
        let temp_Fil = args_PlaceHolder.toString();
        let temp_Len = args_Length - temp_TXT.length;
        for (let i = 0; i < temp_Len; i++) {
            temp_TXT = temp_Fil + temp_TXT;
        }
    }
    return temp_TXT;
}
module.exports.do_StringFormat = func_StringFormat;





/**
 * 生成随机数
 * @param {"最小值，随机数可以选中最小值"} args_Min
 * @param {"最大值，随机数不会选中最大值"} args_Max
 */
function func_Random(args_Min, args_Max) {
    let temp_Val = Math.floor(Math.random() * (args_Max - args_Min)) + args_Min;
    //console.log(temp_Val);
    return temp_Val;
}
module.exports.do_Random = func_Random;





/**
 * 格式化时间
 * @param {"时间对象，如果传入空，那么将使用当前时间"} args_Date
 * @param {"时间格式，例如【yyyy-MM-dd HH:mm:ss.fff】【yyyyMMddHHmmssfff】"} args_Format
 */
function func_DateTimeToString(args_Date, args_Format) {

    if (args_Date == null) {
        args_Date = new Date();
    }

    let t_y = args_Date.getFullYear();        //获取完整的年份(4位)
    let t_M = args_Date.getMonth() + 1;       //获取当前月份(0-11,0代表1月)
    let t_d = args_Date.getDate();            //获取当前日(1-31)
    let t_h = args_Date.getHours();           //获取当前小时数(0-23)
    let t_m = args_Date.getMinutes();         //获取当前分钟数(0-59)
    let t_s = args_Date.getSeconds();         //获取当前秒数(0-59)
    let t_i = args_Date.getMilliseconds();    //获取当前毫秒数(0-999)


    let t_Now = "";
    t_Now = args_Format;
    t_Now = t_Now.replace("yyyy", t_y);
    t_Now = t_Now.replace("MM", func_StringFormat(t_M, 2, '0'));
    t_Now = t_Now.replace("dd", func_StringFormat(t_d, 2, '0'));
    t_Now = t_Now.replace("HH", func_StringFormat(t_h, 2, '0'));
    t_Now = t_Now.replace("mm", func_StringFormat(t_m, 2, '0'));
    t_Now = t_Now.replace("ss", func_StringFormat(t_s, 2, '0'));
    t_Now = t_Now.replace("fff", func_StringFormat(t_i, 3, '0'));

    return t_Now;
}
module.exports.do_DateTimeToString = func_DateTimeToString;





/**
 * 根据给定的左右标签，提取父串中的子串
 * @param {"输入文本"} args_Text
 * @param {"左侧标记"} args_Bin
 * @param {"右侧标记"} args_End
 */
function func_Filter(args_Text, args_Bin, args_End) {

    if (args_Bin == "" && args_End == "") {
        return args_Text;
    }


    let t_iBin = 0;
    let t_iEnd = 0;
    let t_Line = "";
    let t_Start = 0;
    let t_Result = [];

    do {
        if (args_Bin == "") {
            t_iBin = t_Start;
        }
        else {
            t_iBin = args_Text.indexOf(args_Bin, t_Start);
            if (t_iBin == -1) {
                return t_Result;
            }
        }


        if (args_End == "") {
            t_iEnd = args_Text.indexOf(args_Bin, t_iBin + args_Bin.length);
            if (t_iEnd == -1) {
                t_iEnd = args_Text.length;
            }
        }
        else {
            t_iEnd = args_Text.indexOf(args_End, t_iBin + args_Bin.length);
            if (t_iEnd == -1) {
                return t_Result;
            }
        }

        t_Line = args_Text.substring(t_iBin + args_Bin.length, t_iEnd);
        t_Result.push(t_Line);

        t_Start = t_iEnd + args_End.length;
    } while (t_Start > -1 && t_Start < args_Text.length);

    return t_Result;
}
module.exports.do_Filter = func_Filter;





/**
 * 返回一个36位的时间在左侧的UUID
 */
function func_TimeID_36() {
    return func_TimeID(36);
}
module.exports.do_TimeID_36 = func_TimeID_36;

/**
 * 返回一个32位的时间在左侧的UUID
 */
function func_TimeID_32() {
    return func_TimeID(32);
}
module.exports.do_TimeID_32 = func_TimeID_32;

/**
 * 返回一个36位的时间在左侧的UUID
 */
function func_TimeNo_36() {
    return func_TimeID(36, "0123456789");
}
module.exports.do_TimeNo_36 = func_TimeNo_36;

/**
 * 返回一个32位的时间在左侧的UUID
 */
function func_TimeNo_32() {
    return func_TimeID(32, "0123456789");
}
module.exports.do_TimeNo_32 = func_TimeNo_32;

/**
 * 返回一个时间在左侧的UUID
 */
function func_TimeID(args_Digit, args_PlaceHolder) {
    let temp_List = new Array(args_Digit);

    //let temp_PlaceHolder = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"];
    let temp_PlaceHolder = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

    if (args_PlaceHolder != null) {
        temp_PlaceHolder = args_PlaceHolder;
    }

    let temp_Time = func_DateTimeToString(null, "yyyy-MMdd-HHmmss-fff");
    for (let i = 0; i < temp_Time.length; i++) {
        temp_List[i] = temp_Time[i];
    }

    temp_List[temp_Time.length] = "-";

    for (let i = temp_Time.length + 1; i < args_Digit; i++) {
        temp_List[i] = temp_PlaceHolder[func_Random(0, temp_PlaceHolder.length)];
    }

    //temp_List[20] = "-";
    //temp_List[27] = "-";

    let temp_UUID = temp_List.join("");
    return temp_UUID;
}
module.exports.do_TimeID = func_TimeID;





/**
 * 从【16进制文本】转换为【普通文本】
 * @param {"16进制文本"} args_Hex
 */
function func_Hex_goto_Plain(args_Hex) {
    let t_Buffer = Buffer.from(args_Hex, 'hex');
    return t_Buffer.toString("utf8");
}
module.exports.do_Hex_goto_Plain = func_Hex_goto_Plain;

/**
 * 从【普通文本】转换为【16进制文本】
 * @param {"普通文本"} args_Hex
 */
function func_Hex_from_Plain(args_Plain) {
    let t_Buffer = Buffer.from(args_Plain, "utf8");
    return t_Buffer.toString("hex");
}
module.exports.do_Hex_from_Plain = func_Hex_from_Plain;





/**
 * 【主字符串】是否以【从字符串】开头
 * @param {"主字符串"} args_Subject
 * @param {"从字符串"} args_Compare
 */
function func_Bin_With(args_Subject, args_Compare) {
    if (args_Subject == null || args_Compare == null) {
        return false;
    }
    if (args_Compare.length > args_Subject.length) {
        return false;
    }

    for (let i = 0; i < args_Compare.length; i++) {
        if (args_Compare[i] != args_Subject[i]) {
            return false;
        }
    }
    return true;
}
module.exports.do_Bin_With = func_Bin_With;

/**
 * 【主字符串】是否以【从字符串】结尾
 * @param {"主字符串"} args_Subject
 * @param {"从字符串"} args_Compare
 */
function func_End_With(args_Subject, args_Compare) {
    if (args_Subject == null || args_Compare == null) {
        return false;
    }
    if (args_Compare.length > args_Subject.length) {
        return false;
    }

    let temp_Residual = args_Subject.length - args_Compare.length;
    for (let i = args_Compare.length - 1; i > -1; i--) {
        if (args_Compare[i] != args_Subject[temp_Residual + i]) {
            return false;
        }
    }
    return true;
}
module.exports.do_End_With = func_End_With;





/**
 * KeyValue解码
 * @param {"源字符串"} args_Plain
 * @param {"分割字符"} args_Split
 * @param {"等于字符"} args_Equal
 */
function func_KeyValue_Decode(args_Plain, args_Split, args_Equal) {

    let temp_Data = {};
    let temp_Cookie_List = args_Plain.split(args_Split);
    let temp_Cookie_Line = "";
    for (let i = 0; i < temp_Cookie_List.length; i++) {
        if (temp_Cookie_List[i] == "") {
            continue;
        }
        temp_Cookie_Line = temp_Cookie_List[i].split(args_Equal);
        if (temp_Cookie_Line.length < 2) {
            continue;
        }
        temp_Data[decodeURIComponent(temp_Cookie_Line[0]).trim()] = decodeURIComponent(temp_Cookie_Line[1]).trim();
    }
    return temp_Data;
}
module.exports.do_KeyValue_Decode = func_KeyValue_Decode;

/**
 * KeyValue编码
 * @param {"源数据包"} args_Datas
 * @param {"分割字符"} args_Split
 * @param {"等于字符"} args_Equal
 * @param {"是否编码"} args_EncodeUriComponent
 * @param {"是否排序"} args_Sort
 */
function func_KeyValue_Encode(args_Datas, args_Split, args_Equal, args_EncodeUriComponent = true, args_Sort = false) {

    let temp_Keys = Object.keys(args_Datas);
    if (true == args_Sort) {
        temp_Keys.sort();
    }

    let t_Lenth = temp_Keys.length;
    if (t_Lenth == 0) {
        return "";
    }

    let temp_Value = "";
    let temp_Line = "";
    let i = 0;

    {
        if (true == args_EncodeUriComponent) {
            temp_Value = encodeURIComponent(args_Datas[temp_Keys[i]]);
        }
        else {
            temp_Value = args_Datas[temp_Keys[i]];
        }
        temp_Line = encodeURIComponent(temp_Keys[i]) + args_Equal + temp_Value;
        i++;
    }

    for (; i < t_Lenth; i++) {
        temp_Line += args_Split;

        if (true == args_EncodeUriComponent) {
            temp_Value = encodeURIComponent(args_Datas[temp_Keys[i]]);
        }
        else {
            temp_Value = args_Datas[temp_Keys[i]];
        }
        temp_Line += encodeURIComponent(temp_Keys[i]) + args_Equal + temp_Value;
    }

    return temp_Line;
}
module.exports.do_KeyValue_Encode = func_KeyValue_Encode;





/**
 * 【十进制数字】转成【它进制数字】
 * @param {"来源十进制数，例如：110715"} args_DecimalNumber
 * @param {"目标进制基数，例如：62"} args_NumberSystem
 * @param {"目标记号字符，例如：0123456789ABCDEF"} args_VisibleChar
 */
function func_DecimalToOther(args_DecimalNumber, args_NumberSystem, args_VisibleChar = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz") {

    {//通用的验证部分
        if (args_NumberSystem < 2 || args_NumberSystem > 62) {
            throw new Error(`the numberSystem must be between 2 and 62`);
        }

        if (args_VisibleChar.length < args_NumberSystem) {
            throw new Error(`numberSystem can't above to length of visibleChar`);
        }
    }

    if (args_DecimalNumber < 1) {
        return "0";
    }

    let temp_Result = "";
    for (; args_DecimalNumber > 0;) {
        temp_Result = args_VisibleChar[args_DecimalNumber % args_NumberSystem] + temp_Result;
        args_DecimalNumber = Math.floor(args_DecimalNumber / args_NumberSystem);
    }

    return temp_Result;
}
module.exports.do_DecimalToOther = func_DecimalToOther;

/**
 * 【它进制数字】转成【十进制数字】
 * @param {"来源进制数值，例如：TO80HHL"} args_OtherNumber
 * @param {"来源进制基数，例如：62"} args_NumberSystem
 * @param {"来源记号字符，例如：0123456789ABCDEF"} args_VisibleChar
 */
function func_DecimalFromOther(args_OtherNumber, args_NumberSystem, args_VisibleChar = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz") {

    {//通用的验证部分
        if (args_NumberSystem < 2 || args_NumberSystem > 62) {
            throw new Error(`the numberSystem must be between 2 and 62`);
        }

        if (args_VisibleChar.length < args_NumberSystem) {
            throw new Error(`NumberSystem can't above to length of VisibleChar`);
        }
    }

    if (args_OtherNumber == null || args_OtherNumber.trim() == "") {
        return NaN;
    }

    let temp_Char = "";
    let temp_Idex = 0;
    let temp_Result = 0;
    let temp_Leng = args_OtherNumber.length;
    for (let i = 0; i < temp_Leng; i++) {
        temp_Char = args_OtherNumber[i];
        // console.log(temp_Char);
        temp_Idex = args_VisibleChar.indexOf(temp_Char);
        // console.log(temp_Idex);
        temp_Result += temp_Idex * Math.pow(args_NumberSystem, (temp_Leng - i - 1));
    }

    return temp_Result;
}
module.exports.do_DecimalFromOther = func_DecimalFromOther;

/**
 * 【10进制数字】转成【62进制数字】
 * @param {"10进制数"} args_Base10Number
 */
function func_Base62Encode(args_Base10Number) {
    return func_DecimalToOther(args_Base10Number, 62);
}
module.exports.do_Base62Encode = func_Base62Encode;

/**
 * 【62进制数字】转成【10进制数字】
 * @param {"62进制数"} args_Base62Number
 */
function func_Base62Decode(args_Base62Number) {
    return func_DecimalFromOther(args_Base62Number, 62);
}
module.exports.do_Base62Decode = func_Base62Decode;





/**
 * 按照一定的顺序尝试分割字符串
 * @param {原始字符串} args_Text
 * @param {分隔符数组} args_DelimiterArray
 */
function func_Split(args_Text, args_DelimiterArray = [",", "-", "_", "/", "|", "~", "*", "+"]) {
    let temp_Result = [args_Text];
    for (let u = 0; u < args_DelimiterArray.length; u++) {
        if (args_Text.indexOf(args_DelimiterArray[u]) > -1) {
            temp_Result = args_Text.split(args_DelimiterArray[u]);
            temp_Result["delimiter"] = args_DelimiterArray[u];
            break;
        }
    }
    return temp_Result;
}
module.exports.do_Split = func_Split;





/**
 * 按照字节长度截取字符串
 * @param {"原始字符"} args_InputString
 * @param {"目标长度"} args_ByteLength
 * @param {"编码方式"} args_Encoding
*/
function func_Byte_Truncate(args_InputString, args_ByteLength, args_Encoding = "utf8") {
    let temp_Description = args_InputString.substring(0, args_ByteLength);
    let temp_Buffer = Buffer.from(temp_Description, args_Encoding);
    while (temp_Buffer.length > args_ByteLength) {
        temp_Description = temp_Description.substring(0, temp_Description.length - 1);
        temp_Buffer = Buffer.from(temp_Description, args_Encoding);
    }
    return temp_Description;
}
module.exports.do_Byte_Truncate = func_Byte_Truncate;





/**
 * 找到配对的坐标，匹配不上的时候返回-1
 * @param {"目标文本，例如【json串】"} args_Text
 * @param {"右侧的限度位置"} args_LimitIndex
 * @param {"当前字符的位置"} args_CurrentIndex
 * @param {"转义字符，例如【\】"} args_EscapeChar
 */
function func_EscapeChar
    (
       /*目标文本*/ args_Text
        , /*限度位置*/ args_LimitIndex
        , /*当前位置*/ args_CurrentIndex
        , /*转义字符*/ args_EscapeChar
    ) {
    let temp_Amount = 0;
    let temp_Char = "";
    do {
        args_CurrentIndex = args_CurrentIndex - 1;
        if (args_CurrentIndex >= args_LimitIndex) {//如果向前一位置，仍然小于开始位置
            temp_Char = args_Text.substring(args_CurrentIndex, args_CurrentIndex + 1);
            if (temp_Char == args_EscapeChar) {//记录一次
                temp_Amount++;
            }
            else {// 否则：停止
                break;
            }
        }
        else {//否则：停止
            break;
        }
    } while (true);

    return (temp_Amount % 2) == 0;
}
module.exports.do_EscapeChar = func_EscapeChar;





/**
* 返回一个数组，下标0：配对的坐标；下标1：缺失的结束文本个数；匹配不到的时候下标0为【-1】
* @param {"目标文本，例如【json串】"} args_Text
* @param {"开始文本，例如【(<】"} args_BinChar
* @param {"结束文本，例如【)>】"} args_EndChar
* @param {"开始位置，应是开始文本的下一位"} args_StartIndex
* @param {"查找范围，通常是目标文本的长度"} args_MaxLength
* @param {"转义字符，例如【\\】"} args_EscapeChar
*/
function func_PairText
    (
       /*要处理的目标字符串*/ args_Text
        , /*开始字符例如【{[】*/ args_BinChar
        , /*结束字符例如【}]】*/ args_EndChar
        , /*应该是起始字符的位置+1*/ args_StartIndex = 0
        , /*一般是输入字符的length*/ args_MaxLength = 0
        , /*转义字符例如【\\】*/ args_EscapeChar = null
    ) {

    //起步就是1个
    args_Missing = 1;

    if (args_EndChar == "") {//如果【结束符】是空，那么直接返回最后的位置
        return [args_Text.length, args_Missing];
    }




    if (args_BinChar == "") {//如果【开始符】是空，那么直接返回【结束符】的位置
        return [args_Text.indexOf(args_EndChar, args_StartIndex), args_Missing];
    }


    {//参数校验
        if (args_MaxLength == 0) {
            args_MaxLength = args_Text.length;
        }
        if (args_StartIndex == 0) {
            args_StartIndex = args_Text.indexOf(args_BinChar);
            if (args_StartIndex == -1) {
                return [args_Text.indexOf(args_EndChar, 0), args_Missing];
            }
            args_StartIndex = args_StartIndex + args_BinChar.length;
        }
    }


    let t_Index_Bin = 0;
    let t_Index_End = 0;
    let t_Start = 0;

    let t_Even_Number = false;
    for (; args_StartIndex < args_MaxLength;) {



        t_Start = args_StartIndex;
        do {
            t_Index_End = args_Text.indexOf(args_EndChar, t_Start);
            if (args_EscapeChar == null || args_EscapeChar == "") {
                break;
            }
            t_Even_Number = func_EscapeChar(args_Text, t_Start, t_Index_End, args_EscapeChar);

            /**
             * 只能加1，不能加p_EndChar.length
             * 案例：
             *      字符串="aaa0123456\tttt"
             *      开始符="aaa"
             *      结束符="ttt"
             *      转义符="\"
             */
            t_Start = t_Index_End + 1;
        }
        while (false == t_Even_Number);



        t_Start = args_StartIndex;
        do {
            t_Index_Bin = args_Text.indexOf(args_BinChar, t_Start);
            if (args_EscapeChar == null || args_EscapeChar == "") {
                break;
            }
            t_Even_Number = func_EscapeChar(args_Text, t_Start, t_Index_Bin, args_EscapeChar);

            /**
             * 只能加1，不能加p_EndChar.length
             * 案例：
             *      字符串="aaa0123456\tttt"
             *      开始符="aaa"
             *      结束符="ttt"
             *      转义符="\"
             */
            t_Start = t_Index_Bin + 1;
        }
        while (false == t_Even_Number);






        if (t_Index_End == -1) {
            return [-1, args_Missing];
        }
        else {
            if (t_Index_Bin > -1) {
                if (t_Index_End <= t_Index_Bin)//对于【开始符】和【结束符】一样的时候【结束符】优先
                {
                    args_Missing--;
                    args_StartIndex = t_Index_End + args_EndChar.length;
                }
                else {
                    args_Missing++;
                    args_StartIndex = t_Index_Bin + args_BinChar.length;
                }
            }
            else {
                {
                    args_Missing--;
                    args_StartIndex = t_Index_End + args_EndChar.length;
                }
            }
        }


        if (args_Missing == 0) {
            return [t_Index_End, args_Missing];
        }
    }
    return [-1, args_Missing];
}
module.exports.do_PairText = func_PairText;