.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) //串长度不为0且源串不能小于子串长度;
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) //串长度不为0且源串不能小于子串长度;
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)
}
}
评论