Lua字符串模式和捕获

local s = "am+df"
print(string.find(s, "m+", 1, false))    -- 2    2
print(string.find(s, "m+", 1, true))    -- 2    3

local s = "am+df"
print(string.find(s, "(m+)", 1, false))    -- 2    2    m

关于捕获还有一点需要说明的，就是捕获只会在模式能够匹配成功的时候才会跟着 string 的函数进行返回，比如下面这个，我想捕获字母 a ，但事实上这个模式根本无法匹配到，所以肯定是无法返回的：

local s = "am+df"
print(string.find(s, "(m+)(a)", 1, false))    -- nil

另外捕获返回的顺序，是依照左小括号的位置来定的，比如上面那个捕获了3个 m 的例子，第一个 m 其实是最外层的小括号捕获到的。为什么要提到捕获的顺序呢？因为我们可以使用 %n 来取得第n个捕获的字符串，至于取得对应的捕获有什么用处呢？这个在后面会介绍到。

local s = ”am+df“
print(string.find(s, "()(m+)()", 1, false))    -- 2    2    2    m    3

有一点也必须要提一下，就是在Lua5.1的源码当中，捕获字符串的数量是有限制的，默认是32个，也就是说你添加的小括号不能无限加，最多加32个。如果捕获超过限制，当然会报错了，比如：

local s = ”am+df“
print(string.find(s, "()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()", 1, false))    -- 捕获33个

s = "hello world from Lua"
for w in string.gmatch(s, "%a+") do
    print(w)
end
--[[
hello
world
from
Lua
]]

local s = "am+df"
print(string.find(s, "(m+)", 1, false))    -- 2    2    m
print(string.find(s, "^(m+)", 1, false))    -- nil

第二个匹配，因为在模式前面增加了 ^ ，所以会从字符串 s 的最开始就进行匹配，也就是从字母 a 开始匹配，a 当然无法和 (m+) 匹配成功了，所以直接就返回 nil 了。这个处理在上面讲 string.find 的时候源码函数 str_find_aux() 里 else 分支模式匹配里可以看到，有专门处理 ^ 字符的代码。

local s = "am+dmf"
print(string.gsub(s, "()(m+)", "%1"))     -- a2+d5f     2
print(string.gsub(s, "()(m+)", "%2"))      -- am+dmf     2
print(string.gsub(s, "()(m+)", "%3"))    -- error: invalid capture index

local s = "am+dmf"
print(string.gsub(s, "()(m+)", "%0%0%0"))    -- ammm+dmmmf    2

匹配到的串是 m，用 mmm 替换了原串中的 m。

你可能要问，既然 % 被单独处理了，那么我想要用 % 去替换怎么办，只需要用 %% 就可以表示 % 自身了。比如：

local s = "am+dmf"
print(string.gsub(s, "()(m+)", "%%"))    -- a%+d%f    2

当rep是一个table的时候，每次匹配到了之后，都会用第一个捕获作为key去查询这个table，然后用table的内容来替换匹配串，如果没有指定捕获，那么，就用整个匹配串作为key去查询，如果没有查到对应key的值，或者对应的值不是字符串和数字，那么就不做替换：

local s = "am+dmf"
local t1 = {
    [2] = "hh",
    [5] = "xx",
}
local t2 = {}
print(string.gsub(s, "()(m+)", t1))     -- ahh+dxxf     2
print(string.gsub(s, "()(m+)", t2))    -- am+dmf    2
local t3 = {
    [2] = false
}
print(string.gsub(s, "()(m+)", t3))    -- am+dmf    2
local t4 = {
    [2] = { 123 }
}
print(string.gsub(s, "()(m+)", t4))    -- error : invalid replacement value ( a table )

当rep是一个函数的时候，每当匹配到字符串的时候，就把模式所有的捕获按照捕获顺序作为参数传递给这个函数，如果没有指定捕获，则传递整个匹配的字符串给函数，函数的返回值如果是字符串或者是数字就替换掉匹配，如果不是则不做替换：

local s = "am+dmf"
function f1(...)
     print(...)     -- 2     m    -- 5     m
     return "hh"
end
function f2()
     return { 123 }
end
print(string.gsub(s, "()(m+)", f1))     -- ahh+dhhf     2
print(string.gsub(s, "()(m+)", f2))    -- error : invalid replacement value ( a table )

第四个参数，用来表明，需要替换到第几个匹配为止，比如：

local s = "am+dmf"
print(string.gsub(s, "()(m+)", "%%", -1))     -- am+dmf     0
print(string.gsub(s, "()(m+)", "%%", 0))      -- am+dmf     0
print(string.gsub(s, "()(m+)", "%%", 1))      -- a%+dmf     1
print(string.gsub(s, "()(m+)", "%%", 2))      -- a%+d%f     2
print(string.gsub(s, "()(m+)", "%%", 3))    -- a%+d%f    2

依然来看看源码是怎么写的：

