lua匹配非汉字 lua匹配数字

Lua Lpeg
用基本匹配函数，组合匹配表达式
所有匹配函数返回userdata类型，是一个匹配模式(以下用pattern代替)，可相互组合
lpeg.P
lpeg.P(value)
将给定的value，根据规则返回适当的pattern，规则如下：
value是pattern，原封不动的返回这个pattern
value是string， 返回整个该字符串的pattern
value是非负整数，只有在输入的字符串长度大于等于value个字符串时返回成功。
value是负整数，只有在输入的字符串长度还剩下不到value个字符才返回成功，lpeg.P(-n)等价于-lpeg.P(n)
value是boolean，总是返回成功或者失败的pattern
value是table，将它理解为一个语法(Grammar)
value是function，返回pattern，它等价于一个match-time capture用一个空字符串的匹配模式(lpeg.P(function)等价于lpeg.Cmt("", function))。
示例：
都是从第一个字符串开始匹配，若没匹配到就返回nil
如果匹配到pattern，则返回匹配到的字符串长度加1
local lpeg = require "lpeg"
local match = lpeg.match
local P = lpeg.P
-- value是string的情况
local ps = P'ab'
print(match(ps, "a")) ---> nil
print(match(ps, "abcd")) ---> 3 注：只匹配"ab"
-- value是非负整数
-- 注：完全匹配任意value个字符
local pn1 = P(3)
-- local pn1 = P(3.0) -- 这样也是可以的
print(match(pn1, "12")) ---> nil 注：只有2个字符
print(match(pn1, "abcd")) ---> 4
-- 注：value不能是小数，但是小数部分为0是可以的
-- 如果是小数，总是返回1
local pn2 = P(3.1)
print(match(pn2, "")) ---> 1
-- value是负整数
-- 被匹配的字符串长度要小于value
local pn3 = P(-3) -- 等价于 local pn3 = - P(3)
print(match(pn3, "abcd")) ---> nil 注：字符串长度>=3了
print(match(pn3, "ab")) ---> 1
print(match(pn3, "")) ---> 1
-- value是boolean
local pb1 = P(true)
local str1 = "aaa" -- str1为任意字符串
print(match(pb1, str1)) ---> 1 注：当value为true时，不管str1是什么字符串，始终返回1
local pb2 = P(false)
local str2 = "aaa" -- str2为任意字符串
print(match(pb2, str2)) ---> nil 注：当value为false时，不管str2是什么字符串，始终返回nil
-- value是table
local m1 = Cs((P(1) / { a = 1, b = 2, c = 3 }) ^ 0)
print(match(m1, "abc")) ---> 123
-- value是function
-- 请跳到match-time capture(lpeg.Cmt)
lpeg.B
返回一个匹配模式，只有在输入的字符串在当前位置是patt的谓语时，才被匹配到。
patt在有调整长度的字符串中匹配，并且不包含捕获
示例：
local lpeg = require "lpeg"
local match = lpeg.match
local B = lpeg.B
local m1 = B"a"
local m2 = 1 * m1
local m3 = 1 * B"b"
print(match(m1, "a")) ---> nil
print(match(m2, "a")) ---> 2
print(match(m3, "a")) ---> nil
-- 注：这里的m3和m2的区别就是一个是a，一个是b，但得到的结果不一样
local m4 = B(1)
local m5 = 1 * m4
print(match(m4, "a")) ---> nil
print(match(m5, "a")) ---> 2
print(match(-m4, "a")) ---> nil
local m6 = B(250)
local m7 = 250 * m6
print(match(m6, string.rep("a", 250))) ---> nil
print(match(m7, string.rep("a", 250))) ---> 251
lpeg.R
给定一个2字符的字符串(可以传多个这样的字符串)，返回两个字符之间范围的pattern
字符可以为任意字符编码(闭区间)
示例：
local lpeg = require "lpeg"
local match = lpeg.match
local R = lpeg.R
local r1 = R"09" -- 匹配任意数字
print(match(r1, "12345")) ---> 2 注：只要匹配到1个字符就返回
local r2 = R("az", "AZ") -- 可以传多个2个字符组成的字符串
print(match(r2, "abcd")) ---> 2
print(match(r2, "Abcd")) ---> 2
-- 特别注意
local r3 = R()
local str = "aaa"
print(match(r3, str)) ---> nil
-- 当R没有参数时，不管str为什么字符串，总返回nil
lpeg.S
给定一个字符串(字符串等价于字符的集合(set))，返回一个匹配该字符串里任意一个字符的pattern
示例：
local lpeg = require "lpeg"
local match = lpeg.match
local S = lpeg.S
local s1 = S"+-*/"
print(match(s1, "+")) ---> 2
print(match(s1, "-")) ---> 2
print(match(s1, "*")) ---> 2
print(match(s1, "/")) ---> 2
-- 特别注意
local s2 = S""
local str = "aaa"
print(match(s2, str)) ---> nil
-- 注：当S的参数为空字符串的时候，不管str是什么字符串，总返回nil
lpeg.V
这个操作为语法(Grammar)生成一个变量(non-terminal)，变量规则是闭包语法中的v
个人理解：因为语法是通过table来定义的，调用这个函数告诉lpeg在table里定义了哪些变量名
剩下的后面说哇~~
lpeg.locale
返回一个table，table里面的元素是lpeg提供的常用pattern，有以下匹配模式：alnum，alpha，cntrl，digit，graph，lower，print，punct，space，upper，xdigit
如果参数是table，则会把这些pattern放到参数的table里面
示例：
local lpeg = require "lpeg"
local lpegHelp = {}
lpeg.locale(lpegHelp)
local help = lpeg.locale()
Lpeg操作符
#patt
返回一个pattern。如果输入的字符串被patt匹配到，这个pattern才会被匹配。
这个pattern被叫做，and谓语，等价于原生PEG中的&patt
这个pattern从不产生任何捕获。
示例：
local lpeg = require "lpeg"
local match = lpeg.match
local P = lpeg.P
local C = lpeg.C
local V= lpeg.V
local p1 = P"aa"
local p2 = #p1
print(match(p1, "a")) ---> nil
print(match(p2, "a")) ---> nil
print(match(p1, "aaaa")) ---> 3
print(match(p2, "aaaa")) ---> 1
-- 进阶
local pat = P{
"S";
S1 = C("abc") + 3,
S = #V("S1") -- 这里捕获到了结果，但是#必须忽略这个结果
}
print(match(pat, "abc")) ---> 1
-- 调整长度(fixed length)
local m1 = #("a" * (P"bd" + "cd"))
local m2 = C(m1 * 2)
local m3 = C(m1 * 3)
local m4 = C(m1 * 4)
print(match(m1, "acd")) ---> 1
print(match(m2, "acd")) ---> ac
print(match(m3, "acd")) ---> acd
print(match(m4, "acd")) ---> nil
-- 解析：
-- 1. #patt后面跟着 * number时，是对捕获到的值的长度进行调整
-- 2. number的值不能超过捕获到的值的长度
-patt
返回一个pattern，只有patt没有被匹配到的时候始终返回1，否则返回nil
这个pattern从不产生任何捕获
这个pattern等价于patt的补集
个人理解：这里始终返回1是根据结果猜的，如果有其他情况后面再补上
示例：
local lpeg = require "lpeg"
local match = lpeg.match
local P = lpeg.P
local p1 = P"aa"
local p2 = - p1
print(match(p1, "aa")) ---> 3
print(match(p2, "aa")) ---> nil
print(match(p1, "a")) ---> nil
print(match(p2, "a")) ---> 1
patt1 + patt2
返回一个pattern，匹配patt1或者patt2
如果patt1和patt2都是字符集合，这个操作，返回结果的并集。
示例：
local lpeg = require "lpeg"
local match = lpeg.match
local P = lpeg.P
local p1 = P"aaa"
local p2 = P"aa"
local p3 = p1 + p2
print(match(p3, "a")) ---> nil
print(match(p3, "aa")) ---> 3
print(match(p3, "aaa")) ---> 4
patt1 - patt2
返回一个pattern，不捕获patt2并且捕获到patt1
当捕获成功后，这个pattern产生patt1的所有捕获，并且从不捕获patt2
如果patt1和patt2都是字符集合，这个操作相当于两个集合的差集。- patt2 = "" - patt2 = 0 - patt2。(如果patt2是字符集合，那么1 - patt2是补集)
local lpeg = require "lpeg"
local match = lpeg.match
local S = lpeg.S
local s1 = S"\1\0\2"
local s2 = S"\0"
local s3 = s1 - s2
print(match(s1, "\0")) ---> 2
print(match(s2, "\0")) ---> 2
print(match(s3, "\0")) ---> 0
print(match(s3, "\1")) ---> 2
-- 注：这里的s3是s1与s2的差集，也就是不配s2并且匹配s1
patt1 * patt2
返回一个pattern，它会先匹配patt1，如果匹配成功继续匹配patt2
示例：
local lpeg = require "lpeg"
local match = lpeg.match
local P = lpeg.P
local p1 = P"aa"
local p2 = P"bb"
local p3 = p1 * p2
print(match(p3, "aabb")) ---> 5
print(match(p3, "aaaa")) ---> nil
patt^n
如果n是非负整数，这个pattern将匹配n个或n个以上patt
如果n是负整数，那么这个pattern讲最多匹配n个patt，也就是最少匹配0个，最多匹配n个
patt ^ 0类似于lua里面正则表达式的*
patt ^ 1类似于lua里面正则表达式的+
patt ^ -1类似于lua里面正则表达式的?
在所有情况下，此pattern的结果是没有回溯的贪婪模式，也就是说匹配最长的可能匹配到的序列
local lpeg = require "lpeg"
local match = lpeg.match
local P = lpeg.P
local p1 = P"aa"
local p2 = p1 ^ 0
local p3 = p1 ^ 3
local p4 = p1 ^ -1
print(match(p1, "aaaa")) ---> 3
print(match(p2, "aaaa")) ---> 5
print(match(p3, "aaaa")) ---> nil
print(match(p3, "aaaaaa")) ---> 7
print(match(p4, "aaaa")) ---> 3
print(match(p4, "a")) ---> 1 注：这里没有匹配到也返回1
Lpeg语法(Grammars)
在lua的环境下，可以自定义一些patterns，让新定义的pattern可以使用已经定义过的旧的pattern。然而，这种技术不允许定义递归匹配模式。对于递归匹配模式，我们需要真正的语法。
Lpeg用tables来描述语法，每个条目就是一个语法规则。
通过调用lpeg.V(v)来创建一个pattren，它表示在语法中的一个引索V。
当table被转换成了pattern(通过调用lpeg.P或者在一个pattern中使用)，它被固定了。
当table已经固定，结果是一个匹配它初始规则的pattern。第一个引索的条目就是她初始规则。如果这个条目是字符串，那么它被认为是初始规则的名字。否则lpeg假定第一个条目就是table的初始规则。
捕获(Captures)
捕获是一种模式，该模式会根据匹配到的数据返回值(语义信息)。
lpeg有几种捕获方式，产生的值会基于匹配，并且组合这个值产生新的值。
每个捕获可能产生0个或多个值。
lpeg.C (patt)
创建一个简单的捕获，捕获匹配到patt的子字符串。
捕获的值是一个字符串。
如果patt有其他捕获，他们的值将在这个值之后返回
示例：
local lpeg = require "lpeg"
local match = lpeg.match
local P = lpeg.P
local R = lpeg.R
local S = lpeg.S
local C = lpeg.C
local p1 = P"aa" ^ 3
local cp1 = C(p1)
print(match(cp1, "aaaaaa")) ---> aaaaaa
print(match(cp1, "aa")) ---> nil
local r1 = R"09" ^ 0
local cr1 = C(r1)
print(match(cr1, "1234aaaa")) ---> 1234
print(#match(cr1, "aaaa")) ---> 0 注：这里返回的是空字符串，跟lpeg.P不同
local s1 = S"+-*/" ^ 0
local cs1 = C(s1)
print(match(cs1, "++++aaaa")) ---> ++++
print(#match(cs1, "aaaa")) ---> 0 注：这里返回的是空字符串，跟lpeg.P不同
-- 进阶
local m1 = { [1] = C(C(1) * V(1) + -1) }
print(match(m1, "abc")) ---> "abc" "a" "bc" "c" "c" "" 注：这里的值添加了引号，最后一个是空字符串
-- 解析：
-- 过程：
-- ① (1)匹配到a，然后匹配V(1)，由于C(1)，产生结果a
-- ② (1)匹配到b，然后匹配V(1)，由于C(1)，产生结果b
-- ③ (1)匹配到c，然后匹配V(1)，由于C(1)，产生结果c
-- ④ (1)C(1) * V(1)没有匹配到，匹配到-1，返回到③，由于-1，产生""
-- ③ (2)匹配到C(1) * V(1)，返回到②，由于C(1) * V(1)，产生c和④的组合，就是c
-- ② (2)匹配到C(1) * V(1)，返回到①，由于C(1) * V(1)，产生b和③的组合，就是bc
-- ① (2)匹配到C(1) * V(1)，返回结果，由于C(1) * V(1)，产生a和②的组合，就是abc
-- 这个过程是个递归的过程，看似有点复杂，根据结果，仔细分析一下就能得出结论啦
lpeg.Carg (n)
创建一个参数捕获。
未完待续
lpeg.Cb (name)
创建一个回退捕获
这个pattern匹配空字符串，并且通过最近的group cpature(lpeg.Cg)被命名的名字(名字可以是任何Lua类型)，产生返回值
最近的group cpature(lpeg.Cg)被命名的名字的意思是，最近一次完整的给定名字的组捕获
完整的捕获意思是，整个模式对应的捕获匹配。
外层的意思是，这个捕获不是在另一个完整的捕获
示例：
local lpeg = require "lpeg"
local match = lpeg.match
local Cg = lpeg.Cg
local Cb = lpeg.Cb
local t = {}
local foo = function(s)
t[#t + 1] = s
return s .. "x"
end
local m1 = Cg(C(2) / foo, "y") * Cb"y"
* Cg(Cb"y" / foo, "y") * Cb"y"
* Cg(Cb"y" / foo, "y") * Cb"y"
print(match(m1, "ab")) ---> abx abxx abxxx
print(table.concat(t, " ")) ---> ab ab abx ab abx abxx
-- 解析：
-- ① C(2)捕获到"ab"，通过foo函数，向t插入"ab"，并返回"abx"，再给"abx"打上"y"的标记
-- ② 接下来的Cb"y"，捕获到打了"y"标记的"abx"，这里产生了"abx"
-- ③ 第一个Cg(Cb"y" / foo, "y")，这里的Cb"y"，从Cg(C(2) / foo, "y")开始，走①②流程
-- ④ 然后再匹配Cg(③的结果 / foo, "y") * Cb"y"，向t插入"abx"，此时t里面的内容是"ab" "ab" "abx"，并通过foo函数返回"abxx"，并打上"y"标记
-- ⑤ 接下来的Cb"y"，捕获到打了"y"标记的"abxx"，这里产生了"abxx"
-- ⑥ 第二个Cg(Cb"y" / foo, "y")，重复③的流程
-- 最后m1捕获到的结果是："abx" "abxx" "abxxx"
-- t里面的结果是
-- {
-- "ab", -- 这个是Cg(C(2) / foo, "y") * Cb"y"的结果
-- "ab", "abx", -- 这个是第一个* Cg(Cb"y" / foo, "y") * Cb"y"的结果
-- "ab", "abx", "abxx" -- 这个是第二个* Cg(Cb"y" / foo, "y") * Cb"y"的结果
-- }
lpeg.Cg (patt [, name])
创建一个组捕获。这个组捕获的所有返回值都是通过patt捕获到的简单返回值
如果没有给组取名字，那么这个组就是匿名的，或者这个组的名字是给定的名字(nil不能作为名字)
在大多数情况下，一个被命名的组，是没有任何捕获值返回的，只有在back capture(lpeg.Cb)或者table capture(lpeg.Ct)才会有捕获值返回
示例：
local lpeg = require "lpeg"
local match = lpeg.match
local Cg = lpeg.Cg
local Cc = lpeg.Cc
local C = lpeg.C
local m1 = Cg(1)
print(match(m1, "x")) ---> x
local m2 = Cg(Cg(Cg(1)))
print(match(m2, "x")) ---> x
local m3 = Cg(Cg(Cg(C(1)) ^ 0) * Cg(Cc(1) * Cc(2)))
print(match(m3, "abc")) ---> a b c 1 2
local m4 = Ct(Cg(Cc(10), "hi") * C(1) ^ 0 * Cg(Cc(20), "ho"))
print(match(m4, "abc")) ---> { hi = 10, ho = 20, "a", "b", "c" }
-- 非字符串的组名
local print = print
local tab = {}
local m5 = Ct(Cg(1, print) * Cg(1, 23.5) * Cg(1, tab))
local result = match(m5, "abcdefghij")
print(result) ---> { [function: 0x10322db70] = "a", [23.5] = "b", [table: 0x7faaa2408660] = "c" }
print(result[print]) ---> a
print(result[tab]) ---> c
lpeg.Cp ()
创建一个位置捕获。这个pattern匹配空字符串，并且返回捕获的位置
这个捕获值是数字类型
示例：
local lpeg = require "lpeg"
local match = lpeg.match
local R = lpeg.R
local Cp = lpeg.Cp
local letter = R"az" + R"AZ"
local m1 = letter ^ 1
local m2 = Cp() * m1
local m3 = m2 * Cp()
local m4 = C(m3)
local m5 = Cp() * letter ^ 5 * Cp()
print(match(m1, "abcd")) ---> 5
print(match(m2, "abcd")) ---> 1
print(match(m3, "abcd")) ---> 1 5
print(match(m4, "abcd")) ---> abcd 1 5
print(match(m5, "abcd")) ---> nil
-- 解析：
-- 1. 通过m1和m2，推出：如果有Cp的pattern只返回Cp的结果
-- 2. 通过m3，推出：存在Cp时，并匹配成功，只返回Cp()相关结果
-- 3. 通过m4，推出：会优先捕获其他pattern的结果，再返回Cp的结果
lpeg.Cc ([value, ...])
创建一个常量捕获，这个pattern匹配到一个空字符串并且产生所有给定的值作为捕获的值
示例
local lpeg = require "lpeg"
local match = lpeg.match
local R = lpeg.R
local Cc = lpeg.Cc
local m1 = C(R"09" ^ 1 * Cc("a"))
local m2 = C(R"09" ^ 1 * Cc("a", "b"))
local m3 = Cc(nil)
local m4 = Cc()
print(match(m1, "123")) ---> 123 a
print(match(m2, "123")) ---> 123 a b
print(match(m3, "123")) ---> nil
print(match(m4, "123")) ---> 1
----- 分割线 -----
local m5 = Cc() * Cc() * Cc(1) * Cc(20, 30, 40) * "a" * Cp()
print(match(m5, "aaa")) ---> 1 20 30 40 2
local m6 = Cc() * Cc() * Cc(nil) * Cc(1) * Cc() * Cc(20, 30, 40) * "a" * Cp()
local m7 = Cc(1) * Cc(2) * Cc(nil) * Cc(3) * Cc()
print(match(m6, "aaa")) ---> nil 1 20 30 40 2
print(match(m7, "aaa")) ---> 1 2 nil 3 注：这里只返回了4个结果
-- 根据结果，推出以下结论：
-- 1. Cc()单独匹配时返回1，例如m4
-- 2. Cc()和其他太参数的Cc函数或其他pattern组合时，Cc()会被忽略，即Cc()什么都不会返回
lpeg.Cf (patt, func)
创建一个迭代捕获。
如果这个patt产生了一个C1, C2, ..., Cn的捕获列表，那么这个捕获将产生一个值，这个值由func(...func(func(C1, C2), C3)..., Cn)产生
也就是说，它会使用func对产生的捕获值进行迭代
这个patt至少捕获到一个值(任何类型的值)，这个值来作为累积器的初始值。至少要这个条件成立
如果patt要一个特殊的初始值，应该在这个patt前面加一个constant capture(lpeg.Cc)
对于后面的每一个捕获，LPeg调用func，这个累积值作为func的第一个参数，这个捕获产生的所有值作为这个func的额外参数，func的结果成为新的累积值。这个累积的最终值就是这个patt的结果
示例：
local lpeg = require "lpeg"
local match = lpeg.match
local R = lpeg.R
local Cf = lpeg.Cf
local Cc = lpeg.Cc
local C = lpeg.C
local number = R"09" ^ 1 /tonumber
local list = number * ("," * number) ^ 0
function add(acc, cpatureNewValue)
return acc + cpatureNewValue
end
local sum = Cf(list, add)
print(match(sum, "10,30,43")) ---> 83
local f = function(x)
return x + 1
end
local m1 = Cc(0) * C(1) ^ 0
local m2 = Cf(m1, f)
print(match(m1, "alo alo")) ---> 0 "a" "l" "o" "" "a" "l" "o"
print(match(m2, "alo alo")) ---> 7
-- 注：通过m1的结果，推出：Cc(0)是第一个捕获值，最后迭代出7
local m3 = Cf(Cc(1, 2, 3), error)
print(match(m3, "")) ---> 1 注：这里调用error直接返回1(个人理解)
local m4 = Ct(true) * Cg(C(R"az" ^ 1) * "=" * C(R"az" ^ 1) * ";") ^ 0
local m5 = Cf(m4, rawset)
print(match(m4, "a=b;c=du;xux=yuy;")) ---> {} a b c du xux yuy
print(match(m5, "a=b;c=du;xux=yuy;")) ---> { a= "b", c = "du", xux = "yuy" }
-- 注：这里的Ct(true)捕获到一个空table，m5通过rawset向空table设置key-value
lpeg.Cs (patt)
创建一个替换捕获
lpeg.Ct (patt)
创建一个table捕获。这个捕获返回一个table
返回所有patt的匿名捕获的值，key从1开始
此外，每个被命名的捕获组，第一个值是组名
示例：
local lpeg = require "lpeg"
local match = lpeg.match
local R = lpeg.R
local Ct = lpeg.Ct
local C = lpeg.C
local Cc = lpeg.Cc
local letter = R"az" + R"AZ"
local m1 = letter ^ 1
local m2 = Ct(m1)
print(match(m1, "alo")) ---> 4
print(match(m2, "alo")) ---> {} 注：m1没有返回捕获的值
local m3 = C(m1)
local m4 = Ct(m3) * Cc("t")
print(match(m4, "alo")) ---> { "alo" } "t"
local m5 = Ct(C(C(letter) ^ 1))
print(match(m5, "alo")) ---> { "alo", "a", "l", "o" }
local m6 = Ct((Cp() * letter * Cp()) ^ 1)
local m7 = Ct(m6)
print(match(m6, "alo")) ---> { 1, 2, 2, 3, 3, 4 }
print(match(m7, "alo")) ---> { { 1, 2, 2, 3, 3, 4 } }
patt / string
创建一个字符串捕获。这个操作会创建一个基于string的字符串捕获
返回的捕获的值是string的一个副本，string中的%是转义字符，如果要表示%，则用%%来表示
字符串中的任何序列中有%n(n在1到9之间)，在patt中匹配第n个捕获。%0表示匹配到的整个序列
示例：
local lpeg = require "lpeg"
local match = lpeg.match
local P = lpeg.P
local Cp = lpeg.Cp
local pi = "3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510"
local m1 = (P"1" / "a" + P"5" / "b" + P"9" / "c" + 1) ^ 0
print(match(m1, pi)) ---> a a b c b b c c c b a c a c c c b a
-- 注：这里返回的是捕获到值后被替换的值
print(match(m1, "222")) ---> 4 注：这里只匹配到了1，所以返回4
local m2 = Cp() * P(3) * Cp() / "%2%1%1 - %0"
print(match(m2, "abcde")) ---> "411 - abc"
-- 解析：
-- 1. 先匹配Cp() * P(3) * Cp()，匹配到 1 4
-- 2. 然后通过 / "%2%1%1 - %0" 格式化结果
-- 3. 这里的%1对应1，%2对应4，%0对应"abc"
local m3 = C"a" / "%1%%%0"
print(match(m3, "a")) ---> a%a
local m4 = P(1) / "%0"
print(match(m4, "abc")) ---> a
local m5 = C(1) ^ 0 / "%2-%9-%0-%9"
print(match(m5, "0123456789")) ---> "1-8-0123456789-8"
local m6 = C(1) ^ 0 / "9-%1-%0-%3"
print(match(m6, "12345678901234567890")) ---> "9-1-12345678901234567890-3"
-- 注：%1 - %9 是所有捕获的结果，%0 - %9 的值都只能是数字或者字符串，其他类型报错
patt / number
创建一个有编号的捕获
对于非0的number，返回的是被捕获的第n个值
当number为0时，不会返回捕获的值
示例：
local lpeg = require "lpeg"
local match = lpeg.match
local C = lpeg.C
local m1 = C(1)
local m2 = C(C(m1 * C(2)) * C(3))
local m3 = m2 / 3
local m4 = m2 / 0
print(match(m2, "aaabcdefgh")) ---> aaabcd aaa a aa bcd
-- 注：这里返回值的顺序是什么规律？按匹配的顺序也不像哇~~~~
print(match(m3, "aaabcdefgh")) ---> a
print(match(m4, "aaabcdefgh")) ---> 7
-- 注：
-- 1. 如果是负数会报错
-- 2. 如果number超出捕获的长度，也会报错
local m5 = m1 * (C(m1 * C(2)) * C(3) / 4) * m1
print(match(m5, "abcdefgh")) ---> a efg h
-- 解析：
-- ① 匹配m1，捕获到a
-- ② (1)先匹配m1，捕获到b
-- ② (2)再匹配C(2)，捕获到cd
-- ② (3)再匹配m1 * C(2)，捕获到bcd
-- ② (4)再匹配C(3)，捕获到efg
-- ② (5)再取②捕获到的值的第4个捕获值，最终得到efg
-- ③ (6)最后匹配m1，捕获到h
patt / table
创建一个查询捕获。patt捕获到的值作为table中的key，来引索table中的value
table中的值是捕获的最终值。如果table没有key，将不会产生捕获
示例：
local lpeg = require "lpeg"
local match = lpeg.match
local P = lpeg.P
local pi = "3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510"
local m1 = (P(1) / { ["1"] = "a", ["5"] = "b", ["9"] = "c" }) ^ 0
print(match(m1, pi)) ---> a a b c b b c c c b a c a c c c b a
print(match(m1, "222")) ---> 4
patt / function
创建一个函数捕获
这个pattern将调用给定的function，并把捕获到的所有值当参数传个这个function
function的返回值是这个捕获的最终值，如果function没有返回值，也就没有捕获值
示例：
local lpeg = require "lpeg"
local match = lpeg.match
local C = lpeg.C
local Cg = lpeg.Cg
local Cb = lpeg.Cb
local foo = function(s)
return s .. "0"
end
local m1 = Cg(C(3) / foo, "name") * Cb("name")
print(match(m1, "abc")) ---> abc0
lpeg.Cmt(patt, function)
创建一个匹配时的捕获
不像其他捕获，当有一个匹配时，会立即执行(甚至在一个很复杂的匹配模式中失败)
它会强制执行所有嵌入的捕获，并调用function
整个待匹配的字符串，当前匹配到的坐标，还有任何捕获到的值是这个function的参数
function返回的第一个值定义了匹配过程，如果返回的是一个数字，则表示匹配成功，返回的数字成为新的匹配位置
假设一个被匹配的字符串s，和当前的匹配位置i，返回的数字必须在[i, len(s+1)]
如果返回true，匹配成功时，不消耗任何输入(所以返回true，等价于返回i)
如果返回false，nil，或者无返回值，匹配失败
function额外的返回值会成为捕获的值
示例：
local lpeg = require "lpeg"
local match = lpeg.match
local S = lpeg.S
local P = lpeg.P
local R = lpeg.R
local V = lpeg.V
local C = lpeg.C
local Cs = lpeg.Cs
local Ct = lpeg.Ct
local Cg = lpeg.Cg
local Cmt = lpeg.Cmt
local space = S" \t\n" ^ 0
local id = function(s, i, ...)
return true, ...
end
local m1 = P{
"S",
S = V"atom" * space + Cmt(Ct("(" * space * (Cmt(V"S" ^ 1, id) + P(true)) * ")" * space), id),
atom = Cmt(C(R("AZ", "az", "09") ^ 1), id)
}
print(match(m1, "(a g () ((b) c) (d (e)))")) ---> { "a", "g", {}, { { "b" }, "c" }, { "d", { "e" } } }
local m2 = Cmt(1, id) ^ 0
print(match(m2, string.rep("a", 5))) ---> a a a a a
local id = function(s, i, x)
if x == "a" then
return i, 1, 3, 7
end
return nil, 2, 4, 6, 8
end
local m3 = (P(id) * 1 + Cmt(2, id) * 1 + Cmt(1, id) * 1) ^ 0
print(match(m3, "abababab")) ---> 1 3 7 1 3 7 1 3 7 1 3 7
-- 问题：这里每个Cmt后面要 * 1呢？不加的话会报错
local ref = function(s, i, x)
-- print(s, i, x)
return match(x, s, i - #x)
end
local m4 = Cmt(P(1) ^ 0)
local m5 = P(1) * m4
local m6 = P(1) * Cmt(C(1) ^ 0)
print(match(m4, "alo")) ---> 4
print(match(m5, "alo")) ---> 4
print(match(m6, "alo")) ---> nil
-- 注：这里的m5和m6的区别，一个P，一个是C；
-- P后面跟了^0，所以要等P匹配完才产生捕获；
-- 虽然C后面也跟了^0，但是C立马产生捕获，
-- 所以会立马调用ref，就会匹配不到，然后直接返回nil
ref = function(s, i, a, b)
if a == b then
return i, a:upper()
end
end
local any = P(1)
local m7 = Cmt(C(R"az" ^ 1) * "-" * C(R"az" ^ 1), ref)
local m8 = (any - m7) ^ 0 * m7 * any ^ 0 * -1
print(match(m8, "abbbc-bc ddaa")) ---> BC
-- 解析：
-- ① (1)先匹配(any - m7) ^ 0，这里是不匹配m1，并且匹配any，匹配至少0次
-- ① (2)先匹配m7，这里会捕获到"abbbc"和"bc"当做参数传给ref，也就是ref的a和b两个参数，然后"abbbc"不等于"bc"，没有返回值，所以也就没有匹配到m7，且匹配到any
-- ② 重复①的过程，这次m7匹配到"bbbc"和"bc"，也没匹配到m7
-- ③ 重复①的过程，这次m7匹配到"bbc"和"bc"，也没匹配到m7
-- ④ 重复①的过程，这次m7匹配到"bc"和"bc"，这回匹配到m7了，所以(any - m7) ^ 0的匹配终止，产生结果4
-- ⑤ 接着匹配m7，从位置4开始匹配，然后捕获到"bc"和"bc"，返回了一个捕获值"BC"
local check = function(_, _, s1, s2)
return s1 == s2
end
local m9 = "[" * Cg(P"=" ^ 0, "init") * "[" * {
Cmt("]" * C(P"=" ^ 0) * "]" * Cb("init"), check) + 1 * V(1)
} / 0
print(match(m9, "[==[]]====]]]]==]===[]")) ---> 18
-- 解析：
-- ① 首先匹配"[" * Cg(P"=" ^ 0, "init") * "["，这里捕获到"=="，并命名为"init"，返回位置5
-- ② (1)再匹配{ Cmt("]" * C(P"=" ^ 0) * "]" * Cb("init"), check) + 1 * V(1) } / 0，这里有两个捕获，一个是C(P"=" ^ 0)，另一个是Cb("init")
-- ② (2)先匹配Cmt("]" * C(P"=" ^ 0) * "]" * Cb("init"), check)，从位置5开始匹配，匹配到]]，产生捕获""，和前面捕获的"=="比较，不相等，返回false，匹配失败
-- ② (3)然后匹配1 * V(1)，重复过程②(1)
-- ③ 直到匹配到]==]
Lpeg 小技巧
示例：
local lpeg = require "lpeg"
local match = lpeg.match
local P = lpeg.P
local R = lpeg.R
local V = lpeg.V
local C = lpeg.C
print(match(3, "aaaa")) ---> 4
print(match(P(3), "aaaa")) ---> 4
-- lpeg 对lua的数据类型默认使用lpeg.P来处理
local m1 = R"09" * -1
local m2 = R"09" * P(-1)
local m3 = R"09" * -P(1)
-- 这里的m1、m2、m3等价
print(match(m1, "9")) ---> 2
print(match(m1, "99")) ---> nil
print(match(m2, "9")) ---> 2
print(match(m2, "99")) ---> nil
print(match(m3, "9")) ---> 2
print(match(m3, "99")) ---> nil
-- lpeg.V、#patt
local tab = {
[1] = "(" * (((1 - S"()") + #P"(" * V(1)) ^ 0)
}
-- 这里的V(1)指的是tab[1]的规则
-- 这里的#P"("表示这条规则匹配到的"("的个数(个人结论，不太确定)
local digit = R"09"
local upper = R"AZ"
local lower = R"az"
local letter = S"" + upper + lower
local alpha = letter + digit + R()
local m1 = letter ^ 1
local m2 = m1:C()
local m3 = C(m1) -- 注：这里的m3等价于m2
local m4 = P{ [1] = m2 + (1 * V(1)) }
local m5 = m4 ^ 0
print(match(m1, " 4achou123...")) ---> nil
print(match(m4, " 4achou123...")) ---> achou
print(match(m5, " two words, one more ")) ---> two words one more
-- 解析：
-- m1是匹配所有字母，通过m4的语法，就可以匹配不以字母开头的字符串
-- 关键点是 1 * V(1) 中的 1 *，这里的1等价于P(1)，也就是至少匹配任意一个字符
-- 匹配过程：
-- (1) 第一个字符是空白符，m2是肯定没匹配到，那么匹配(1 * V(1))
-- (2) 匹配到1的时候，符合匹配条件，再匹配V(1)，此时又回到过程(1)
-- 直到都不符合匹配。整个过程是个递归的过程，最后把匹配到的结果返回
-- 语法例子
local m6 = P{ P"x" * V(1) + P"y" }
-- 这里的m6可以改为 local m6 = P{ P"x" * V(1) + -1 } 看看是什么结果
local m7 = -m6
local m8 = C(m7)
print(match(m6, "xxx")) ---> nil
print(match(m7, "xxx")) ---> 1
print(match(m8, "xxx")) ---> "" 注：这里是空字符串
-- 解析：
-- ① m6的匹配过程：一直匹配P"x" * V(1)，知道最后一个x，然后匹配P"y"，但是没有没匹配到，直接返回nil
-- ② m7根据①的返回结果，返回①的补集，这里nil的补集就是1
-- ③ m8根据②的返回结果，捕获到一个空字符串