Lu中的字符串函数

Lu中的字符串函数

ASCII字符串	单字节字符串。通常先转换为双字节字符串，操作后，再将结果转换为单字节字符串。
sys::astring	整数常量，用在函数new[sys::astring,... ...]中，申请astring对象（ASCII字符串）。函数new将调用函数astr以生成astring对象。
sys::astr	用法1：astr[k]。k为一个整数，返回一个k字节长的单字节字符串，初始化为一个空串。 用法2：astr[str]。str为一个双字节字符串，转换为单字节字符串并返回该串。 运行错误：1：参数非法；2：内存错误。
sys::ustr	用法：astr[str]。str为一个单字节字符串，转换为双字节字符串并返回该串。运行错误：1：参数非法；2：内存错误。
o	该函数是重载函数。仅提示信息： ***ASCII字符串须先用函数ustr转换为Unicode字符串后才能显示***
Unicode字符串	双字节字符串。Lu系统默认字符串。
sys::String	整数常量，用在函数new[sys::String,... ...]中，申请String对象。该对象的基本类型为string，扩展类型为String。
sys::String["abc"]	生成String对象并用一个字符串初始化 ，实际上是生成了该字符串的一个副本。该对象的基本类型为string，扩展类型为String。 运行错误：1：不可识别的初始化参数。
new	该函数是重载函数，但直接调用了string的new函数。用于申请String对象，该对象的基本类型为string，扩展类型为String。
+	重载运算符+，但直接调用了string的+函数。连接两个String。
len	该函数是重载函数，但直接调用了string的len函数。返回String的缓冲区长度。strlen函数返回一个字符串的长度。
o	该函数是重载函数。输出String的内容。运行错误：1：不可识别对象。
oset	该函数是重载函数，但直接调用了string的oset函数。设a是一个String，则执行形如a[i]=2的赋值语句时将调用该函数。
oget	该函数是重载函数，但直接调用了string的oget函数。设a是一个String，则执行形如a[i]的语句时将调用该函数。
sys::strlen[str]	返回字符串str的长度。len(str)返回字符串str的缓冲区大小。运行错误：1：不可识别对象。
sys::strcpy[str1,str2]	复制字符串str2到str1。当str1是动态字符串时，如果缓冲区不够用，会自动增加缓冲区。该函数不生成新的字符串 ，仍返回str1。 运行错误：1：参数非法；2：内存错误；3：静态缓冲区不够用。
sys::strcat[str1,str2]	将字符串str2连接到str1的后面。当str1是动态字符串时，如果缓冲区不够用，会自动增加缓冲区。该函数不生成新的字符串 ，仍返回str1。 运行错误：1：参数非法；2：内存错误；3：静态缓冲区不够用。
sys::substr[str,begin,end]	返回字符串str的子字符串，begin和end指定了子字符串的位置。如果begin或end为-1，或者大于字符串长度，取字符串的最后一个字符位置；此时，若begin>end，取end和begin之间字符串的反序字符串。运行错误：1：参数非法；2：内存错误。 例子1：substr["abcdefg",-1,3]，结果：gfed 例子2：substr["abcdefg",3,-1]，结果：defg
sys::strchr[str,c]	在字符串str中定位首次出现的字符c（整数），返回c在str中的下标（相对偏移量），失败时返回-1。运行错误：1：参数非法。
sys::strrchr[str,c]	在字符串str中定位最后出现的字符c（整数），返回c在str中的下标（相对偏移量），失败时返回-1。运行错误：1：参数非法。
sys::strcmp[str1,str2]	按字母顺序，对字符串进行比较。若str1<str2，返回值<0；若str1=str2，返回值=0；若str1>str2，返回值>0。运行错误：1：参数非法。
sys::strpbrk[str1,str2]	在字符串str1中定位字符集str2中首次出现的某个字符，返回这个字符在str1中的下标（相对偏移量），失败时返回-1。运行错误：1：参数非法。
sys::strspn[str1,str2]	在字符串str1中定位首次出现的不包含在字符集str2中的某个字符，返回这个字符在str1中的下标（相对偏移量），失败时返回-1。运行错误：1：参数非法。
sys::strstr[str1,str2,begin,end]	在字符串str1中查找子串str2，返回子串在str1中的位置（相对偏移量），失败时返回-1。begin和end指定了查找位置；若缺省end，则从begin位置开始查找；若begin和end都缺省，则查找整个字符串。运行错误：1： 参数个数非法；2：参数非法。
sys::strtok[str1,str2]	在字符串str1（包含分隔符和记号）中提取记号，str2是包含分隔符的字符串，返回一个luu对象，luu对象包含了所有提取的记号，失败时返回nil。 运行错误：1：参数非法。 例子：sys::strtok["one,two three , four*five", ", *"].o[];
sys::strlwr[str]	将字符串str转换为小写，仍返回该字符串。运行错误：1：参数非法。
sys::strupr[str]	将字符串str转换为大写，仍返回该字符串。运行错误：1：参数非法。
sys::strset[str,ch,begin,end]	将字符串str中从begin～end的内容设置为字符ch。若缺省begin和end，则设置整个内容；若仅缺省end，则设置从begin开始的内容。仍返回该字符串。运行错误：1：参数个数非法；2：参数非法。
sys::strrev[str]	反转字符串str中的字符顺序，仍返回该字符串。运行错误：1：参数非法。
sys::strrep[str,oldstr,newsyt,start,ntimes]	将字符串str中的子串oldstr替换为newstr，返回替换后的字符串。start为查找替换的开始位置，缺省为从头开始替换。ntimes指定进行替换的次数，缺省表示替换所有匹配。运行错误：1：参数个数非法；2：参数非法 ；3：内存错误。
sys::strdate[]	把日期拷贝到一个字符串中并返回该字符串，失败时返回nil。
sys::strtime[]	把时间拷贝到一个字符串中并返回该字符串，失败时返回nil。
Regex正则表达式	使用 DEELX 正则表达式引擎。请参考：DEELX正则引擎文档，或者 DEELX正则引擎网站。
sys::ComRegex	编译正则表达式文本。
sys::MatchExact	验证传入的文本是否刚好匹配正则表达式。
sys::Match	从文本中查找匹配符合表达式的子字符串。
sys::GetNamedGroupNumber	通过命名分组名，返回命名分组编号。
sys::PrepareMatch	初始化上下文对象，准备从文本中查找匹配符合表达式的子字符串。
sys::Replace	文本替换操作。
sys::IsMatched	获取是否匹配成功。
sys::GetStart	获取匹配到的子字符串开始位置。
sys::GetEnd	获取匹配到的子字符串结束位置。
sys::GetGroupStart	获取分组开始位置。
sys::GetGroupEnd	获取分组结束位置。
sys::MaxGroupNumber	获取正则表达式最大捕获组编号。

 

     LuSystem32.dll是一个Lu系统扩展动态库，包含一些增强Lu系统功能的函数、对系统内置类型的扩展以及一些新增数据类型等等。LuSystem不仅是对Lu系统的扩充，更在于演示Lu是极易扩充其功能的脚本，很少有脚本允许用户能方便地添加像字典、结构、类等高级的数据结构，但Lu允许，而且实现这些很容易，因而，LuSystem也是编程用户极佳的练手工具。

    主要的数据类型有：

    luu：系统内置类型lu表的扩展类型。

    String：系统内置类型字符串string的扩展类型。使用Unicode字符串。 可以使用正则表达式。

    dict：字典。

    struct：结构。

    class：类。

    file：文件类型。

    在LuSystem中的函数是通过二级函数命名空间“sys”输出的，所有函数均具有类似“sys::lufun(...)”的格式。使用!!!using("sys");可简化LuSystem中的函数访问。

    LuSystem目前还不完善，主要用来演示Lu系统的可扩充性，但一些实用的功能或函数会不断添加进来， 任何人也可以根据需要添加或改进函数的功能，欢迎大家给出各种改进的建议！

    LuSystem的源代码是开放的，源代码下载：http://www.forcal.net/xiazai/lu1/lu1code.rar

