Lua基础

1.注释：

单行：--

多行：--[[

]]--

2.标识符命名规则和C差不多，保留字是：_全大写字母（一般不用来命名标识符）

3.关键字：

and	break	do	else
elseif	end	false	for
function	if	in	local
nil	not	or	repeat
return	then	true	until
while

4.数据类型：

动态语言，不需类型，不赋值直接用则值为nil，可 val=nil来删除变量释放资源，数组从1开始算

数据类型	描述
nil	这个最简单，只有值nil属于该类，表示一个无效值（在条件表达式中相当于false）。
boolean	包含两个值：false和true。只有false和nil为假
number	表示双精度类型的实浮点数，只有double
string	字符串由一对双引号或单引号来表示，[[  ]]里面表示绝对字符串块
function	由 C 或 Lua 编写的函数
userdata	表示任意存储在变量中的C数据结构
thread	表示执行的独立线路，用于执行协同程序
table	Lua 中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字或者是字符串。在 Lua 里，table 的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。

#前缀为获得长度

5.变量

Lua 变量有三种类型：全局变量、局部变量、表中的域。

函数外的变量默认为全局变量，除非用 local 显示声明。函数内变量与函数的参数默认为局部变量。

局部变量的作用域为从声明位置开始到所在语句块结束（或者是直到下一个同名局部变量的声明）。

变量的默认值均为 nil

尽量用local（访问快，避免命名冲突）

支持多值赋值（a,b=b,a）

a. 变量个数 > 值的个数 按变量个数补足nil

b. 变量个数 < 值的个数 多余的值会被忽略

6.循环

while、repeat-until、数值for、泛型for

7.函数

   可变参数，local arg={...}

8.运算符

优先级：

^
not    - (unary)
*      /
+      -
..
<      >      <=     >=     ~=     ==
and
or

除了^和..外所有的二元运算符都是左连接的。

9.字符串

序号	方法 & 用途
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	.. 链接两个字符串

10.table 相当于C++的map映射数组

序号	方法 & 用途
1	table.concat (table [, step [, start [, end]]]): concat是concatenate(连锁, 连接)的缩写. table.concat()函数列出参数中指定table的数组部分从start位置到end位置的所有元素, 元素间以指定的分隔符(sep)隔开。
2	table.insert (table, [pos,] value): 在table的数组部分指定位置(pos)插入值为value的一个元素. pos参数可选, 默认为数组部分末尾.
3	table.maxn (table) 指定table中所有正数key值中最大的key值. 如果不存在key值为正数的元素, 则返回0。(Lua5.2之后该方法已经不存在了)
4	table.remove (table [, pos]) 返回table数组部分位于pos位置的元素. 其后的元素会被前移. pos参数可选, 默认为table长度, 即从最后一个元素删起。
5	table.sort (table [, comp]) 对给定的table进行升序排序。

11.模板与包

直接看例子：

-- 文件名为 module.lua

-- 定义一个名为 module 的模块

module = {} -- 定义一个常量

module.constant = "这是一个常量" -- 定义一个函数

function module.func1()

io.write("这是一个公有函数！\n")

end

local function func2()

print("这是一个私有函数！")

end

function module.func3()

func2()

end

return module

然后在其他的lua代码文件中使用require来加载模块，两种方法。

require("module");--然后可以直接使用module.func3(),但是不可以module.func2()

local tempFun=require("module");--可以使用tempFun.fun3()

加载机制

对于自定义的模块，模块文件不是放在哪个文件目录都行，函数 require 有它自己的文件路径加载策略，它会尝试从 Lua 文件或 C 程序库中加载模块。

require 用于搜索 Lua 文件的路径是存放在全局变量 package.path 中，当 Lua 启动后，会以环境变量 LUA_PATH 的值来初始这个环境变量。如果没有找到该环境变量，则使用一个编译时定义的默认路径来初始化。

当然，如果没有 LUA_PATH 这个环境变量，也可以自定义设置，在当前用户根目录下打开 .profile 文件（没有则创建，打开 .bashrc 文件也可以），例如把 "~/lua/" 路径加入 LUA_PATH 环境变量里：

#LUA_PATH
export LUA_PATH="~/lua/?.lua;;"

文件路径以 ";" 号分隔，最后的 2 个 ";;" 表示新加的路径后面加上原来的默认路径。

接着，更新环境变量参数，使之立即生效。

source ~/.profile

C 包

Lua和C是很容易结合的，使用C为Lua写包。

与Lua中写包不同，C包在使用以前必须首先加载并连接，在大多数系统中最容易的实现方式是通过动态连接库机制。

Lua在一个叫loadlib的函数内提供了所有的动态连接的功能。这个函数有两个参数:库的绝对路径和初始化函数。所以典型的调用的例子如下:

local path = "/usr/local/lua/lib/libluasocket.so"
local f = loadlib(path, "luaopen_socket")
f() --正在打开库

