Nil：
Lua中特殊的类型，他只有一个值：nil；一个全局变量没有被赋值以前默认值为nil；给全局变量赋值nil可以删除该变量。
Booleans：
两个取值false和true。但要注意Lua中所有的值都可以作为条件。在控制结构的条件中除了false和nil为假，其他值都为真。所以Lua认为0和空串都是真。
Number：
Lua中没有整数。
Strings：
Lua可以高效的处理长字符串，1M的string在Lua中是很常见的。可以使用单引号或者双引号表示字符串
Lua中的转义序列：
\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 -- 右中括号
string和numbers的转换：
Lua会自动在string和numbers之间自动进行类型转换，当一个字符串使用算术操作符时，string就会被转成数字。
如果需要显式将string转成数字可以使用函数tonumber()，如果string不是正确的数字该函数将返回nil。反之，可以调用tostring()将数字转成字符串
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(tostring(10) == "10") --> true
print(10 .. "" == "10") --> true
连接运算符：
".."在Lua中是字符串连接符，当在一个数字后面写..时，必须加上空格以防止被解释错。字符串连接，如果操作数为数字，Lua将数字转成字符串。
print(10 .. 20) --> 1020
Functions：
函数是第一类值（和其他变量相同），意味着函数可以存储在变量中，可以作为函数的参数，也可以作为函数的返回值。
Userdata：
userdata可以将C数据存放在Lua变量中，userdata用来描述应用程序或者使用C实现的库创建的新类型。
关系运算符：
==和~=比较两个值，如果两个值类型不同，Lua认为两者不同；nil只和自己相等。Lua通过引用比较tables、userdata、functions。也就是说当且仅当两者表示同一个对象时相等。
逻辑运算符：
and or not逻辑运算符认为false和nil是假（false），其他为真，0也是true.
and和or的运算结果不是true和false，而是和它的两个操作数相关。
a and b -- 如果a为false，则返回a，否则返回b
a or b -- 如果a为true，则返回a，否则返回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为false或者nil则给x赋初始值v
x = x or v 等价于
if not x then
x = v
end and的优先级比or高。
C语言中的三元运算符：a ? b : c 在Lua中可以这样实现：(a and b) or c
not的结果一直返回false或者true
print(not nil) --> true
print(not false) --> true
print(not 0) --> false
print(not not nil) --> false
优先级：
从高到低的顺序：
^
not - (unary)
* /
+ -
..
< > <= >= ~= ==
and
or
表的构造：
在构造函数的最后的","是可选的，可以方便以后的扩展。
a = {[1]="red", [2]="green", [3]="blue",} 在构造函数中域分隔符逗号（","）可以用分号（";"）替代，通常我们使用分号用来分割不同类型的表元素。
{x=10, y=45; "one", "two", "three"} 如果真的想要数组下标从0开始：
days = {[0]="Sunday", "Monday", "Tuesday", "Wednesday",
"Thursday", "Friday", "Saturday"}
注意：不推荐数组下标从0开始，否则很多标准库不能使用。
赋值语句：
Lua可以对多个变量同时赋值，变量列表和值列表的各个元素用逗号分开，赋值语句右边的值会依次赋给左边的变量。
a, b = 10, 2*x <--> a=10; b=2*x 遇到赋值语句Lua会先计算右边所有的值然后再执行赋值操作，所以我们可以这样进行交换变量的值：
x, y = y, x -- swap 'x' for 'y'
a[i], a[j] = a[j], a[i] -- swap 'a[i]' for 'a[i]'
交换变量的赋值逻辑可以这么理解：创建两个变量存储等号右边的结果，在进行等号左边的赋值运算,这样就好理解了
当变量个数和值的个数不一致时，Lua会一直以变量个数为基础采取以下策略：
a. 变量个数>值的个数按变量个数补足nil
b. 变量个数<值的个数多余的值会被忽略
局部变量与代码块：
应该尽可能的使用局部变量，有两个好处：
1. 避免命名冲突
2. 访问局部变量的速度比全局变量更快.
控制结构语句：
if语句，有三种形式：
if conditions then
then-part
end;
if conditions then
then-part
else
else-part
end;
if conditions then
then-part
elseif conditions then
elseif-part
.. --->多个elseif
else
else-part
end; while语句：
while condition do
statements;
end; repeat-until语句：
repeat
statements;
until conditions; 范型for循环：
-- print all values of array 'a'
for i,v in ipairs(a) do print(v) end 遍历表key的例子：
-- print all keys of table 't'
for k in pairs(t) do print(k) end
break和return语句：
当一个函数自然结束结尾会有一个默认的return。
函数：
函数有两种用途：1.完成指定的任务，这种情况下函数作为调用语句使用；2.计算并返回值，这种情况下函数作为赋值语句的表达式使用。
function func_name (arguments-list)
statements-list;
end; 当函数只有一个参数并且这个参数是字符串或者表构造的时候，()是可选的：
print "Hello World" <--> print("Hello World")
dofile 'a.lua' <--> dofile ('a.lua')
print [[a multi-line <--> print([[a multi-line
message]] message]])
f{x=10, y=20} <--> f({x=10, y=20})
type{} <--> type({}) Lua也提供了面向对象方式调用函数的语法，比如o:foo(x)与o.foo(o, x)是等价的
可以使用圆括号强制使调用返回一个值。
（这里可能是匹配的作用）
function foo (i)
if i == 0 then return foo0()
elseif i == 1 then return foo1()
elseif i == 2 then return foo2()
end
end
print(foo(1)) --> a
print(foo(2)) --> a b
print(foo(0)) -- (no results)
print(foo(3)) -- (no results)
print((foo0())) --> nil
print((foo1())) --> a
print((foo2())) --> a 一个return语句如果使用圆括号将返回值括起来也将导致返回一个值。
unpack：
函数多值返回的特殊函数unpack，接受一个数组作为输入参数，返回数组的所有元素。unpack被用来实现范型调用机制，unpack返回a所有的元素作为f()的参数：
f = string.find
a = {"hello", "ll"}
print(f(unpack(a))) --> 3 4 预定义的unpack函数是用C语言实现的，我们也可以用Lua来完成：
function unpack(t, i)
i = i or 1
if t[i] then
return t[i], unpack(t, i + 1)
end
end
可变参数
Lua函数可以接受可变数目的参数，和C语言类似在函数参数列表中使用三点（...）表示函数有可变的参数。Lua将函数的参数放在一个叫arg的表中，除了参数以外，arg表中还有一个域n表示参数的个数。
例如，我们可以重写print函数：
printResult = ""
function print(...)
for i,v in ipairs(arg) do
printResult = printResult .. tostring(v) .. "\t"
end
printResult = printResult .. "\n"
end
再论函数
Lua中的函数是带有词法定界（lexical scoping）的第一类值（first-class values）。
第一类值指：在Lua中函数和其他值（数值、字符串）一样，函数可以被存放在变量中，也可以存放在表中，可以作为函数的参数，还可以作为函数的返回值。
词法定界指：
被嵌套的函数可以访问他外部函数中的变量。这一特性给Lua提供了强大的编程能力。
Lua中关于函数稍微难以理解的是函数也可以没有名字，匿名的。当我们提到函数名（比如print），实际上是说一个指向函数的变量，像持有其他类型值的变量一样：
a = {p = print}
a.p("Hello World") --> Hello World
print = math.sin -- `print' now refers to the sine function
a.p(print(1)) --> 0.841470
sin = a.p -- `sin' now refers to the print function
sin(10, 20) --> 10 20 既然函数是值，那么表达式也可以创建函数了
foo = function (x) return 2*x end
排序函数
例如：
network = {
{name = "grauna", IP = "210.26.30.34"},
{name = "arraial", IP = "210.26.30.23"},
{name = "lua", IP = "210.26.23.12"},
{name = "derain", IP = "210.26.23.20"},
} 如果我们想通过表的name域排序：
table.sort(network, function (a,b)
return (a.name > b.name)
end)
闭包
看下面的代码：
function newCounter()
local i = 0
return function() -- anonymous function
i = i + 1
return i
end
end
c1 = newCounter()
print(c1()) --> 1
print(c1()) --> 2 匿名函数使用upvalue i保存他的计数，当我们调用匿名函数的时候i已经超出了作用范围，因为创建i的函数newCounter已经返回了。然而Lua用闭包的思想正确处理了这种情况。简单的说闭包是一个函数加上它可以正确访问的upvalues。如果我们再次调用newCounter，将创建一个新的局部变量i，因此我们得到了一个作用在新的变量i上的新闭包。
c2 = newCounter()
print(c2()) --> 1
print(c1()) --> 3
print(c2()) --> 2
c1、c2是建立在同一个函数上，但作用在同一个局部变量的不同实例上的两个不同的闭包。
技术上来讲，闭包指值而不是指函数，函数仅仅是闭包的一个原型声明；尽管如此，在不会导致混淆的情况下我们继续使用术语函数代指闭包。
感觉闭包的意思就是把一个值存储到一个变量中，使用时会作为一个独立的变量存在，类似静态变量，每次调用就创建一个新的静态变量
非全局函数
1. 表和函数放在一起
Lib = {}
Lib.foo = function (x,y) return x + y end
Lib.goo = function (x,y) return x - y end 2. 使用表构造函数
Lib = {
foo = function (x,y) return x + y end,
goo = function (x,y) return x - y end
} 3. Lua提供另一种语法方式
Lib = {}
function Lib.foo (x,y)
return x + y
end
function Lib.goo (x,y)
return x - y
end 有一点需要注意的是在声明递归局部函数的方式：
local fact = function (n)
if n == 0 then
return 1
else
return n*fact(n-1) -- buggy
end
end 上面这种方式导致Lua编译时遇到fact(n-1)并不知道他是局部函数fact，Lua会去查找是否有这样的全局函数fact。为了解决这个问题我们必须在定义函数以前先声明：
local fact
fact = function (n)
if n == 0 then
return 1
else
return n*fact(n-1)
end
end
正确的尾调用
尾调用是一种类似在函数结尾的goto调用，当函数最后一个动作是调用另外一个函数时，我们称这种调用尾调用。例如：
function f(x)
return g(x)
end g的调用是尾调用。
例子中f调用g后不会再做任何事情，这种情况下当被调用函数g结束时程序不需要返回到调用者f；所以尾调用之后程序不需要在栈中保留关于调用者的任何信息。一些编译器比如Lua解释器利用这种特性在处理尾调用时不使用额外的栈，我们称这种语言支持正确的尾调用。
由于尾调用不需要使用栈空间，那么尾调用递归的层次可以无限制的。例如下面调用不论n为何值不会导致栈溢出。
function foo (n)
if n > 0 then return foo(n - 1) end
end 需要注意的是：必须明确什么是尾调用。
一些调用者函数调用其他函数后也没有做其他的事情但不属于尾调用。比如：
function f (x)
g(x)
return
end 上面这个例子中f在调用g后，不得不丢弃g地返回值，所以不是尾调用，同样的下面几个例子也不时尾调用：
return g(x) + 1 -- must do the addition
return x or g(x) -- must adjust to 1 result
return (g(x)) -- must adjust to 1 result Lua中类似return g(...)这种格式的调用是尾调用。可以将尾调用理解成一种goto，在状态机的编程领域尾调用是非常有用的。状态机的应用要求函数记住每一个状态，改变状态只需要goto(or call)一个特定的函数。
如果没有正确的尾调用，每次移动都要创建一个栈，多次移动后可能导致栈溢出。但正确的尾调用可以无限制的尾调用，因为每次尾调用只是一个goto到另外一个函数并不是传统的函数调用。
迭代器与闭包
迭代器是一种支持指针类型的结构，它可以遍历集合的每一个元素。在Lua中我们常常使用函数来描述迭代器，每次调用该函数就返回集合的下一个元素。
迭代器需要保留上一次成功调用的状态和下一次成功调用的状态，也就是他知道来自于哪里和将要前往哪里。闭包提供的机制可以很容易实现这个任务。记住：闭包是一个内部函数，它可以访问一个或者多个外部函数的外部局部变量。每次闭包的成功调用后这些外部局部变量都保存他们的值（状态）。当然如果要创建一个闭包必须要创建其外部局部变量。所以一个典型的闭包的结构包含两个函数：一个是闭包自己；另一个是工厂（创建闭包的函数）。
举一个简单的例子，我们为一个list写一个简单的迭代器，与ipairs()不同的是我们实现的这个迭代器返回元素的值而不是索引下标：
function list_iter (t)
local i = 0
local n = table.getn(t)
return function ()
i = i + 1
if i <= n then return t[i] end
end
end 这个例子中list_iter是一个工厂，每次调用他都会创建一个新的闭包（迭代器本身）。闭包保存内部局部变量(t,i,n)，因此每次调用他返回list中的下一个元素值，当list中没有值时，返回nil.我们可以在while语句中使用这个迭代器：
t = {10, 20, 30}
iter = list_iter(t) -- creates the iterator
while true do
local element = iter() -- calls the iterator
if element == nil then break end
print(element)
end
范性for的语义
范性for的文法如下：
for <var-list> in <exp-list> do
<body>
end <var-list>是一个或多个以逗号分割的变量名列表，<exp-list>是一个或多个以逗号分割的表达式列表，通常情况下exp-list只有一个值：迭代工厂的调用。
for k, v in pairs(t) do
print(k, v)
end 我们称变量列表中第一个变量为控制变量，其值为nil时循环结束。
下面我们看看范性for的执行过程：
首先，初始化，计算in后面表达式的值，表达式应该返回范性for需要的三个值：迭代函数，状态常量和控制变量；与多值赋值一样，如果表达式返回的结果个数不足三个会自动用nil补足，多出部分会被忽略。
第二，将状态常量和控制变量作为参数调用迭代函数（注意：对于for结构来说，状态常量没有用处，仅仅在初始化时获取他的值并传递给迭代函数）。
第三，将迭代函数返回的值赋给变量列表。
第四，如果返回的第一个值为nil循环结束，否则执行循环体。
第五，回到第二步再次调用迭代函数。
更精确的来说：
for var_1, ..., var_n in explist do block end 等价于
do
local _f, _s, _var = explist
while true do
local var_1, ... , var_n = _f(_s, _var)
_var = var_1
if _var == nil then break end
block
end
end 如果我们的迭代函数是f，状态常量是s，控制变量的初始值是a0，那么控制变量将循环：a1=f(s,a0)、a2=f(s,a1)、⋯⋯，直到ai=nil。
loadstring
loadstring与loadfile相似，只不过它不是从文件里读入chunk，而是从一个串中读入。例如：
f = loadstring("i = i + 1") f将是一个函数，调用时执行i=i+1
i = 0
f(); print(i) --> 1
f(); print(i) --> 2 loadstring函数功能强大，但使用时需多加小心。确认没有其它简单的解决问题的方法再使用。
loadfile
当我们执行命令f = loadfile("foo.lua")后，foo被编译了但还没有被定义，如果要定义他必须运行chunk：
f() -- defines `foo'
foo("ok") --> ok 如果你想快捷的调用dostring（比如加载并运行），可以这样
loadstring(s)()
require函数
Lua提供高级的require函数来加载运行库。粗略的说require和dofile完成同样的功能但有两点不同：
1. require会搜索目录加载文件
2. require会判断是否文件已经加载避免重复加载同一文件。由于上述特征，require在Lua中是加载库的更好的函数。
require使用的路径和普通我们看到的路径还有些区别，我们一般见到的路径都是一个目录列表。require的路径是一个模式列表，每一个模式指明一种由虚文件名（require的参数）转成实文件名的方法。更明确地说，每一个模式是一个包含可选的问号的文件名。匹配的时候Lua会首先将问号用虚文件名替换，然后看是否有这样的文件存在。如果不存在继续用同样的方法用第二个模式匹配。例如，路径如下：
?;?.lua;c:\windows\?;/usr/local/lua/?/?.lua 调用require "lili"时会试着打开这些文件：
lili
lili.lua
c:\windows\lili
/usr/local/lua/lili/lili.lua require关注的问题只有分号（模式之间的分隔符）和问号，其他的信息（目录分隔符，文件扩展名）在路径中定义。
错误
可以通过调用error函数显示的抛出错误，error的参数是要抛出的错误信息。
if not n then error("invalid input") end
异常和错误处理
如果在Lua中需要处理错误，需要使用pcall函数封装你的代码。
假定你想运行一段Lua代码，这段代码运行过程中可以捕捉所有的异常和错误。
第一步：将这段代码封装在一个函数内
function foo ()
...
if unexpected_condition then error() end
...
print(a[i]) -- potential error: `a' may not be a table
...
end 第二步：使用pcall调用这个函数
if pcall(foo) then
-- no errors while running `foo'
...
else
-- `foo' raised an error: take appropriate actions
...
end 当然也可以用匿名函数的方式调用pcall：
if pcall(function () ... end) then ...
else ... pcall在保护模式下调用他的第一个参数并运行，因此可以捕获所有的异常和错误。如果没有异常和错误，pcall返回true和调用返回的任何值；否则返回nil加错误信息。
错误信息不一定非要是一个字符串（下面的例子是一个table），传递给error的任何信息都会被pcall返回：
local status, err = pcall(function () error({code=121}) end)
print(err.code) --> 121 这种机制提供了我们在Lua中处理异常和错误的所需要的全部内容。我们通过error抛出异常，然后通过pcall捕获他。
错误信息和回跟踪
虽然你可以使用任何类型的值作为错误信息，通常情况下，我们使用字符串来描述遇到的错误信息。如果遇到内部错误（比如对一个非table的值使用索引下表访问）Lua将自己产生错误信息，否则Lua使用传递给error函数的参数作为错误信息。不管在什么情况下，Lua都尽可能清楚的描述发生的错误。
local status, err = pcall(function () a = 'a'+1 end)
print(err)
--> stdin:1: attempt to perform arithmetic on a string value
local status, err = pcall(function () error("my error") end)
print(err)
--> stdin:1: my error 例子中错误信息给出了文件名（stdin）加上行号。
函数error还可以有第二个参数，表示错误的运行级别。有了这个参数你就无法抵赖错误是别人的了，比如，加入你写了一个函数用来检查error是否被正确的调用：
function foo (str)
if type(str) ~= "string" then
error("string expected")
end
...
end 可能有人这样调用这个函数：
foo({x=1}) Lua会指出发生错误的是foo而不是error，实际的错误是调用error时产生的，为了纠正这个问题修改前面的代码让error报告错误发生在第二级（你自己的函数是第一级）如下：
function foo (str)
if type(str) ~= "string" then
error("string expected", 2)
end
...
end 当错误发生的时候，我们常常需要更多的错误发生相关的信息，而不单单是错误发生的位置。至少期望有一个完整的显示导致错误发生的调用栈的tracebacks，当pcall返回错误信息的时候他已经释放了保存错误发生情况的栈的信息。因此，如果我们想得到tracebacks我们必须在pcall返回以前获取。Lua提供了xpcall来实现这个功能，xpcall接受两个参数：调用函数和错误处理函数。当错误发生时。Lua会在栈释放以前调用错误处理函数，因此可以使用debug库收集错误相关的信息。有两个常用的debug处理函数：debug。debug和debug.traceback,前者给出Lua的提示符，你可以自己动手察看错误发生时的情况；后者通过traceback创建更多的错误信息,后者是控制台解释器用来构建错误信息的函数。你可以在任何时候调用debug.traceback获取当前运行的traceback信息：
print(debug.traceback())
