您的位置：首页 > 编程语言 > Lua

Lua 字符串操作

2016-01-20 14:07 429 查看
https://segmentfault.com/a/1190000002735965

1 模式

1.1 字符类

字符类代表一组字符。可以用下列组合来表示一个字符类。

组合代表字母代表字符类型
x（变量 x）
^$()%.[]*+-?
以外的任一字符
.（dot）任意字符
%a（alphabet）字母
%b（bracket）对称字符以及字符间的内容
%c（control）控制字符（即各类转义符）
%d（digits）数字
%l（lowercase）小写字母
%p（punctuation）标点符号
%s（space）空格
%u（uppercase）大写字母
%w（word）字母和数字
%x（hexadecimal）十六进制字符
%z（zero）值为 0 的字符，即 '\0'
%x（变量 x）字母和数字以外的任一字符
如果组合中的字符写成大写形式（例如将 '%a' 写成 '%A'），相当于对原来所代表的字符类型取补集。

例子：

前两行的数字标出每个字符的下标。find函数返回找出第一个符合查找条件的字符的下标。

-----------------00000000001111111112 222222222333333333344444444445555 5
-----------------12345678901234567890 123456789012345678901234567890123 4
x = string.find("Tutu is a young man.\n His student number is 20230001.\0","i")
--> 6
x = string.find("Tutu is a young man.\n His student number is 20230001.\0",".")
--> 1
x = string.find("Tutu is a young man.\n His student number is 20230001.\0","%a")    --> 1
x = string.find("Tutu is a young man.\n His student number is 20230001.\0","%c")    --> 21
x = string.find("Tutu is a young man.\n His student number is 20230001.\0","%d")    --> 45
x = string.find("Tutu is a young man.\n His student number is 20230001.\0","%l")    --> 2
x = string.find("Tutu is a young man.\n His student number is 20230001.\0","%p")    --> 20
x = string.find("Tutu is a young man.\n His student number is 20230001.\0","%s")    --> 5
x = string.find("Tutu is a young man.\n His student number is 20230001.\0","%u")    --> 1
x = string.find("Tutu is a young man.\n His student number is 20230001.\0","%w")    --> 1
x = string.find("Tutu is a young man.\n His student number is 20230001.\0","%x")    --> 9
x = string.find("Tutu is a young man.\n His student number is 20230001.\0","%z")    --> 54

加 
()
表示捕捉，find的第三个参数返回被捕捉到的字符串,在这里即返回找到的那个字符。

x,y,z = string.find("%()~!@#$%^&*():\";\'?<>._[]","(%%)")   --> 1   1   %
x,y,z = string.find("%()~!@#$%^&*():\";\'?<>._[]","(%#)")   --> 7   7   #
x,y,z = string.find("%()~!@#$%^&*():\";\'?<>._[]","(%\")")  --> 16  16  "

下句中的 
+
表示取一个或多个满足条件的连续字符。

--1 2 3 4 5 6 7 8
x,y = string.find("\a\b\f\n\r\t\v\0","%c+")     --> 1   7

上句基本列出了所有控制字符，并不是所有转义符都是控制字符，例如 
\\
和 
\xff
不属于控制字符。

match
函数返回符合匹配条件的字符子串。

x = string.match("0123456789ABCDEFabcdefg","%x+")   --> 0123456789ABCDEFabcdef

输出的符号即为 
%x
所支持的所有字符。

%b
的使用方法与前面的组合形式略有不同，其形式为 
%bxy
，使用示例如下：

---------------------00000000001111111112 22222222233333333334444444444555555 5
---------------------12345678901234567890 12345678901234567890123456789012345 6
x,y,z = string.find("Tutu is a young man.\n His student number is [20230001].\0","(%b[])")  --> 45  54  [20230001]
x,y,z = string.find("Tutu is a young man.\n His student number is _20230001_.\0","(%b__)")  --> 45  54  _20230001_
x,y,z = string.find("Tutu is a young man.\n His student number is _20230001_.\0","(%b21)")  --> 48  53  230001

1.2 
[]
字符集

字符集操作是对字符类中组合的一个扩展。可以通过 
[]
制定出用户所需的一套字符选取范围。

