网易 
新闻 LOFTER 邮箱 相册 阅读 图书 有道 摄影 企业邮箱 优惠券 云笔记 闪电邮 邮箱大师 印像派 考拉海购
 
更多
博客 
手机博客 博客搬家 博客VIP服务 发现 小组 风格
 
LiveWriter写博 word写博 邮件写博 短信写博
 
群博客 博客油菜地 博客话题 博客热点 博客圈子 找朋友
 
注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示！由于新浪微博认证机制调整，您的新浪微博帐号绑定已过期，请重新绑定！立即重新绑定新浪微博》  |  关闭

沙漠里de烟雨

原创分享，禁止转载

导航

 
 
 
 
 

日志

 
 
关于我
漠雨
文章分类
网易考拉推荐

qml下的可处理中文字符的JS类  

2017-05-11 02:45:44|  分类： QT5.x与QML |  标签： |举报 |字号大中小 订阅

  下载LOFTER 我的照片书  |
jString.js =>

.pragma library

//////////////////////////////////////
    ////以下函数均支持中文,utf-8;////
//////////////////////////////////////

//================================
//功能：获取子串;
//源串:srcStr;
//开始位置：begPos(包含);
//结束位置：endPos(包含);
//返回：子串,string类型;错误则为空串("");
//================================
function mid(srcStr,begPos,endPos)
{
    ///先判断参数类型是否正确,确保代码运行安全;
    if(typeof srcStr != "string")
    {
        print("Error: param 1 typeof(srcStr)!=string");
        return ;
    }
    if(typeof begPos != "number")
    {
        print("Error: param 2 typeof(begPos)!=int");
        return ;
    }
    if(typeof endPos != "number")
    {
        print("Error: param 3 typeof(endPos)!=int");
        return ;
    }
    ///-

    var src_len = srcStr.length; //源串长度;

    if(src_len <= 0) //空串;
        return "";

    ///--
    if(begPos < 0) //左边界不能<0,否则纠正;
        begPos = 0;
    if(begPos >= src_len) //左边界超过源串;
        return "";
    ///--确保begPos在[0,src_len)内;

    ///--
    if(endPos >= src_len) //右边界不能>src_len-1,否则纠正;
        endPos = src_len - 1;
    if(endPos < begPos) //左边界不能超过右边界;
        return "";
    ///--确保endPos在[begPos,src_len)内;

    var newStr = "";
    for(var i=begPos;i<=endPos;i++)
    {
        newStr = newStr.concat(srcStr.charAt(i));
    }

    return newStr;
}

//================================
//功能：获取左子串;
//源串:srcStr;
//结束位置：endPos(包含此位置,若endPos>=srcStr.length，则endPos=srcStr.length-1);
//返回：子串,string类型;错误则为空串("");
//================================
function left(srcStr,endPos)
{
    ///先判断参数类型是否正确,确保代码运行安全;
    if(typeof srcStr != "string")
    {
        print("Error: param 1 typeof(srcStr)!=string");
        return ;
    }
    if(typeof endPos != "number")
    {
        print("Error: param 2 typeof(endPos)!=int");
        return ;
    }
    ///-

    return mid(srcStr,0,endPos);
}

//================================
//功能：获取右子串;
//源串:srcStr;
//结束位置：begPos(包括此位置,如果begPos<0,则begPos=0);
//返回：子串,string类型;错误则为空串("");
//================================
function right(srcStr,begPos)
{
    ///先判断参数类型是否正确,确保代码运行安全;
    if(typeof srcStr != "string")
    {
        print("Error: param 1 typeof(srcStr)!=string");
        return ;
    }
    if(typeof begPos != "number")
    {
        print("Error: param 2 typeof(begPos)!=int");
        return ;
    }
    ///-

    return mid(srcStr,begPos,srcStr.length-1);
}