loadlib函数加载指定的库并且连接到Lua，然而它并不打开库（也就是说没有调用初始化函数）

12.Lua元表

每一个元表对应于一种操作（元方法），可以给一个表设置元表。

• setmetatable(table,metatable): 对指定table设置元表(metatable)，如果元表(metatable)中存在__metatable键值，setmetatable会失败 。返回操作后的table
• getmetatable(table): 返回对象的元表(metatable)。

eg： mytable = setmetatable({},{})

getmetatable(mytable)

__index 元方法

这是 metatable 最常用的键。

当你通过键（val.key）来访问 table 的时候，如果这个键没有值，那么Lua就会寻找该table的metatable（假定有metatable）中的__index 键。

如果__index包含一个表格，Lua会在表格中查找相应的键。

如果__index包含一个函数的话，Lua就会调用那个函数，table和键会作为参数传递给函数。

__newindex 元方法

__newindex 元方法用来对表更新。

当你给表的一个缺少的索引赋值，解释器就会查找__newindex 元方法：如果存在则调用这个函数而不进行赋值操作。

如果__index包含一个表格，使用一个不存在的key访问或给原方法所代表的表添加键值而原表不添加

如果__index包含一个函数的话，会调用元方法，而不进行赋值。而且传入：table，键，值。ps:rawset(table,键，值)为给表更新值。

为表添加操作符

模式	描述
__add	对应的运算符 '+'.
__sub	对应的运算符 '-'.
__mul	对应的运算符 '*'.
__div	对应的运算符 '/'.
__mod	对应的运算符 '%'.
__unm	对应的运算符 '-'.
__concat	对应的运算符 '..'.
__eq	对应的运算符 '=='.
__lt	对应的运算符 '<'.
__le	对应的运算符 '<='.

eg：两表相加，会调用_add函数，并且传入mytable和newtable（两个操作数）

__call 元方法

调用一个参数时（可以是另一个表），table（newtable）会调用_call函数，传入table和newtable

__tostring 元方法

__tostring 元方法用于修改表的输出行为。__tostring = function(mytable)

print（table）时会调用_tostring方法

13.Lua协同程序

什么是协同(coroutine)？

Lua 协同程序(coroutine)与线程比较类似：拥有独立的堆栈，独立的局部变量，独立的指令指针，同时又与其它协同程序共享全局变量和其它大部分东西。

线程和协同程序区别

线程与协同程序的主要区别在于，一个具有多个线程的程序可以同时运行几个线程，而协同程序却需要彼此协作的运行。

在任一指定时刻只有一个协同程序在运行，并且这个正在运行的协同程序只有在明确的被要求挂起的时候才会被挂起。

协同程序有点类似同步的多线程，在等待同一个线程锁的几个线程有点类似协同。

基本语法

方法	描述
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的线程号

co = coroutine.create(

function(i)

print(i);

end

)

coroutine.resume(co, 1) -- 1

print(coroutine.status(co)) -- dead

co = coroutine.wrap(

function(i)

print(i);

end

)

co(1)

14.文件IO

• 简单模式（simple model）拥有一个当前输入文件和一个当前输出文件，并且提供针对这些文件相关的操作。
• 完全模式（complete model） 使用外部的文件句柄来实现。它以一种面对对象的形式，将所有的文件操作定义为文件句柄的方法

file = io.open (filename [, mode])

mode 的值有：

模式	描述
r	以只读方式打开文件，该文件必须存在。
w	打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失。若文件不存在则建立该文件。
a	以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。（EOF符保留）
r+	以可读写方式打开文件，该文件必须存在。
w+	打开可读写文件，若文件存在则文件长度清为零，即该文件内容会消失。若文件不存在则建立该文件。
a+	与a类似，但此文件可读可写
b	二进制模式，如果文件是二进制文件，可以加上b
+	号表示对文件既可以读也可以写

eg：

简单模式

-- 以附加的方式打开只写文件

file = io.open("test.lua", "a")-- 设置默认输出文件为

test.luaio.output(file)-- 在文件最后一行添加 Lua 注释

io.write("-- test.lua 文件末尾注释")-- 关闭打开的文件

io.close(file)

在以上实例中我们使用了 io."x" 方法，其中 io.read() 中我们没有带参数，参数可以是下表中的一个：

模式	描述
"*n"	读取一个数字并返回它。例：file.read("*n")
"*a"	从当前位置读取整个文件。例：file.read("*a")
"*l"（默认）	读取下一行，在文件尾 (EOF) 处返回 nil。例：file.read("*l")
number	返回一个指定字符个数的字符串，或在 EOF 时返回 nil。例：file.read(5)

其他的 io 方法有：

• io.tmpfile():返回一个临时文件句柄，该文件以更新模式打开，程序结束时自动删除

• io.type(file): 检测obj是否一个可用的文件句柄

• io.flush(): 向文件写入缓冲中的所有数据

• io.lines(optional file name): 返回一个迭代函数,每次调用将获得文件中的一行内容,当到文件尾时，将返回nil,但不关闭文件

