通过例子学习lua语言
前言
Lua是一种完全免费的脚本语言, 可以和C/C++语言紧密结合,它的官方网站在https://www.doczj.com/doc/7b6620748.html,./在网站上可以下载到lua的源码, 没有可执行版本, 不过不用担心, 因为lua源码可以在任何一种C/C++的编译器上编译.如果要学习Lua, 官方网站上的Reference是必备的，上面有每个命令的用法，非常详细。
参考手册https://www.doczj.com/doc/7b6620748.html,/manual/5.0/
作者写的Programming in Lua https://www.doczj.com/doc/7b6620748.html,/pil/
2.编译
如果用的VC6, 可以下载所需的project文件,地址在
https://www.doczj.com/doc/7b6620748.html,/project/showfiles.php?group_id=32250&package_id=115604
VSNET2003可以下载这个sln文件https://www.doczj.com/doc/7b6620748.html,/~vertigrated/lua/vs7.zip
偶用的是cygwin和linux, 打入以下命令即可,
tar -zxvf lua-5.0.2.tar.gz
cd lua-5.0.2
sh ./configure
make
这样就OK了。
为了以后使用方便，最好把bin目录加入到path里面。
通过例子学习Lua(1) ---- Hello World把以下程序打入文件e01.lua
例1:e01.lua
-- Hello World in Lua
print("Hello World.")
Lua有两种执行方式，一种是嵌入到C程序中执行，还有一种是直接从命令行方式下执行。这里为了调试方便，采用第二种方式，执行命令lua e01.lua
输出结果应该是：
Hello World.
4.程序说明
第一行-- Hello World in Lua
这句是注释，其中--和C++中的//意思是一样的
第二行print("Hello World.")
调用lua内部命令print，输出"Hello World."字符串到屏幕，Lua中的字符串全部是由"括起来的。
这个命令是一个函数的调用，print是lua的一个函数，而"Hello World."是print的参数。
5.试试看
在Lua中有不少字符串的处理操作，本次的课后试试看的内容就是，找出连接两个字符串的操作，
并且print出来。
通过例子学习Lua(2) --- Lua流程控制(转)
1. 函数的使用
以下程序演示了如何在Lua中使用函数, 及局部变量
例e02.lua
-- functions
function pythagorean(a, b)
local c2 = a^2 + b^2
return sqrt(c2)
end
print(pythagorean(3,4))
运行结果
5
程序说明
在Lua中函数的定义格式为:
function 函数名(参数)
...
end
与Pascal语言不同, end不需要与begin配对, 只需要在函数结束后打个end就可以了.
本例函数的作用是已知直角三角形直角边, 求斜边长度. 参数a,b分别表示直角边长,
在函数内定义了local形变量用于存储斜边的平方. 与C语言相同, 定义在函数内的代
码不会被直接执行, 只有主程序调用时才会被执行.
local表示定义一个局部变量, 如果不加local刚表示c2为一个全局变量, local的作用域
是在最里层的end和其配对的关键字之间, 如if ... end, while ... end等。全局变量的
作用域是整个程序。
2. 循环语句
例e03.lua
-- Loops
for i=1,5 do
print("i is now " .. i)
end
运行结果
i is now 1
i is now 2
i is now 3
i is now 4
i is now 5
程序说明
这里偶们用到了for语句
for 变量= 参数1, 参数2, 参数3 do
循环体
end
变量将以参数3为步长, 由参数1变化到参数2
例如:
for i=1,f(x) do print(i) end
for i=10,1,-1 do print(i) end
这里print("i is now " .. i)中，偶们用到了..，这是用来连接两个字符串的，
偶在(1)的试试看中提到的，不知道你们答对了没有。
虽然这里i是一个整型量，Lua在处理的时候会自动转成字符串型，不需偶们费心。
3. 条件分支语句
例e04.lua
-- Loops and conditionals
for i=1,5 do
print(“i is now “ .. i)
if i < 2 then
print(“small”)
elseif i < 4 then
print(“medium”)
else
print(“big”)
end
end
运行结果
i is now 1
small
i is now 2
medium
i is now 3
medium
i is now 4
big
i is now 5
big
程序说明
if else用法比较简单, 类似于C语言, 不过此处需要注意的是整个if只需要一个end,
哪怕用了多个elseif, 也是一个end.
例如
if op == "+" then
r = a + b
elseif op == "-" then
r = a - b
elseif op == "*" then
r = a*b
elseif op == "/" then
r = a/b
else
error("invalid operation")
end
4.试试看
Lua中除了for循环以外, 还支持多种循环, 请用while...do和repeat...until改写本文中的for 程序
通过例子学习Lua(3) ---- Lua数据结构(转)
1.简介
Lua语言只有一种基本数据结构, 那就是table, 所有其他数据结构如数组啦,
类啦, 都可以由table实现.
2.table的下标
例e05.lua
-- Arrays
myData = {}
myData[0] = “foo”
myData[1] = 42
-- Hash tables
myData[“bar”] = “baz”
-- Iterate through the
-- structure
for key, value in myData do
print(key .. “=“ .. value)
end
输出结果
0=foo
1=42
bar=baz
程序说明
首先定义了一个table myData={}, 然后用数字作为下标赋了两个值给它. 这种
定义方法类似于C中的数组, 但与数组不同的是, 每个数组元素不需要为相同类型,
就像本例中一个为整型, 一个为字符串.
程序第二部分, 以字符串做为下标, 又向table内增加了一个元素. 这种table非常
像STL里面的map. table下标可以为Lua所支持的任意基本类型, 除了nil值以外.
Lua对Table占用内存的处理是自动的, 如下面这段代码
a = {}
a["x"] = 10
b = a -- `b' refers to the same table as `a'
print(b["x"]) --> 10
b["x"] = 20
print(a["x"]) --> 20
a = nil -- now only `b' still refers to the table
b = nil -- now there are no references left to the table
b和a都指向相同的table, 只占用一块内存, 当执行到a = nil时, b仍然指向table,
而当执行到b=nil时, 因为没有指向table的变量了, 所以Lua会自动释放table所占内存
3.Table的嵌套
Table的使用还可以嵌套，如下例
例e06.lua
-- Table …constructor?
myPolygon = {
color=“blue”,
thickness=2,
npoints=4;
{x=0, y=0},
{x=-10, y=0},
{x=-5, y=4},
{x=0, y=4}
}
-- Print the color
print(myPolygon[“color”])
-- Print it again using dot
-- notation
print(myPolygon.color)
-- The points are accessible
-- in myPolygon[1] to myPolygon[4]
-- Print the second point?s x
-- coordinate
print(myPolygon[2].x)
程序说明
首先建立一个table, 与上一例不同的是，在table的constructor里面有{x=0,y=0}, 这是什么意思呢？这其实就是一个小table, 定义在了大table之内, 小table的table名省略了.
最后一行myPolygon[2].x，就是大table里面小table的访问方式.
通过例子学习Lua(4) -- 函数的调用(转)
1.不定参数
例e07.lua
-- Functions can take a
-- variable number of
-- arguments.
function funky_print (...)
for i=1, arg.n do
print("FuNkY: " .. arg)
end
end
funky_print("one", "two")
运行结果
FuNkY: one
FuNkY: two
* 如果以...为参数, 则表示参数的数量不定.
* 参数将会自动存储到一个叫arg的table中.
* arg.n中存放参数的个数. arg[]加下标就可以遍历所有的参数.
2.以table做为参数
例e08.lua
-- Functions with table
-- parameters
function print_contents(t)
for k,v in t do
print(k .. "=" .. v)
end
end
print_contents{x=10, y=20}
运行结果
x=10
y=20
程序说明
* print_contents{x=10, y=20}这句参数没加圆括号, 因为以单个table为参数的时候, 不需要加圆括号
* for k,v in t do 这个语句是对table中的所有值遍历, k中存放名称, v中存放值
3.把Lua变成类似XML的数据描述语言
例e09.lua
function contact(t)
-- add the contact …t?, which is
-- stored as a table, to a database
end
contact {
name = "Game Developer",
email = "hack@https://www.doczj.com/doc/7b6620748.html,",
url = "https://www.doczj.com/doc/7b6620748.html,/",
quote = [[
There are
10 types of people
who can understand binary.]]
}
-- some other contact
}
程序说明
* 把function和table结合, 可以使Lua成为一种类似XML的数据描述语言
* e09中contact{...}, 是一种函数的调用方法, 不要弄混了
* [[...]]是表示多行字符串的方法
* 当使用C API时此种方式的优势更明显, 其中contact{..}部分可以另外存成一配置文件
4.试试看
想想看哪些地方可以用到例e09中提到的配置方法呢？
通过例子学习Lua(5) ---- Lua与C交互入门(转)
1.简介
Lua与C/C++结合是很紧密的, Lua与C++交互是建立在Lua与C的基础上的, 所
以偶先从Lua与C讲起.
正如第一讲所说, 运行Lua程序或者说调用Lua主要有两种方式:
* 通过命令行执行"Lua"命令
* 通过Lua的C库
虽然此前偶们一直用第一种方式, 但偶要告诉你, 通过Lua的C库执行才是游戏中常用的方式.
2.Lua的C库
Lua的C库可以做为Shared Library调用, 但一般开发游戏时会把Lua的所有源程序都包含在内, 并不把Lua编译成共享库的形式. 因为Lua程序只有100多K, 而且几乎可以在任何编译器下Clean Compile. 带Lua源程序的另一个好处时, 可以随时对Lua 本身进行扩充, 增加偶们所需的功能.
Lua的C库提供一系列API:
* 管理全局变量
* 管理tables
* 调用函数
* 定义新函数, 这也可以完全由C实现
* 垃圾收集器Garbage collector, 虽然Lua可以自动进行, 但往往不是立即执行的,
所以对实时性要求比较高的程序, 会自己调用垃圾收集器
* 载入并执行Lua程序, 这也可以由Lua自身实现
* 任何Lua可以实现的功能, 都可以通过Lua的C API实现, 这对于优化程序的运行速度
有帮助. 经常调用的共用的Lua程序片断可以转成C程序, 以提高效率. 连Lua都是C 写的
还有什么C不能实现呢?
3.Lua与C集成的例子
例e10.c
/* A simple Lua interpreter. */
#include
#include
int main(int argc, char *argv[]) {
char line[BUFSIZ];
lua_State *L = lua_open(0);
while (fgets(line, sizeof(line), stdin) != 0)
lua_dostring(L, line);
lua_close(L);
return 0;
}
编译
Linux/Cygwin
* 先编译Lua, 并把头文件放入include路径
* gcc e10.c -llua -llualib -o e10
VC6/VC2003
* 先编译Lua, 在Option中设置头文件和库文件路径
* 新建工程,在工程配置中加入附加库lua.lib和lualib.lib
* 编译成exe
运行结果
本程序的功能是实现一个Lua解释器, 输入的每行字符都会被解释成Lua并执行.
程序说明
* #include
* lua_State *L = lua_open(0) 打开一个Lua执行器
* fgets(line, sizeof(line), stdin) 从标准输入里读入一行
* lua_dostring(L, line) 执行此行
* lua_close(L) 关闭Lua执行器
例e11.c
/* Another simple Lua interpreter. */
#include
#include
#include
int main(int argc, char *argv[]) {
char line[BUFSIZ];
lua_State *L = lua_open(0);
lua_baselibopen(L);
lua_iolibopen(L);
lua_strlibopen(L);
lua_mathlibopen(L);
while (fgets(line, sizeof(line), stdin) != 0)
lua_dostring(L, line);
lua_close(L);
return 0;
}
运行结果
本程序的功能是实现一个Lua解释器, 输入的每行字符都会被解释成Lua并执行.
与上例不同的是, 本例调用了Lua的一些标准库.
程序说明
* #include
* 以下这几行是用来读入Lua的一些库, 这样偶们的Lua程序就可以有更多的功能.
lua_baselibopen(L);
lua_iolibopen(L);
lua_strlibopen(L);
lua_mathlibopen(L);
4.试试看
把上面两个小例子在你熟悉的编译器中编译执行, 并试试能否与Lua源码树一起编译通过例子学习Lua(6) ---- C/C++中用Lua函数(转)
1.简介
偶们这次主要说说怎么由Lua定义函数, 然后在C或者C++中调用. 这里偶们
暂不涉及C++的对象问题, 只讨论调用函数的参数, 返回值和全局变量的使用.
2.
这里偶们在e12.lua里先定义一个简单的add(), x,y为加法的两个参数,
return 直接返回相加后的结果.
例e12.lua
-- add two numbers
function add ( x, y )
return x + y
end
在前一次里, 偶们说到lua_dofile() 可以直接在C中执行lua文件. 因为偶们这个程序里只定义了一个add()函数, 所以程序执行后并不直接结果, 效果相当于在C中定义了一个函数一样.
Lua的函数可以有多个参数, 也可以有多个返回值, 这都是由栈(stack)实现的. 需要调用一个函数时, 就把这个函数压入栈, 然后顺序压入所有参数, 然后用lua_call()调用这个函数. 函数返回后, 返回值也是存放在栈中. 这个过程和
汇编执行函数调用的过程是一样的.
例e13.cpp 是一个调用上面的Lua函数的例子
#include
extern "C" { // 这是个C++程序, 所以要extern "C",
// 因为lua的头文件都是C格式的
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}
/* the Lua interpreter */
lua_State* L;
int luaadd ( int x, int y )
{
int sum;
/* the function name */
lua_getglobal(L, "add");
/* the first argument */
lua_pushnumber(L, x);
/* the second argument */
lua_pushnumber(L, y);
/* call the function with 2
arguments, return 1 result */
lua_call(L, 2, 1);
/* get the result */
sum = (int)lua_tonumber(L, -1);
lua_pop(L, 1);
return sum;
}
int main ( int argc, char *argv[] )
{
int sum;
/* initialize Lua */
L = lua_open();
/* load Lua base libraries */
lua_baselibopen(L);
/* load the script */
lua_dofile(L, "e12.lua");
/* call the add function */
sum = luaadd( 10, 15 );
/* print the result */
printf( "The sum is %d
", sum );
/* cleanup Lua */
lua_close(L);
return 0;
}
程序说明:
main中过程偶们上次已经说过了, 所以这次只说说luaadd的过程* 首先用lua_getglobal()把add函数压栈
* 然后用lua_pushnumber()依次把x,y压栈
* 然后调用lua_call(), 并且告诉程序偶们有两个参数一个返回值* 接着偶们从栈顶取回返回值, 用lua_tonumber()
* 最后偶们用lua_pop()把返回值清掉
运行结果:
The sum is 25
编译方法
Linux下把程序存成e13.cpp
g++ e13.cpp -llua -llualib -o e13
./e13
VC下编译方法
* 首先建立一个空的Win32 Console Application Project
* 把e13.cpp加入工程中
* 点project setting,然后设置link选项, 再加上lua.lib lualib.lib两个额外的库
* 最后编译
建立好的project可以在这里下载
VC https://www.doczj.com/doc/7b6620748.html,/tutorials/luaadd.zip
Linux https://www.doczj.com/doc/7b6620748.html,/tutorials/luaadd.tar.gz
3.全局变量
上面偶们用到了lua_getglobal()但并没有详细讲, 这里偶们再举两个小例子来说下全局变量
lua_getglobal()的作用就是把lua中全局变量的值压入栈
lua_getglobal(L, "z");
z = (int)lua_tonumber(L, 1);
lua_pop(L, 1);
假设Lua程序中定义了一个全局变量z, 这段小程序就是把z的值取出放入C的变量z 中.
另外Lua中还有一个对应的函数lua_setglobal(), 作用是用栈顶的值填充指定的全局变量lua_pushnumber(L, 10);
lua_setglobal(L, "z");
例如这段小程序就是把lua中的全局变量z设为10, 如果lua中未定义z的话, 就会自动创建一个
全局变量z并设为10.
4.试试看
自己写个函数用C/C++来调用下试试
2.
通过例子学习Lua(7) ---- Lua中调用C/C++函数(转)
1.前言
上次偶说到从C/C++中调用Lua的函数, 然后就有朋友问从Lua中如何调用C/C++的函数, 所以偶们这次就来说说这个问题. 首先偶们会在C++中建立一个函数, 然后
告知Lua有这个函数, 最后再执行它. 另外, 由于函数不是在Lua中定义的, 所以
无法确定函数的正确性, 可能在调用过程中会出错, 因此偶们还会说说Lua出错处理的问题.
2.Lua中调用C函数
在lua中是以函数指针的形式调用函数, 并且所有的函数指针都必须满足如下此种类型:
typedef int (*lua_CFunction) (lua_State *L);
也就是说, 偶们在C++中定义函数时必须以lua_State为参数, 以int为返回值才能被Lua所调用. 但是不要忘记了, 偶们的lua_State是支持栈的, 所以通过栈可以
传递无穷个参数, 大小只受内存大小限制. 而返回的int值也只是指返回值的个数真正的返回值都存储在lua_State的栈中. 偶们通常的做法是做一个wrapper, 把
所有需要调用的函数都wrap一下, 这样就可以调用任意的函数了.
下面这个例子是一个C++的average()函数, 它将展示如何用多个参数并返回多个值
例e14.cpp
#include
extern "C" {
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}
/* the Lua interpreter */
lua_State* L;
static int average(lua_State *L)
{
/* get number of arguments */
int n = lua_gettop(L);
double sum = 0;
int i;
/* loop through each argument */
for (i = 1; i <= n; i++)
{
/* total the arguments */
sum += lua_tonumber(L, i);
}
/* push the average */
lua_pushnumber(L, sum / n);
/* push the sum */
lua_pushnumber(L, sum);
/* return the number of results */
return 2;
}
int main ( int argc, char *argv[] )
{
/* initialize Lua */
L = lua_open();
/* load Lua base libraries */
lua_baselibopen(L);
/* register our function */
lua_register(L, "average", average);
/* run the script */
lua_dofile(L, "e15.lua");
/* cleanup Lua */
lua_close(L);
return 0;
}
例e15.lua
-- call a C++ function
avg, sum = average(10, 20, 30, 40, 50)
print("The average is ", avg)
print("The sum is ", sum)
程序说明:
* lua_gettop()的作用是返回栈顶元素的序号. 由于Lua的栈是从1开始编号的, 所以栈顶元素的序号也相当于栈中的元素个数. 在这里, 栈中元素的个数就
是传入的参数个数.
* for循环计算所有传入参数的总和. 这里用到了数值转换lua_tonumber().
* 然后偶们用lua_pushnumber()把平均值和总和push到栈中.
* 最后, 偶们返回2, 表示有两个返回值.
* 偶们虽然在C++中定义了average()函数, 但偶们的Lua程序并不知道, 所以需
要在main函数中加入
/* register our function */
lua_register(L, "average", average);
这两行的作用就是告诉e15.lua有average()这样一个函数.
* 这个程序可以存成cpp也可以存成c, 如果以.c为扩展名就不需要加extern "C"
编译的方法偶们上次说过了, 方法相同.
e15.lua执行的方法只能用上例中的C++中执行, 而不能用命令行方式执行.
3.错误处理
在上例中, 偶们没有对传入的参数是否为数字进行检测, 这样做不好. 所以这里偶
们再加上错误处理的片断.
把这段加在for循环之内:
if (!lua_isnumber(L, i)) {
lua_pushstring(L, "Incorrect argument to 'average'");
lua_error(L);
}
这段的作用就是检测传入的是否为数字.
加上这段之后, 偶们debug的时候就会简单许多. 对于结合两种语言的编程, 它们之
间传递数据的正确性检测是非常重要的.
这里有别人写好的例子:
VC的https://www.doczj.com/doc/7b6620748.html,/tutorials/luaavg.zip
Linux的https://www.doczj.com/doc/7b6620748.html,/tutorials/luaavg.tar.gz
LuaPlus: 好用的Lua For C++扩展
LuaPlus是Lua的C++增强，也就是说，LuaPlus本身就是在Lua的源码上进行增强得来的。用它与C++进行合作，是比较好的一个选择。
LuaPlus目前版本为：LuaPlus for Lua 5.01 Distribution Build 1080 (February 28, 2004)。大家可以到https://www.doczj.com/doc/7b6620748.html,/站点下载：
源码(https://www.doczj.com/doc/7b6620748.html,/LuaPlus/LuaPlus50_Build1081.zip)
目标码(https://www.doczj.com/doc/7b6620748.html,/LuaPlus/LuaPlus50_Build1081_Win32Binaries.zip)
我将在下面说明，如何使用LuaPlus，以及如何更方便的让LuaPlus与C++的类合作无间。
1. 调用Lua脚本
// 创建Lua解释器：
LuaStateOwner state;
// 执行Lua脚本：
state->DoString("print('Hello World\\n')");
// 载入Lua脚本文件并执行：
state->DoFile("C:\\test.lua");
// 载入编译后的Lua脚本文件并执行：
state->DoFile("C:\\test.luac");
2. 与Lua脚本互相调用
// 为Lua脚本设置变量
state->GetGlobals().SetNumber("myvalue", 123456);
// 获得Lua变量的值
int myvalue = state->GetGlobal("myvalue").GetInteger();
// 调用Lua函数
LuaFunction
luaPrint("Hello World\n");
// 让Lua调用C语言函数
int add(int a, int b){ return a+b;}
state->GetGlobals().RegisterDirect("add", add);
state->DoString("print(add(3,4))");
// 让Lua调用C++类成员函数
class Test{public: int add(int a, int b){return a+b;}};
Test test;
state->GetGlobals().RegisterDirect("add", test, &Test::add);
state->DoString("print(add(3,4))");
3. 在Lua脚本中使用C++类
这个稍微有点小麻烦。不过，我包装了一个LuaPlusHelper.h的文件，它可以很轻松的完成这个工作。它的实现也很简单，大家可以从源码上来获得如何用纯LuaPlus实现同样的功能。
不过，这里仍然有一个限制没有解决：不能使用虚成员函数。不过考虑到我们仅是在Lua调
用一下C++函数，并不是要将C++完美的导入到Lua，这个限制完全可以接受。
另外，类成员变量不能直接在Lua中访问，可以通过类成员函数来访问（比如SetValue/GetValue之类)。
// 下面是一个简单的C++类:
class Logger
{
public:
void LOGMEMBER(const char* message)
{
printf("In member function: %s\n", message);
}
Logger()
{
printf("Constructing(%p)\n", this);
v = 10;
}
virtual ~Logger()
{
printf("Destructing(%p)\n", this);
}
Logger(int n)
{
printf(" -- Constructing[%d](%p)\n", n, this);
}
Logger(Logger* logger)
{
printf(" -- Constructing[%p](%p)\n", logger, this);
logger->LOGMEMBER(" Call From Constructor\n");
}
int SetValue(int val)
{
v = val;
}
int GetValue()
{
return v;
}
public:
int v;
};
// 导入到Lua脚本：
LuaClass
.create("Logger") // 定义构造函数 Logger::Logger()
.create
.create
.destroy("__gc") // 定义析构函数 Logger::~Logger()
.def("lm", &Logger::LOGMEMBER) // 定义成员函数 Logger::LOGMEMBER(const char*)
.def("SetValue", &Logger::SetValue)
.def("GetValue", &Logger::GetValue);
// 在Lua中使用Logger类(1)：
state->DoString(
"l = Logger();" // 调用构造函数 Logger::Logger()
"l:lm('Hello World 1');" // 调用成员函数 Logger::LOGMEMBER(const char*) "l:Free();" // 调用析构函数 Logger::~Logger()
);
// 在Lua中使用Logger类(2)：
state->DoString(
"m = Logger2(10);" // 调用构造函数 Logger::Logger(int)
"m:lm('Hello World 2');" // 调用成员函数 Logger::LOGMEMBER(const char*) "n = Logger3(m);" // 调用构造函数 Logger::Logger(Logger*)
"n:lm('Hello World 3');" // 调用成员函数 Logger::LOGMEMBER(const char*) "m:SetValue(11);"
"print(m.GetValue());"
"m,n = nil, nil;" // m,n 将由Lua的垃极回收来调用析构函数
);
4. 将一组C函数归类到Lua模块
//同上面一样，我采用LuaPlusHelper.h来简化：
LuaModule(state, "mymodule")
.def("add", add)
.def("add2", test, add);
state->DoString(
"print(mymodule.add(3,4));"
"print(mymodule.add2(3,4));"
);
5. 使用Lua的Table数据类型
// 在Lua中创建T able
LuaObject table = state->GetGlobals().CreateT able("mytable");
table.SetInteger("m", 10);
table.SetNumber("f", 1.99);
table.SetString("s", "Hello World");
table.SetWString("ch", L"你好");
table.SetString(1, "What");
// 相当于Lua中的：
// mytable = {m=10, f=1.99, s="Hello World", ch=L"你好", "What"}
// 也可以使用table作为key和value:
state->GetGlobals().CreateT able("nexttable")
.SetString(table, "Hello")
.SetObject("obj", table);
// 相当于Lua中的：
// nexttable = {mytable="Hello", obj=mytable}
//获得T able的内容：
LuaObject t2 = state->GetGlobals("mytable");
int m = t2.GetByName("m").GetInteger();
Programming in Lua Lua程序设计 作者：Roberto Ierusalimschy 翻译：https://www.doczj.com/doc/7b6620748.html, 制作：中国lua开发者https://www.doczj.com/doc/7b6620748.html, 相关链接：lua中文在线手册https://www.doczj.com/doc/7b6620748.html,
译序 “袁承志知道若再谦逊，那就是瞧人不起，展开五行拳，发拳当胸打去。荣彩和旁观三人本来都以为他武功有独到之秘，哪知使出来的竟是武林中最寻常不过的五行拳。敌对三人登时意存轻视，温青脸上不自禁露出失望的神色。 “荣彩心中暗喜，双拳如风，连抢三下攻势，满拟自己的大力魔爪手江南独步，三四招之间就可破去对方五行拳，那知袁承志轻描淡写的一一化解。再拆数招，荣彩暗暗吃惊，原来对方所使虽是极寻常的拳术，但每一招均是含劲不吐，意在拳先，举手抬足之间隐含极浑厚的内力。” ——金庸《碧血剑》 编程语言之于程序员，若武功招式之于习武之人，招式虽重要，却更在于使用之人。胜者之道，武功只行于表，高手用剑，片草只叶亦威力无穷。 当今武林，派别林立，语言繁杂，林林总总不计其数。主流文化的C/C++、Java、C#、VB[1]；偏安一隅的Fortran；动态语言中的Perl、Tcl、Ruby、Forth、Python，以及本书介绍的Lua；……，等等等等。再加上世界上那些不知道躲在哪的旮旯的奇奇怪怪的hacker捣鼓出来的异想天开的语言，要想各类语言样样精通，不异于痴人说梦。不信可欣赏一下BrainFuck语言[2]的Hello World程序，语言本身依如其名。-?- >+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.[-]>+++++++ +[<++++>-]<.#>+++++++++++[<+++++>-]<.>++++++++[<+++>-]<.+++.------.--------.[-]>++++++++[<++++>-]<+.[-]++++++++++. 虽说语言的威力依使用者本身的修为高低而定，但不同语言本身的设计又有不同。若让用Java写写操作系统内核、Perl写写驱动程序、C/C++写写web应用，都无异于舍近求远，好刀只用上了刀背。 Lua本身是以简单优雅为本，着眼于处理那些C不擅长的任务。借助C/C++为其扩展，Lua可闪现无穷魅力。Lua本身完全遵循ANSI C而写成，只要有C 编译器的地方，Lua便可发挥她的力量。Lua不需要追求Python那样的大而全的库，太多累赘，反而破坏了她的优美。 语言的优美，来自于使用者自己的感悟。Lua的优雅，也只有使用后才会明白。 扬起帆，让我们一同踏上Lua的学习之旅…… 本书的翻译，是https://www.doczj.com/doc/7b6620748.html,中朋友们共同努力的结果。下面是参与翻译与校对的朋友：
Lua参考手册 Wikipedia，自由的百科全书 Lua 5.0 参考手册 作者： Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes Copyright ? 2003 Tecgraf, PUC-Rio. All rights reserved. 主要译者、维护人员：曹力丁舜佳 [NirvanaStudio (https://www.doczj.com/doc/7b6620748.html,)] 目录 [隐藏] 1 1 - 绪论 2 2 - 语言 2.1 2.1 - 词法约定 2.2 2.2 - 值和类型 2.2.1 2.2.1 - 类型转换 2.3 2.3 - 变量 2.4 2.4 - 语句 2.4.1 2.4.1 - 语句段 2.4.2 2.4.2 - 语句块 2.4.3 2.4.3 - 赋值 2.4.4 2.4.4 - 控制结构 2.4.5 2.4.5 - For 语句 2.4.6 2.4.6 - 语句式函数调用 2.4.7 2.4.7 - 局部变量声明 2.5 2.5 - 表达式 2.5.1 2.5.1 - 算术运算符 2.5.2 2.5.2 - 关系运算符 2.5.3 2.5.3 - 逻辑运算符 2.5.4 2.5.4 - 串联接 2.5.5 2.5.5 - 优先级 2.5.6 2.5.6 - 表构造器 2.5.7 2.5.7 - 函数调用 2.5.8 2.5.8 - 函数定义 2.6 2.6 - 可见性规则 2.7 2.7 - 错误处理 2.8 2.8 - 元表 2.9 2.9 - 垃圾收集 2.9.1 2.9.1 - 垃圾收集元方法 2.9.2 2.9.2 - 弱表 2.10 2.10 - 同步程序
1.利用lua编写hello world！ 1. 用记事本新建一个test.lua的文件，并用winSCP上传到路由器，并用用chmod 777 XX 修改属性。里面的内容是：print("hello world！,lua") 2. 用putty登录，执行命令：lua test.lua 3. 在终端屏幕上中可以看到hello world！ 2. 测试串口 1. 新建2ser.lua，里面的内容是：(以下代码是一个完整的处理字符串的例子) io.input("/www/cgi-bin/test.txt") -->设置当前输入文件 t = io.read("*all") -->读取整个文件 t = string.gsub(t, "([\128-\255=])", function (c) return string.format("=%02X", string.byte(c)) end) -- io.output("/www/cgi-bin/test2.txt") io.output("/dev/ttyUSB0") -->设置当前输出文件，利用usb转串口输出至超级终端显示io.write(t) -->输出 2. 上传，改属性，打开超级终端，设置波特率为9600（此为默认，可修改） 3. putty登陆执行：lua 2ser.lua 4. 超级终端中可显示文件中的数据 3.web与lua连接（web显示数据） 1. 新建test文件（没有后缀名），其内容如下： #! /usr/bin/lua -- HTTP header -->告诉浏览器将网页解释成纯文本 print [[ Content-Type: text/plain ]] io.write("hello", "Lua") 2. 需要将test文件利用Notepad++等强力编辑工具，转换为UNIX格式 3. 上传到/www/cgi-bin/目录下，改属性，在浏览器查看 http://192.168.8.1/cgi-bin/test 4. 浏览器中可看到：hellolua 4.web向串口发送数据 1. 新建2ser,内容如下： #!/usr/bin/lua -->调用lua脚本解释器 -- HTTP header print [[ Content-Type: text/plain ]] io.output("/dev/ttyUSB0") io.write(os.getenv("QUERY_STRING")) 2. 需要将test文件利用Notepad++等强力编辑工具，转换为UNIX格式 3. 上传到/www/cgi-bin/目录下，改属性，在浏览器查看
用lua语言编写Wireshark插件解析自定义协议 Wireshark默认支持大量网络协议，我们可以在Wireshark主菜单“Internals > Support Protocols (slow!)”查看当前支持的所有协议。Wireshark 1.6.2版本已支持1170种协议，包括我们熟悉的Diameter、GTP、FTP、SCTP等协议。 上述都是业界的通用协议，然而对我们产品的自定义协议，Wireshark是不得而知的，抓包后只能看到一串二进制码流，导致开发调试或者测试分析效率较低。 有什么办法让Wireshark也能解析自定义协议呢？本文介绍的用lua编写Wireshark解析器插件就是一种常用方法。Wireshark软件内嵌一个lua语言执行引擎并提供一系列lua函数接口，从而满足用户各种各样的协议解析目的。 下面以一个简单的自定义协议为例，演示如何编写Wireshark解析插件。不过本文只是业余学习的笔记和简单实践，不能覆盖“lua编写Wireshark解析器插件”的所有知识点（更全面的介绍请参考Wireshark软件自带手册第11章“Lua Support in Wireshark”，只是开源软件的手册似乎总是不够详尽。）。 1. 配置Wireshark执行lua脚本 通过Wireshark主菜单“Help > About Wireshark”可以查看当前安装版本已经内嵌Lua 5.1执行引擎。默认安装情况下Wireshark会在安装路径下生成一个init.lua，它是Wireshark启动过程执行的第一个lua脚本。一般来说，我们可以在此文件中添加dofile函数调用其他lua 脚本，实现各种扩展目的。例如，默认安装后init.lua文件末尾有一句： dofile(DATA_DIR.."console.lua") 此语句执行了安装目录下的console.lua脚本，该脚本也是Wireshark自带的，用途是在主菜单Tool下创建一个子菜单Lua。我们甚至可以在上述语句之前添加注释--符来取消它。 dofile是lua基础库提供的一个函数，用途如下： dofile (filename) Opens the named file and executes its contents as a Lua chunk. When called without arguments, dofile executes the contents of the standard input (stdin). Returns all values returned by the chunk. In case of errors, dofile propagates the error to its caller (that is, dofile does not run in protected mode). 我们下来编写的解析器也是以.lua脚本形式保存，然后在init.lua文件末尾中添加一个dofile调用即可。 2. 需要解析的自定义协议 假设我们需要基于UDP协议实现一种根据员工ID查询员工姓名的信息服务，客户端向
Lua脚本语言介绍与如何实现嵌入式UART通信设计方案 引言 随着变电站智能化程度的逐步提高，对温度、湿度等现场状态参量的采集需求也越来越多。就目前而言，在现场应用中，此类设备多采用RS232或RS485等UART串行通信方式和IED（Intelligent Electronic Device,智能电子设备）装置进行交互。一般来说，不同的设备采用的通信数据帧格式并不相同。各式各样的串口数据帧格式，对IED装置的软件定型造成一定的困难。传统的做法一般是由装置生产厂家指定和其配套的外围设备，装置的灵活性不够理想。本文针对此类问题，提出了一种基于Lua脚本语言的解决方案，可有效地提高IED装置对各种类型串口数据报文帧格式的适应性。该方案将具体串口报文规约的组建和解析交给Lua脚本进行处理，从而使设计者在装置的软件开发中，可仅关注于相关接口的设计，而不用关心具体的串口通信规约，从而方便软件的定型，并提高了装置自身在应用中的灵活性。 1 Lua脚本语言介绍 Lua是一种源码开放的、免费的、轻量级的嵌入式脚本语言，源码完全采用ANSI（ISO）C.这一点使它非常适合融入目前以C语言为主的嵌入式开发环境之中。两者之间实现交互的关键在于一个虚拟的栈，通过该虚拟栈和Lua提供的可对该栈进行操作的相关接口函数，可以很方便地在它们之间实现各种类型数据的传递。 与其他脚本语言（如Perl、Tcl、Python等）相比，Lua表现出了足够的简单性以及非常高的执行效率，结合其与平台的高度无关以及充分的可扩展性[1],这使得它越来越多地得到大家的关注。因此，在本文的方案中优先选用Lua脚本来进行设计。 2 系统方案概述 本方案主要是围绕着IED装置和外围串口设备之间的通信来进行设计的，系统框架如图1所示。 图1 系统框架
Lua 简明教程 2013-12-313:45|发布者:红黑魂|查看:2591|评论:0|原作者:陈皓|来自:酷壳网 摘要:这几天系统地学习了一下Lua 这个脚本语言，Lua 脚本是一个很轻量级的脚本，也是号称性能最高的脚本，用在很多需要性能的地方，比如：游戏脚本，nginx，wireshark 的脚本，当你把他的源码下下来编译后，你会发现解释器居... 这几天系统地学习了一下Lua 这个脚本语言，Lua 脚本是一个很轻量级的脚本，也是号称性能最高的脚本，用在很多需要性能的地方，比如：游戏脚本，nginx ，wireshark 的脚本，当你把他的源码下下来编译后，你会发现解释器居然不到200k ，这是多么地变态啊（/bin/sh 都要1M ，MacOS 平台），而且能和C 语言非常好的互动。我很好奇得浏览了一下Lua 解释器的源码，这可能是我看过最干净的C 的源码了。 我不想写一篇大而全的语言手册，一方面是因为已经有了（见本文后面的链接），重要的原因是，因为大篇幅的文章会挫败人的学习热情，我始终觉得好的文章读起来就像拉大便一样，能一口气很流畅地搞完，才会让人爽（这也是我为什么不想写书的原因）。所以，这必然又是一篇“入厕文章” ，还是那句话，我希望本文能够让大家利用上下班，上厕所大便的时间学习一个技术。呵呵。相信你现在已经在厕所里脱掉裤子露出屁股已经准备好大便了，那就让我们畅快地排泄吧…… 运行 首先，我们需要知道，Lua 是类C 的，所以，他是大小写字符敏感的。 下面是Lua 的Hello World 。注意：Lua 脚本的语句的分号是可选的，这个和GO 语言很类似。 你可以像python 一样，在命令行上运行lua 命令后进入lua 的shell 中执行语句。 也可以把脚本存成一个文件，用如下命令行来运行。 或是像shell 一样运行：
脚本制作实例讲解： 脚本制作实例讲解：
助手的Lua脚本制作需要你对编程有一定基础，特别是脚本编程；需要你熟悉Lua 基本的语法结构、程序结构、使用习惯及约定、注意事项等。只要你有一定的编程基础， 并基于以上知识的了解和学习，脚本制作将不难进行。助手的Lua脚本制作中关于模拟操 作的脚本你还需要清楚你实现模拟操作的每一个细节，要能分解每一个细节到程序实现 上，这样你才能更好的完成脚本。下面我们举出一个具体的魔兽操作实例脚本给大家一个 脚本制作实现思路和方式。我们来看一个魔兽内吃药脚本的实现。
脚本实例： 脚本实例：魔兽吃药脚本 思路准备： 1. 思路准备：
魔兽吃药是玩魔兽的一个关键项，然而有些地图药品繁多更显吃药之特点。 吃药虽然是一个简单的事情，但是当我们玩一个单机或挂机升级的图时，能自动 吃药挂机那将是有用的了，我们就此来进行实现魔兽自动吃药挂机的脚本，其中 吃药最常见的就是一点即用型药品了，还有一种使用后需要指定目标的麻烦点， 但是新版本的智能改键指令加上执行改键序列函数实现起来也是很简单的事。而 且最好能挂机吃药魔兽可以不再前端，那我们就可以挂机干其他事了^_^。
实现思想： 2. 实现思想：
要进行自动吃药监视我们要先想如何自动法？自动的前提当然是要定时检测 当前英雄血蓝量，这就需要用到定时器和延时；检查血量又需要用到查询单位属 性getunitattribute函数,此外还需要用到键鼠模拟操作函数等。下面我们以一 个具体地图实例来讲解脚本制作。地图就选择风霜的《遗失的记忆》吧
开始编写测试修改代码： 3. 开始编写测试修改代码：
基于以上的准备那我们先新建一个脚本，暂时命名为“runAutoPress.txt”吧， 下面就逐步开始代码吧： 1) 先定义几个可能用到的变量和初始值，并将血瓶放到包裹7位置，魔瓶放到 包裹8位置。 hppt=0.75 --血量值监视限度保户值，即血量值的 75% mppt=0.15 --魔法值监视限度保户值，即魔法值的 15% msPress=200 --监视间隔时间，暂停200ms 2) 设置对应血魔监视的定时器函数，并加入基本代码： function runAutoPressFunc() if 1==isplaying() then --当游戏正在进行时才执行 unitid,unithandle=getselunitex() --获取当前英雄单位ID和句柄信息 hpmax,hp,mpmax,mp= getunitattribute(unithandle, 1, 2, 3, 4) --获取该单位的血魔的最大值和实际值 if hp/hpmax
Lua脚本语言入门(目前魔兽使用的可以写在宏内的语言).txt蜜蜂整日忙碌，受到赞扬；蚊子不停奔波，人见人打。多么忙不重要，为什么忙才重要。在这篇文章中，我想向大家介绍如何进行Lua程序设计。我假设大家都学过至少一门编程语言，比如Basic或C，特别是C。 因为Lua的最大用途是在宿主程序中作为脚本使用的。 Lua的语法比较简单，学习起来也比较省力，但功能却并不弱。 在Lua中，一切都是变量，除了关键字。请记住这句话。 I.首先是注释 写一个程序，总是少不了注释的。 在Lua中，你可以使用单行注释和多行注释。 单行注释中，连续两个减号"--"表示注释的开始，一直延续到行末为止。相当于C++语言中的"//"。 多行注释中，由"--[["表示注释开始，并且一直延续到"]]"为止。这种注释相当于C语言中的"/*…*/"。在注释当中，"[["和"]]"是可以嵌套的。 II. Lua编程 经典的"Helloworld"的程序总是被用来开始介绍一种语言。在Lua中，写一个这样的程序很简单： print("Hello world") 在Lua中，语句之间可以用分号"；"隔开，也可以用空白隔开。一般来说，如果多个语句写在同一行的话，建议总是用分号隔开。 Lua有好几种程序控制语句，如： 条件控制： if条件then…elseif条件then…else…end
While循环： while条件do…end Repeat循环： repeat…until条件 For循环： for变量=初值，终点值，步进do…end For循环： for变量1，变量2，…，变量N in表或枚举函数do…end 注意一下，for的循环变量总是只作用于for的局部变量，你也可以省略步进值，这时候，for循环会使用1作为步进值。 你可以用break来中止一个循环。 如果你有程序设计的基础，比如你学过Basic，C之类的，你会觉得Lua也不难。但Lua有几个地方是明显不同于这些程序设计语言的，所以请特别注意。 ．语句块 语句块在C++中是用"{"和"}"括起来的，在Lua中，它是用do和end括起来的。 比如： do print("Hello") end 你可以在函数中和语句块中定局部变量。 ．赋值语句 赋值语句在Lua被强化了。它可以同时给多个变量赋值。
Lua语言如何调用自己编写的C DLL文件 /*---c code:---*/ #include "lua.h" #include "lualib.h" #include "lauxlib.h" #include
lua 目录 基本信息 目标 轻量级 可扩展 其它特性 示例代码 数据交换介绍 C和Lua脚本互相调用举例 编辑本段基本信息 Lua 是一个小巧的脚本语言。作者是巴西人。该语言的设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。Lua最著名的应用是在暴雪公司的网络游戏WOW中。Lua脚本可以很容易的被C/C++代码调用，也可以反过来调用C/C++的函数，这使得Lua在应用程序中可以被广泛应用。不仅仅作为扩展脚本，也可以作为普通的配置文件，代替XML,Ini等文件格式，并且更容易理解和维护。Lua由标准C编写而成，代码简洁优美，几乎在所有操作系统和平台上都可以编译，运行。一个完整的Lua解释器不过200k，在目前所有脚本引擎中，Lua的速度是最快的。这一切都决定了Lua是作为嵌入式脚本的最佳选择。Lua 有一个同时进行的JIT项目，提供在特定平台上的即时编译功能，这将给Lua 带来更加优秀的性能。和Python等脚本不同，Lua并没有提供强大的库，这是由它的定位决定的。所以Lua不适合作为开发独立应用程序的语言。不过Lua还是具备了比如数学运算和字符串处理等基本的功能。Lua 目前的最新版本是 5.2. 编辑本段目标
LUA的目标是成为一个很容易嵌入其它语言中使用的语言。大多数程序员也认为它的确做到了这一点。很多应用程序使用LUA作为自己的嵌入式脚本语言，以此来实现可配置性、可扩展性。这其中包括魔兽世界、博德之门等。 编辑本段轻量级 LUA有如下特性：轻量级LUA语言的官方版本只包括一个精简的核心和最基本的库。这使得LUA体积小、启动速度快，从而适合嵌入在别的程序里。 编辑本段可扩展 可扩展LUA并不象其它许多"大而全"的语言那样，包括很多功能，比如网络通讯、图形界面等。但是LUA可以很容易地被扩展：由宿主语言(通常是C或C++)提供这些功能，LUA可以使用它们，就像是本来就内置的功能一样。 编辑本段其它特性 其它特性LUA还具有其它一些特性：同时支持面向过程编程和面向对象编程；自动内存管理；提供一系列数据结构，包括数组、链表、集合、字典、散列表等；语言内置正则表达式匹配；闭包(closure)；函数也可以看做一个值；提供多线程支持；等等。 编辑本段示例代码 是的，你猜对了：hello world... print "Hello, world!" 一个比较复杂一点的例子，但是它展示了什么是闭包: function create_a_counter() local count = 0 return function() count = count + 1 return count end end create_a_counter()返回一个记数器，每次调用这个记数器，都会得到一个比上次大1的值。 编辑本段数据交换介绍 Lua和C程序通过一个堆栈交换数据: struct lua_State 堆栈的序号可以从栈顶和栈底计数，从栈底计数，则栈底是1,向栈顶方向递增。从栈顶计数，则栈顶是-1,向栈底方向递减。一般都用从栈顶计数的方式。堆栈的默认大小是20，可以用lua_checkstack修改.用lua_gettop则可以获得栈里的元素数目。并不是说在栈顶有一个整形元素。而是计算了一下栈顶元素在栈里的正index,相当于元素数目。Lua 调用C函数用的堆栈是临时的，调用结束之后就被销毁了。如何从堆栈中获取从Lua脚本中的参数如果知道Lua脚本中某个全局变量的名字，可以用void lua_getglobal (lua_State *L, const char *name) 。这个函数会将name所指Lua 变量的值放在栈顶. 如果是在 C 函数中要获取Lua调用函数使用的参数：
第2章探讨Lua基础知识 Lua语言与您所了解的其他编程语言比较接近，它相对较小。在Lua的设计与发展过程中，Lua从许多不同的语言中得到了灵感，包括Lisp、Scheme、Pascal和C等。 本章内容是对Lua编程语言的一个概述，如果您在这之前已经有Lua或者其他编程语言的使用经验，您可能会希望浏览本章然后选做一些相关的练习。 您可以从https://www.doczj.com/doc/7b6620748.html,中阅读到更多Lua编程语言的相关资料。这个网站有很多参考资料，包括Programing in Lua一书的在线版，这是一部完全关于Lua编程语言的书。 2.1使用Lua解释器 您可以使用第1章已安装的Lua解释器来运行本章的所有例子和习题。 2.1.1运行命令 Lua解释器是交互的，您可以输入命令，并得到回应，就像两个朋友在交谈一样。（默然说话：这让我想起了上初中时使用过的Basic解释器。。。。已逝的年华，不再复还的时光。。。。）对于代码中的错误，您会接收到一个即时的反馈，使您可以通过修正该语言来了解它是如何动作的。 在提示符下输入下面的命令（您只需要输入“>”后面的部分）： >print(“Hello艾泽拉斯！”) 您会看见下面的输出： Hello艾泽拉斯 > 2.1.2错误信息的理解 在运行命令的时候，偶尔会出现输入错误并从Lua中获得一个错误反馈。错误信息通常是通俗易懂（默然说话：此话针对美国人，对于我们中国人。。。。。。唉，让人爱不起来的英文字母呀。。。。如果你的英语不太好，其实关系并不大，你完全可以通过学习计算机把英语学好——我就是活生生的例子。不要放弃这个一举两得的机会哦！），并且能指出哪里出了问题。在提示符中输入如下命令（注意要故意拼错print这个单词）： >prnit("Hello艾泽拉斯") 得到的响应是一个跟下面差不多的典型的Lua错误信息：
通过例子学习lua语言 前言 Lua是一种完全免费的脚本语言, 可以和C/C++语言紧密结合,它的官方网站在https://www.doczj.com/doc/7b6620748.html,./在网站上可以下载到lua的源码, 没有可执行版本, 不过不用担心, 因为lua源码可以在任何一种C/C++的编译器上编译.如果要学习Lua, 官方网站上的Reference是必备的，上面有每个命令的用法，非常详细。 参考手册https://www.doczj.com/doc/7b6620748.html,/manual/5.0/ 作者写的Programming in Lua https://www.doczj.com/doc/7b6620748.html,/pil/ 2.编译 如果用的VC6, 可以下载所需的project文件,地址在 https://www.doczj.com/doc/7b6620748.html,/project/showfiles.php?group_id=32250&package_id=115604 VSNET2003可以下载这个sln文件https://www.doczj.com/doc/7b6620748.html,/~vertigrated/lua/vs7.zip 偶用的是cygwin和linux, 打入以下命令即可, tar -zxvf lua-5.0.2.tar.gz cd lua-5.0.2 sh ./configure make 这样就OK了。 为了以后使用方便，最好把bin目录加入到path里面。 通过例子学习Lua(1) ---- Hello World把以下程序打入文件e01.lua 例1:e01.lua -- Hello World in Lua print("Hello World.") Lua有两种执行方式，一种是嵌入到C程序中执行，还有一种是直接从命令行方式下执行。这里为了调试方便，采用第二种方式，执行命令lua e01.lua 输出结果应该是： Hello World. 4.程序说明 第一行-- Hello World in Lua
Lua脚本语法说明（修订） Posted on 2006-08-04 11:39 沐枫阅读(3512) 评论(9)编辑收藏引用网摘所属分类: C++ Lua脚本语法说明（增加lua5.1部份特性） Lua 的语法比较简单，学习起来也比较省力，但功能却并不弱。 所以，我只简单的归纳一下Lua的一些语法规则，使用起来方便好查就可以了。估计看完了，就懂得怎么写Lua 程序了。 在Lua中，一切都是变量，除了关键字。 I. 首先是注释 写一个程序，总是少不了注释的。 在Lua中，你可以使用单行注释和多行注释。 单行注释中，连续两个减号"--"表示注释的开始，一直延续到行末为止。相当于C++语言中的"//"。 多行注释中，由"--[["表示注释开始，并且一直延续到"]]"为止。这种注释相当于C语言中的"/*...*/"。在注释当中，"[["和"]]"是可以嵌套的（在lua5.1中，中括号中间是可以加若干个"="号的，如[==[ ... ]==]），见下面的 字符串表示说明。 II. Lua编程 经典的"Hello world"的程序总是被用来开始介绍一种语言。在Lua中，写一个这样的程序很简单： print("Hello world") 在Lua中，语句之间可以用分号"；"隔开，也可以用空白隔开。一般来说，如果多个语句写在同一行的话，建议总是用分号隔开。 Lua 有好几种程序控制语句，如：
注意一下，for的循环变量总是只作用于for的局部变量；当省略步进值时，for循环会使用1作为步进值。 使用break可以用来中止一个循环。 相对C语言来说，Lua有几个地方是明显不同的，所以面要特别注意一下： ．语句块 语句块在C中是用"{"和"}"括起来的，在Lua中，它是用do 和end 括起来的。比如： do print("Hello") end 可以在函数中和语句块中定局部变量。 ．赋值语句 赋值语句在Lua被强化了。它可以同时给多个变量赋值。 例如： a,b,c,d=1,2,3,4 甚至是： a,b=b,a -- 多么方便的交换变量功能啊。 在默认情况下，变量总是认为是全局的。假如需要定义局部变量，则在第一次赋值的时候，需要用local说明。比如： local a,b,c = 1,2,3 -- a,b,c都是局部变量 ．数值运算 和C语言一样，支持+, -, *, /。但Lua还多了一个"^"。这表示指数乘方运算。比如2^3 结果为8, 2^4结果为16。 连接两个字符串，可以用".."运处符。如： "This a " .. "string." -- 等于"this a string"
Lua脚本语言入门 来源: LUPA开源社区 发布时间: 2007-07-02 13:53 版权申明 字体: 小中大 文章来源于https://www.doczj.com/doc/7b6620748.html, 作者：沐枫 在这篇文章中，我想向大家介绍如何进行Lua程序设计。我假设大家都学过至少一门编程语言，比如Basic或C，特别是C。因为Lua的最大用途是在宿主程序中作为脚本使用的。 Lua 的语法比较简单，学习起来也比较省力，但功能却并不弱。 在Lua中，一切都是变量，除了关键字。请记住这句话。 I. 首先是注释 写一个程序，总是少不了注释的。 在Lua中，你可以使用单行注释和多行注释。 单行注释中，连续两个减号"--"表示注释的开始，一直延续到行末为止。相当于C++语言中的"//"。 多行注释中，由"--[["表示注释开始，并且一直延续到"]]"为止。这种注释相当于C语言中的"/*…*/"。在注释当中，"[["和"]]"是可以嵌套的。 II. Lua编程 经典的"Hello world"的程序总是被用来开始介绍一种语言。在Lua中，写一个这样的程序很简单： print("Hello world") 在Lua中，语句之间可以用分号"；"隔开，也可以用空白隔开。一般来说，如果多个语句写在同一行的话，建议总是用分号隔开。 Lua 有好几种程序控制语句，如： 条件控制：if 条件then …elseif 条件then …else …end While循环：while 条件do …end Repeat循环：repeat …until 条件 For循环：for 变量= 初值，终点值，步进do …end For循环：for 变量1，变量2，…，变量N in表或枚举函数do …end 注意一下，for的循环变量总是只作用于for的局部变量，你也可以省略步进值，这时候，for循环会使用1作为步进值。 你可以用break来中止一个循环。 如果你有程序设计的基础，比如你学过Basic，C之类的，你会觉得Lua也不难。但Lua 有几个地方是明显不同于这些程序设计语言的，所以请特别注意。 ．语句块 语句块在C++中是用"{"和"}"括起来的，在Lua中，它是用do 和end 括起来的。比如：
Lua脚本语法说明（修订） Lua脚本语法说明（增加lua5.1部份特性） Lua 的语法比较简单，学习起来也比较省力，但功能却并不弱。 所以，我只简单的归纳一下Lua的一些语法规则，使用起来方便好查就可以了。估计看完了，就懂得怎么写Lua程序了。 在Lua中，一切都是变量，除了关键字。 I. 首先是注释 写一个程序，总是少不了注释的。 在Lua中，你可以使用单行注释和多行注释。 单行注释中，连续两个减号"--"表示注释的开始，一直延续到行末为止。相当于C++语言中的"//"。 多行注释中，由"--[["表示注释开始，并且一直延续到"]]"为止。这种注释相当于C语言中的"/*...*/"。在注释当中，"[["和"]]"是可以嵌套的（在lua5.1中，中括号中间是可以加若干个"="号的，如[==[ ... ]==]），见下面的字符串表示说明。 II. Lua编程 经典的"Hello world"的程序总是被用来开始介绍一种语言。在Lua中，写一个这样的程序很简单： print("Hello world") 在Lua中，语句之间可以用分号"；"隔开，也可以用空白隔开。一般来说，如果多个语句写在同一行的话，建议总是用分号隔开。 Lua 有好几种程序控制语句，如： 注意一下，for的循环变量总是只作用于for的局部变量；当省略步进值时，for循环会使用1作为步进值。 使用break可以用来中止一个循环。 相对C语言来说，Lua有几个地方是明显不同的，所以面要特别注意一下： ．语句块 语句块在C中是用"{"和"}"括起来的，在Lua中，它是用do 和end 括起来的。比如： do print("Hello") end 可以在函数中和语句块中定局部变量。
在这篇文章中，我想向大家介绍如何进行Lua程序设计。我假设大家都学过至少一门编程语言，比如Basic或C，特别是C。因为Lua的最大用途是在宿主程序中作为脚本使用的。 Lua 的语法比较简单，学习起来也比较省力，但功能却并不弱。 在Lua中，一切都是变量，除了关键字。请记住这句话。 I. 首先是注释 写一个程序，总是少不了注释的。 在Lua中，你可以使用单行注释和多行注释。 单行注释中，连续两个减号"--"表示注释的开始，一直延续到行末为止。相当于C++语言中的"//"。 多行注释中，由"--[["表示注释开始，并且一直延续到"]]"为止。这种注释相当于C语言中的"/*…*/"。在注释当中，"[["和"]]"是可以嵌套的。 II. Lua编程 经典的"Hello world"的程序总是被用来开始介绍一种语言。在Lua中，写一个这样的程序很简单： print("Hello world") 在Lua中，语句之间可以用分号"；"隔开，也可以用空白隔开。一般来说，如果多个语句写在同一行的话，建议总是用分号隔开。 Lua 有好几种程序控制语句，如： 条件控制：if 条件then … elseif 条件then … else … end While循环：while 条件do … end Repeat循环：repeat … until 条件 For循环：for 变量 = 初值，终点值，步进do … end For循环：for 变量1，变量2，… ，变量N in表或枚举函数do … end 注意一下，for的循环变量总是只作用于for的局部变量，你也可以省略步进值，这时候，for循环会使用1作为步进值。 你可以用break来中止一个循环。 如果你有程序设计的基础，比如你学过Basic，C之类的，你会觉得Lua也不难。但Lua有几个地方是明显不同于这些程序设计语言的，所以请特别注意。 ．语句块 语句块在C++中是用"{"和"}"括起来的，在Lua中，它是用do 和 end 括起来的。比如： do print("Hello") end 你可以在函数中和语句块中定局部变量。 ．赋值语句 赋值语句在Lua被强化了。它可以同时给多个变量赋值。 例如： a,b,c,d=1,2,3,4 甚至是：
官方站点 开发者网站 手册 论坛 工具
tolua++一个很好的帮助程序员将C/C++代码整合进Lua的工具 在这篇文章中，我想向大家介绍如何进行Lua程序设计。我假设大家都学过至少一门编程语言，比如Basic或C，特别是C。因为Lua的最大用途是在宿主程序中作为脚本使用的。 Lua 的语法比较简单，学习起来也比较省力，但功能却并不弱。 在Lua中，一切都是变量，除了关键字。请记住这句话。 I. 首先是注释 写一个程序，总是少不了注释的。 在Lua中，你可以使用单行注释和多行注释。 单行注释中，连续两个减号"--"表示注释的开始，一直延续到行末为止。相当于C++语言中的"//"。 多行注释中，由"--[["表示注释开始，并且一直延续到"]]"为止。这种注释相当于C语言中的"/*…*/"。在注释当中，"[["和"]]"是可以嵌套的。 II. Lua编程 经典的"Hello world"的程序总是被用来开始介绍一种语言。在Lua中，写一个这样的程序很简单： print("Hello world") 在Lua中，语句之间可以用分号"；"隔开，也可以用空白隔开。一般来说，如果多个语句写在同一行的话，建议总是用分号隔开。 Lua 有好几种程序控制语句，如： 条件控制：if 条件then … elseif 条件then … else … end While循环：while 条件do … end Repeat循环：repeat … until 条件 For循环：for 变量 = 初值，终点值，步进do … end For循环：for 变量1，变量2，… ，变量N in表或枚举函数do … end 注意一下，for的循环变量总是只作用于for的局部变量，你也可以省略步进值，这时候，for循环会使用1作为步进值。 你可以用break来中止一个循环。
游戏策划-Lua游戏脚本语言入门 这篇文章向大家介绍如何进行Lua程序设计。假设大家都学过至少一门编程语言，比如Basic 或C，特别是C。因为Lua的最大用途是在宿主程序中作为脚本使用的。 Lua 的语法比较简单，学习起来也比较省力，但功能却并不弱。在Lua中，一切都是变量，除了关键字。请记住这句话。 I. 首先是注释 写一个程序，总是少不了注释的。在Lua中，你可以使用单行注释和多行注释。单行注释中，连续两个减号"--"表示注释的开始，一直延续到行末为止。相当于C++语言中的"//"。多行注释中，由"--[["表示注释开始，并且一直延续到"]]"为止。这种注释相当于C语言中的"/*…*/"。在注释当中，"[["和"]]"是可以嵌套的。 II. Lua编程 经典的"Hello world"的程序总是被用来开始介绍一种语言。在Lua中，写一个这样的程序很简单： print("Hello world") 在Lua中，语句之间可以用分号"；"隔开，也可以用空白隔开。一般来说，如果多个语句写在同一行的话，建议总是用分号隔开。 Lua 有好几种程序控制语句，如： 条件控制：if 条件then …elseif 条件then …else …end While循环：while 条件do …end Repeat循环：repeat …until 条件 For循环：for 变量= 初值，终点值，步进do …end For循环：for 变量1，变量2，…，变量N in表或枚举函数do …end 注意一下，for的循环变量总是只作用于for的局部变量，你也可以省略步进值，这时候，for 循环会使用1作为步进值。 你可以用break来中止一个循环。 如果你有程序设计的基础，比如你学过Basic，C之类的，你会觉得Lua也不难。但Lua有几个地方是明显不同于这些程序设计语言的，所以请特别注意。 ．语句块 语句块在C++中是用"{"和"}"括起来的，在Lua中，它是用do 和end 括起来的。比如： do print("Hello") end 你可以在函数中和语句块中定局部变量。 ．赋值语句 赋值语句在Lua被强化了。它可以同时给多个变量赋值。 例如： a,b,c,d=1,2,3,4
LUA语言学习教程 在这篇文章中，我想向大家介绍如何进行Lua程序设计。我假设大家都学过至少一门编程语言，比如Basic或C，特别是C。因为Lua的最大用途是在宿主程序中作为脚本使用的。 Lua 的语法比较简单，学习起来也比较省力，但功能却并不弱。 在Lua中，一切都是变量，除了关键字。请记住这句话。 I. 首先是注释 写一个程序，总是少不了注释的。 在Lua中，你可以使用单行注释和多行注释。 单行注释中，连续两个减号"--"表示注释的开始，一直延续到行末为止。相当于C++语言中的"//"。 多行注释中，由"--[["表示注释开始，并且一直延续到"]]"为止。这种注释相当于C语言中的"/*…*/"。在注释当中，"[["和"]]"是可以嵌套的。 II. Lua编程 经典的"Hello world"的程序总是被用来开始介绍一种语言。在Lua中，写一个这样的程序很简单： print("Hello world") 在Lua中，语句之间可以用分号"；"隔开，也可以用空白隔开。一般来说，如果多个语句写在同一行的话，建议总是用分号隔开。 Lua 有好几种程序控制语句，如： 条件控制：if 条件then … elseif 条件then … else … end While循环：while 条件do … end Repeat循环：repeat … until 条件 For循环：for 变量 = 初值，终点值，步进do … end For循环：for 变量1，变量2，… ，变量N in表或枚举函数do … end 注意一下，for的循环变量总是只作用于for的局部变量，你也可以省略步进值，这时候，for循环会使用1作为步进值。 你可以用break来中止一个循环。 如果你有程序设计的基础，比如你学过Basic，C之类的，你会觉得Lua也不难。但Lua有几个地方是明显不同于这些程序设计语言的，所以请特别注意。 ．语句块 语句块在C++中是用"{"和"}"括起来的，在Lua中，它是用do 和 end 括起来的。比如： do print("Hello") end 你可以在函数中和语句块中定局部变量。 ．赋值语句 赋值语句在Lua被强化了。它可以同时给多个变量赋值。