快捷注释： 

- -[[

print(10) - ->10  - - 不起作用(因为这是注释)

- -]]

当重新启用这段代码时，只需在一次行行首添加一个连接字符即可：

- - -[[

print(10) - ->10  - - 10

- -]]

全局变量：

全局变量不需要声明，只需将一个值赋予一个全局变量就可以创建了， 在Lua中，访问一个未初始化的变量不会引发错误，访问结果是一个特殊的值 nil ，

 print(b)  - -> nil

 b=10

print(b) - ->10

通常没有必要删除一个全局变量，如果一个变量只有较短的生存周期，那么久应该使用局部变量。但是，诶果一定要删除某个全局变量的话，只需要将其赋值为nil

b=nil

print(b)=nil

字符串：

指字符的序列。lua是8位字节，所以字符串可以包含任何数值字符，包括嵌入的0。这意味着你可以存储任意的二进制数据在一个字符串里。Lua中字符串是不可以修改的，你可以创建一个新的变量存放你要的字符串，如下：

a = "one string"

b = string.gsub(a, "one", "another")   -- 修改字符串的一部分

print(a)          --> one string

print(b)          --> another string

string和其他对象一样，Lua自动进行内存分配和释放，一个string可以只包含一个字母也可以包含一本书，Lua可以高效的处理长字符串，1M的string在Lua中是很常见的。可以使用单引号或者双引号表示字符串

a = "a line"

b = 'another line'

为了风格统一，最好使用一种，除非两种引号嵌套情况。对于字符串中含有引号的情况还可以使用转义符\来表示。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     -- 右中括号

例子：

> 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: '\'

运行时，Lua会自动在string和numbers之间自动进行类型转换，当一个字符串使用算术操作符时，string就会被转成数字。

print("10" + 1)             --> 11

print("10 + 1")             --> 10 + 1

print("-5.3e - 10" * "2")   --> -1.06e-09

print("hello" + 1)          -- 错误(不能转换为”hello”)

反过来，当Lua期望一个string而碰到数字时，会将数字转成string。

print(10 .. 20)      --> 1020

在Lua中，“..”是字符串的连接操作符，当直接在一个数字后面输入它的时候，必须要用一个空格来分隔它们，不然，lua会就将第一个点理解为一个小数点。

尽管字符串和数字可以自动转换，但两者是不同的，像10 == "10"这样的比较永远都是错的。如果需要显式将string转成数字可以使用函数tonumber()，如果string不是正确的数字该函数将返回nil。

line = io.read()         -- 读取一行

n = tonumber(line)       -- 尝试将它转换为一个数字

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   这样的转换是合法的

在Lua 5.1中，可以在字符串前放置操作符 ”#“ ，这样可以获得该字符串的长度

A = “hello”

