lua教程
分类：Lua作者：编程之家用户
--------------------------------------
----------------------------------------
-----------------------------------------
本章包括作者的序言、文章的体例（
convention
）以及其它一些“每本书开头都会的内容”。
目前很多程序语言都专注于帮你编写成千上万行的代码，所以此类型的语言所提供的包、命名空间、复杂的类型系统及无数的结构，有上千页的文档需要操作者学习。
而
Lua
并不帮你编写大量的代码的程序，相反的，
仅让你用少量的代码解决关键问题。为实现这个目标，像其他语言一样
依赖于其可扩展性。但是与其他语言不同的是，不仅用
编写的软件易于扩展，而且用其他语言比如
C/C++
编写的软件也很容易使用
扩展其功能。
一开始，
就被设计成很容易和传统的
整合的语言。这种语言的二元性带来了极大的好处。
是一个小巧而简单的语言，因为
不致力于做
C
语言已经做得很好的领域，比如：性能、底层操作以及与第三方软件的接口。
依赖于
去做完成这些任务。
所提供的机制是
不善于的：高级语言、动态结构、简洁、易于测试和调试等。正因为如此，
具有良好的安全保证，自动内存管理，简便的字符串处理功能及其他动态数据的改变。
不仅是一种易于扩展的语言，也是一种易整合语言（
glue language
）；
支持基于组件的，我们可以将一些已经存在的高级组件整合在一起实现一个应用软件。一般情况下，组件使用像
等静态的语言编写。但
是我们整合各个组件的粘合剂。又通常情况下，组件（或对象）表现为具体在程序开发过程中很少变化的、占用大量
CPU
时间的决定性的程序，例如窗口部件和数据结构。对那种在产品的生命周期内变化比较多的应用方向使用
可以更方便的适应变化。除了作为整合语言外，
自身也是一个功能强大的语言。
不仅可以整合组件，还可以编辑组件甚至完全使用
创建组件。
除了
外，还有很多类似的脚本语言，例如：
Perl
、
Tcl
Ruby
Forth
Python
。虽然其他语言在某些方面与
有着共同的特色，但下面这些特征是
特有的：
①
可扩展性。Lua的扩展性非常卓越，以至于很多人把用作搭建领域语言的工具（注：比如游戏脚本）。被设计为易于扩展的，可以通过代码或者C代码扩展，的很多功能都是通过外部库来扩展的。很容易与C/C++、javafortranSmalltalkAda，以及其他语言接口。
②
简单本身简单，小巧；内容少但功能强大，这使得易于学习，很容易实现一些小的应用。他的完全发布版（代码、手册以及某些平台的二进制文件）仅用一张软盘就可以装得下。
③
高效率有很高的执行效率，统计表明是目前平均效率最高的脚本语言。
④
与平台无关几乎可以运行在所有我们听说过的系统上，如NextStepOS/2PlayStation II (Sony)Mac OS-9OS XBeOSMS-DOSIBM mainframesEPOCPalmOSMCF5206eLITE Evaluation BoardRISC OS，及所有的Windows和Unix不是通过使用条件编译实现平台无关，而是完全使用ANSI (ISO) C，这意味着只要你有ANSI C编译器你就可以编译并使用。
大部分强大的功能来自于他的类库，这并非偶然。
的长处之一就是可以通过新类型和函数来扩展其功能。动态类型检查最大限度允许多态出现，并自动简化调用内存管理的接口，因为这样不需要关心谁来分配内存谁来释放内存，也不必担心数据溢出。高级函数和匿名函数均可以接受高级参数，使函数更为通用。
自带一个小规模的类库。在受限系统中使用
，如嵌入式系统，我们可以有选择地安装这些类库。若运行环境十分严格，我们甚至可以直接修改类库源代码，仅保留需要的函数。记住：
是很小的（即使加上全部的标准库）并且在大部分系统下你仍可以不用担心的使用全部的功能。
使用者分为三大类：使用
嵌入到其他应用中的、独立使用
的、将
和
混合使用的。
第一：很多人使用
嵌入在应用程序，比如
CGILua
（搭建动态网页）、
LuaOrb
（访问
CORBA
对象。这些类型用
Lua-API
注册新函数，创建新类型，通过配置
就可以改变应用宿主语言的行为。通常，这种应用的使用者并不知道
是一种独立的语言。例如：
用户一般会认为
是一种用于
Web
的语言。
第二：作为一种独立运行的语言，
也是很有用的，主要用于文本处理或者只运行一次的小程序。这种应用
主要使用它的标准库来实现，标准库提供模式匹配和其它一些字串处理的功能。我们可以这样认为：
是文本处理领域的嵌入式语言。
第三：还有一些使用者使用其他语言开发，把
当作库使用。这些人大多使用
语言开发，但使用
建立简单灵活易于使用的接口。
本书面向以上三类读者。书的第一部分阐述了语言的本身，展示语言的潜在功能。我们讲述了不同的语言结构，并用一些例子展示如何解决实际问题。这部分既包括基本的语言的控制结构，也包括高级的迭代子和协同。
第二部分重点放在
特有的数据结构——
tables
上
,
讨论了数据结构、持久性、包及面向对象编程，这里我们将看到
的真正强大之处。
第三部分介绍标准库。每个标准库一章：数学库、
table
库、
string
I/O
OS
Debug
库。
最后一部分介绍了
接口的
API
，这部分介绍在
语言中开发应用而不是
中，应用对于那些打算将
嵌入到
中的读者可能会对此部分更感兴趣。
如果你真得想学一门语言，参考手册是必备的。本书和
参考手册互为补充，手册仅仅描述语言本身，因此他既不会告诉你语言的数据结构也不会举例说明，但手册是
的权威性文档，
http://www.lua.org
可以得到手册的内容。
-- Lua
用户社区，提供了一些第三方包和文档
--
本书的更新勘误表，代码和例子
另外本书仅针对
Lua 5.0
，如果你的版本不同，请查阅
手册或者比较版本间的差异。
<1>
字符串使用双引号，比如
"literal strings"
；单字符使用单引号，比如
'a'
；模式串也是用单引号，比如
'[%w_]*'
。
<2>
符号
-->
表示语句的输出或者表达式的结果
:
print(10) --> 10
13 + 3 --> 16
<3>
<-->
表示等价，即对于
来说，用
this
与
that
没有区别。
this <--> that
开始打算写这本书是
1998
年冬天
(
南半球
)
，那时候
版本是
3.1
；
2000
年
v4.0
2003
v5.0
很明显的是，这些变化给本书带来很大的冲击，有些内容失去了它存在理由，比如关于超值（
upvalues
）的复杂的解释。一些章节被重写，比如
C API
，另外一些章节被增加进来，比如协同处理。
不太明显的是，
语 言本身的发展对本书的完成也产生了很大的影响。一些语言的变化在本书中并没有被涵盖进来，这并非偶然的。在本书的创作过程中，有的时候在某个章节我会突然 感觉很困惑，因为我不知道该从何开始或者怎样去讲问题阐述清楚。当你想尽力去解释清楚如何使用的前提是你应该觉得使用这个东西很容易，这表明
某些地方需要被改进。还有的时候，我顺利的写完某个章节，结果却是没有人能看得懂我写的或者没有人对我在这个章节内表达的观点达成一致。大部分情况下，这是我的过错因为我是个作家，偶尔我也会因此发现语言本身的一些需要改进的缺陷（举例来说，从
到
lexical scoping
的转变是由无意义的尝试所带来的抱怨所引发的，在此书的先前的草稿里，把
形容成是
的一种）。
本书的完成必须服从语言的变化，本书在这个时候完成的原因：
<1> Lua 5.0
是一个成熟的版本
<2>
语言变得越来越大，超出了最初本书的目标。此外一个原因是我迫切的想将
Lua
介绍给大家让更多的人了解
。
在完成本书的过程中，很多人给了我极大的帮助：
Luiz Henrique de Figueiredo
Waldemar Celes
给了我很大的帮助，使得本书能够更好完成，
Luiz Henrique
也帮助设计了本书的内部。
Noemi Rodriguez,Andr
é
Carregal,Diego Nehab,
以及
Gavin Wraith
阅读了本书的草稿提出了很多有价值的建议。
Renato Cerqueira,Carlos Cassino,Tom
á
s Guisasola,Joe Myers
Ed Ferguson
也提出了很多重要的建议。
Alexandre Nakonechnyj
负责本书的封面和内部设计。
Rosane Teles
负责
CIP
数据的准备。
谢谢他们所有人。
写一个最最简单的程序——Hello World。
假定你把上面这句保存在hello.lua文件中，你在命令行只需要：
prompt> lua hello.lua
看到结果了吗?
让我们来看一个稍微复杂点的例子：
-- defines a factorial function
function fact (n)
if n == 0 then
return 1
else
return n * fact(n-1)
end
end
print("enter a number:")
a = io.read("*number") -- read a number
print(fact(a))
这个例子定义了一个函数，计算输入参数n的阶乘；本例要求用户输入一个数字，然后打印的阶乘。
Chunk是一系列语句，Lua执行的每一块语句，比如一个文件或者交互模式下的每一行都是一个。
每个语句结尾的分号（;）是可选的，但如果同一行有多个语句最好用；分开
a = 1 b = a*2 -- ugly,but valid
一个可以是一个语句，也可以是一系列语句的组合，还可以是函数，可以很大，在中几个MByte的是很常见的。
你还可以以交互模式运行，不带参数运行Lua:
Lua 5.0 Copyright © 1994-2003 Tecgraf,PUC-Rio
>
你键入的每个命令（比如："Hello World"）在你键入回车之后立即被执行，键入文件结束符可以退出交互模式（Ctrl-D in Unix,Ctrl-Z in DOS/Windows），或者调用OS库的os.exit()函数也可以退出。
在交互模式下，通常把每一个行当作一个，但如果一行不是一个完整的时，他会等待继续输入直到得到一个完整的Chunk.在等待续行时，显示不同的提示符（一般是>>）.
可以通过指定参数让执行一系列。例如：假定一个文件a内有单个语句x=1；另一个文件b有语句print(x)
prompt> lua -la -lb
命令首先在一个内先运行然后运行。（注意：-l选项会调用require，将会在指定的目录下搜索文件，如果环境变量没有设好，上面的命令可能不能正确运行。我们将在8.1节详细更详细的讨论the require function）
-i选项要求运行指定后进入交互模式.
prompt> lua -i -la -lb
将在一个，最后直接进入交互模式。
另一个连接外部的方式是使用dofile函数，函数加载文件并执行它.假设有一个文件:
-- file 'lib1.lua'
function norm (x,y)
local n2 = x^2 + y^2
return math.sqrt(n2)
function twice (x)
return 2*x
end
在交互模式下：
> dofile("lib1.lua") -- load your library
> n = norm(3.4,1.0)
> print(twice(n)) --> 7.0880180586677
和在调试或者测试代码时是很方便的。
全局变量不需要声明，给一个变量赋值后即创建了这个全局变量，访问一个没有初始化的全局变量也不会出错，只不过得到的结果是：nil.
print(b) --> nil
b = 10
print(b) --> 10
如果你想删除一个全局变量，只需要将变量负值为nil
b = nil
print(b) --> nil
这样变量就好像从没被使用过一样换句话说当且仅当一个变量不等于nil时，这个变量存在。
标示符：字母(letter)或者下划线开头的字母、下划线、数字序列最好不要使用下划线加大写字母的标示符，因为的保留字也是这样的。中，letter的含义是依赖于本地环境的。
保留字：以下字符为的保留字，不能当作标识符。
and break do else elseif
end false for function if
in local nil not or
repeat return then true until
while
注意：是大小写敏感的注释：单行注释:--
多行注释：--[[ --]]
--[[
print(10) -- no action (comment)
--]]
lua [options] [script [args]]
-e：直接将命令传入Lua
prompt> lua -e "print(math.sin(12))" --> -0.53657291800043
：加载一个文件：进入交互模式_PROMPT内置变量作为交互模式的提示符
prompt> lua -i -e "_PROMPT=' lua> '"
lua>
的运行过程，在运行参数之前，会查找环境变量LUA_INIT的值，如果变量存在并且值为@filename，将加载指定文件。如果变量存在但不是以@开头，假定filename为代码文件并且运行他。利用这个特性，我们可以通过配置，灵活的设置交互模式的环境。可以加载包，修改提示符和路径，定义自己的函数，修改或者重命名函数等。
全局变量arg存放的命令行参数。
prompt> lua script a b c
在运行以前，使用所有参数构造表。脚本名索引为0，脚本的参数从1开始增加。脚本前面的参数从-1开始减少。
prompt> lua -e "sin=math.sin" script a b
表如下：
arg[-3] = "lua"
arg[-2] = "-e"
arg[-1] = "sin=math.sin"
arg[0] = "script"
arg[1] = "a"
arg[2] = "b"
是动态类型语言，变量不要类型定义。中有8个基本类型分别为：、booleannumberstringuserdatafunctionthreadtable。函数type可以测试给定变量或者值的类型。
print(type("Hello world")) --> string
print(type(10.4*3)) --> number
print(type(print)) --> function
print(type(type)) --> function
print(type(true)) --> boolean
print(type(nil)) --> nil
print(type(type(X))) --> string
变量没有预定义的类型，每一个变量都可能包含任一种类型的值。
print(type(a)) --> nil ('a' is not initialized)
a = 10
print(type(a)) --> number
a = "a string!!"
print(type(a)) --> string
a = print -- yes,this is valid!
a(type(a)) --> function
注意上面最后两行，我们可以使用像使用其他值一样使用（更多的介绍参考第六章）。一般情况下同一变量代表不同类型的值会造成混乱，最好不要用，但是特殊情况下可以带来便利，比如。
中特殊的类型，他只有一个值：；一个全局变量没有被赋值以前默认值为；给全局变量负可以删除该变量。
两个取值falsetrue。但要注意中所有的值都可以作为条件。在控制结构的条件中除了为假，其他值都为真。所以认为和空串都是真。
表示实数，中没有整数。一般有个错误的看法CPU运算浮点数比整数慢。事实不是如此，用实数代替整数不会有什么误差（除非数字大于100,000,000）。numbers可以处理任何长整数不用担心误差。你也可以在编译的时候使用长整型或者单精度浮点型代替，在一些平台硬件不支持浮点数的情况下这个特性是非常有用的，具体的情况请参考发布版所附的详细说明。和其他语言类似，数字常量的小数部分和指数部分都是可选的，数字常量的例子：
4 0.4 4.57e-3 0.3e12 5e+20
指字符的序列。lua是位字节，所以字符串可以包含任何数值字符，包括嵌入的。这意味着你可以存储任意的二进制数据在一个字符串里。中字符串是不可以修改的，你可以创建一个新的变量存放你要的字符串，如下：
a = "one string"
b = string.gsub(a,"one","another") -- change string parts
print(a) --> one string
print(b) --> another string
和其他对象一样，自动进行内存分配和释放，一个可以只包含一个字母也可以包含一本书，可以高效的处理长字符串，1M中是很常见的。可以使用单引号或者双引号表示字符串
a = "a line"
b = 'another line'
为了风格统一，最好使用一种，除非两种引号嵌套情况。对于字符串中含有引号的情况还可以使用转义符/来表示。中的转义序列有：
/a bell
/b back space -- 后退
/f form feed -- 换页
/n newline -- 换行
/r carriage return -- 回车
/t horizontal tab -- 制表
/v vertical tab
// backslash -- "/"
/" double quote -- 双引号
/' single quote -- 单引号
/[ left square bracket -- 左中括号
/] right square bracket -- 右中括号
例子：
> print("one line/nnext line/n/"in quotes/",'in quotes'")
one line
next line
"in quotes",'in quotes'
> print('a backslash inside quotes: /'///'')
a backslash inside quotes: '/'
> print("a simpler way: '//'")
a simpler way: '/'
还可以在字符串中使用/ddd（ddd为三位十进制数字）方式表示字母。
"alo/n123/""'/97lo/10/04923"'是相同的。
还可以使用[[...]]表示字符串。这种形式的字符串可以包含多行也，可以嵌套且不会解释转义序列，如果第一个字符是换行符会被自动忽略掉。这种形式的字符串用来包含一段代码是非常方便的。
page = [[
<HTML>
<HEAD>
<TITLE>An HTML Page</TITLE>
</HEAD>
<BODY>
Lua
[[a text between double brackets]]
</BODY>
</HTML>
]]
io.write(page)
运行时，会自动在之间自动进行类型转换，当一个字符串使用算术操作符时，就会被转成数字。
print("10" + 1) --> 11
print("10 + 1") --> 10 + 1
print("-5.3e - 10" * "2") --> -1.06e-09
print("hello" + 1) -- ERROR (cannot convert "hello")
反过来，当期望一个而碰到数字时，会将数字转成。
print(10 .. 20) --> 1020
..中是字符串连接符，当在一个数字后面写时，必须加上空格以防止被解释错。
尽管字符串和数字可以自动转换，但两者是不同的，像10 == "10"这样的比较永远都是错的。如果需要显式将转成数字可以使用函数tonumber()，如果不是正确的数字该函数将返回line = io.read() -- read a line
n = tonumber(line) -- try to convert it to a number
if n == nil then
error(line .. " is not a valid number")
else
print(n*2)
end
反之可以调用tostring()将数字转成字符串，这种转换一直有效：
print(tostring(10) == "10") --> true
print(10 .. "" == "10") --> true
函数是第一类值（和其他变量相同），意味着函数可以存储在变量中，可以作为函数的参数，也可以作为函数的返回值。这个特性给了语言很大的灵活性：一个程序可以重新定义函数增加新的功能或者为了避免运行不可靠代码创建安全运行环境而隐藏函数，此外这特性在实现面向对象中也起了重要作用（在第16章详细讲述）。
或者C实现的函数，所有标准库都是用实现的。标准库包括库、I/O库、算术库、debug库。
可以将数据存放在变量中，中除了赋值和相等比较外没有预定义的操作。用来描述应用程序或者使用实现的库创建的新类型。例如：用标准库来描述文件。下面在C API章节中我们将详细讨论。
在第九章讨论协同操作的时候，我们介绍线程。
---------------------------------------------------
中的表达式包括数字常量、字符串常量、变量、一元和二元运算符、函数调用。还可以是非传统的函数定义和表构造。
二元运算符：+ - * / ^ (加减乘除幂)
一元运算符：- (负值这些运算符的操作数都是实数。
这些操作符返回结果为；==~=比较两个值，如果两个值类型不同，认为两者不同；只和自己相等。通过引用比较tablesfunctions。也就是说当且仅当两者表示同一个对象时相等。
a = {}; a.x = 1; a.y = 0
b = {}; b.x = 1; b.y = 0
c = a
a==c but a~=b
比较数字按传统的数字大小进行，比较字符串按字母的顺序进行，但是字母顺序依赖于本地环境。
当比较不同类型的值的时候要特别注意：
"0" == 0 -- false
2 < 15 -- true
"2" < "15" -- false (alphabetical order!)
为了避免不一致的结果，混合比较数字和字符串，会报错，比如：2 < "15"
and or not
逻辑运算符认为是假（），其他为真，也是true.
andor的运算结果不是，而是和它的两个操作数相关。
a and b -- 如果，则返回，否则返回b
a or b -- b
例如：
print(4 and 5) --> 5
print(nil and 13) --> nil
print(false and 13) --> false
print(4 or 5) --> 4
print(false or 5) --> 5
一个很实用的技巧：如果x则给赋初始值v
x = x or v
等价于
if not x then
x = v
end
的优先级比高。
语言中的三元运算符
a ? b : c
中可以这样实现：
(a and b) or c
not的结果只返回true
print(not nil) --> true
print(not false) --> true
print(not 0) --> false
print(not not nil) --> false
.. --两个点
字符串连接，如果操作数为数字，将数字转成字符串。
print("Hello " .. "World") --> Hello World
print(0 .. 1) --> 01
从高到低的顺序：
^
not - (unary)
* /
+ -
..
< > <= >= ~= ==
and
or
除了^外所有的二元运算符都是左连接的。
a+i < b/2+1 <--> (a+i) < ((b/2)+1)
5+x^2*8 <--> 5+((x^2)*8)
a < y and y <= z <--> (a < y) and (y <= z)
-x^2 <--> -(x^2)
x^y^z <--> x^(y^z)
构造器是创建和初始化表的表达式。表是特有的功能强大的东西。最简单的构造函数是{}，用来创建一个空表。可以直接初始化数组:
days = {"Sunday","Monday","Tuesday","Wednesday",
"Thursday","Friday","Saturday"}
将"Sunday"初始化days[1]（第一个元素索引为），用"Monday"days[2]...
print(days[4]) --> Wednesday
构造函数可以使用任何表达式初始化：
tab = {sin(1),sin(2),sin(3),sin(4),255);"> sin(5),sin(6),sin(7),sin(8)}
如果想初始化一个表作为record使用可以这样：
a = {x=0,y=0} <--> a = {}; a.x=0; a.y=0
不管用何种方式创建，我们都可以向表中添加或者删除任何类型的域，构造函数仅仅影响表的初始化。
w = {x=0,y=0,label="console"}
x = {sin(0),sin(1),sin(2)}
w[1] = "another field"
x.f = w
print(w["x"]) --> 0
print(w[1]) --> another field
print(x.f[1]) --> another field
w.x = nil -- remove field "x"
每次调用构造函数，都会创建一个新的，可以使用构造一个list：
list = nil
for line in io.lines() do
list = {next=list,value=line}
这段代码从标准输入读进每行，然后反序形成链表。下面的代码打印链表的内容：
l = list
while l do
print(l.value)
l = l.next
在同一个构造函数中可以混合列表风格和风格进行初始化，如：
polyline = {color="blue",thickness=2,npoints=4,255);"> {x=0, y=0},255);"> {x=-10,y=0},y=1}, y=1}
}
这个例子也表明我们可以嵌套构造函数来表示复杂的数据结构.
print(polyline[2].x) --> -10
上面两种构造函数的初始化方式还有限制，比如你不能使用负索引初始化一个表中元素，字符串索引也不能被恰当的表示。下面介绍一种更一般的初始化方式，我们用[expression]显示的表示将被初始化的索引：
opnames = {["+"] = "add",["-"] = "sub",255);"> ["*"] = "mul",["/"] = "div"}
i = 20; s = "-"
a = {[i+0] = s,[i+1] = s..s,[i+2] = s..s..s}
print(opnames[s]) --> sub
print(a[22]) --> ---
风格初始化和风格初始化是这种一般初始化的特例{x=0,y=0} <--> {["x"]=0,["y"]=0}
{"red","green","blue"} <-->
{[1]="red",[2]="green",[3]="blue"}
如果真的想要数组下标从开始：
days = {[0]="Sunday",255);">注意：不推荐数组下标从开始，否则很多标准库不能使用。
在构造函数的最后的","是可选的，可以方便以后的扩展。
a = {[1]="red",[3]="blue",}
在构造函数中域分隔符逗号（）可以用分号（";"）替代，通常我们使用分号用来分割不同类型的表元素。
{x=10,y=45; "one","two","three"}
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。
相关推荐
1.github代码实践源代码是lua脚本语言，下载th之后运行thmain.lua-netTypevgg-savevgg_cifar10/-S0.0001，报错： 试看看安装lua:报错了，参考这篇文章：ubuntu18.04安装lua的步骤以及出现的问题_weixin_41355132的博客-CSDN博客问题解决，安装成功：情况并没有好转，出现相
此文为搬运帖,原帖地址https://www.cnblogs.com/zwywilliam/p/5999924.html前言在看了uwa之前发布的《Unity项目常见Lua解决方案性能比较》，决定动手写一篇关于lua+unity方案的性能优化文。整合lua是目前最强大的unity热更新方案，毕竟这是唯一可以支持ios热更新的办法。然而作
Rime输入法通过定义lua文件，可以实现获取当前时间日期的功能。1.TIMERime是一款可以高度自定义的输入法，相关教程可以查看往期文章，关于时间获取是指输入一个指定关键字，输出当前时间，效果如下（我定义了time关键字）：实现如下：①在用户文件夹中新建一个rime.lua文件加入如下代码 ti
localfunctiongenerate_action(params)localscale_action=cc.ScaleTo:create(params.time,params.scale_x,params.scale_y)localfade_action=cc.FadeIn:create(params.time)returncc.Spawn:create(scale_action,fade_action)end
2022年1月11日13:57:45 官方：https://opm.openresty.org/官方文档：https://opm.openresty.org/docs#table-of-contents为什么建议使用opm不建议使用luarocks？http://openresty.org/cn/using-luarocks.html官方解释：请注意！LuaRocks并不是OpenResty官方推荐的装包方式。LuaRoc
在Lua中的table（表），就像c#中的HashMap（哈希表），key和value一一对应。元表：table的一个操作的拓展，里面包含关联了对应的方法，元方法就是其中一个。元方法：当你通过键来访问table的时候，如果这个键没有值，那么Lua就会寻找该table的metatable（假定有metatable）中的__index键。如果__inde
表排序：table.sort(list[,comp])参数list：指定表，可选参数comp：排序函数，无参数时通常按升序排序。排序函数针对表中连续的序列，其间不可以存在空洞或nil，排序函数需要两个形参(对应表中每次参加比较的两个数据)，需要一个比较两个形参表达式的返回值，不能含有等于关系，例如>=，<=，==。do
一、安装lua环境1.1安装依赖包[root@centos7~]#yuminstallgccreadline-devel1.2下线lua源码包并解压[root@centos7~]#wgethttp://www.lua.org/ftp/lua-5.3.5.tar.gz[root@centos7~]#tarxvflua-5.3.5.tar.gz-C/usr/local/src1.3进行编译[root@centos7~]
官网OpenResty® 是一个基于 Nginx 与Lua的高性能Web平台，其内部集成了大量精良的Lua库、第三方模块以及大多数的依赖项。用于方便地搭建能够处理超高并发、扩展性极高的动态Web应用、Web服务和动态网关。OpenResty® 通过汇聚各种设计精良的 Nginx 模块（主要由
表参考《lua程序设计》可以认为，表是一种动态分配的对象，程序只能操作指向表的引用（或指针）。除此以外，Lua语言不会进行隐藏的拷贝（hiddencopies）或创建新的表--创建表a={}--创建空表k="x"a[k]=10--键“x”值10a[20]="great"--键20值“great”print(a["x"])-->10
https://github.com/galenho/crossover.git一个跨平台的lua游戏服务器开发框架，该框架采用多线程并发来处理消息，开发者只需要调用相应的接口函数并绑定相应的回调函数即可，在逻辑层表现为单线程的开发模式，使开发者易用，易调试，易维护，易扩展，同时拥有快速的响应能力。 框架使用面
参考链接：https://www.runoob.com/lua/lua-metatables.htmlhttps://www.jianshu.com/p/cb945e7073a3 元表是一个table，可以让我们改变table的行为，每个行为有对应的元方法例如，对table进行设置键值，查找键值，运算等，就会触发对应的元方法1--__index:table被访问时，如果找不到这
https://github.com/yuin/gopher-luahttps://github.com/yuin/gopher-lua Lua5.1ReferenceManual-contentshttp://www.lua.org/manual/5.1/ go中使用luapackagemainimport( lua"github.com/yuin/gopher-lua")funcmain(){ l:=lua.NewState() d
编译问题不要留到运行时才跑出来啊。早上9:00-中午3:00,6个小时，服了自己了。 写了一个测试，springboot+redis+lua执行到redisTemplate.execute(redisScript,idList)的时候一直报错，integer无法转换为string。我一直以为是lua脚本写错了，翻文档翻过来又翻过去，写法变了又变，还是解
。。是字符串连接符，字典用=号连接， 注意fordoend都是连一起， 注意ifthen， 如果local在函数里，是可以访问，非local出了函数一样能用， doend代码块也是一样， 注意点号表示，只能key是字符串， 注意括号不是必须
C语言与Lua之间的相互调用详解写一个C调用Lua的Demo编译运行C语言调用Lua编译问题总结正确的编译命令问题1：缺少-lm参数问题2：缺少-ldl参数1、为什么会出现undefinedreferenceto‘xxxxx’错误？2、-l参数和-L参数写一个C调用Lua的Demo编译运行add.c内容//你需要
1、动态输出打开E:\study\openresty\openresty-1.19.9.1-win64目录下的confginx.conf文件在server中增加一下代码 location/hello{ default_typetext/html; content_by_lua'ngx.say("<p>hello,world</p>")'; }运行后，效果如下图localhost
参见：lipp/lua-websockets:WebsocketsforLua.(github.com)github网址可能需手动转换lipp.github.com/lua-websockets/>github.com/lipp/lua-websocketswebsockets为底层的类似于TCP、UDP的socket（实现上基于更底层的socket），不同于上层的webserver服务端（Service）需并行地支持多
lua发送消息到rabbitmq，我们选择类库lua-resty-rabbitmqstomp 来完成这个任务。类库安装：进入nginx.conf中 lua_package_path 中对应的目录下的resty目录（没有则创建）,执行:wget-chttps:/aw.githubusercontent.com/wingify/lua-resty-rabbitmqstomp/master/libes
1Lua介绍Lua是一门以其性能著称的脚本语言，被广泛应用在很多方面。Lua一般用于嵌入式应用，现在越来越多应用于游戏当中，魔兽世界,愤怒的小鸟都有用到。优势Lua极易嵌入到其他程序，可当做一种配置语言。提升应用性能，比如:游戏脚本，nginx，wireshark的脚本兼容性强，可以直接使用C