//================================
//功能：获取子串第一次出现在源字符串（以srcBegPos位置开始）中的位置;
//源字符串：srcStr;
//子字符串：subStr;
//源串开始比较位置：srcBegPos;
//返回：首次出现的位置resBegPos,int类型;不存在则为-1;
//================================
function indexOf(srcStr,subStr,srcBegPos)
{
    ///先判断参数类型是否正确,确保代码运行安全;
    if(typeof srcStr != "string")
    {
        print("Error: param 1 typeof(srcStr)!=string");
        return ;
    }
    if(typeof subStr != "string")
    {
        print("Error: param 2 typeof(subStr)!=string");
        return ;
    }
    if(typeof srcBegPos != "number")
    {
        print("Error: param 3 typeof(srcBegPos)!=int");
        return ;
    }
    ///-

    var src_len = srcStr.length; //源串长度;
    var sub_len = subStr.length; //子串长度;

    if(src_len<=0 || sub_len<=0 || src_len<sub_len) //串长度不为０且源串不能小于子串长度;
        return -1;

    if(srcBegPos>=src_len) //源串起始位置超过其长度;
        return -1;

    if(srcBegPos<0) //起始边界<0,纠正;确认srcBegPos在[0,src_len)内;
        srcBegPos = 0;

    var resBegPos = -1; //结果值;
    var sub_pos = 0;
    var sub_begChar_val = subStr.charCodeAt(sub_pos); //子串首字符的Unicode值;

    while(srcStr.charCodeAt(srcBegPos) != sub_begChar_val) //拿子串的首字符值与源串从头开始逐个比较,遇到相同时退出此循环;
    {
        if(src_len <= srcBegPos) //源串已结束;
            return -1;
        srcBegPos++;
    }

    //此时源串中存在与子串首字符相同的字符,然后从下一个字符开始做同步比较;
    resBegPos = srcBegPos;
    srcBegPos++;
    sub_pos++;

    while(sub_len > sub_pos) //子串未结束;
    {
        if(src_len <= srcBegPos) //源串已结束;
            return -1;

        if(srcStr.charCodeAt(srcBegPos) != subStr.charCodeAt(sub_pos)) //同步比较时源串与子串某个对应字符不同;
        {
            //此时子串还未比较完,应该以srcBegPos的这个位置开始之后的字符串与子串(subStr)重新比较;
            return indexOf(srcStr,subStr,srcBegPos);
        }
        else
        {
            srcBegPos++;
            sub_pos++;
        }
    }

    return resBegPos;
}

//================================
//功能：获取子串第一次出现在源字符串中的位置;
//源字符串：srcStr;
//子字符串：subStr;
//返回：首次出现的位置begPos,int类型;不存在则为-1;
//================================
function firstIndexOf(srcStr,subStr)
{
    ///先判断参数类型是否正确,确保代码运行安全;
    if(typeof srcStr != "string")
    {
        print("Error: param 1 typeof(srcStr)!=string");
        return ;
    }
    if(typeof subStr != "string")
    {
        print("Error: param 2 typeof(subStr)!=string");
        return ;
    }
    ///-

    return indexOf(srcStr,subStr,0);
}

//================================
//功能：获取子串最后一次出现在源字符串中的位置;
//源字符串：srcStr;
//子字符串：subStr;
//返回：最后出现的位置resLastIndex,int类型;不存在则为-1;
//================================
function lastIndexOf(srcStr,subStr)
{
    ///先判断参数类型是否正确,确保代码运行安全;
    if(typeof srcStr != "string")
    {
        print("Error: param 1 typeof(srcStr)!=string");
        return ;
    }
    if(typeof subStr != "string")
    {
        print("Error: param 2 typeof(subStr)!=string");
        return ;
    }
    ///-

    var resLastIndex = -1;

    var src_len = srcStr.length; //源串长度;
    var sub_len = subStr.length; //子串长度;

    if(src_len<=0 || sub_len<=0 || src_len<sub_len) //串长度不为０且源串不能小于子串长度;
        return -1;

    var srcBegPos = 0;
    while(srcBegPos < src_len)
    {
        var index = indexOf(srcStr,subStr,srcBegPos);
        if(index < 0)
            break;

        resLastIndex = index;
        srcBegPos = srcBegPos + subStr.length;
    }

    return resLastIndex;
}

