标准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\nline 2\nline 3\nline 4\nline 5\n'
while true do
i = string.find(s, "\n", 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
