【导语】“BB9”通过精心收集，向本站投稿了8篇Lua函数用法研究，下面是小编整理后的Lua函数用法研究，欢迎大家阅读借鉴，并有积极分享。
- 目录
篇1：Lua函数用法研究
这篇文章主要介绍了Lua函数用法研究,本文讲解了函数、变量的用法、返回多个结果值和可变参数等特性的示例,需要的朋友可以参考下
在Lua 基本语法快速入门 中有涉及到函数的用法，但只是普通的应用，并没有深成次的研究一下，介于函数用的还是比较多的就专门做个专题研究一下~
一、函数、变量的用法
函数的定义用关键字function ，然后加函数名和变量。注意后面没有do。最后以end结束。
在函数中的变量默认是全局变量，但通常情况下函数中的变量都是在函数中有效的。所以要在声明的时候加上“local” 标明只在局部有效。
二、返回多个结果值
在Lua中的函数可以返回多个返回值。这与C等语言有很大的不同。因为从根本上讲Lua支持多赋值。
我猜测在内部运行时，多个返回值被封装到了一个table中。然后在赋值时再按顺序取出。
看这个示例：
function max(a) local mi = 1 local m = a[mi] for i,val in ipairs(a) do --其中i为顺序位置，val为相应的值 print(”i= “..i..”val=“..val) if val >m then mi = i m = val end end return m,mi end print(max({8,10,23,12,5}))
这个函数的作用是返回一个数列中最大的值和下标，
在实际应用的过程中，在C中调用lua_pcall(L,0,2,0) 即可接受这两个返回值入栈，然后通过 lua_tonumber(L,-1) 和 lua_tonumber(L,-2)即可
三、可变参数
Lua 函数可以接受可变数目的参数，和 C 语言类似在函数参数列表中使用三点（...）表示函数有可变的参数。
Lua 将函数的参数放在一个叫 arg 的表中，除了参数以外，arg表中还有一个域 n 表示参数的个数。
例如：
function myprint(...) local printResult = ”“ --如果不显式声明，程序会自动检查全局的变量，会找不到出错 print(arg.n) for i,v in ipairs(arg) do printResult = printResult..tostring(v)..‘\\t‘ end printResult=printResult..‘\\n‘ return printResult end print(myprint(2,4,6,‘2es‘))
篇2：举例简介Lua中函数的基本用法
这篇文章主要介绍了举例简介Lua中函数的基本用法,--两个横线开始单行的注释,--[[加上两个[和]表示多行的注释--]],需要的朋友可以参考下
代码如下:
function fib(n)
if n < 2 then return 1 end
return fib(n - 2) + fib(n - 1)
end
代码如下:
-- 支持闭包及匿名函数：
function adder(x)
-- 调用adder时，会创建用于返回的函数，并且能记住变量x的值：
return function (y) return x + y end
end
a1 = adder(9)
a2 = adder(36)
print(a1(16)) -->25
print(a2(64)) -->100
代码如下:
-- 返回值、函数调用和赋值都可以使用长度不匹配的list，
-- 不匹配的接收方会被赋为nil；
-- 不匹配的发送方会被忽略。
x, y, z = 1, 2, 3, 4
-- 现在x = 1, y = 2, z = 3, 而 4 会被丢弃，
代码如下:
function bar(a, b, c)
print(a, b, c)
return 4, 8, 15, 16, 23, 42
end
x, y = bar(‘zaphod‘) -->prints ”zaphod nil nil“
-- 现在 x = 4, y = 8, 而值15..42被丢弃。
代码如下:
-- 函数是一等公民，可以是局部或者全局的。
-- 下面是等价的：
function f(x) return x * x end
f = function (x) return x * x end
代码如下:
-- 这些也是等价的：
local function g(x) return math.sin(x) end
local g; g = function (x) return math.sin(x) end
-- ‘local g‘可以支持g自引用。
代码如下:
-- 顺便提一下，三角函数是以弧度为单位的。
代码如下:
-- 用一个字符串参数调用函数，不需要括号：
print ‘hello‘ --可以工作。
篇3：C语言调用Lua函数
记得上学时，初中英文课本中，上网叫做surfing the internet，中文叫网上冲浪，那个时期，人们经常称互联网为赛博空间。如今工作了，大量的零碎时间用于上微博，知乎，QQ，这些碎片化的阅读让人读起来轻松，也能获取些粗浅的信息。然而它们是消耗时间的黑洞，时间就这样一分一秒地飞逝，年末的时候，知乎会告诉你回答了多少问题，阅读了相当于一部《红楼梦》那么多的文字。只是当你静下来一想，这些浅阅读并没给你带来有深度，系统的知识。在你的时间线上，两条相邻信息往往是八竿子也打不着的。而且你还时不时去看看关注者有没有更新，期待让你眼前一亮的信息。结果往往是趁兴而去，败兴而回。屏幕上的信息永无止境地滚动着，是如此的热闹，仿佛每个人都在狂欢，而我的内心却如此的空虚与孤独。
在lua API中，调用一个函数的步骤很简单：1.压入你要调用的函数，使用lua_getglobal。2.压入调用参数。3.使用lua_pcall4.从栈中弹出结果。
举例说明，假设你有这么一个lua函数：function f (x, y)
return (x^2 * math.sin(y))/(1 - x)
end
那么，我们就可以定义个c函数来封装这个调用：/* call a function ‘f‘ defined in Lua */
double f (double x, double y) {
double z;lua_getglobal(L, ”f“); lua_pushnumber(L, x); lua_pushnumber(L, y); /* do the call (2 arguments, 1 result) */if (lua_pcall(L, 2, 1, 0) != 0) error(L, ”error running function ‘f‘: %s“,lua_tostring(L, -1));
if (!lua_isnumber(L, -1)) error(L, ”function ‘f‘ must return a number“);z = lua_tonumber(L, -1);lua_pop(L, 1); return z;}
lua_pcall在压入结果的之前，会将函数，和参数弹出，如果返回多个结果，第一个最先压入，
如果lua_pcall运行出错，那么会返回个非0值。(完)
篇4：Lua教程（二十）：Lua调用C函数
这篇文章主要介绍了Lua教程（二十）：Lua调用C函数,本文讲解了C函数作为应用程序的一部分、C函数库成为Lua的模块等内容,需要的朋友可以参考下
Lua可以调用C函数的能力将极大的提高Lua的可扩展性和可用性，对于有些和操作系统相关的功能，或者是对效率要求较高的模块，我们完全可以通过C函数来实现，之后再通过Lua调用指定的C函数。对于那些可被Lua调用的C函数而言，其接口必须遵循Lua要求的形式，即typedef int (*lua_CFunction)(lua_State* L)。简单说明一下，该函数类型仅仅包含一个表示Lua环境的指针作为其唯一的参数，实现者可以通过该指针进一步获取Lua代码中实际传入的参数。返回值是整型，表示该C函数将返回给Lua代码的返回值数量，如果没有返回值，则return 0即可。需要说明的是，C函数无法直接将真正的返回值返回给Lua代码，而是通过虚拟栈来传递Lua代码和C函数之间的调用参数和返回值的。这里我们将介绍两种Lua调用C函数的规则。
1. C函数作为应用程序的一部分。
代码如下:
#include
#include
#include
#include
#include
//待Lua调用的C注册函数。
static int add2(lua_State* L)
{
//检查栈中的参数是否合法，1表示Lua调用时的第一个参数(从左到右)，依此类推。
//如果Lua代码在调用时传递的参数不为number，该函数将报错并终止程序的执行。
double op1 = luaL_checknumber(L,1);
double op2 = luaL_checknumber(L,2);
//将函数的结果压入栈中。如果有多个返回值，可以在这里多次压入栈中。
lua_pushnumber(L,op1 + op2);
//返回值用于提示该C函数的返回值数量，即压入栈中的返回值数量。
return 1;
}
//另一个待Lua调用的C注册函数。
static int sub2(lua_State* L)
{
double op1 = luaL_checknumber(L,1);
double op2 = luaL_checknumber(L,2);
lua_pushnumber(L,op1 - op2);
return 1;
}
const char* testfunc = ”print(add2(1.0,2.0)) print(sub2(20.1,19))“;
int main
{
lua_State* L = luaL_newstate();
luaL_openlibs(L);
//将指定的函数注册为Lua的全局函数变量，其中第一个字符串参数为Lua代码
//在调用C函数时使用的全局函数名，第二个参数为实际C函数的指针。
lua_register(L, ”add2“, add2);
lua_register(L, ”sub2“, sub2);
//在注册完所有的C函数之后，即可在Lua的代码块中使用这些已经注册的C函数了。
if (luaL_dostring(L,testfunc))
printf(”Failed to invoke.\\n“);
lua_close(L);
return 0;
}
2. C函数库成为Lua的模块，
电脑资料
将包含C函数的代码生成库文件，如Linux的so，或Windows的DLL，同时拷贝到Lua代码所在的当前目录，或者是LUA_CPATH环境变量所指向的目录，以便于Lua解析器可以正确定位到他们。在我当前的Windows系统中，我将其copy到”C:\\Program Files\\Lua\\5.1\\clibs\\“，这里包含了所有Lua可调用的C库。见如下C语言代码和关键性注释：
代码如下:
#include
#include
#include
#include
#include
//待注册的C函数，该函数的声明形式在上面的例子中已经给出。
//需要说明的是，该函数必须以C的形式被导出，因此extern ”C“是必须的。
//函数代码和上例相同，这里不再赘述。
extern ”C“ int add(lua_State* L)
{
double op1 = luaL_checknumber(L,1);
double op2 = luaL_checknumber(L,2);
lua_pushnumber(L,op1 + op2);
return 1;
}
extern ”C“ int sub(lua_State* L)
{
double op1 = luaL_checknumber(L,1);
double op2 = luaL_checknumber(L,2);
lua_pushnumber(L,op1 - op2);
return 1;
}
//luaL_Reg结构体的第一个字段为字符串，在注册时用于通知Lua该函数的名字。
//第一个字段为C函数指针。
//结构体数组中的最后一个元素的两个字段均为NULL，用于提示Lua注册函数已经到达数组的末尾。
static luaL_Reg mylibs[] = {
{”add“, add},
{”sub“, sub},
{NULL, NULL}
};
//该C库的唯一入口函数。其函数签名等同于上面的注册函数。见如下几点说明：
//1. 我们可以将该函数简单的理解为模块的工厂函数。
//2. 其函数名必须为luaopen_xxx，其中xxx表示library名称。Lua代码require ”xxx“需要与之对应。
//3. 在luaL_register的调用中，其第一个字符串参数为模块名”xxx“，第二个参数为待注册函数的数组。
//4. 需要强调的是，所有需要用到”xxx“的代码，不论C还是Lua，都必须保持一致，这是Lua的约定，
// 否则将无法调用。
extern ”C“ __declspec(dllexport)
int luaopen_mytestlib(lua_State* L)
{
const char* libName = ”mytestlib“;
luaL_register(L,libName,mylibs);
return 1;
}
见如下Lua代码：
代码如下:
require ”mytestlib“ --指定包名称
--在调用时，必须是package.function
print(mytestlib.add(1.0,2.0))
print(mytestlib.sub(20.1,19))
篇5：Lua字符串模式匹配函数小结
这篇文章主要介绍了Lua字符串模式匹配函数小结,本文涉及一些正则操作,需要的朋友可以参考下
模式匹配函数
在string库中功能最强大的函数是：
代码如下:
string.find（字符串查找）
string.gsub（全局字符串替换）
string.gfind（全局字符串查找）
string.gmatch(返回查找到字符串的迭代器)
这些函数都是基于模式匹配的，与其他脚本语言不同的是，Lua并不使用POSIX规范的正则表达式[4]（也写作regexp）来进行模式匹配。主要的原因出于程序大小方面的考虑：实现一个典型的符合POSIX标准的regexp大概需要4000行代码，这比整个Lua标准库加在一起都大。权衡之下，Lua中的模式匹配的实现只用了500行代码，当然这意味着不可能实现POSIX所规范的所有更能。然而，Lua中的模式匹配功能是很强大的，并且包含了一些使用标准POSIX模式匹配不容易实现的功能。
string.gmatch(str, pattern)
这是一个返回迭代器的函数. 实际的用例如下:
代码如下:
s = ”hello world from Lua“
for w in string.gmatch(s, ”%a+“) do
print(w)
end
这里是一个捕获并将配对字符分别存到不同变量的例子:
代码如下:
t = {}
s = ”from=world, to=Lua“
for k, v in string.gmatch(s, ”(%w+)=(%w+)“) do
t[k]=v
end
for k, v in pairs(t) do
print(k, v)
end
string.gsub(str, pattern, repl, n)
string.gsub()函数根据给定的配对表达式对源字符串str进行配对, 同时返回源字符串的一个副本, 该副本中成功配对的所有子字符串都将被替换. 函数还将返回成功配对的次数.实际的替换行为由repl参数的类型决定:
当repl为字符串时, 所有成功配对的子字符串均会被替换成指定的repl字串.
当repl为table时, 对每个成功配对的子字符串, 函数均会试图寻找以其为key值的table中的元素, 并返回该元素. 如果该配对包含任何捕获信息, 则以编号为1号的捕获作为key值进行查找.
当repl为函数时, 每个成功配对的子字符串均会作为参数被传入到该函数中去.
在repl是table或函数时, 如果该table或函数返回了字串或数字的值, 这个值依然会被用于替换副本字串中的配对子字串. 如果该table/函数返回的值为空, 将不发生替换.
n参数可选, 当它被指定时, string.gsub()函数只对源字符串中的前n个成功配对的成员进行操作.
以下是几个例子:
代码如下:
>print(string.gsub(”hello world“, ”(%w+)“, ”%1 %1“))
hello hello world world 2
>print(string.gsub(”hello Lua“, ”(%w+)%s*(%w+)“, ”%2 %1“))
Lua hello 1
>string.gsub(”hello world“, ”%w+“, print)
hello world 2
>lookupTable = {[”hello“] = ”hola“, [”world“] = ”mundo“}
>print(string.gsub(”hello world“, ”(%w+)“, lookupTable))
hola mundo 2
string.match(str, pattern, init)
string.match()只寻找源字串str中的第一个配对. 参数init可选, 指定搜寻过程的起点, 默认为1.
在成功配对时, 函数将返回配对表达式中的所有捕获结果; 如果没有设置捕获标记, 则返回整个配对字符串. 当没有成功的配对时, 返回nil.
代码如下:
string.match(”abcdaef“, ”a“)
->a
string.reverse(str)
返回一个字符串的倒序排列
代码如下:
string.reverse(”abcde“)
->edcba
string.dump(function)
返回指定函数的二进制代码(函数必须是一个Lua函数，并且没有上值)
string.find(str, pattern, init, plain)
string.find的基本应用就是用来在目标串（subject string）内搜索匹配指定的模式的串。函数如果找到匹配的串返回他的位置，否则返回nil.最简单的模式就是一个单词，仅仅匹配单词本身。比如，模式‘hello‘仅仅匹配目标串中的”hello“。当查找到模式的时候，函数返回两个值：匹配串开始索引和结束索引。
代码如下:
s = ”hello world“
string.find(s, ”hello“) -->1 5
string.find(s, ”world“) -->7 11
string.find(s, ”l“) -->3 3
string.find(s, ”lll“) -->nil
string.find函数第三个参数是可选的：标示目标串中搜索的起始位置。当我们想查找目标串中所有匹配的子串的时候，这个选项非常有用。我们可以不断的循环搜索，每一次从前一次匹配的结束位置开始。下面看一个例子，下面的代码用一个字符串中所有的新行构造一个表：
代码如下:
local t = {} -- 存放回车符的位置
local i = 0
while true do
i = string.find(s, ”\\n“, i+1) -- 查找下一行
if i == nil then break end
table.insert(t, i)
end
string.sub(str,sPos,ePos)
string.gsub的功能是截取字符串，他从指定起始位置截取一个字符串。string.sub可以利用string.find返回的值截取匹配的子串。
对简单模式而言，匹配的就是其本身
代码如下:
s = ”hello world“
local i, j = string.find(s, ”hello“) -->1 5
string.sub(s, i, j) -->hello
string.gsub(str, sourcestr, desstr)
string.gsub的基本作用是用来查找匹配模式的串，并将使用替换串其替换掉：
string.gsub函数有三个参数：目标串，模式串，替换串。
代码如下:
s = string.gsub(”Lua is cute“, ”cute“, ”great“)
print(s) -->Lua is great
s = string.gsub(”all lii“, ”l“, ”x“)
print(s) -->axx xii
s = string.gsub(”Lua is great“, ”perl“, ”tcl“)
print(s) -->Lua is great
第四个参数是可选的，用来限制替换的范围：
代码如下:
s = string.gsub(”all lii“, ”l“, ”x“, 1)
print(s) -->axl lii
s = string.gsub(”all lii“, ”l“, ”x“, 2)
print(s) -->axx lii
string.gsub的第二个返回值表示他进行替换操作的次数，
例如，下面代码涌来计算一个字符串中空格出现的次数：
代码如下:
_, count = string.gsub(str, ” “, ” “)
（注意，_ 只是一个哑元变量）
模式
你还可以在模式串中使用字符类。字符类指可以匹配一个特定字符集合内任何字符的模式项。比如，字符类%d匹配任意数字。所以你可以使用模式串‘%d%d/%d%d/%d%d%d%d‘搜索dd/mm/yyyy格式的日期：
代码如下:
s = ”Deadline is 30/05/1999, firm“
date = ”%d%d/%d%d/%d%d%d%d“
print(string.sub(s, string.find(s, date))) -->30/05/1999
下面的表列出了Lua支持的所有字符类：
单个字符(除^$()%.[]*+-?外): 与该字符自身配对
.(点): 与任何字符配对
%a: 与任何字母配对
%c: 与任何控制符配对(例如\\n)
%d: 与任何数字配对
%l: 与任何小写字母配对
%p: 与任何标点(punctuation)配对
%s: 与空白字符配对
%u: 与任何大写字母配对
%w: 与任何字母/数字配对
%x: 与任何十六进制数配对
%z: 与任何代表0的字符配对
%x(此处x是非字母非数字字符): 与字符x配对. 主要用来处理表达式中有功能的字符(^$()%.[]*+-?)的配对问题, 例如%%与%配对
[数个字符类]: 与任何[]中包含的字符类配对. 例如[%w_]与任何字母/数字, 或下划线符号(_)配对
[^数个字符类]: 与任何不包含在[]中的字符类配对. 例如[^%s]与任何非空白字符配对
当上述的字符类用大写书写时, 表示与非此字符类的任何字符配对. 例如, %S表示与任何非空白字符配对.例如，‘%A‘非字母的字符
代码如下:
print(string.gsub(”hello, up-down!“, ”%A“, ”.“))
-->hello..up.down. 4
（数字4不是字符串结果的一部分，他是gsub返回的第二个结果，代表发生替换的次数。下面其他的关于打印gsub结果的例子中将会忽略这个数值。）在模式匹配中有一些特殊字符，他们有特殊的意义，Lua中的特殊字符如下：
代码如下:
( ) . % + - * ? [ ^ $
‘%‘ 用作特殊字符的转义字符，因此 ‘%.‘ 匹配点；‘%%‘ 匹配字符 ‘%‘。转义字符 ‘%‘不仅可以用来转义特殊字符，还可以用于所有的非字母的字符。当对一个字符有疑问的时候，为安全起见请使用转义字符转义他。
对Lua而言，模式串就是普通的字符串。他们和其他的字符串没有区别，也不会受到特殊对待。只有他们被用作模式串用于函数的时候，‘%‘ 才作为转义字符。所以，如果你需要在一个模式串内放置引号的话，你必须使用在其他的字符串中放置引号的方法来处理，使用 ‘\\‘ 转义引号，‘\\‘ 是Lua的转义符。你可以使用方括号将字符类或者字符括起来创建自己的字符类（译者：Lua称之为char-set，就是指传统正则表达式概念中的括号表达式）。比如，‘[%w_]‘ 将匹配字母数字和下划线，‘[01]‘ 匹配二进制数字，‘[%[%]]‘ 匹配一对方括号。下面的例子统计文本中元音字母出现的次数：
代码如下:
_, nvow = string.gsub(text, ”[AEIOUaeiou]“, ”“)
在char-set中可以使用范围表示字符的集合，第一个字符和最后一个字符之间用连字符连接表示这两个字符之间范围内的字符集合。大部分的常用字符范围都已经预定义好了，所以一般你不需要自己定义字符的集合。比如，‘%d‘ 表示 ‘[0-9]‘；‘%x‘ 表示 ‘[0-9a-fA-F]‘。然而，如果你想查找八进制数，你可能更喜欢使用 ‘[0-7]‘ 而不是 ‘[01234567]‘。你可以在字符集(char-set)的开始处使用 ‘^‘ 表示其补集：‘[^0-7]‘ 匹配任何不是八进制数字的字符；‘[^\\n]‘ 匹配任何非换行符户的字符。记住，可以使用大写的字符类表示其补集：‘%S‘ 比 ‘[^%s]‘ 要简短些。
Lua的字符类依赖于本地环境，所以 ‘[a-z]‘ 可能与 ‘%l‘ 表示的字符集不同。在一般情况下，后者包括 ‘ç‘ 和 ‘ã‘，而前者没有。应该尽可能的使用后者来表示字母，除非出于某些特殊考虑，因为后者更简单、方便、更高效。
可以使用修饰符来修饰模式增强模式的表达能力，Lua中的模式修饰符有四个：
代码如下:
+ 匹配前一字符1次或多次
* 匹配前一字符0次或多次
- 匹配前一字符0次或多次
? 匹配前一字符0次或1次
‘+‘，匹配一个或多个字符，总是进行最长的匹配。比如，模式串 ‘%a+‘ 匹配一个或多个字母或者一个单词：
代码如下:
print(string.gsub(”one, and two; and three“, ”%a+“, ”word“))
-->word, word word; word word
‘%d+‘ 匹配一个或多个数字（整数）：
代码如下:
i, j = string.find(”the number 1298 is even“, ”%d+“)
print(i,j) -->12 15
‘*‘ 与 ‘+‘ 类似，但是他匹配一个字符0次或多次出现.一个典型的应用是匹配空白。比如，为了匹配一对圆括号()或者括号之间的空白，可以使用 ‘%(%s*%)‘。（ ‘%s*‘ 用来匹配0个或多个空白。由于圆括号在模式中有特殊的含义，所以我们必须使用 ‘%‘ 转义他。）再看一个例子，‘[_%a][_%w]*‘ 匹配Lua程序中的标示符：字母或者下划线开头的字母下划线数字序列。
‘-‘ 与 ‘*‘ 一样，都匹配一个字符的0次或多次出现，但是他进行的是最短匹配。某些时候这两个用起来没有区别，但有些时候结果将截然不同。比如，如果你使用模式 ‘[_%a][_%w]-‘ 来查找标示符，你将只能找到第一个字母，因为 ‘[_%w]-‘ 永远匹配空。另一方面，假定你想查找C程序中的注释，很多人可能使用 ‘/%*.*%*/‘（也就是说 ”/*“ 后面跟着任意多个字符，然后跟着 ”*/“ ）。然而，由于 ‘.*‘ 进行的是最长匹配，这个模式将匹配程序中第一个 ”/*“ 和最后一个 ”*/“ 之间所有部分：
代码如下:
test = ”int x; /* x */ int y; /* y */“
print(string.gsub(test, ”/%*.*%*/“, ”
-->int x;
然而模式 ‘.-‘ 进行的是最短匹配，她会匹配 ”/*“ 开始到第一个 ”*/“ 之前的部分：
代码如下:
test = ”int x; /* x */ int y; /* y */“
print(string.gsub(test, ”/%*.-%*/“, ”
-->int x;
‘?‘ 匹配一个字符0次或1次。举个例子，假定我们想在一段文本内查找一个整数，整数可能带有正负号。模式 ‘[+-]?%d+‘ 符合我们的要求，它可以匹配像 ”-12“、”23“ 和 ”+1009“ 等数字。‘[+-]‘ 是一个匹配 ‘+‘ 或者 ‘-‘ 的字符类；接下来的 ‘?‘ 意思是匹配前面的字符类0次或者1次。
与其他系统的模式不同的是，Lua中的修饰符不能用字符类；不能将模式分组然后使用修饰符作用这个分组。比如，没有一个模式可以匹配一个可选的单词（除非这个单词只有一个字母）。下面我将看到，通常你可以使用一些高级技术绕开这个限制。
以 ‘^‘ 开头的模式只匹配目标串的开始部分，相似的，以 ‘$‘ 结尾的模式只匹配目标串的结尾部分。这不仅可以用来限制你要查找的模式，还可以定位（anchor）模式。比如：
代码如下:
if string.find(s, ”^%d“) then ...
检查字符串s是否以数字开头，而
代码如下:
if string.find(s, ”^[+-]?%d+$“) then ...
检查字符串s是否是一个整数。
‘%b‘ 用来匹配对称的字符。常写为 ‘%bxy‘ ，x和y是任意两个不同的字符；x作为匹配的开始，y作为匹配的结束。比如，‘%b()‘ 匹配以 ‘(‘ 开始，以 ‘)‘ 结束的字符串：
代码如下:
print(string.gsub(”a (enclosed (in) parentheses) line“, ”%b()“, ”“))
-->a line
常用的这种模式有：‘%b()‘ ，‘%b[]‘，‘%b%{%}‘ 和 ‘%b‘。你也可以使用任何字符作为分隔符。
篇6：DECODE函数用法
DECODE函数用法
作用：将输入数值与函数中的参数列表相比较，根据输入值返回一个对应值，函数的参数列表是由若干数值及其对应结果值组成的若干序偶形式。当然，假如未能与任何一个实参序偶匹配成功，则函数也有默认的返回值。 区别于SQL的其它函数，DECODE函数还能识别和操作空值。
语法：DECODE(control_value,value1,result1[,value2,result2…][,default_result]);
control _value试图处理的数值。DECODE函数将该数值与后面的一系列的偶序相比较，以决定返回值。 value1是一组成序偶的数值。假如输入数值与之匹配成功，则相应的结果将被返回。对应一个空的返回值，可以使用要害字NULL于之对应 result1 是一组成序偶的结果值。 default_result 未能与任何一个值匹配时，函数返回的默认值。
例如： selectdecode( x , 1 , ‘x is 1 ’, 2 , ‘x is 2 ’, ‘others’) from dual 当x等于1时，则返回‘x is 1’。 当x等于2时，则返回‘x is 2’。 否则，返回others’。 需要，比较2个值的时候，可以配合SIGN()函数一起使用。 SELECT DECODE( SIGN(5 -6), 1 'Is Positive', -1, 'Is Nagative', 'Is Zero') 同样，也可以用CASE实现： SELECT CASE SIGN(5 - 6) WHEN 1 THEN 'Is Positive'WHEN -1 THEN 'Is Nagative'ELSE 'Is Zero' ENDFROM DUAL此外，还可以在Order by中使用Decode，
例如：表table_subject，有subject_name列。要求按照：语、数、外的顺序进行排序。这时，就可以非常轻松的使用Decode完成要求了。 select * from table_subject order by decode(subject_name, '语文', 1, '数学', 2, , '外语',3)
将所有的结果全部写出
select * from classes t
数据为
11一班NUM_1
22二班NUM_2
33三班NUM_3
44四班NUM_4
select t.* from classes t order by decode(t.classnum,'NUM_1',4,'NUM_2',3,'NUM_3',1);
13三班NUM_3
22二班NUM_2
31一班NUM_1
44四班NUM_4
必须将所有的结果写出
作者 myxieyu
篇7：C语言中调用Lua函数实例
这篇文章主要介绍了C语言中调用Lua函数实例,本文讲解了调用一个Lua函数的步骤和C语言调用Lua函数实例,需要的朋友可以参考下
记得上学时，初中英文课本中，上网叫做surfing the internet，中文叫网上冲浪，那个时期，人们经常称互联网为赛博空间。如今工作了，大量的零碎时间用于上微博，知乎，QQ，这些碎片化的阅读让人读起来轻松，也能获取些粗浅的信息。然而它们是消耗时间的黑洞，时间就这样一分一秒地飞逝，年末的时候，知乎会告诉你回答了多少问题，阅读了相当于一部《红楼梦》那么多的文字。只是当你静下来一想，这些浅阅读并没给你带来有深度，系统的知识。在你的时间线上，两条相邻信息往往是八竿子也打不着的。而且你还时不时去看看关注者有没有更新，期待让你眼前一亮的信息。结果往往是趁兴而去，败兴而回。屏幕上的信息永无止境地滚动着，是如此的热闹，仿佛每个人都在狂欢，而我的内心却如此的空虚与孤独。
在lua API中，调用一个函数的步骤很简单：
1.压入你要调用的函数，使用lua_getglobal。
2.压入调用参数。
3.使用lua_pcall
4.从栈中弹出结果。
举例说明，假设你有这么一个lua函数：
代码如下:
function f (x, y)
return (x^2 * math.sin(y))/(1 - x)
end
那么，我们就可以定义个c函数来封装这个调用：
代码如下:
/* call a function ‘f‘ defined in Lua */
double f (double x, double y)
{
double z;
lua_getglobal(L, ”f“);
lua_pushnumber(L, x);
lua_pushnumber(L, y);
/* do the call (2 arguments, 1 result) */
if (lua_pcall(L, 2, 1, 0) != 0)
error(L, ”error running function ‘f‘: %s“,
lua_tostring(L, -1));
if (!lua_isnumber(L, -1))
error(L, ”function ‘f‘ must return a number“);
z = lua_tonumber(L, -1);
lua_pop(L, 1);
return z;
}
lua_pcall在压入结果的之前，会将函数，和参数弹出，如果返回多个结果，第一个最先压入，
如果lua_pcall运行出错，那么会返回个非0值。
(完)
篇8：Lua内置的调试器用法详解
这篇文章主要介绍了Lua内置的调试器用法,在编程debug操作中非常有用,要的朋友可以参考下
Lua提供了一个调试库，它提供了所有的基本功能，创造自己的调试器，即便如此，也没有内置的Lua调试器，Lua为开发者创建很多调试器是开源。
调试Lua库中可用的功能列于下表连同它的用途。
上面列表中的Lua调试功能的完整列表，我们经常使用，使用上述功能，并提供了更方便的调试库。使用这些函数和创建自己的调试器是相当复杂，不是最好的选择的。无论如何，我们将看到使用简单的调试功能的例子。
代码如下:
function myfunction ()
print(debug.traceback(”Stack trace“))
print(debug.getinfo(1))
print(”Stack trace end“)
return 10
end
myfunction ()
print(debug.getinfo(1))
当我们运行上面的程序，会得到堆栈跟踪信息，如下图所示。
代码如下:
Stack trace
stack traceback:
test2.lua:2: in function ‘myfunction‘
test2.lua:8: in main chunk
[C]: ?
table: 0054C6C8
Stack trace end
在上面的示例程序中，堆栈跟踪是通过使用调试库中可用debug.trace功能打印。debug.getinfo得到函数的当前表。
另外一个例子
我们经常会需要知道一个函数的局部变量而进行调试。为此可以使用setupvalue设置并使用getupvalue获取这些局部变量、。一个简单的例子对本如下所示。
代码如下:
function newCounter ()
local n = 0
local k = 0
return function ()
k = n
n = n + 1
return n
end
end
counter = newCounter ()
print(counter())
print(counter())
local i = 1
repeat
name, val = debug.getupvalue(counter, i)
if name then
print (”index“, i, name, ”=“, val)
if(name == ”n\") then
debug.setupvalue (counter,2,10)
end
i = i + 1
end -- if
until not name
print(counter())
当我们运行上面的程序，会得到下面的输出，
代码如下:
1
2
index 1 k = 1
index 2 n = 2
11
在这个例子中，每次计数器更新当它被调用。可以使用getupvalue函数获取局部变量的当前状态。然后将局部变量的设置新值。这里，n设定为2在操作被调用之前。使用setupvalue函数更新为10，当调用计数器功能，它会返回11，而不是3。
调试类型
命令行调试
图形化调试
命令行调试
命令行调试是使用命令行用命令和打印报表进行调试的调试类型。有这几个下面列出许多Lua可用的命令行调试器。
RemDebug: RemDebug是一个远程调试器在Lua5.0和5.1。它可以远程控制另一个Lua程序执行，设置断点和检查程序的当前状态。 RemDebug也可以调试CGILua脚本。
clidebugger: lua5.1的一个简单命令行界面调试程序用纯Lua编写。它不依赖于任何其他比标准的Lua5.1库。它是从RemDebug启发，但不具有其远端设备。
ctrace: 一种工具，跟踪Lua的API调用。
xdbLua: Windows平台的一个简单Lua命令行调试器。
LuaInterface - Debugger: 本项目为扩展LuaInterface调试器。它提出了建立在Lua调试接口到一个更高的水平。与调试器的交互是通过事件和方法调用完成。
Rldb: 这是通过套接字的远程LUA调试器，适用于Windows和Linux。它可以给你比任何现有的更多的功能。
ModDebug: 这使得可以远程控制其它Lua程序的执行，设置断点，并检查程序的当前状态。
图形化调试
图形化调试提供有IDE提供了各种状态，如变量值，堆栈跟踪信息和其他相关信息的可视化调试。有一种视觉表示，一步执行了断点的帮助下步控制，步入，跳过和其他按钮在IDE中。
有图形化Lua调试器的数量，它包括以下内容。
SciTE: 默认Windows IDE中的Lua提供了多种调试工具，如断点，一步，一步进入，跳过，查看变量等。
Decoda: 这是一个支持图形化调试器远程调试。
ZeroBrane Studio: Lua的IDE集成了远程调试器，堆栈视图，表视图，远程控制台，静态分析器等。工程与LuaJIT，Love2d，Moai，和其他的Lua引擎。 在Windows，OSX和Linux并且开源。
akdebugger: Lua的Eclipse插件-调试器和编辑器。
luaedit: 此功能远程调试，本地调试，语法高亮，自动完成建议列表，参数命题引擎，推进断点管理（包括断点空调系统和命中数），函数列表，全局变量和局部变量列表，查看，解决问题为导向的管理
★ 函数的单调性教案
Lua函数用法研究（推荐8篇）