//================================
//功能：判断一字符串是否包含子串;
//源字符串：srcStr;
//子字符串：subStr;
//返回：Boolean 值;
//================================
function contains(srcStr,subStr)
{
    ///先判断参数类型是否正确,确保代码运行安全;
    if(typeof srcStr != "string")
    {
        print("Error: param 1 typeof(srcStr)!=string");
        return ;
    }
    if(typeof subStr != "string")
    {
        print("Error: param 2 typeof(subStr)!=string");
        return ;
    }
    ///-

    return firstIndexOf(srcStr,subStr)>=0 ;
}

//================================
//功能：获取子串出现在源字符串数组中的下标索引位置;
//源字符串数组：srcStrArray;
//子字符串：subStr;
//是否模糊查询：bFuzzyQuery;
//返回：源字符串数组中出现子串的下标索引位置所组成的数组，int[]类型;
//================================
function containsInArray(srcStrArray,subStr,bFuzzyQuery)
{
    ///先判断参数类型是否正确,确保代码运行安全;
    if(typeof srcStrArray != "object")
    {
        print("Error: param 1 typeof(srcStrArray)!=array");
        return ;
    }
    if(typeof subStr != "string")
    {
        print("Error: param 2 typeof(subStr)!=string");
        return ;
    }
    if(typeof bFuzzyQuery != "boolean")
    {
        print("Error: param 3 typeof(bFuzzyQuery)!=bool");
        return ;
    }
    ///-

    var indexArray = new Array;

    if(srcStrArray.length<=0 || subStr.length<=0)
        return indexArray;

    var nCount = srcStrArray.length;

    if(bFuzzyQuery) //模糊匹配;
    {
        for(var i=0;i<nCount;i++)
        {
            if(firstIndexOf(srcStrArray[i],subStr) >= 0)
                indexArray.push(i);
        }
    }
    else //精确匹配;
    {
        for(var j=0;j<nCount;j++)
        {
            if(isEqual(srcStrArray[j],subStr,true))
                indexArray.push(j);
        }
    }

    return indexArray;
}

//================================
//功能：获取字符串的长度大小;
//字符串：srcStr;
//返回：int 类型;
//================================
function size(srcStr)
{
    ///先判断参数类型是否正确,确保代码运行安全;
    if(typeof srcStr != "string")
    {
        print("Error: param 1 typeof(srcStr)!=string");
        return ;
    }
    ///-

   return srcStr.length;
}

//================================
//功能：判断字符串是否为空;
//字符串：srcStr;
//返回：boolean 类型;
//================================
function isNull(srcStr)
{
    ///先判断参数类型是否正确,确保代码运行安全;
    if(typeof srcStr != "string")
    {
        print("Error: param 1 typeof(srcStr)!=string");
        return ;
    }
    ///-

   return srcStr.length<=0 ;
}

//================================
//功能：判断字符串是否为空;
//字符串：srcStr;
//返回：boolean 类型;
//================================
function isEmpty(srcStr)
{
    ///先判断参数类型是否正确,确保代码运行安全;
    if(typeof srcStr != "string")
    {
        print("Error: param 1 typeof(srcStr)!=string");
        return ;
    }
    ///-

   return srcStr.length<=0 ;
}

