lua的总结

1、打印

print(“hello,world”)

2、注释

– 或者 --[[“aaa”]]

3、变量

a=5 全局变量
local b=1 局部变量
想删除一个全局变量，只需要将变量赋值为nil。
本地变量，能够及时地垃圾回收 在另外的一个main.lua里面读取不了 尽量使用本地变量，全局变量会一直占用内存，而且查错会比较麻烦

4、格式

c=2 print(a);–对于lua来说，其实用个空格就能够实现下一条语句了，
但是可读性非常差，一般都是换行的，分号自动换行

5、数据类型

Lua是动态类型语言，变量不要类型定义,只需要为变量赋值。 值可以存储在变量中，作为参数传递或结果返回。
Lua中有8个基本类型分别为：nil、boolean、number、string、userdata、function、thread和table。
（1）nil这个最简单，只有值nil属于该类，表示一个无效值（在条件表达式中相当于false）。
（2）boolean 包含两个值：false和true。
（3）number 表示双精度类型的实浮点数
（4）string字符串由一对双引号或单引号来表示
（5）function 由 C 或 Lua 编写的函数
（6）userdata表示任意存储在变量中的C数据结构
（7）thread表示执行的独立线路，用于执行协同程序
（8）table Lua 中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字或者是字符串。在 Lua 里，table 的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。
type代表数据类型，print(type(“hello”))

nil: nil 类型表示一种没有任何有效值，它只有一个值 – nil，例如打印一个没有赋值的变量，便会输出一个 nil 值
对于全局变量和 table，nil 还有一个"删除"作用，给全局变量或者 table 表里的变量赋一个 nil 值，等同于把它们删掉;
nil 作比较时应该加上双引号 " "

boolean: boolean 类型只有两个可选值：true（真） 和 false（假），Lua 把 false 和 nil 看作是"假"，其他的都为"真":

number: Lua 默认只有一种 number 类型 – double（双精度）类型

6、string的相关

在对一个数字字符串上进行算术操作时，Lua 会尝试将这个数字字符串转成一个数字:
string1=“4”
print(string1+5) >>> 9
字符串连接使用的是 … 而不是使用+
string1=“hello”
print(string1…" world")>>>>> hello world