---------------------0000000001111111111222222222
---------------------1234567890123456789012345678
x,y,z = string.find("[Email]: tangyikejun@163.com","([123])")           --> 22  22  1
x,y,z = string.find("[Email]: tangyikejun@163.com","([l]])")            --> 6   7   l]
x,y,z = string.find("[Email]: tangyikejun@163.com","([1-3])")           --> 22  22  1
x,y,z = string.find("[Email]: tangyikejun@163.com","([^1-3])")          --> 1   1   [
x,y,z = string.find("[Email]: tangyikejun@163.com","([^%d])")           --> 1   1   [
x,y,z = string.find("[Email]: tangyikejun@163.com","([0-9][%d][%d])")   --> 22  24  163
x,y,z = string.find("[Email]: tangyikejun@163.com","([0-9]+)")          --> 22  24  163

使用特点：

每个字符集仅限定一个字符的范围。
连字符 
-
用于限定字符的范围，值域根据字符在ASCII码中对应的值得出，例如 
[0-7]
代表字符范围为 0-7。

x,y,z = string.find("!\"#$%&0123","([$-1]+)") --> 4 8 $%&01

添加 
^
表示对指定的字符范围取补集。
[^%d]
等价于 
[%D]
。

1.3 模式项

模式项作用
+匹配1个或多个字符，尽可能多地匹配
-匹配0个或多个字符，尽可能少地匹配
*匹配0个或多个字符，尽可能多地匹配
？匹配0个或1个字符，尽可能多地匹配
使用特点：

模式项都是针对前一个字符而言的。例如 
abc-
作用于字符 
c
。

---------------------0000000001
---------------------1234567890
x,y,z = string.find("aaaabbbccc","(%a+)")       --> 1   10  aaaabbbccc
x,y,z = string.find("bbbccc","(a+)")            --> nil nil nil
x,y,z = string.find("aaaabbbccc","(ab-c)")      --> 4   8   abbbc
-- x,y,z = string.find("aaaaccc","(ab-c)")      --> 4   5   ac
-- x,y,z = string.find("aaaaccc","(ab*c)")      --> 4   5   ac
-- x,y,z = string.find("aaaabccc","(ab?c)")     --> 4   6   abc
-- x,y,z = string.find("aaaabccc","(ba?c)")     --> 5   6   bc

---------------------000000000111 111111122
---------------------123456789012 345678901
x,y,z = string.find("tangyikejun\0 163.com","(%z%s%w+)")    --> 12  16
x,y,z = string.find("tangyikejun\0163.com","(%z%d%w+)")     --> nil nil     nil

注意： 
\0
后面不能跟数字。而且用 find 返回的匹配字符串无法输出 
\0
之后的部分。

1.4 模式

多个模式项组合形成模式。

模式的前面添加 
^
表示匹配从目标字符串的起始位置开始。
模式的末尾添加 
$
表示匹配目标字符串的末尾子串。
其他位置的 
^
和 
$
作为普通字符处理。

---------------------0000000001111111111222222222
---------------------1234567890123456789012345678
x,y,z = string.find("[Email]: tangyikejun@163.com","^(.%a+)")   -->1    6   [Email
x,y,z = string.find("[Email]: tangyikejun@163.com","(%a+)$")    -->26   28  com

1.5 
()
捕捉

捕捉是指将括号内的组合匹配结果保存起来，每个括号保存一个结果。

保存的数据的顺序按照左括号的顺序排列。

x,y,z,h,l = string.find("Tutu is a young man.\n His student number is _20230001_.\0","((%a+%s)(%a+%s)%b__)")    --> 35  54  number is _20230001_    number  is

字符串模式匹配可参考Lua模式匹配。

2 库函数

字符串的下标从1开始。正数下标表示正向下标，负数表示反向下标（例如 -1 表示字符串最后一个字符）。
函数均默认支持模式匹配。
返回的匹配字符串无法输出 
\0
之后的部分。

string.find(s,pattern[,init[,plain]])

查找字符串的子串，如果找到，返回子串的起始位置、结束位置；找不到返回 nil。

如果使用捕获（即对模式串用括号包裹起来）,则一并返回匹配得到的字符串。

定义

string.find([字符串],[待查找字符串],[查找起始位置]=1,[禁用模式匹配]=false)

只有显式指定了 init 参数才能控制 plain 参数。

例子

x,y,z = string.find("1001 is a Robot", "Robot")
print(x,y,z)                                --> 11 15   nil
x,y,z = string.find("1001 is a Robot","1%d",1,true)
print(x,y,z)                                --> nil nil nil
x,y,z = string.find("1001 is a Robot","(%d+)",1,false)
print(x,y,z)                                --> 1   2   1001

string.match(s,pattern[,init])

与 
string.find
类似，返回值不一样。
string.match
查找字符串的子串，如果找到，返回子串；找不到返回 nil。

支持模式匹配。

定义

略

例子

x = string.match("1001 is a Robot","001")
print(x)                --> 001
x = string.match("1001 is a Robot","%d%d")
print(x)                --> 10

string.gmatch(s,pattern)

返回一个迭代函数，该函数每执行一次，就返回下一个捕捉到的匹配（如果没有使用捕捉，就返回整个匹配结果）。

例子

for s in string.gmatch("I have a Dream.","%a+") do
print(s)
end
--> I
--> have
--> a
--> Dream

t = {}
s = "name=tangyikejun, number=20250001"

-- 将捕获的两个子串分别作为键和值放到表t中
for k, v in string.gmatch(s, "(%w+)=(%w+)") do
t[k] = v
end

-- 输出表t
for k,v in pairs(t) do
print(k,v)
end

--> name    tangyikejun
--> number  20250001

string.format(formatstring,...)

返回格式化之后的字符串。

定义

略

例子

string.format("My name is %s", "tangyikejun")   --> My name is tangyikejun

string.len(s)

返回字符串长度

string.lower(s)

返回小写字母的字符串

string.upper(s)

返回大写字母的字符串

string.rep(s,n)

对字符串进行重复

定义

string.rep([字符串],[重复次数])

例子

string.rep("Hello",4)   -- HelloHelloHelloHello

string.reverse(s)

返回反转后的字符串。

string.sub(s,i[,j])

返回子字符串。

定义

string.sub([字符串],[开始字符下标],[结束字符下标]=-1)

例子

x = string.sub("tangyikejun",7)
print(x)                --> kejun
x = string.sub("tangyikejun",1,-6)
print(x)                --> tangyi

string.gsub(s,pattern,repl[,n])

根据模式匹配对字符串中每一个匹配部分都做替换处理，返回替换后的字符串。

定义

string.gsub([字符串],[模式匹配],[替换字符],[最大替换次数] = 无限制)

repl 参数（
[替换字符]
）支持 字符串、表、函数。

如果 repl 是字符串，那么该字符串就是用于替换的字符串。同时支持 
%n
转义符操作，n 的范围是 0-9。n 范围为 [1,9] 时表示第 n 个捕获的匹配字符串，
%0
表示整个匹配的字符串，
%%
表示替换为一个
%
。

如果 repl 是表，那么将捕获的第一个字符串作为键值（Key）进行查询（没有定义捕捉则以整个匹配的字符串为键值），查到的值作为替换的字符串。

如果 repl 是函数，那么每次匹配成功都会调用该函数，并以按序以所有捕捉作为参数传入函数。没有捕捉则以整个匹配的字符作为参数。

如果从表或函数得到是字符串或者是数字，就将其用于替换；如果得到的是 false 或 nil，那么匹配部分将不会发生变化。

例子

repl 为字符串

s = "Never say die."
x = string.gsub(s,"die","never")            --> Never say never.
x = string.gsub(s,"die","'%0'")             --> Never say 'die'.
x = string.gsub(s,"(%a+)%s%a+%s(%a+)","%2") --> die.

限制最大替换次数

s = "never say never."
x = string.gsub(s,"never","Never",1)    --> Never say never.

repl 是表

t = {name="Lua",version="5.1"}
x = string.gsub("$name-$version.tar.gz","$(%a+)",t) --> Lua-5.1.tar.gz

repl是函数

x = string.gsub("4+5 = $return 4+5$","%$(.-)%$",function(s)return loadstring(s)() end)  --> 4+5 = 9
x = string.gsub("23+45=$result", "((%d+)%+(%d+)=)%$%a+", function (s,a,b)
sum = a+b
return s..sum
end)    --> 23+45=68

~~注意：似乎只支持匿名函数。~~

从表或函数返回的是 false 或 nil

x = string.gsub("4+5 = $return 4+5$","%$(.-)%$",function(s)return nil end)  --> 4+5 = $return 4+5$
t = {name="Lua",version=false}
x = string.gsub("$name-$version.tar.gz","$(%a+)",t) --> Lua-$version.tar.gz

string.byte(s[,i[,j]])

返回字符的 ASCII 码值。

定义

string.byte([字符串],[起始下标]=1,[结束下标]=[起始下标])

例子

x,y,z = string.byte("abc",2)    --> 98  nil nil
x,y,z = string.byte("abc",1,3)  --> 97  98  99

string.char(...)

根据传入的 ASCII 编码值（[0-255]）得到对应的字符，传入多少编码值就返回多长的字符串。

例子

x = string.char(98,99,100)  --> bcd

如果输入字符超限会编译报错。

string.dump(function)

返回函数的二进制表示（字符串形式），把这个返回值传给 loadingstring 可以获得函数的一份拷贝（传入的函数必须是没有上值的 Lua 函数）。

例子

function sum(a,b)
return a + b
end

s = string.dump(sum)
x = loadstring(s)(4,4) -- 8
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签： 
相关文章推荐
新的分享
章节导航