脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Lua - 深入探究Lua中的解析表达式

深入探究Lua中的解析表达式

2020-05-05 13:09脚本之家 Lua

这篇文章主要介绍了深入探究Lua中的解析表达式,对于其语法部分的说明和示例都超详细,极力推荐此文!需要的朋友可以参考下

 使用一个模式

这个例子显示了一个建立和使用模式的程序，它非常简单但很完整：

 

复制代码 代码如下:

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来当作一个方法和函数。在以上成功案例，匹配函数返回成功 匹配的第一个字符的索引，为其字符串长度加1。

 

复制代码 代码如下:
Name-value lists

 

这个例子解析一个名称 - 值配对的列表，并返回那些配对的表：

 

复制代码 代码如下:

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)然后折叠这些捕获。 它以空列表开始，通过创建列表捕获匹配一个空字符串，然后为每个捕获（一名称对）appliesrawsetover累加器（表）和捕捉值（对名称）。rawsetreturns((未初始化的集合)返回表本身，所以累加器总是表中执行。


以下代码创建了一个模式，该模式使用给定的分隔模式sep作为分隔器来来拆分字符串：

 

复制代码 代码如下:
function split (s, sep)
  sep = lpeg.P(sep)
  local elem = lpeg.C((1 - sep)^0)
  local p = elem * (sep * elem)^0
  return lpeg.match(p, s)
end

 

首先，该函数确保sep一个合适的模式。只要没有匹配分隔器，该模式的elem 是重复的零个或多个任意字符。它还捕捉其匹配值。模式p匹配由sep拆分的一组元素.

如果拆分产生的结果值太多，可能会溢出由一个Lua函数返回的最大数目的值。在这种情况下，我们可以将这些值放到一个表中：

 

复制代码 代码如下:
function split (s, sep)
  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

 

模式搜索

基本的匹配仅仅工作在锚定模式下。如果我们打算查找匹配字符串中任何地方的模式，那么我们必须写一个匹配任何地方的模式。

因为模式是可以编写的，所以我们可以编写一个函数，它给定一个任意的模式p,返回一个搜索p的新模式，以匹配字符串的任何位置。执行这种搜索有几种方法。一种方法如下：

 

复制代码 代码如下:
function anywhere (p)
  return lpeg.P{ p + 1 * lpeg.V(1) }
end

 

这个语法的直接解读：匹配p或者跳过一个字符，然后试图再次匹配。

如果我们想知道这个模式在字符串的所有匹配位置（而不仅仅知道它在字符串的某个位置），那么我们可以给这个模式添加位置捕捉:

 

复制代码 代码如下:
local I = lpeg.Cp()
function anywhere (p)
  return lpeg.P{ I * p * I + 1 * lpeg.V(1) }
end

 

print(anywhere("world"):match("hello world!"))   -> 7   12

这种搜索的另一个方法如下：

 

复制代码 代码如下:
local I = lpeg.Cp()
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

 

平衡的括号

以下模式只匹配带有平衡括号的字符串：:

 

复制代码 代码如下:
b = lpeg.P{ "(" * ((1 - lpeg.S"()") + lpeg.V(1))^0 * ")" }

 

阅读第一个（也是唯一的）所给语法规则，所谓平衡字符串，就是一个开括号，后跟零个或多个非括号字符或者平衡字符串（LPFG.V(1)），最后跟着与开括号能够闭合的结束括号。
全局替换

下面的例子和tostring.gsub所做工作类似。它接收一个母串和一个模式以及一个替换值，然后替代所传入的母串中所有与指定模式匹配的子串为指定的替换值：:

 

复制代码 代码如下:
function gsub (s, patt, repl)
  patt = lpeg.P(patt)
  patt = lpeg.Cs((patt / repl + 1)^0)
  return lpeg.match(patt, s)
end

 

作为instring.gsub，替换值可以是一个字串、函数，或者一个表.

逗号分隔值（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

 

一个字段或是一个引用的字段(一族可能包含任何字符除单引号，或双引号)或是一个未被引用的字段(不包含逗号，换行符或引号)。一个记录就是一个用逗号分隔的字段列表(以换行符或以字符串结尾)。

就像这样，前面的匹配返回的每个字段都是独立返回的。若我们添加一个列表截取定义的记录。返回的将不再是一个独立的包含所有字段的列表。

 

复制代码 代码如下:
local record = lpeg.Ct(field * (',' * field)^0) * (lpeg.P'\n' + -1)

 


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))

 

现在，如果模式utf8^0  在字符串尾部之前停止，会调用一个适用的出错函数。