===================================================================================

    String是系统内置类型字符串string的扩展类型。

（1）生成String

!!!using("sys");
new[String,5 : "abc"].o[];    //用函数new生成String，长度为5， 并用一个字符串进行初始化。函数o用于输出String，并返回输出的字符数目。

用函数String生成String更为方便：实际上该函数生成了原字符串的一个副本。

!!!using("sys");
String["abc"].o[];            //用函数String生成String，必须用一个字符串作为初始化数据。

注意：函数strcpy将原字符串复制到目标字符串，但不会返回一个新串。

!!!using("sys");
main(:a)= a=String[""], strcpy[a,"abc"], o[a];

（2）元素存取：可直接对字符串做更改。

!!!using("sys");
main1(:a)= a=String["abc"], a[1]=a[2]+1, o[a];  //动态字符串
main2(:a)= a="abc",         a[1]=a[2]+1, o[a];  //静态字符串

（3）String缓冲区大小和长度

!!!using("sys");
main(:a)= a=new[String,5 : "abc"], o{"字符串缓冲区=",len(a),"  字符串长度=",strlen(a),"\r\n"};

（4）String连接：用加号+连接两个字符串，返回一个新串。

!!!using("sys");
o{String["abc"]+String["def"]};
o{String["abc"]+"def"};