完全模式：通常我们需要在同一时间处理多个文件。我们需要使用 file:function_name 来代替 io.function_name 方法。

-- 以只读方式打开文件

file = io.open("test.lua", "r")-- 输出文件第一行

print(file:read())-- 关闭打开的文件

file:close()

read 的参数与简单模式一致。

其他方法:

• file:seek(optional whence, optional offset): 设置和获取当前文件位置,成功则返回最终的文件位置(按字节),失败则返回nil加错误信息。参数 whence 值可以是:

  • "set": 从文件头开始
  • "cur": 从当前位置开始[默认]
  • "end": 从文件尾开始
  • offset:默认为0
  不带参数file:seek()则返回当前位置,file:seek("set")则定位到文件头,file:seek("end")则定位到文件尾并返回文件大小

• file:flush(): 向文件写入缓冲中的所有数据

• io.lines(optional file name): 打开指定的文件filename为读模式并返回一个迭代函数,每次调用将获得文件中的一行内容,当到文件尾时，将返回nil,并自动关闭文件。
  若不带参数时io.lines() io.input(); 读取默认输入设备的内容，但结束时不关闭文件

15.错误处理

任何程序语言中，都需要错误处理。错误类型有：

• 语法错误:语法错误通常是由于对程序的组件（如运算符、表达式）使用不当引起的。
• 运行错误：运行错误是程序可以正常执行，但是会输出报错信息。

assert(type(a) == "number", "a 不是一个数字") --第一个参数为false才把第二个参数作为内容抛出

error (message [, level])

功能：终止正在执行的函数，并返回message的内容作为错误信息(error函数永远都不会返回)

通常情况下，error会附加一些错误位置的信息到message头部。

Level参数指示获得错误的位置:

• Level=1[默认]：为调用error位置(文件+行号)
• Level=2：指出哪个调用error的函数的函数
• Level=0:不添加错误位置信息

pcall(function_name, ….) 参数是函数以及它的参数，无错误返回true，有错误则false

xpcall接收第二个参数——一个错误处理函数：

• debug.debug：提供一个Lua提示符，让用户来检查错误的原因
• debug.traceback：根据调用桟来构建一个扩展的错误消息

也可以自定义错误处理函数：

eg：

function myerrorhandler( err )

print( "ERROR:", err )

end

status = xpcall( myfunction, myerrorhandler )

print( status)

16.调试

17.垃圾回收

Lua 采用了自动内存管理。 这意味着你不用操心新创建的对象需要的内存如何分配出来， 也不用考虑在对象不再被使用后怎样释放它们所占用的内存。

Lua 运行了一个垃圾收集器来收集所有死对象 （即在 Lua 中不可能再访问到的对象）来完成自动内存管理的工作。 Lua 中所有用到的内存，如：字符串、表、用户数据、函数、线程、 内部结构等，都服从自动管理。

• collectgarbage("collect"): 做一次完整的垃圾收集循环。通过参数 opt 它提供了一组不同的功能：

• collectgarbage("count"): 以 K 字节数为单位返回 Lua 使用的总内存数。 这个值有小数部分，所以只需要乘上 1024 就能得到 Lua 使用的准确字节数（除非溢出）。

• collectgarbage("restart"): 重启垃圾收集器的自动运行。

• collectgarbage("setpause"): 将 arg 设为收集器的 间歇率 。 返回 间歇率 的前一个值。

• collectgarbage("setstepmul"): 返回 步进倍率 的前一个值。

• collectgarbage("step"): 单步运行垃圾收集器。 步长"大小"由 arg 控制。 传入 0 时，收集器步进（不可分割的）一步。 传入非 0 值， 收集器收集相当于 Lua 分配这些多（K 字节）内存的工作。 如果收集器结束一个循环将返回 true 。

• collectgarbage("stop"): 停止垃圾收集器的运行。 在调用重启前，收集器只会因显式的调用运行。

18.面向对象

对象由属性和方法组成。LUA中最基本的结构是table，所以需要用table来描述对象的属性。

lua中的function可以用来表示方法。那么LUA中的类可以通过table + function模拟出来。

至于继承，可以通过metetable模拟出来（不推荐用，只模拟最基本的对象大部分时间够用了）。

Account = {balance = 0}

function Account.withdraw (v)

Account.balance = Account.balance - v

end

派生类

-- Meta class

Rectangle = {area = 0, length = 0, breadth = 0}

-- 派生类的方法 new

function Rectangle:new (o,length,breadth)

o = o or {}

setmetatable(o, self)

self.__index = self

self.length = length or 0

self.breadth = breadth or 0

self.area = length*breadth;

return o

end

-- 派生类的方法 printArea

function Rectangle:printArea ()

print("矩形面积为 ",self.area)

end

19.数据库访问

支持数据库：LuaSQL，ODBC, ADO, Oracle, MySQL, SQLite 和 PostgreSQL。