Lua 之string库

标准string库

基础字符串函数

string.len(s)

返回一个字符串的长度，例如

print(string.len("hello world")) -- 11

string.rep(s, n)

返回一个新的字符串，该字符串是参数s重复n次得到的结果，例如

print(string.rep("go", 3)) -- gogogo

string.lower(s)

string.upper(s)

字符串大小写转换，例如

print(string.lower("gOogLe")) -- google
print(string.upper("gOogLe")) -- GOOGLE

string.sub(s, i, j)

返回字符串的一个子串，子串的起始/结束位置由参数i, j决定。例如：

print(string.sub("google", 2, 3))   -- 'oo'
print(string.sub("google", 4))      -- 'gle'
print(string.sub("google", 1, -2))  -- 'googl'
print(string.sub("google", 100))    -- ''

string.char(num1, num2, ...)

string.byte(s, i, j)

在字符与其ASCII码之间转换。

string.char 函数接收零个或多个整数，并将每个整数转换成对应的字符，然后返回一个由这些字符构成的字符串。

string.byte 返回字符串s中第i到第j个字符的ASCII值，i值默认等于1，j值默认等于i。

print(string.byte('google'))        -- 103  
print(string.byte('google', 2))     -- 111  
print(string.byte('google', 1, -1)) -- 103     111     111     103     108     101

print(string.char(111))             -- 'o'
print(string.char(103, 111, 101))   -- 'goe'

注意，string.char()返回一个字符串，而string.byte可能存在多个返回值，其中每个值都是一个number类型的数字。

string.format("format", s, ...)

格式化字符串，它跟C语言里面的printf函数非常类似，例如：

print(string.format("pi=%.4f", math.pi))

print(string.format("today is %02d/%02d/%04d", 27, 10, 2014))

---

模式匹配函数

模式匹配函数有4个：find、match、gsub（全局替换）、gmatch（全局匹配），它们都是基友模式匹配（pattern match）实现的。

string.find(s, pattern, b)

string.find 函数在一个给定的目标字符串中搜索符合指定pattern的第一个子串，如果找到返回子串的起始和结束位置，没有找到任何匹配，返回nil。

s = "hello sky, the sky is mine"

i, j = string.find(s, "sky")

print('i=' .. i .. ', j=' .. j)     -- i=7, j=9
print(string.sub(s, i, j))          -- 'sky'
print(string.find(s, 'world'))      -- nil

string.find函数的第3个参数可选（默认值为1），用于告诉函数应从目标字符串的哪个位置开始搜索，如果我们需要找到目标字符串中所有符合pattern的子串，这个参数就很有用，例如：

local t = {}
local i = 0
local s = 'line 1
line 2
line 3
line 4
line 5
'