（5）String连接：用函数strcat连接两个字符串，不返回新串。

!!!using("sys");
main(:me)=
  me=String["abc"], printf["%s\r\n",me],  //输出me
  strcat(me,"def"), printf["%s\r\n",me];  //输出me

（6）大小写互换：用自定义函数实现

!!!using("sys");
Swapcase(str:i,k,ch,a,z,A,Z)=
  k="azAZ", a=k[0], z=k[1], A=k[2], Z=k[3],  //获得字符azAZ的ASCII值
  k=strlen[str], i=0,
  while{i<k, ch=str(i),
    which{ch>=a & ch<=z : str(i)=ch-a+A,
          ch>=A & ch<=Z : str(i)=ch-A+a,
          ch},
    i++
  },
  str;
Swapcase["abc 88 啊啊 DEF"].o[];

（7）格式化字符串，用sprintf函数实现

!!!using("sys");
main(:a,b,k,i,s)=
  a=String[""], sprintf[a,"%20s","abc"],  o[a,"\r\n"],  //固定长度，右对齐，左边不够用空格补齐
  a=String[""], sprintf[a,"%-20s","abc"], o[a,"\r\n"],  //固定长度，左对齐，右边不够用空格补齐
  a=String[""], b="abc", k=[20-strlen(b)]/2, s=new[String,k+1], i=0, while{i<k,s[i++]=32},
  sprintf[a,"%s%s%s",s,b,s], o[a,"\r\n"];  //固定长度，中间对齐，两边不够用空格补齐

（8）去字符串两边空格

!!!using("sys");
main(:a,i,j,k)=  a=["   asd  啊啊  def   "], i=strspn(a," \r\n\t"), strrev(a), j=strlen(a)-strspn(a," \r\n\t")-1, strrev(a), o{substr[a,i,j]};

（9）是否以start开头

!!!using("sys");
main(:a)=  a=["   start 啊啊  def   "], strspn(a," \r\n\t")==strstr(a,"start");

（10）是否全小写

!!!using("sys");
main(:a)=  a=["   start wsx  def   "], strspn(a,"abcdefghijklmnopqrstuvwxyz \r\n\t")<0;