使用 # 来计算字符串的长度，放在字符串前面
string1=“hello”
print(#string1)>>>>>>>>>>>>>5

Lua 语言中字符串可以使用以下三种方式来表示：
• 单引号间的一串字符。
• 双引号间的一串字符。
• [[和]]间的一串字符。

Lua的字符串有很多内置函数
序号 方法 & 用途
1 string.upper(argument):
字符串全部转为大写字母。
2 string.lower(argument):
字符串全部转为小写字母。
3 string.gsub(mainString,findString,replaceString,num)
在字符串中替换,mainString为要替换的字符串， findString 为被替换的字符，replaceString 要替换的字符，
num 替换次数（可以忽略，则全部替换），如：

string.gsub(“aaaa”,“a”,“z”,3);
zzza 3
4 string.find (str, substr, [init, [end]])
在一个指定的目标字符串中搜索指定的内容(第三个参数为索引),返回其具体位置。不存在则返回 nil。
string.find(“Hello Lua user”, “Lua”, 1)
7 9
5 string.reverse(arg)
字符串反转
string.reverse(“Lua”)
auL
6 string.format(…)
返回一个类似printf的格式化字符串
string.format(“the value is:%d”,4)
the value is:4
7 string.char(arg) 和 string.byte(arg[,int])
char 将整型数字转成字符并连接， byte 转换字符为整数值(可以指定某个字符，默认第一个字符)。
string.char(97,98,99,100)
abcd
string.byte(“ABCD”,4)
68
string.byte(“ABCD”)
65

8 string.len(arg)
计算字符串长度。
string.len(“abc”)
3
9 string.rep(string, n)
返回字符串string的n个拷贝

string.rep(“abcd”,2)
abcdabcd
10 …
链接两个字符串
print(“www.runoob.”…“com”)
www.runoob.com
11 string.gmatch(str, pattern)
回一个迭代器函数，每一次调用这个函数，返回一个在字符串 str 找到的下一个符合 pattern 描述的子串。
如果参数 pattern 描述的字符串没有找到，迭代函数返回nil。
for word in string.gmatch(“Hello Lua user”, “%a+”) do print(word) end
Hello
Lua
user
12 string.match(str, pattern, init)
string.match()只寻找源字串str中的第一个配对. 参数init可选, 指定搜寻过程的起点, 默认为1。
在成功配对时, 函数将返回配对表达式中的所有捕获结果; 如果没有设置捕获标记, 则返回整个配对字符串.
当没有成功的配对时, 返回nil。
= string.match(“I have 2 questions for you.”, “%d+ %a+”)
2 questions

= string.format("%d, %q", string.match(“I have 2 questions for you.”, “(%d+) (%a+)”))
2, “questions”
字符串的长度 string.len
字符串的子串 string.sub(str,3,6)
字符串的查找 local b,c =string.find(str，”head”)
字符串的替换 string.gsub(str,”head”,”end”)

7、表

在 Lua 里，table 的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。也可以在表里添加一些数据，直接初始化表
table1={“aaa”,“bbb”}
print(#table1)>>>>>>>>>>2

table1={“aaa”,“bbb”}
print(table1[2])>>>>>>>>>>>>>>bbb

Lua 中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字或者是字符串
table1={“aaa”,“bbb”,3,6}
table1[6]=“qqq”
print(table1[6])>>>>>>>>>>>qqq

不同于其他语言的数组把 0 作为数组的初始索引，在 Lua 里表的默认初始索引一般以 1 开始
table 不会固定长度大小，有新数据添加时 table 长度会自动增长，没初始的 table 都是 nil。
表的一些函数
（1）table.getn(a);–表的大小
（2）table.insert(a,3,“000”);表的插入 第一是表名，第二个是键位，就是插入第几位，第三是值。注意，插入后的中间不能为空，就是表有三元素，插在第五位是不发生的。
（3）table.remove()函数。从数组中删除元素 table.remove(数组名，键)
table.remove(数组名) 默认删除最后一个元素
（4）table.sort()函数
table.sort(数组，排序规则） 强大的排序函数
表有几种构造方法‘
（1）
– 使用花括号来创建一个空表, 然后赋值
mytab = {}
mytab[‘x’] = 12
mytab[2] = ‘hello’
（2）
– 创建表的时候, 同时初始化表数据
– 表中存储键值对数据, 格式如: [key] = value, 键和值可以是多种类型
mytab = {
[‘x’] = 12,
[2] = ‘hello’
}
（3）
– 同第二种方式, 不过非数字类型的键可以省略中括号, 数字类型不能省略
mytab = {
x = 12,
[2] = ‘hello’
}

表的遍历
– 先构造一个表
mytab = {
11, 12, 13,
a = ‘A’,
b = ‘B’,
c = ‘C’
}

– 以下是最常用的两种遍历方式
– 全表遍历
– 这种遍历方式是按照 table中 key的 hash值排列顺序来遍历的,
– 并非是 table中 key的定义顺序, 并且不关心 key是否从1开始和 key是否以1递增
for k, v in pairs(tab) do
print(k, v)
end

– [[
output:
1 11
2 12
3 13
c C
b B
a A
]]

– 仅遍历表中的数组部分

– 按照 key的大小顺序来遍历 (注意不是 key定义的顺序)
– 因为表中非数字键的键值对是使用 hash表存储的, 这样的数据是无序的, 所以无法遍历
for k, v in ipairs(mytab) do
print(k, v)
end
–[[
output:
1 11
2 12
3 13
]]

8、函数

示例：
function Myfunc(pa)
print(pa);
end

Myfunc(12);
Myfunc(“haha”);

lua的函数允许返回多个返回值，返回值用逗号隔开
function Myfunc(pa)
print(pa);
return 1,2,3
end

print(Myfunc(12));
print(Myfunc(“haha”));

9、循环

Lua提供了四种循环方式
（1）while循环
（2）for循环
（3）repeat…until循环
（4）循环嵌套
还支持控制语句break
[1]、while 循环
语法：while(condition)
do
statements
end
[2]、for循环
• 数值for循环
• 泛型for循环
数值for循环
–在使用for循环时，需要注意 （1）循环次数只在第一次执行时确定，用户更改了参数值也不会影响最终的循环洗漱
–（2）循环结构为局部变量，一旦循环结束就会被清除
语法：for var=exp1,exp2,exp3 do
<执行体>
end
var 从 exp1 变化到 exp2，每次变化以 exp3 为步长递增 var，并执行一次 “执行体”。exp3 是可选的，如果不指定，默认为1。
例子：for va=1,10,1 do
print(va)
end >>>>>遍历1到了10

泛型for循环
例子：
a = {“one”, “two”, “three”}
for i, v in ipairs(a) do
print(i, v) >>>
1 one
2 two
3 three

[3]、repeat…until循环
repeat
循环体 --先执行代码段在进行条件判断
until 循环条件
[4]

10、运算符

Lua 语言中的常用算术运算符，设定 A 的值为10，B 的值为 20：
操作符 描述 实例

• 加法 A + B 输出结果 30

• 减法 A - B 输出结果 -10

• 乘法 A * B 输出结果 200
  / 除法 B / A 输出结果 2
  % 取余 B % A 输出结果 0
  ^ 乘幂 A^2 输出结果 100

• 负号 -A 输出结果v -10
  — Lua 语言中的常用关系运算符，设定 A 的值为10，B 的值为 20：
  作符 描述 实例
  == 等于，检测两个值是否相等，相等返回 true，否则返回 false (A == B) 为 false。
  ~= 不等于，检测两个值是否相等，相等返回 false，否则返回 true (A ~= B) 为 true。

大于，如果左边的值大于右边的值，返回 true，否则返回 false (A > B) 为 false。
< 小于，如果左边的值大于右边的值，返回 false，否则返回 true (A < B) 为 true。
= 大于等于，如果左边的值大于等于右边的值，返回 true，否则返回 false (A >= B) 返回 false。
<= 小于等于， 如果左边的值小于等于右边的值，返回 true，否则返回 false (A <= B) 返回 true。–

---

逻辑运算符
下表列出了 Lua 语言中的常用逻辑运算符，设定 A 的值为 true，B 的值为 false：
操作符 描述 实例
and 逻辑与操作符。 若 A 为 false，则返回 A，否则返回 B。 (A and B) 为 false。
or 逻辑或操作符。 若 A 为 true，则返回 A，否则返回 B。 (A or B) 为 true。
not 逻辑非操作符。与逻辑运算结果相反，如果条件为 true，逻辑非为 false。 not(A and B) 为 true。

其他运算符
下表列出了 Lua 语言中的连接运算符与计算表或字符串长度的运算符：
操作符 描述 实例
… 连接两个字符串 a…b ，其中 a 为 "Hello " ， b 为 “World”, 输出结果为 “Hello World”。

一元运算符，返回字符串或表的长度。 #“Hello” 返回 5

11、数组

一维数组是最简单的数组，其逻辑结构是线性表。一维数组可以用for循环出数组中的元素，如下实例：
array = {“Lua”, “Tutorial”}

for i= 0, 2 do
print(array[i])
end

Lua 索引值是以 1 为起始，但你也可以指定 0 开始。
除此外我们还可以以负数为数组索引值：
实例
array = {}
for i= -2, 2 do
array[i] = i *2
end
for i = -2,2 do
print(array[i])
end

12、在lua载入其他lua文件

dofile(“1.lua”);
1.功能：载入文件并执行代码块，对于相同的文件每次都会执行
2.调用：dofile(“filename”)
3.错误处理：如果代码块中有错误则会引发错误
4.优点：对简单任务而言，非常便捷
5.缺点：每次载入文件时都会执行程序块
6.定位：内置操作，辅助函数

13、关于C++内嵌lua文件的写法

extern “C” {
#include “lua.h”
#include “lualib.h”
#include “lauxlib.h”
}//表示这部分的函数都是用C语言定义的
#include <windows.h>
using namespace std;
int main()
{
lua_Statel = luaL_newstate();//lua_State提供了执行lua代码的环境
/Lua脚本的编译执行是相互独立的，在不同的线程上执行。通过luaL_newstate()函数可以申请一个虚拟机，
返回指针类型 lua_State。今后其他所有Lua Api函数的调用都需要此指针作为第一参数，用来指定某个虚拟机/
luaL_openlibs(l);//luaopen_base(l);也可以，是载入基本文件的意思
luaL_dofile(l, “demo1.lua”); / 执行脚本 */
lua_close(l);
system(“pause”); //为了保证在windows资源管理器中打开main.exe不闪退。需要windows.h
return 0;
}
//如果luaL_dofile()函数返回值为0就是调用成功。

14、一些数学函数

math.abs(-12)—取绝对值
math.max(1,-12,55,232,12121,66);–取最大值，参数似乎无限
math.min
随机数的产生
for i=0, 10 do
local n = math.random(10)
print(n)
end
math.modf()–把数分为整数和小数
math.pow()–得到x的y次方
math.ceil()–不小于x的最大整数

15、Lua操作系统工具

os.clock()–返回程序使用的CPU时间(以秒为单位)的近似值
os.date([format[, time]])-- 返回包含日期和时间的字符串或表，根据给定的字符串格式进行格式化。
例子：io.write(“The date is “, os.date(”%m/%d/%Y”),"\n")
os.execute([command])-- 此功能相当于ANSI C功能系统。 它传递要由操作系统shell执行的命令。 如果命令成功终止，则第一个结果为true，否则为nil。
os.getenv(varname)-- 返回进程环境变量varname的值，如果未定义变量，则返回nil。
os.tmpname()–返回一个文件名，该文件名可用于临时文件。 文件必须在使用前显式打开，并在不再需要时显式删除。

16、lua的io

Lua I/O 库用于读取和处理文件。分为简单模式（和C一样）、完全模式。
简单模式（simple model）拥有一个当前输入文件和一个当前输出文件，并且提供针对这些文件相关的操作。
完全模式（complete model） 使用外部的文件句柄来实现。它以一种面对对象的形式，将所有的文件操作定义为文件句柄的方法
简单模式在做一些简单的文件操作时较为合适。但是在进行一些高级的文件操作的时候，简单模式就显得力不从心。例如同时读取多个文件这样的操作，使用完全模式则较为合适。

打开文件操作语句如下：
file = io.open (filename [, mode])
mode 的值有：
模式 描述
r 以只读方式打开文件，该文件必须存在。
w 打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失。若文件不存在则建立该文件。
a 以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。（EOF符保留）
r+ 以可读写方式打开文件，该文件必须存在。
w+ 打开可读写文件，若文件存在则文件长度清为零，即该文件内容会消失。若文件不存在则建立该文件。
a+ 与a类似，但此文件可读可写
b 二进制模式，如果文件是二进制文件，可以加上b

• 号表示对文件既可以读也可以写

17、错误处理

local function add(a,b)
assert(type(a) == “number”, “a 不是一个数字”)
assert(type(b) == “number”, “b 不是一个数字”)
return a+b
end
add(10)

就是相当于写了个if那样，如果b不是number类型就打印后面的字符串来抛出异常
错误处理函数
error函数是让程序停止，进行错误处理

print(“开始”);
error(“发生错误”)
print(“结束”)

pcall()函数：如果程序发生错误，不想让程序停止
pcall 有两个返回值
1 ： 是否正确
2 ： 错误原因

function test()
print(“a”)
print(a[1]) – 错误，将原因打印
end

local b , r = pcall(test)
print(b) --false
print® – attempt to index global ‘a’ (a nil value) a[1] 是nil值无法打印

xpcall 和debug
function traceback( msg )
print("----------------------------------------")
print(“LUA ERROR: " … tostring(msg) … “\n”)
print(debug.traceback())
print(”----------------------------------------")
end
local function main()
– …
print(“hello”)
v=1+nil
end
xpcall(main, traceback)
//就是说xpcall接受两个参数，第二个参数是个错误处理函数，当错误发生时，Lua会在调用桟展看（unwind）前调用错误处理函数，于是就可以在这个函数中使用debug库来获取关于错误的额外信息了。

debug库提供了两个通用的错误处理函数:
debug.debug：提供一个Lua提示符，让用户来价差错误的原因
debug.traceback：根据调用桟来构建一个扩展的错误消息

18、垃圾回收

Lua的垃圾回收是自动进行的，但是我们可以collectgarbage方法进行手动回收。collectgarbage方法的第一个参数是字符串，代表操作类型，第二个参数只有某些操作类型有，是该操作所需要的参数。常用的操作类型有：
collect：执行一次完整的垃圾回收
count：返回当前使用的内存，单位是kb

mytable = {“apple”, “orange”, “banana”}
print(collectgarbage(“count”))
mytable = nil
print(collectgarbage(“count”))
print(collectgarbage(“collect”))
print(collectgarbage(“count”))

//注意：就是全局变量变成nil就会

19、协同程序

coroutine就是lua的协同程序

一个协同程序可以处于四种不同的状态：
• 挂起(suspended)
• 运行(running)
• 死亡(dead)
• 正常(normal)

coroutine.create()
创建coroutine，返回coroutine， 参数是一个函数，当和resume配合使用的时候就唤醒函数调用
coroutine.resume()
重启coroutine，和create配合使用
coroutine.yield()
挂起coroutine，将coroutine设置为挂起状态，这个和resume配合使用能有很多有用的效果
coroutine.status()
查看coroutine的状态
注：coroutine的状态有三种：dead，suspend，running，具体什么时候有这样的状态请参考下面的程序
coroutine.wrap（）
创建coroutine，返回一个函数，一旦你调用这个函数，就进入coroutine，和create功能重复
coroutine.running()
返回正在跑的coroutine，一个coroutine就是一个线程，当使用running的时候，就是返回一个corouting的线程号

Lua将所有关于协同程序的函数放置在一个名为"coroutine"的table中。 函数create用于创建新的协同程序， 它只有一个参数，就是一个函数。该函数代码就是协同程序所需执行的内容。 create会返回一个thread类型的值， 用以表示新的协同程序。 通常create的参数是一个匿名函数。
co = coroutine .create(function () print(“hi”) end)
print( co )// >>>>>>>>>>>>>>>>thread: 0045A320

当创建一个协同程序的时，它处于挂起状态。 也就是说协同程序不会在创建它时，自动执行其内容
可以通过status来检查协同程序的状态
print(coroutine.status(co)) --> suspended
函数coroutine.resume用于启动或再次启动一个协同程序的执行，并将其状态改为运行：
coroutine.resume(co) --> hi
在本例中，协同程序内容只是简单地打印了"hi"后便终止了， 然后它就处于死亡状态。也就再也无法返回。
print(coroutine.status(co)) -->dead

20、模块和包

模块类似于弄个带有类的头文件一样。
module={}

module.constant=“知识”;
function module.func1()
io.write(“公有函数”)
end
local function fun2()
print(“私有函数”)
end
function module.func3()
fun2();
end
return module

–
然后再主文件写
test_module.lua 文件
– test_module.lua 文件
– module 模块为上文提到到 module.lua
require(“module”)
print(module.constant)
module.func3()

或者弄个别名也可以的
local m = require(“module”)
print(m.constant)
m.func3()

Lua和C是很容易结合的，使用 C 为 Lua 写包。
与Lua中写包不同，C包在使用以前必须首先加载并连接，在大多数系统中最容易的实现方式是通过动态连接库机制。
Lua在一个叫loadlib的函数内提供了所有的动态连接的功能。这个函数有两个参数:库的绝对路径和初始化函数。所以典型的调用的例子如下:
local path = “/usr/local/lua/lib/libluasocket.so”
local f = loadlib(path, “luaopen_socket”)
loadlib 函数加载指定的库并且连接到 Lua，然而它并不打开库（也就是说没有调用初始化函数），反之他返回初始化函数作为 Lua 的一个函数，这样我们就可以直接在Lua中调用他。
如果加载动态库或者查找初始化函数时出错，loadlib 将返回 nil 和错误信息。我们可以修改前面一段代码，使其检测错误然后调用初始化函数：
local path = “/usr/local/lua/lib/libluasocket.so”
– 或者 path = “C:\windows\luasocket.dll”，这是 Window 平台下
local f = assert(loadlib(path, “luaopen_socket”))
f() – 真正打开库

21、多线程

lua原生没有多线程

22、C++/lua相互调用

lua调用C++无参函数
首先先在C++文件写一个想要调用的函数

注意第一个参数是lua的指针，就是形参

然后再在main函数里面注册

第一个是lua指针，第二个是传递在lua里面显示的名字，第三个是在cpp文件里面显示的名字

在lua里面直接调用第二个名字就可以了

lua里面会把传进去的参数传到lua堆栈的栈底
Ctext(“haha”,123)—第一个字符串放在栈底，也就是为1的地方，123放在为2的地方。
在C++里面就用几个函数调出来就行了

tolstring必须要三个参数，所以要传一个size_t类型的

之后的上面布尔类型就差不多那类型的函数弄出来就行了

获取数组的写法

23、迭代器

就是泛型 for 迭代器
t={11,12,13,14,15,16,17,18,19}
for V,A in pairs(t) do
print(V,A);
end

pairs可以遍历表中所有的key，并且除了迭代器本身以及遍历表本身还可以返回nil;
ipairs是只能遍历到表中第一个缺失的整数

local tabFiles = {
[1] = “test2”,
[6] = “test3”,
[4] = “test1”
}
for k, v in ipairs(tabFiles) do
print(k, v)
end
–将ipairs改成无i的，和数组第一个是否为1都互改试试就知道了
有i的，就是遍历到1发现没2就不遍历了，没i的，无规则的全部遍历

24、lua堆栈

lua的堆栈一开始是为空的，如果硬要提一个数字出来，就会提出0
在C++里面往lua堆栈push元素
lua_pushnumber(lua, 221);
都是类似的函数

lua_isstring(L,1)还有这种函数用来判断是声明类型
int lua_gettop (lua_State *L); //返回栈顶索引（即栈长度）
void lua_settop (lua_State *L, int idx);
// void lua_pushvalue (lua_State *L, int idx);
//将idx索引上的值的副本压入栈顶
void lua_remove (lua_State *L, int idx);
//移除idx索引上的值
void lua_insert (lua_State *L, int idx);
//弹出栈顶元素，并插入索引idx位置
void lua_replace (lua_State *L, int idx);
//弹出栈顶元素，并替换索引idx位置的值
lua_settop将栈顶设置为一个指定的位置，即修改栈中元素的数量。如果值比原栈顶高，则高的部分nil补足，如果值比原栈低，则原栈高出的部分舍弃。所以可以用lua_settop(0)来清空栈。