UTF-8 和 Unicode

我们可以扩展以前的模式来处理所有的Unicdoe代码片段，当然， 我们不能把它们翻译阿拉伯数字1或其他任何一个字节编码。相反，我们的翻译序列结果中的数字表示的代码片段。这里完整的代码：
 

复制代码 代码如下:

-- 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中的长字符串由模式 [= *[ 开始，到第一次出现的带有完全相同数量的等号的 ] =*] 结束。如果开括号后跟一个换行符，换行符将被丢弃（即，不会把它当作字符串的一部分）。

在Lua中想要匹配一个长字符串，模式必须捕捉第一次重复的等号，然后，只需找到有关闭字符串的候选项，检查其是否具有相同数量的等号。

 

复制代码 代码如下:
equals = lpeg.P"="^0
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。最后的数字捕获简单地丢弃由 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

 

第二种风格不用建立语法树，直接求值。下面代码就按此种途径（假定和上面有相同的词典元素）：

 

复制代码 代码如下:

-- 辅助函数
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 (收集器) 捕获的用法。 要计算一个表达式的值，收集器从第一个术语的值开始，为每个副本应用进化收集器，操作符，和新术语。

  • Lua
  • 解析表达式

    • 延伸 · 阅读

    精彩推荐
    • LuaLua中的元方法__newindex详解

      Lua中的元方法__newindex详解

      这篇文章主要介绍了Lua中的元方法__newindex详解,本文讲解了查询与更新、监控赋值、通过table给另一个table赋值等内容,需要的朋友可以参考下 ...

      笨木头8872020-04-09
    • LuaLua和C语言的交互详解

      Lua和C语言的交互详解

      这篇文章主要介绍了Lua和C语言的交互详解,Lua和C语言通过栈完成交互,本文结合代码实例详细讲解了交互的方法,需要的朋友可以参考下 ...

      果冻想3702020-04-14
    • LuaLua中table库函数方法介绍

      Lua中table库函数方法介绍

      这篇文章主要介绍了Lua中table库函数方法介绍,本文讲解了concat、insert、maxn、remove、sort、foreachi等方法,需要的朋友可以参考下 ...

      脚本之家2502020-04-17
    • LuaLua简介、编译安装教程及变量等语法介绍

      Lua简介、编译安装教程及变量等语法介绍

      这篇文章主要介绍了Lua简介、编译安装教程及变量等语法介绍,本文同时讲解了lua注释语法、Lua命令行方式等内容,需要的朋友可以参考下 ...

      junjie3632020-04-14
    • LuaLua实现__add方法重载示例

      Lua实现__add方法重载示例

      这篇文章主要介绍了Lua实现__add方法重载示例,本文直接给出实现代码,需要的朋友可以参考下 ...

      脚本之家7452020-04-24
    • Lua深入探究Lua中的解析表达式

      深入探究Lua中的解析表达式

      这篇文章主要介绍了深入探究Lua中的解析表达式,对于其语法部分的说明和示例都超详细,极力推荐此文!需要的朋友可以参考下 ...

      脚本之家3542020-05-05
    • LuaLua教程（二）：基础知识、类型与值介绍

      Lua教程（二）：基础知识、类型与值介绍

      这篇文章主要介绍了Lua教程（二）：基础知识、类型与值介绍,本文讲解了Hello World程序、代码规范、全局变量、类型与值等内容,需要的朋友可以参考下 ...

      脚本之家5922020-04-28
    • LuaLua中计算、执行字符串中Lua代码的方法

      Lua中计算、执行字符串中Lua代码的方法

      这篇文章主要介绍了Lua中计算、执行字符串中Lua代码的方法,类似JavaScript中eval函数的功能,在Lua中也可以实现,需要的朋友可以参考下 ...

      脚本之家6322020-04-30
    最近更新
    编辑推荐
    阅读排行
    热门标签
    Lua应用 　 metamethod 　 newindex 　 非全局环境 　 冒号 　 多重继承 　 私密性 　 Lua教程 　 通信方式 　 ipair 　 pair 　 外部脚本 　 Lua数组 　 C++类 　 元方法 　 metatable 　 元表 　 HelloWorld.lua 　 通信流程 　 Lua函数 　 C++函数 　 构造方式 　 闭合函数 　 非全局函数 　 尾调用 　 协同程序 　 resume-yield 　 table.concat 　 loadfile 　 dofile 　
    © 2019-2023 脚本之家 | 服务器之家(www.zzvips.com)旗下站点 版权所有关于我们联系我们版权申明网站地图