while true do
    i = string.find(s, "
", i+1)
    if i==nil then break end
    t[#t+1] = i
end

当然，上面例子中的功能，有一个更加简单的实现办法，就是使用string.gmatch函数。

string.match(s, pattern)

函数string.match与string.find非常类似，不过它返回的是目标字符串中与pattern匹配的子串，而非子串所在的位置。

date = "today is 27/10/2014"
print(string.match(date, "%d+/%d+/%d+"))    -- 27/10/2014

string.gmatch(s, pattern)

string.gmatch 是全局匹配函数，它返回一个迭代器，通过返回的迭代器可以遍历目标字符串中所有出现指定模式的地方。

一个例子，找出给定字符串中的所有单词：

s = "hello sky, the sky is mine"

words = {}

for w in string.gmatch(s, "%a+") do
    words[#words+1] = w
end

for _,v in ipairs(words) do
    print(v)
end

string.gsub(s, pattern, rep, max)

string.gsub 是全局替换函数，将目标字符串中所有模式出现的地方替换为替换字符串。

第4个参数可选，用于限定替换的最大次数。

string.gsub函数有2个返回值，第一个返回值表示替换后的新字符串，第二个返回值表示替换次数。如果没有找到需要替换的模式，则分别返回原字符串和0；

old = "hello sky, the sky is mine"
new, count = string.gsub(old, "sky", "world")

print(new)      -- hello world, the world is mine  
print(count)    -- 2

string.gsub 第3个参数除了是字符串以外，还可以是函数或table。

当用一个函数来调用时，string.gsub会在每次找到匹配时调用该函数，调用时的参数就是捕获到的内容，而该函数的返回值则作为要替换的字符串。
当用一个table来调用时，string.gsub会用每次捕获到的内容作为key，并将对于的value作为要替换的字符串，如果table中不包含这个key，那么string.gsub不改变这个匹配。

function expand(s)
    return (string.gsub(s, "$(%w+)", _G))
end

name = "Lua"
status = "greate"

print(expand("$name is $status, isn't it?"))
-- Lua is greate, isn't it?

上面的例子中，对每处与"$(%w+)"相匹配的地方，string.gsub都会在_G中查找捕获到的名称，并用找到的value替换字符串中的匹配部分。

如果不确定所有的变量都有一个对应的字符串值，则可以对它们的值应用tostring，这种情况下，可以用一个函数来提供要替换的值：

function expand(s)
    return (string.gsub(s, "$(%w+)", function(n) return tostring(_G[n]) end ))
end 
    
print(expand("print=$print; a=$a"))
-- print=function: 0x1f3fa40; a=nil

模式（pattern）

限于Lua解释器的大小，Lua并不支持完整的PCRE，但Lua的模式匹配也非常强大，支持元字符、字符集等。

注意：对于Lua来说，模式就是普通的字符串，只有上面提到的几个模式函数才能解释它们。

字符类	对应的字符集
.	任意字符
%a	字母
%c	控制字符
%d	数字
%l	小写字母
%p	标点符号
%s	空白符
%u	大写字母
%w	字母和数字
%x	16进制数字
%z	代表0的字符

上面字符类的大写形式表示小写所代表的集合的补集。

例如将目标字符串中出现的非字母字符替换为"." 

print(string.gsub("hello, up-down!", "%A", ".")) -- hello..up.down. 4

计算一段文本中元音字母出现的次数：

count = select(2, string.gsub(text, "[AEIOUaeiou]", ""))

%	用作特殊字符（非字母字符）的转义字符，比如‘%%’匹配字符’%’
[ ]	匹配指定的字符集，比如[%w_]匹配数字、字母和下划线
+	匹配前一字符1次或多次，比如”%a+”匹配一个单词
*	匹配前一字符0次或多次，贪婪匹配，比如”%s*”匹配空白
-	匹配前一字符0次或多次，懒惰匹配
?	匹配前一字符0次或1次
^	匹配开头，如果在字符集[]里面就表示补集
$	匹配结尾
%b	匹配成对的字符

"+"修饰符可匹配属于字符分类的一个或多个字符，它总是获取与模式相匹配的最长序列。

修饰符"-"和"*"的区别是，前者匹配最短的子串，后者匹配最长的子串。

s = "if condition then statements end"
print(string.match(s, '[_%a][_%w]*'))   -- if
print(string.match(s, '[_%a][_%w]-'))   -- i

test = "int x; /* x */ int y; /* y */"
print(string.gsub(test, "/%*.*%*/", "<COMMENT>")) 
-- int x; <COMMENT>        1

print(string.gsub(test, "/%*.-%*/", "<COMMENT>")) 
-- int x; <COMMENT> int y; <COMMENT>       2

注意：在模式的开始或结尾处使用修饰符“-” 没有意义，因为它总会匹配空字符。

%b用于匹配成对的字符，如下：

s = "a (enclosed (in) parentheses) line"
print(string.gsub(s, "%b()", ""))       -- a  line 1

test = "<title> hello world </title>"
print(string.gsub(test, "%b<>", ""))    -- hello world    2

捕获（capture）

捕获功能可根据一个模式从目标字符串中抽出匹配与该模式的内容。在指定捕获时，在模式中将需要捕获的部分写到一对圆括号内。

对于具有捕获的模式，函数string.match会将所有捕获到的值作为单独的结果返回。即将目标字符串切成多个捕获到的部分。

pair = "name = Anna"
key, value = string.match(pair, "(%a+)%s*=%s*(%a+)")
print(key, value)       -- name    Anna

在一个模式中，可以使用 "%1"、"%2" 这样的项，表示匹配与第d个捕获相同的内容。

如下面的例子，模式中的"%1"表示匹配第一个捕获（即引号）的内容，从而用来指定第二个引号。

s = [[then he said: "it's all right"!]]
q, quotedPart = string.match(s, "(["'])(.-)%1")
print(quotedPart)   -- it's all right

对于捕获到的值，还可用于string.gsub函数的字符串替换。和模式一样，用于替换的字符串中也可以包含"%d"这样的项。当进行替换时，这些项就对应于捕获到的内容。"%0"表示整个匹配，并且替换字符串中的"%"必须转义为"%%"。

print(string.gsub("hello Lua!", "%a", "%0-%0"))
-- h-he-el-ll-lo-o L-Lu-ua-a!      8

print(string.gsub(" hello world ", "^%s*(.-)%s*$", "%1"))
-- hello world