使用一個模式
這個例子顯示了一個建立和使用模式的程序，它非常簡單但很完整：
local lpeg = require "lpeg"
-- matches a word followed by end-of-string
p = lpeg.R"az"^1 * -1
print(p:match("hello")) --> 6
print(lpeg.match(p, "hello")) --> 6
print(p:match("1 hello")) --> nil
模式是簡單的一個或多個小寫字符并在尾端以(-1)結束的序列。該程序調用match來當作一個方法和函數(shù)。在以上成功案例，匹配函數(shù)返回成功 匹配的第一個字符的索引，為其字符串長度加1。
這個例子解析一個名稱 - 值配對的列表，并返回那些配對的表：
lpeg.locale(lpeg) -- adds locale entries into 'lpeg' table
local space = lpeg.space^0
local name = lpeg.C(lpeg.alpha^1) * space
local sep = lpeg.S(",;") * space
local pair = lpeg.Cg(name * "=" * space * name) * sep^-1
local list = lpeg.Cf(lpeg.Ct("") * pair^0, rawset)
t = list:match("a=b, c = hi; next = pi") --> { a = "b", c = "hi", next = "pi" }
每一配對都有 formatname =namefollowed 的一個可選的分離器（用逗號或分號）。 配對模式(Thepairpattern)在一個組模式里形成閉包，那么那些名稱就可以成為單個捕獲的值。 列表模式 (Thelistpattern)然后折疊這些捕獲。 它以空列表開始，通過創(chuàng)建列表捕獲匹配一個空字符串，然后為每個捕獲（一名稱對）appliesrawsetover累加器（表）和捕捉值（對名稱）。rawsetreturns((未初始化的集合)返回表本身，所以累加器總是表中執(zhí)行。
以下代碼創(chuàng)建了一個模式，該模式使用給定的分隔模式sep作為分隔器來來拆分字符串：
sep = lpeg.P(sep)
local elem = lpeg.C((1 - sep)^0)
local p = elem * (sep * elem)^0
return lpeg.match(p, s)
end
首先，該函數(shù)確保sep一個合適的模式。只要沒有匹配分隔器，該模式的elem 是重復的零個或多個任意字符。它還捕捉其匹配值。模式p匹配由sep拆分的一組元素.
如果拆分產生的結果值太多，可能會溢出由一個Lua函數(shù)返回的最大數(shù)目的值。在這種情況下，我們可以將這些值放到一個表中：
sep = lpeg.P(sep)
local elem = lpeg.C((1 - sep)^0)
local p = lpeg.Ct(elem * (sep * elem)^0) -- make a table capture
return lpeg.match(p, s)
end
模式搜索
基本的匹配僅僅工作在錨定模式下。如果我們打算查找匹配字符串中任何地方的模式，那么我們必須寫一個匹配任何地方的模式。
因為模式是可以編寫的，所以我們可以編寫一個函數(shù)，它給定一個任意的模式p,返回一個搜索p的新模式，以匹配字符串的任何位置。執(zhí)行這種搜索有幾種方法。一種方法如下：
return lpeg.P{ p + 1 * lpeg.V(1) }
end
這個語法的直接解讀：匹配p或者跳過一個字符，然后試圖再次匹配。
如果我們想知道這個模式在字符串的所有匹配位置（而不僅僅知道它在字符串的某個位置），那么我們可以給這個模式添加位置捕捉:
function anywhere (p)
return lpeg.P{ I * p * I + 1 * lpeg.V(1) }
end
print(anywhere("world"):match("hello world!")) -> 7 12
這種搜索的另一個方法如下：
function anywhere (p)
return (1 - lpeg.P(p))^0 * I * p * I
end
再次說明，這個模式的直接解讀：當不匹配p時，它跳過盡可能多的字符，然后對p進行匹配（外加正確的位置捕捉）。
如果我們打算查找僅僅匹配單詞邊界的模式的話，那么我們可以使用以下轉換：
local t = lpeg.locale()
function atwordboundary (p)
return lpeg.P{
[1] = p + t.alpha^0 * (1 - t.alpha)^1 * lpeg.V(1)
}
end
平衡的括號
以下模式只匹配帶有平衡括號的字符串：:
閱讀第一個（也是唯一的）所給語法規(guī)則，所謂平衡字符串，就是一個開括號，后跟零個或多個非括號字符或者平衡字符串（LPFG.V(1)），最后跟著與開括號能夠閉合的結束括號。
全局替換
下面的例子和tostring.gsub所做工作類似。它接收一個母串和一個模式以及一個替換值，然后替代所傳入的母串中所有與指定模式匹配的子串為指定的替換值：:
patt = lpeg.P(patt)
patt = lpeg.Cs((patt / repl + 1)^0)
return lpeg.match(patt, s)
end
作為instring.gsub，替換值可以是一個字串、函數(shù)，或者一個表.
逗號分隔值（CSV）
下面的例子將字符串轉換成逗號分隔的值，并返回所有的字段:
local field = '"' * lpeg.Cs(((lpeg.P(1) - '"') + lpeg.P'""' / '"')^0) * '"' +
lpeg.C((1 - lpeg.S',\n"')^0)
local record = field * (',' * field)^0 * (lpeg.P'\n' + -1)
function csv (s)
return lpeg.match(record, s)
end
一個字段或是一個引用的字段(一族可能包含任何字符除單引號，或雙引號)或是一個未被引用的字段(不包含逗號，換行符或引號)。一個記錄就是一個用逗號分隔的字段列表(以換行符或以字符串結尾)。
就像這樣，前面的匹配返回的每個字段都是獨立返回的。若我們添加一個列表截取定義的記錄。返回的將不再是一個獨立的包含所有字段的列表。
UTF-8 和 Latin 1
使用LPeg來將一字符串從UTF-8編碼轉換成Latin 1(ISO 88590-1)，這并不困難：
-- convert a two-byte UTF-8 sequence to a Latin 1 character
local function f2 (s)
local c1, c2 = string.byte(s, 1, 2)
return string.char(c1 * 64 + c2 - 12416)
end
local utf8 = lpeg.R("\0\127")
+ lpeg.R("\194\195") * lpeg.R("\128\191") / f2
local decode_pattern = lpeg.Cs(utf8^0) * -1
這些代碼中，UTF-8定義已經為Latin 1的編碼范圍(從0到255)。所有不在該范圍內的編碼（以及任何無效的編碼）將不匹配該模式。
正如decode_pattern所要求的，這個模式匹配所有的輸入（因為-1在它的結尾處），任何無效字符串會匹配失敗，而無任何關于此問題的有用信息。我們可以通過重定義如下decode_pattern來改善這種情況：
local function er (_, i) error("invalid encoding at position " .. i) end
local decode_pattern = lpeg.Cs(utf8^0) * (-1 + lpeg.P(er))
現(xiàn)在，如果模式utf8^0 在字符串尾部之前停止，會調用一個適用的出錯函數(shù)。
UTF-8 和 Unicode
我們可以擴展以前的模式來處理所有的Unicdoe代碼片段，當然， 我們不能把它們翻譯阿拉伯數(shù)字1或其他任何一個字節(jié)編碼。相反，我們的翻譯序列結果中的數(shù)字表示的代碼片段。這里完整的代碼：
-- decode a two-byte UTF-8 sequence
local function f2 (s)
local c1, c2 = string.byte(s, 1, 2)
return c1 * 64 + c2 - 12416
end
-- decode a three-byte UTF-8 sequence
local function f3 (s)
local c1, c2, c3 = string.byte(s, 1, 3)
return (c1 * 64 + c2) * 64 + c3 - 925824
end
-- decode a four-byte UTF-8 sequence
local function f4 (s)
local c1, c2, c3, c4 = string.byte(s, 1, 4)
return ((c1 * 64 + c2) * 64 + c3) * 64 + c4 - 63447168
end
local cont = lpeg.R("\128\191") -- continuation byte
local utf8 = lpeg.R("\0\127") / string.byte
+ lpeg.R("\194\223") * cont / f2
-- decode a two-byte UTF-8 sequence
local function f2 (s)
local c1, c2 = string.byte(s, 1, 2)
return c1 * 64 + c2 - 12416
end
-- decode a three-byte UTF-8 sequence
local function f3 (s)
local c1, c2, c3 = string.byte(s, 1, 3)
return (c1 * 64 + c2) * 64 + c3 - 925824
end
-- decode a four-byte UTF-8 sequence
local function f4 (s)
local c1, c2, c3, c4 = string.byte(s, 1, 4)
return ((c1 * 64 + c2) * 64 + c3) * 64 + c4 - 63447168
end
local cont = lpeg.R("\128\191") -- continuation byte
local utf8 = lpeg.R("\0\127") / string.byte
+ lpeg.R("\194\223") * cont / f2
Lua的長字符串
Lua中的長字符串由模式 [= *[ 開始，到第一次出現(xiàn)的帶有完全相同數(shù)量的等號的 ] =*] 結束。如果開括號后跟一個換行符，換行符將被丟棄（即，不會把它當作字符串的一部分）。
在Lua中想要匹配一個長字符串，模式必須捕捉第一次重復的等號，然后，只需找到有關閉字符串的候選項，檢查其是否具有相同數(shù)量的等號。
open = "[" * lpeg.Cg(equals, "init") * "[" * lpeg.P"\n"^-1
close = "]" * lpeg.C(equals) * "]"
closeeq = lpeg.Cmt(close * lpeg.Cb("init"), function (s, i, a, b) return a == b end)
string = open * lpeg.C((lpeg.P(1) - closeeq)^0) * close / 1
open 模式匹配 [=*[，在一個名為 init 的組中捕獲重復的等號;它也會丟棄一個可選的換行符（如果它存在的話）。close 模式匹配 ]= *]，也是捕捉重復的等號。closeeq模式首先匹配 close，然后它采用逆向捕捉來恢復先前由 open 捕捉并命名為 init 的內容，最后，用 match-time 捕捉來檢查兩個捕獲是否相同。字符串模式從 open 開始之后，它會一直包含到匹配了 closeeq 為止，然后匹配最終的 close。最后的數(shù)字捕獲簡單地丟棄由 close 產生的捕獲。
算術表達式
本例對簡單的算術表達式進行完整的解析和求值。而且我們用兩種風格來書寫。
第一種途徑首先建立一個語法樹，然后遍歷這棵樹來計算表達式的值：
-- 詞典元素
[code]local Space = lpeg.S(" \n\t")^0
local Number = lpeg.C(lpeg.P"-"^-1 * lpeg.R("09")^1) * Space
local TermOp = lpeg.C(lpeg.S("+-")) * Space
local FactorOp = lpeg.C(lpeg.S("*/")) * Space
local Open = "(" * Space
local Close = ")" * Space
-- 語法
local Exp, Term, Factor = lpeg.V"Exp", lpeg.V"Term", lpeg.V"Factor"
G = lpeg.P{ Exp,
Exp = lpeg.Ct(Term * (TermOp * Term)^0);
Term = lpeg.Ct(Factor * (FactorOp * Factor)^0);
Factor = Number + Open * Exp * Close;
}
G = Space * G * -1
-- 求值器
function eval (x)
if type(x) == "string" then
return tonumber(x)
else
local op1 = eval(x[1])
for i = 2, #x, 2 do
local op = x[i]
local op2 = eval(x[i + 1])
if (op == "+") then op1 = op1 + op2
elseif (op == "-") then op1 = op1 - op2
elseif (op == "*") then op1 = op1 * op2
elseif (op == "/") then op1 = op1 / op2
end
end
return op1
end
end
-- 解析/求值
function evalExp (s)
local t = lpeg.match(G, s)
if not t then error("syntax error", 2) end
return eval(t)
end
-- 使用例子
print(evalExp"3 + 5*9 / (1+1) - 12") --> 13.5
第二種風格不用建立語法樹，直接求值。下面代碼就按此種途徑（假定和上面有相同的詞典元素）：
-- 輔助函數(shù)
function eval (v1, op, v2)
if (op == "+") then return v1 + v2
elseif (op == "-") then return v1 - v2
elseif (op == "*") then return v1 * v2
elseif (op == "/") then return v1 / v2
end
end
-- 語法
local V = lpeg.V
G = lpeg.P{ "Exp",
Exp = lpeg.Cf(V"Term" * lpeg.Cg(TermOp * V"Term")^0, eval);
Term = lpeg.Cf(V"Factor" * lpeg.Cg(FactorOp * V"Factor")^0, eval);
Factor = Number / tonumber + Open * V"Exp" * Close;
}
-- 使用例子
print(lpeg.match(G, "3 + 5*9 / (1+1) - 12")) --> 13.5
注意 fold (收集器) 捕獲的用法。 要計算一個表達式的值，收集器從第一個術語的值開始，為每個副本應用進化收集器，操作符，和新術語。