[返回页首] sys::ComRegex(pattern,flags)：编译正则表达式文本

    pattern：字符串，正则表达式。
    flags：表达式匹配模式。支持的匹配模式有：sys::reIgnoreCase,  sys::reSingleline, sys::reMultiline, sys::reGlobal,  sys::reRightToLeft, sys::reExtended 这 6 种模式以及它们的组合，或者使用缺省的sys::reNoFlag模式。可以缺省该参数，缺省值为sys::reNoFlag。详细说明如下：

    sys::reIgnoreCase  ：匹配时忽略大小写。默认情况下，正则表达式是要区分大小写的。不管是否指定忽略大小写模式，字符类，比如 [A-Z] 是要区分大小写的。

    sys::reSingleline ：使小数点 "."  可以匹配包含换行符（\n）在内的任意字符。默认情况下，小数点只匹配换行符以外的任意字符，不匹配换行符。

    sys::reMultiline ：使 ^ 符号除了能够匹配字符串开始位置外，还能匹配换行符（\n）之后的位置；使  $ 符号除了能够匹配字符串结束位置外，还能匹配换行符之前的位置。默认情况下， ^ 符号只能匹配字符串开始位置， $ 符号只能匹配字符串结束位置。sys::reSingleline  和 sys::reMultiline 虽然听起来相互矛盾，但却是作用在不同的地方。因此它们是可以组合使用的。在指定了  sys::reMultiline 之后，如果需要仅匹配字符串开始和结束位置，可以使用 \A 和 \Z。

    sys::reGlobal ：使 \G  可以用来匹配本次查找匹配的开始位置，对于连续的匹配来说，也就是上次匹配的结束位置。默认情况下， \G 没有作用。在进行替换操作（Replace）时，不管是否指定  sys::reGlobal 模式，都可以进行所有的替换。是否指定 sys::reGlobal 模式只是对 \G  起作用。如果希望进行有限次数的替换，可在替换操作时指定替换次数。

    sys::reRightToLeft  ：从右向左的进行匹配。从被匹配字符串的结束位置向前进行查找匹配，同时，在表达式中也是右侧的表达式先进行匹配。表达式的写法仍然按原来的习惯：匹配次数修饰符（*,  +, {n}, ……）仍然位于被修饰部分的右侧而不是左侧；^ 仍然匹配文本开始而不是文本结束；(?=xxx)  仍然是正向与搜索（向右预搜索），而不是向左；分组（group）编号仍然是从左向右进行编号；等等。不管整个表达式是否指定了  sys::reRightToLeft 模式，"反向预搜索（反向零宽度断言）" 内的表达式始终采用 sys::reRightToLeft 模式。

    sys::reExtended ：使 DEELX 忽略表达式中的空白字符，并且把从 #  开始到该行行末的内容视为注释。默认情况下，正则表达式中的空格，换行等字符将可以匹配相应的字符。指定了 sys::reExtended  模式后，如果要在正则表达式中表示空白字符比如空格符号（space）时，应该用 \x20 表示，如果要在表达式中表示 # 符号，应该用 \# 表示。不管是否指定了  sys::reExtended 模式，括号内以 ?# 号开始时，比如(?# xxx )，那么这一对括号以及包含的内容都始终作为注释而被忽略。

    返回值：pattern。出错时返回nil。

     说明：任何一个正则表达式对象，都需要先用该函数编译正则表达式文本后才能使用。

     运行错误：1：参数个数非法；2：参数非法。

    例子：判断一个字符串是否全由数字组成

!!!using["sys"];                              //使用命名空间sys
main()=
{
    ComRegex(@"\d+"),                         //编译正则表达式文本
    MatchExact("12345"),                      //验证是否刚好匹配
    which{
        IsMatched() : printf{"\r\nyes!\r\n"}, //匹配成功输出yes
        printf{"\r\nno!\r\n"}                 //匹配失败输出no
    }
};

[返回页首] sys::MatchExact(str)：验证传入的文本是否刚好匹配正则表达式

    str：进行匹配的字符串。

    返回值：str。

     说明：所谓刚好匹配，就是要求正则表达式从文本开始位置刚好匹配到文本结束位置。匹配结果可通过函数sys::IsMatched获取。

    运行错误：1：非法的字符串。

    例子

[返回页首] sys::Match(...  ...)：从文本中查找匹配符合表达式的子字符串

    格式1：sys::Match()：使用上下文对象，从上次匹配结束位置或者初始化位置开始查找匹配。上下文对象需要先使用函数sys::PrepareMatch进行初始化。
    格式2：sys::Match(str)：Match  方法未指定开始位置，则根据当前匹配模式是否是 sys::reRightToLeft 模式决定开始位置：如果是普通模式，则从 0 开始，向右查找；如果是  sys::reRightToLeft  模式，则从字符串结束位置开始，向左查找。
    格式3：sys::Match(str,start)：Match  方法指定了开始位置，则从指定位置开始查找。

    str：进行匹配的字符串。
    start：开始查找匹配的位置。

    返回值：str。

    说明：匹配结果可通过函数sys::IsMatched等函数获取。

     运行错误：1：参数个数非法；2：参数非法。

    例子1：Match格式1：在一段  C++ 源代码文本中，查找注释

