--Lua笔记-string
--转载请注明出处: yuliying的CSDN博客.
--第一部分: lua的string库函数
--1.string.byte
--string.byte (s [, i [, j]])
--取出字符串中的字节.i是起始位置,j是结束位置.
--解析协议的时候经常用来将字符串中的某几个字节取出,然后重新组装为一个多字节的数字.
print("------string.byte------")
print( string.byte("hello world" , 1 , 3) ) --104(h) 101(e) 108(l)
--2.string.char
--string.char (···)
--接受若干数字,组成一个字符串,字符串的长度为参数个数.字符串内部的字节和数字对应.
--解析协议的时候,经常用来将一个多字节的数字按字节存入字符串.
print("------string.char------")
print( string.char( 104 , 101 , 108) ) -- hel
--3.string.dump
--string.dump (function)
--将一个lua函数作为一个字符串返回.可以用load函数加载这个字符串,返回该函数的拷贝.
print("------string.dump------")
local function dump(str) print(str) end
print( string.dump(dump) )
--4.string.find
--string.find (s, pattern [, init [, plain]])
--在字符串s中查找符合pattern的子串,如果找到了返回子串的开始位置和结束位置,否则返回nil
--init参数为查找的起始位置,可以为负数.
--plain参数为true的话会关闭模式匹配,只进行纯字符串匹配.
--更多的模式匹配规则会在下面详细记录.
print("------string.find------")
print( string.find("hello world" , "llo") )
print( string.find("hello world" , "llt?") )
--5.string.format
--string.format (formatstring, ···)
--类似c语言的sprintf函数.返回一个格式化的字符串.区别是string.format不支持 *, h, L, l, n, p 这些模式. 额外支持一个q模式.
--%c - 接受一个数字, 并将其转化为ASCII码表中对应的字符
--%d, %i - 接受一个数字并将其转化为有符号的整数格式
--%o - 接受一个数字并将其转化为八进制数格式
--%u - 接受一个数字并将其转化为无符号整数格式
--%x - 接受一个数字并将其转化为十六进制数格式, 使用小写字母
--%X - 接受一个数字并将其转化为十六进制数格式, 使用大写字母
--%e - 接受一个数字并将其转化为科学记数法格式, 使用小写字母e
--%E - 接受一个数字并将其转化为科学记数法格式, 使用大写字母E
--%f - 接受一个数字并将其转化为浮点数格式
--%g(%G) - 接受一个数字并将其转化为%e(%E, 对应%G)及%f中较短的一种格式
--%q - 接受一个字符串并将其转化为可安全被Lua编译器读入的格式
--%s - 接受一个字符串并按照给定的参数格式化该字符--6.string.gmatch
--string.gmatch (s, pattern)
--匹配字符串s中的pattern , 返回一个迭代器函数, 每次调用该迭代器函数,返回下一个子串.
--pattern中捕获( 使用小括号() )了几个内容,则每次返回几个值. 如果没有捕获任何值,则返回整个子串.
print("------string.gmatch------")
s = "hello world from Lua"
for w in string.gmatch(s, "%a+") do --没有捕获,每次返回整个子串
print(w)
end
s = "from=world, to=Lua"
for k, v in string.gmatch(s, "(%w+)=(%w+)") do --捕获了key和value两个值
print( k , v )
end
--7.string.gsub
--string.gsub (s, pattern, repl [, n])
--第一个返回值为字符串s的副本, 其中所有(或者前n个)符合模式pattern的子串都被替换为repl.
--第二个返回值为替换的次数.
--repl 可以为一个字符串,一个table 或者一个函数.
--如果repl为一个字符串.则使用这个字符串来替换.repl中,字符%是一个转义字符.出现在repl中的( %d , 其中d的范围为1-9)对应符合pattern模式的字串中捕获的值.
--%0代表整个字串. %%代表一个单独的%
--如果repl为一个table. 则每次匹配到字串的时候都会查询这个table. 使用第一个捕获的值做为key.
--如果repl为一个函数. 则每次匹配到字串的时候都会调用, 依次传入每个捕获的值.
--如果repl所对应的table或者函数返回的值为一个字符串或者数字,则使用返回值来替换.
--如果repl所对应的table或者函数返回的值为false或者nil,则不执行该字串的替换.
print("------string.gsub------")
print( string.gsub("hello world", "(%w+)", "%1 %1") ) -- hello hello world world 2
print( string.gsub("hello world", "%w+", "%0 %0", 1) ) -- hello hello world 1
print( string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1") ) -- world hello Lua from 2
print( string.gsub("home = $HOME, user = $USER", "%$(%w+)", os.getenv) ) -- home = /home/roberto, user = roberto 2
print( string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s)return load(s)() end) ) -- 4+5 = 9 1
print( string.gsub("$name-$version.tar.gz", "%$(%w+)", {name="lua", version="5.2"} ) ) -- lua-5.2.tar.gz 2
--8.string.len
--string.len (s)
--返回字符串的长度. \000 被算进长度 . 因此字符串 "a\000bc\000" 的长度为5
print("------string.len------")
print( string.len("") )
print( string.len("a\000bc\000") )
--9.string.lower
--string.lower (s)
--将字符串中的大写字符转换为小写.
print("------string.lower------")
print( string.lower("HeLlo WorLd") )
--10.string.match
--string.match (s, pattern [, init])
--匹配字符串s中的第一个符合pattern的子串 , 如果找到了 , 返回所有捕获的值。否则返回nil
--如果没有捕获任何值,则返回整个字串.
--init参数为匹配的起始位置,可以为负数.
print("------string.match------")
print( string.match( "love=you hate=me" , "(%w+)=(%w+)" ) )
--11.string.rep
--string.rep (s, n [, sep])
--将n个字符串s拼起来, 重复n次 , sep是他们之间的间隔.
print("------string.rep------")
print( string.rep("fish" , 3 , "-") )
--12.string.reverse
--string.reverse (s)
--翻转字符串
print("------string.reverse------")
print( string.reverse("hello") )
--13.string.sub
--string.sub (s, i [, j])
--截取子串.参数i为开始位置,j为结束位置.
--i和j都可以为负数. 字符串的起始位置为1,字符串的末尾为-1.
--如果经过转换后,i小于1,i被修正为1. (例如字符串长度为3,i为-4,则实际i到了字符串起始位置之前)
--如果经过转换后,j大于字符串长度,j被修正为字符串长度.
--如果经过转换后,i大于j.则返回一个空串.
print("------string.sub------")
print( string.sub("hello" , 1 , 3 ) )
print( string.sub("hello" , -2 ) )
print( string.sub("hello" , -100 , 100 ) )
--14.string.upper
--string.lower (s)
--将字符串中的小写字符转换为大写.
print("------string.upper------")
print( string.upper("HeLlo WorLd") )
--第二部分: lua中string的模式匹配
----------- 字符集合 ------------------------
-- X: X为不包含在特殊字符中的字符,属于一个普通字符. 代表字符X本身
-- .: 代表所有字符
-- %a: 代表所有字母
-- %c: 代表所有控制字符
-- %d: 代表所有数字(0-9)
-- %g: 代表除了空格外的所有可打印字符
-- %l: 代表所有小写字母
-- %p: 代表所有标点字符
-- %s: 代表所有空白字符
-- %u: 代表所有大写字母
-- %w: 代表所有包含字母或者数子的字符
-- %x: 代表所有16进制数字(0-F)
-- %X: X为所有非字母和数字的字符,代表字符X本身.可以用来转义特殊字符.所有标点字符(即使不是特殊字符)之前都可以加一个%,代表这个标点本身.
-- [set]: 代表[]之间所有字符或者模式的集合. '-'可以用来表示前后两个字符之间的范围. 例如 [%w_] 代表所有数字,字母和下划线.
-- [0-7] 代表数字0到7 . [0-7%l%-] 代表0到7的数字,所有小写字母,还有'-', 其中'-'为特殊字符,必须转义.
-- [^set]: 代表[set]的补集
----------- 模式 --------------------------
-- * : 匹配0个或多个字符集合中的字符. 匹配尽可能多的字符
-- + : 匹配1个或多个字符集合中的字符. 匹配尽可能多的字符
-- - : 匹配0个或多个字符集合中的字符. 匹配尽可能少的字符
-- ? : 匹配0个或1个字符集合中的字符.
-- %n: 1<=n<=9 , 对应匹配的字串中捕获的字符串.
-- %bxy: 其中x和y是两个指定的字符. 匹配一个以x开头,并以y结尾的字符串. x和y是成对匹配的.
-- %f[set]: 一种边界模式,匹配一个空字符,这个空字符的下一个字符属于集合set,它的前一个字符不属于集合set.
-- ^ : ^在一个pattern的开头匹配字符串的开始.在pattern的其他位置代表该字符本身.
-- $ : $在一个pattern的结尾匹配字符串的结尾.在pattern的其他位置代表该字符本身.
----------- 捕获 -----------------------------
-- 一个模式可以包含用括号包含起来的子模式,叫做捕获.
-- 当一个模式被匹配时,捕获的内容被储存起来,用作更多用途.
-- 捕获是按照先后来排序的. 例如在模式 "(a*(.)%w(%s*))" 中, "a*(.)%w(%s*)"是捕获的第一个子模式,"."是第二个,"%s*"是第三个.
-- 空捕获() , 捕获的是当前子串的开始位置和结束位置的下一个位置, 如果我们在字符串"flaaap"中使用"()aa()"模式来匹配, 那么捕获的值分别为3和5.
print("------------pattern----------------")
print( string.match("flaaap" , "()aa()") ) --捕获匹配子串的位置.
print( string.match("fflaaap" , "^f+") ) --匹配开头的n个f.
print( string.match("flaaappp" , "p+$") ) --匹配结尾的n个p
print( string.match("xw_2" , "^[%l%d_]+$" ) ) --匹配整个字符串,这个字符串只包含小写字母,数字,下划线
print( string.match("ynEF8" , "%x+" ) ) --相当于pattern "[a-fA-F0-9]+"
-- + 和 - 的区别
print( string.match("hello" , "hel+o" ) ) --都匹配两个l
print( string.match("hello" , "hel-o" ) ) --都匹配两个l
print( string.match("hello" , "hel+" ) ) --匹配两个l
print( string.match("hello" , "hel-" ) ) --匹配0个l
--在后面的模式可以匹配更多的时候, - 选择匹配更少
print( string.match("he3_llo" , "^(%l+)([3_]-)([%l_]+)$" ) ) -- he 3 _llo
print( string.match("he3_llo" , "^(%l+)([3_]+)([%l_]+)$" ) ) -- he 3_ llo