//================================
//功能：判断两字符串是否相同;
//字符串：oneStr;
//字符串：otherStr;
//是否区分大小写：bDiffCaps;为true则表示区分大小写，false则不区分大小写;
//返回：boolean 类型;
//================================
function isEqual(oneStr,otherStr,bDiffCaps)
{
    ///先判断参数类型是否正确,确保代码运行安全;
    if(typeof oneStr != "string")
    {
        print("Error: param 1 typeof(oneStr)!=string");
        return ;
    }
    if(typeof otherStr != "string")
    {
        print("Error: param 2 typeof(otherStr)!=string");
        return ;
    }
    ///-

    var one_len = oneStr.length;
    var other_len = otherStr.length;

    if(one_len<=0 || other_len<=0 || one_len!=other_len)
        return false;

    if(bDiffCaps) //区分大小写;
    {
        for(var i=0;i<one_len;i++)
        {
            if(oneStr.charCodeAt(i) != otherStr.charCodeAt(i))
                return false;
        }
    }
    else
    {
        for(var j=0;j<one_len;j++)
        {
            var oneVal = oneStr.charCodeAt(j);
            var otherVal = otherStr.charCodeAt(j);
            if(oneVal != otherVal) //首先不相等;
            {
                var bRes = (oneVal-otherVal==32) || (otherVal-oneVal==32); //其次值相差32;
                if(bRes == true)
                {
                    bRes = (isChart(oneVal,false)||isChart(oneVal,true)) && (isChart(otherVal,false)||isChart(otherVal,true)); //然后是它俩均是字母;
                    if(bRes == true)
                        continue;
                }
                return false;
            }
        }
    }

    return true;
}

//================================
//功能：克隆字符串;
//源字符串：srcStr;
//返回：新的字符串newStr;
//================================
function colone(srcStr)
{
    ///先判断参数类型是否正确,确保代码运行安全;
    if(typeof srcStr != "string")
    {
        print("Error: param 1 typeof(srcStr)!=string");
        return ;
    }
    ///-

    if(srcStr.length<=0)
        return "";

    var newStr = "";
    var nCount = srcStr.length;
    for(var i=0;i<nCount;i++)
    {
        newStr = newStr.concat(srcStr.charAt(i));
    }

    return newStr;
}

//================================
//功能：将一字符串添加到源字符串的后面;字符串拼接;
//源字符串：srcStr;
//要新添加的字符串：appendStr;
//返回：新的字符串newStr;
//================================
function append(srcStr,appendStr)
{
    ///先判断参数类型是否正确,确保代码运行安全;
    if(typeof srcStr != "string")
    {
        print("Error: param 1 typeof(srcStr)!=string");
        return ;
    }
    if(typeof appendStr != "string")
    {
        print("Error: param 2 typeof(appendStr)!=string");
        return ;
    }
    ///-

    if(srcStr.length<=0)
        return colone(appendStr);

    if(appendStr.length<=0)
        return colone(srcStr);

    var newStr = colone(srcStr);
    var nCount = appendStr.length;
    for(var i=0;i<nCount;i++)
    {
        newStr = newStr.concat(appendStr.charAt(i));
    }

    return newStr;
}

//================================
//功能：将一字符串插入到源字符串的某个位置;
//源字符串：srcStr;
//待插入的字符串：insertStr;
//插入的位置:pos;
//返回：新的字符串newStr;
//================================
function insert(srcStr,insertStr,pos)
{
    ///先判断参数类型是否正确,确保代码运行安全;
    if(typeof srcStr != "string")
    {
        print("Error: param 1 typeof(srcStr)!=string");
        return ;
    }
    if(typeof insertStr != "string")
    {
        print("Error: param 2 typeof(insertStr)!=string");
        return ;
    }
    if(typeof pos != "number")
    {
        print("Error: param 3 typeof(pos)!=int");
        return ;
    }
    ///-

    var src_len = srcStr.length;
    var insert_len = insertStr.length;

    if(src_len<=0)
        return "";

    if(insert_len<=0)
        return colone(srcStr);

    if(pos<0)
        return append(insertStr,srcStr);

    if(pos>=src_len)
        return append(srcStr,insertStr);

    var newStr = "";
    var nCount = src_len + insert_len;
    var src_pos = 0;
    var insert_pos = 0;
    for(var i=0;i<nCount;i++)
    {
        if(i<pos)
        {
            newStr = newStr.concat(srcStr.charAt(src_pos));
            src_pos++;
        }
        else if(i>=pos && i<pos+insert_len)
        {
            newStr = newStr.concat(insertStr.charAt(insert_pos));
            insert_pos++;
        }
        else
        {
            newStr = newStr.concat(srcStr.charAt(src_pos));
            src_pos++;
        }
    }

    return newStr;
}