static int str_gsub (lua_State *L) {
  size_t srcl;
  const char *src = luaL_checklstring(L, 1, &srcl);
  const char *p = luaL_checkstring(L, 2);
  int max_s = luaL_optint(L, 4, srcl+1);
  int anchor = (*p == ‘^‘) ? (p++, 1) : 0;
  int n = 0;
  MatchState ms;
  luaL_Buffer b;
  luaL_buffinit(L, &b);
  ms.L = L;
  ms.src_init = src;
  ms.src_end = src+srcl;
  while (n < max_s) {
    const char *e;
    ms.level = 0;
    e = match(&ms, src, p);
    if (e) {
      n++;
      add_value(&ms, &b, src, e);
    }
    if (e && e>src) /* non empty match? */
      src = e;  /* skip it */
    else if (src < ms.src_end)
      luaL_addchar(&b, *src++);
    else break;
    if (anchor) break;
  }
  luaL_addlstring(&b, src, ms.src_end-src);
  luaL_pushresult(&b);
  lua_pushinteger(L, n);  /* number of substitutions */
  return 2;
}

可以看到它处理了符号 ^ ，循环进行匹配，如果匹配到了，就按照不同的类型把替换串添加进结果里，最后把所有字符压回栈上。

总的来说 string.gsub() 函数实现的效果跟我们一般意义上的替换是相同的，你可能会纳闷为什么它不叫 string.greplace ，其实我也纳闷。

上面介绍完了 4 个用到了模式的函数之后，我们再来看看Lua的模式有什么奇妙之处。

模式

让我们来看看，都有哪些特殊字符需要解释，其实这一部分在Lua的官方文档中，介绍的还是很清楚的：

首先，任何单独的字符，除了上面那些特殊字符外，都代表他们本身。注意前提是他们独立出现。

其次，Lua定义了一些集合，它们分别如下：

. ：代表任意的字符。

%a ：代表任意字母。

%c ：代表任意控制字符。

%d ：代表任意数字。

%l ：代表任意小写字母。

%p ：代表任意标点符号。

%s ：代表任意空白字符（比如空格，tab啊）。

%u ：代表任意大写字母。

%w ：代表任意字母和数字。

%x ：代表任意16进制数字。

%z ：代表任意跟0相等的字符。

%后面跟任意一个非字母和数字的字符，都代表了这个字符本身，包括上面那些特殊字符以及任何标点符号都可以用这个方式来表达。

[set] ：代表一个自定义的字符集合。你可以使用符号 - 来标识一个范围，比如 1-9，a-z 之类的。需要注意的是，上面提到的那些字符集合也可以在这个自定义的集合里用，但是你不能这么写[%a-z]，这样的集合是没有意义的。

[^set] ：代表字符集合[set]的补集（补集是什么意思，我了个去，问你数学老师去）。

另外，对于上面提到的所有用 % 跟一个字母组成的集合，如果把字母大写，那么就对应那个集合的补集，比如 %S 的意思就是所有非空白字符。Lua官网还强调了一下，这里个定义跟本地的字符集有关，比如集合 [a-z] 就不一定跟 %l 是相等的。

任意一个单字符表达的集合，包括 % 加单字符表达的集合后面都可以跟4种符号，他们分别是 * 、 + 、 - 、 ?。

* ：意思是前面的集合匹配0个或者更多字符，并且是尽量多的匹配。

+ ：意思是前面的集合匹配1个或者更多字符。

- ：意思是前面的集合匹配0个或者更多字符，尽量少的匹配。

? ：意思是前面的集合匹配0个或者1个。

如下：

local a = "ammmf"
print(string.match(a, "%a"))     -- a
print(string.match(a, "%a*"))     -- ammmf
print(string.match(a, "%a+"))     -- ammmf
print(string.match(a, "%a-"))     --
print(string.match(a, "%a?"))    -- a

看了上面的例子，你可能会想，那 * 和 + 或者加不加 ? 有什么区别呢？是有区别的，因为匹配0个和匹配1个有的时候就是有没有匹配成功的关键，比如加上 ? 就可以匹配0个，意味着即使没有对应集合的内容，也算匹配成功了，如果有捕获的话，这个时候捕获是生效的。比如：

local a = "ammmf"
print(string.match(a, "()c"))     -- nil
print(string.match(a, "()c?"))    -- 1

如果你现在还不知道 string.match() 是什么意思，就翻到前面去看吧。

还有一个特殊的字符需要介绍，就是 %b 后面跟两个不同的字符xy，它的意思是匹配从x开始，到y结束的字符串，而且要求这个字符串里x和y的数量要相同。比如 %b() 就是匹配正常的小括号，如下：

local a = "aaabb"
print(string.match(a, "%bab"))    -- aabb

最后，我在介绍 string.gmatch 的时候介绍过字符 ^ 的用法，它放在模式的首部，意思是从原串的首部就开始匹配，这里还有一个特殊字符跟它的用法类似，它就是 $ 字符，这个字符放在模式的末尾，意思是从原串的尾部开始匹配。在其他位置就跟 ^ 一样，也没有意义。

捕获

捕获的意思在介绍 string.find 的时候已经详细介绍过了，这里再提一笔，捕获是在模式中，用小括号括起来的子模式，它在匹配发生的时候截取小括号内模式匹配到的字符串，然后保存下来，默认最多保存 32 个，可以在Lua源码中修改保存的数量。另外捕获的顺序是按照小括号左括号的位置来定的。至于捕获如何使用，请参看我上面介绍的4个使用了模式的函数的具体用法。