print(#A)    - -> 5

print(#”good\0bye”)  - -> 8

Lua的逻辑操作符

逻辑操作符有 and、or 和 not 。与条件控制语句一样，所有的逻辑操作符将 false 和 nil 视为假，而将其他的任何东西视为真。对于操作符 and 来说，如果它的第一个操作数为假，就返回第一个操作数；不然就返回第二个操作数。对于操作符 or 来说，如果它的第一个操作数为真，就返回第一个操作数，不然就返回第二个操作数

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

..         --两个点

字符串连接，如果操作数为数字，Lua将数字转成字符串。

print("Hello " .. "World")      --> Hello World

print(0 .. 1)                   --> 01

table 构造试

构造器是创建和初始化表的表达式。表是Lua特有的功能强大的东西。最简单的构造函数是{}，用来创建一个空表。可以直接初始化数组:

 例如：days = {"Sunday", "Monday", "Tuesday", "Wednesday",

              "Thursday", "Friday", "Saturday"}

Lua将"Sunday"初始化days[1]（第一个元素索引为1），用"Monday"初始化days[2]...

print(days[4])       --> Wednesday

    Lua还提供了一种特殊的语法用于初始化记录风格的table

a = {X=10,y=20}   等价于  a={ }; a.x = 10; a.y = 20

不管用何种方式创建table，我们都可以向表中添加或者删除任何类型的域，构造函数仅仅影响表的初始化。

w = {x=0, y=0, label="console"}

x = {sin(0), sin(1), sin(2)}

w[1] = "another field"    - - 添加key 1 到 table w

x.f = w - - 添加key “f” 到 table x

print(w["x"])     --> 0

print(w[1])       --> another field

print(x.f[1])     --> another field

w.x = nil         -- 删除字段 "x"

每当Lua调用构造函数，Lua都会创建一个新的table，然后初始化它，这样，就能用table写出以下的链接代表码，可以使用table构造一个list：

list = nil

for line in io.lines() do

    list = {next=list, value=line}

end

这段代码从标准输入读进每行的内容，然后将每行按相反的次序存储到一个链表中。链表的每一个节点都是一个table，table 中含有两个字段：value（没行的内容）和 nex（指向下一个节点的引用）。下面的代码打印链表的内容：

l = list

while l do

    print(l.value)

    l = l.next

end

在同一个构造函数中可以混合列表风格和record风格进行初始化，如：

polyline = {

color="blue", thickness=2, npoints=4,

              {x=0,   y=0},

              {x=-10, y=0},

              {x=-10, y=1},

              {x=0,   y=1}

  }

这个例子也表明我们可以嵌套构造函数来表示复杂的数据结构.

print(polyline[2].x)     --> -10

print(polyline[4].y)     --> -1

这两种风格的构造式各有其限制，例如 不能使用负数的索引，也不能用运算符作为记录的字段名，为了满足这些要求，Lua还提供了一种更通用的表达格式。这种格式允许在方括号之间，显式地用一个表达式来初始化索引值：

opnames = {["+"] = "add", ["-"] = "sub",

              ["*"] = "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])         --> ---

如果真的想要数组下标从0开始：

days = {[0]="Sunday", "Monday", "Tuesday", "Wednesday",

              "Thursday", "Friday", "Saturday"}

注意：不推荐数组下标从0开始，否则很多标准库不能使用。

在构造函数的最后的","是可选的，可以方便以后的扩展。

a = {[1]="red", [2]="green", [3]="blue",}

在构造函数中域分隔符逗号（","）可以用分号（";"）替代，通常我们使用分号用来分割不同类型的表元素。

{x=10, y=45; "one", "two", "three"}

赋值是改变一个变量的值和改变表域的最基本的方法。

　　a = "hello" .. "world"

　　t.n = t.n + 1

Lua可以对多个变量同时赋值，变量列表和值列表的各个元素用逗号分开，赋值语句右边的值会依次赋给左边的变量。

　　a, b = 10, 2*x       <-->       a=10; b=2*x

遇到赋值语句Lua会先计算右边所有的值然后再执行赋值操作，所以我们可以这样进行交换变量的值：

　　x, y = y, x                     -- 交换 'x' for 'y'

　　a[i], a[j] = a[j], a[i]         -- 交换3 'a[i]' for 'a[i]'

当变量个数和值的个数不一致时，Lua会一直以变量个数为基础采取以下策略：

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

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

例如：

　　a, b, c = 0, 1

　　print(a,b,c)             --> 0   1   nil

　　a, b = a+1, b+1, b+2     -- value of b+2 is ignored

　　print(a,b)               --> 1   2

　　a, b, c = 0

　　print(a,b,c)             --> 0   nil   nil

上面最后一个例子是一个常见的错误情况，注意：如果要对多个变量赋值必须依次对每个变量赋值。

　　a, b, c = 0, 0, 0

　　print(a,b,c)             --> 0   0   0

多值赋值经常用来交换变量，或将函数调用返回给变量：

　　a, b = f()

f()返回两个值，第一个赋给a，第二个赋给b。