//================================
//功能：从源字符串中删除所有与removeStr匹配的字符;
//源字符串：srcStr;
//要删除的字符串：removeStr;
//返回：新的字符串newStr;
//================================
function remove(srcStr,removeStr)
{
    ///先判断参数类型是否正确,确保代码运行安全;
    if(typeof srcStr != "string")
    {
        print("Error: param 1 typeof(srcStr)!=string");
        return ;
    }
    if(typeof removeStr != "string")
    {
        print("Error: param 2 typeof(removeStr)!=string");
        return ;
    }
    ///-

    if(srcStr.length<=0)
        return "";

    if(removeStr.length<=0)
        return colone(srcStr);

    var begPos = 0;
    var newStr = "";
    var remove_len = removeStr.length;

    var index = indexOf(srcStr,removeStr,begPos);
    if(index<=0) //srcStr中不存在removeStr;
        return colone(srcStr);

    while(index>=begPos)
    {
        for(var i=begPos;i<index;i++)
        {
            newStr = newStr.concat(srcStr.charAt(i));
        }
        begPos = index + remove_len;
        index = indexOf(srcStr,removeStr,begPos);
    }

    if(newStr.length>0 && index<0)
    {
        var last_len = srcStr.length-begPos;
        for(var j=begPos;j<begPos+last_len;j++)
        {
            newStr = newStr.concat(srcStr.charAt(j));
        }
    }

    return newStr;
}

//================================
//功能：将一字符串替换源字符串中的某些字符串;
//源字符串：srcStr;
//要被替换的字符串：be_replaced_Str;
//替换的字符串：replacer_Str;
//返回：新的字符串newStr;
//================================
function replace(srcStr,be_replaced_Str,replacer_Str)
{
    ///先判断参数类型是否正确,确保代码运行安全;
    if(typeof srcStr != "string")
    {
        print("Error: param 1 typeof(srcStr)!=string");
        return ;
    }
    if(typeof be_replaced_Str != "string")
    {
        print("Error: param 2 typeof(be_replaced_Str)!=string");
        return ;
    }
    if(typeof replacer_Str != "string")
    {
        print("Error: param 3 typeof(replacer_Str)!=string");
        return ;
    }
    ///-

    if(srcStr.length<=0)
        return ""

    if(replacer_Str.length<=0)
        return colone(srcStr);

    if(be_replaced_Str.length<=0)
        return colone(replacer_Str);

    var index = indexOf(srcStr,be_replaced_Str,0);
    if(index<0)
        return colone(srcStr);

    var begPos = 0;
    var newStr = "";
    var be_replaced_len = be_replaced_Str.length;
    var replacer_len = replacer_Str.length;
    while(index>=begPos)
    {
        for(var i=begPos;i<index;i++)
        {
            newStr = newStr.concat(srcStr.charAt(i));
        }
        for(var j=0;j<replacer_len;j++)
        {
            newStr = newStr.concat(replacer_Str.charAt(j));
        }
        begPos = index+be_replaced_len;
        index = indexOf(srcStr,be_replaced_Str,begPos);
    }

    if(newStr.length>0 && index<0)
    {
        var last_len = srcStr.length-begPos;
        for(var k=begPos;k<begPos+last_len;k++)
        {
            newStr = newStr.concat(srcStr.charAt(k));
        }
    }

    return newStr;
}

//================================
//功能：将字符串反转;
//源字符串：srcStr;
//返回：新的字符串newStr;
//================================
function reverse(srcStr)
{
    ///先判断参数类型是否正确,确保代码运行安全;
    if(typeof srcStr != "string")
    {
        print("Error: param 1 typeof(srcStr)!=string");
        return ;
    }
    ///-

    var nCount = srcStr.length;

    if(nCount<=0)
        return "";

    var newStr = "";
    for(var i=nCount-1;i>=0;i--)
    {
        newStr = newStr.concat(srcStr.charAt(i));
    }

    return newStr;
}