!!!using["sys"];
main(:str)=
{
    str=new(string,"int a; /* a */"),          //申请字符串，存放源代码
    ComRegex(@"/\*((?!\*/).)*(\*/)?|//([^\x0A-\x0D\\]|\\.)*"),  //编译正则表达式文本
    PrepareMatch(str),                         //匹配准备
    Match(),                                   //匹配子字符串
    which{
        IsMatched() : printf{"\r\nfound:%s\r\n",substr[str,GetStart(),GetEnd()-1]},   //匹配成功输出匹配结果
        printf{"\r\nnot found!\r\n"}           //匹配失败输出 not found!
    }
};

    例子2：Match格式2：在一段  C++ 源代码文本中，查找注释

!!!using["sys"];
main(:str)=
{
    str=new(string,"int a; /* a */"),          //申请字符串，存放源代码
    ComRegex(@"/\*((?!\*/).)*(\*/)?|//([^\x0A-\x0D\\]|\\.)*"),  //编译正则表达式文本
    Match(str),                                //匹配子字符串
    which{
        IsMatched() : printf{"\r\nfound:%s\r\n",substr[str,GetStart(),GetEnd()-1]},   //匹配成功输出匹配结果
        printf{"\r\nnot found!\r\n"}           //匹配失败输出 not found!
    }
};

    例子3：列举一段文本中所有的带小数的数字

!!!using["sys"];
main(:str,result)=
{
    str=new(string,"12.5, a1.1, 0.123, 178"),  //申请字符串，存放文本
    ComRegex(@"\b\d+\.\d+"),                   //编译正则表达式文本
    PrepareMatch(str),                         //匹配准备
    Match(),                                   //匹配子字符串
    while{IsMatched(),                         //匹配成功输出匹配结果
        printf{"%s\r\n",substr[str,GetStart(),GetEnd()-1]},
        Match()                                //匹配子字符串
    }
};

[返回页首] sys::GetNamedGroupNumber(GroupName)：通过命名分组名，返回命名分组编号

    GroupName：字符串，命名分组名。

    返回值：命名分组编号。

     运行错误：1：非法的字符串。

[返回页首] sys::PrepareMatch(tstring,start)：初始化上下文对象，准备从文本中查找匹配符合表达式的子字符串

    tstring：进行匹配的字符串。
    start：开始查找的起始位置。可以缺省该参数，此时根据当前匹配模式是否是 sys::reRightToLeft 模式决定开始位置：如果是普通模式，则从 0  开始，向右查找；如果是 sys::reRightToLeft 模式，则从结束位置开始，向左查找。

    返回值：tstring。

     运行错误：1：参数个数非法；2：参数非法。

    例子

[返回页首] sys::Replace(str,rplto,start,ntimes)：文本替换操作

    str： 字符串。被进行替换的初始文本。
    rplto：“替换为”字符串，将匹配到的子字符串替换成  rplto 字符串。
    start：进行查找替换的开始位置。可以缺省该参数（默认-1），此时根据是否是  sys::reRightToLeft 自动决定开始位置。
    ntimes：指定进行替换的次数。可以缺省该参数（默认-1），此时表示替换所有匹配。

    返回值：替换后得到的新字符串。

     运行错误：1：参数个数非法；2：参数非法；3：内存错误。

[返回页首] sys::IsMatched()：获取是否匹配成功

    返回值：返回 true 表示匹配成功，返回 false 表示匹配失败。

    例子

[返回页首] sys::GetStart()：获取匹配到的子字符串开始位置

    返回值：匹配成功后，获取所匹配到的子字符串的开始位置。如果匹配失败，则返回负值。

    例子

[返回页首] sys::GetEnd()：获取匹配到的子字符串结束位置

    返回值：匹配成功后，获取所匹配到的子字符串的结束位置。如果匹配失败，则返回负值。

    例子

[返回页首] sys::GetGroupStart(nGroupNumber)：获取分组开始位置

    nGroupNumber： 整数，分组编号。

    返回值： 获取指定分组捕获的字符串的开始位置。如果指定分组未捕获，或者整个表达式未匹配成功，则返回负值。

    运行错误：1：非法的参数。

[返回页首] sys::GetGroupEnd(nGroupNumber)：获取分组结束位置

    nGroupNumber： 整数，分组编号。

    返回值： 获取指定分组捕获的字符串的结束位置。如果指定分组未捕获，或者整个表达式未匹配成功，则返回负值。

    运行错误：1：非法的参数。

[返回页首] sys::MaxGroupNumber()：获取正则表达式最大捕获组编号

    返回值：返回最大分组编号。