//================================
//功能：将源字符串根据拆分字符串(spliterStr)拆分成字符串数组;
//源字符串：srcStr;
//拆分字符串：appendStr;
//返回：新的字符串newStrArray数组;
//================================
function split(srcStr,spliterStr)
{
    ///先判断参数类型是否正确,确保代码运行安全;
    if(typeof srcStr != "string")
    {
        print("Error: param 1 typeof(srcStr)!=string");
        return ;
    }
    if(typeof spliterStr != "string")
    {
        print("Error: param 2 typeof(spliterStr)!=string");
        return ;
    }
    ///-

    var newStrArray = new Array;

    if(srcStr.length<=0)
        return newStrArray;

    if(spliterStr.length<=0)
    {
        newStrArray.push(srcStr);
        return newStrArray;
    }

    var begPos = 0;
    var index = indexOf(srcStr,spliterStr,begPos);
    var spliter_len = spliterStr.length;
    if(index<0)
    {
        newStrArray.push(srcStr);
        return newStrArray;
    }

    while(index>=begPos)
    {
        newStrArray.push(mid(srcStr,begPos,index-1));
        begPos = index+spliter_len;
        index = indexOf(srcStr,spliterStr,begPos);
    }
    if(newStrArray.length>0)
    {
        newStrArray.push(right(srcStr,begPos));
    }

    return newStrArray;
}

//================================
//功能：将字符串数组以连接字符串为连接器组合成一个新的字符串;
//源字符串数组：srcStrArray;
//连接器字符串：joinerStr;
//返回：新的字符串newStr;
//================================
function join(srcStrArray,joinerStr)
{
    ///先判断参数类型是否正确,确保代码运行安全;
    if(typeof srcStrArray != "object")
    {
        print("Error: param 1 typeof(srcStrArray)!=array");
        return ;
    }
    if(typeof joinerStr != "string")
    {
        print("Error: param 2 typeof(joinerStr)!=string");
        return ;
    }
    ///-

    if(srcStrArray.length<=0)
        return "";

    if(joinerStr.length<=0)
        return strArrayToString(srcStrArray);

    var newStr = "";
    var nCount = srcStrArray.length;
    for(var i=0;i<nCount;i++)
    {
        newStr = append(newStr,srcStrArray[i]);
        if(i<nCount-1)
            newStr = append(newStr,joinerStr);
    }

    return newStr;
}

//================================
//功能：将字符串数组依次组合成一个新的字符串;
//源字符串数组：srcStrArray;
//返回：新的字符串newStr;
//================================
function strArrayToString(srcStrArray)
{
    ///先判断参数类型是否正确,确保代码运行安全;
    if(typeof srcStrArray != "object")
    {
        print("Error: param 1 typeof(srcStrArray)!=array");
        return ;
    }
    ///-

    if(srcStrArray.length<=0)
        return "";

    var newStr = "";
    var nCount = srcStrArray.length;
    for(var i=0;i<nCount;i++)
    {
        var subStr = srcStrArray[i];
        var sub_len = subStr.length;
        for(var j=0;j<sub_len;j++)
        {
            newStr = newStr.concat(subStr.charAt(j));
        }
    }

    return newStr;
}

//================================
//功能：判断某个字符是否英文字母;
//字符的值：charVal;
//是否是大写字母：bIsCaps;
//返回：Boolean;
//================================
function isChart(charVal,bIsCaps)
{
    ///先判断参数类型是否正确,确保代码运行安全;
    if(typeof charVal != "number")
    {
        print("Error: param 1 typeof(charVal)!=int");
        return ;
    }
    if(typeof bIsCaps != "boolean")
    {
        print("Error: param 2 typeof(bIsCaps)!=boolean");
        return ;
    }
    ///-

    if(bIsCaps)
    {
        return (charVal>=65 && charVal<=90)
    }
    else
    {
        return (charVal>=97 && charVal<=122)
    }
}

  评论这张
 
阅读(23)| 评论(0)
推荐

历史上的今天

在LOFTER的更多文章

评论

<#--最新日志，群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇，下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

我的照片书 - 博客风格 - 手机博客 - 下载LOFTER APP - 订阅此博客

网易公司版权所有 ©1997-2018