02Lua入门

前言：

语言学起来其实相似点很多，简单整理的知识点

目录：

1.使用控制台

2.Lua基础

3.变量

4.运算符

5.控制结构

1.使用控制台

Lua脚本是包含一系列Lua命令的简单脚本（扩展名为.lua的文本文件）。Lua不关注格式，制表符，换行符或者其他让脚本文件更具可读性的转换符号（不过Lua还是需要命令之间的空格符号，用来区别变量和函数调用）

简单的Lua脚本：

for indx = 1,4 do

print("line:",indx )

end

也可以写成：for indx = 1,4 do print("line:",indx ) end

注：

格式化后的脚本更容易阅读，但不改变结果

可以把脚本放在本地文件夹通过dofile命令来在控制台执行脚本，参数是字符串，指定文件的名字和路径。使用dofile命令可以在命令行中运行脚本，如果脚本有什么错误的化，命令行会给出错误信息以便调试。

语法格式：

dofile<"c:\\file_name\\lua_scripts_name.lua">

2.Lua基础

优势：整合C++的模块来扩展自身的功能。

语言定义

不以数字为标识符开头（同C），避免下划线接大写字母（_NAME），因为这种格式是Lua自身保留的(保留字)，如_Start。

Lua保留关键字

and    local    break    nil    do

not    else    or    elseif    repeat

end    return    false    then    for

true    function    until    if    while

in

变量，常量，函数名的格式和命名规则：

常用全大写和下划线（MY_NAME）

变量第一个字母小写（myVariable）

全局变量第一个字母用小写（gMyGlobal）

函数名第一个字母大写（function  MyFunction）

--单行注释

--[[
     statements    块注释

--]]

使用技巧：--[[ 或者 --]]  加一个 - 可以重新使用这段代码  ---[[   ---]]

3.变量

在Lua中，变量不需要在使用前声明，这个稍微有些争议。因为不需要声明，所以可以才任何地方引入需要的变量。由于不是显式声明，所以很难追踪变量（不造），或者在另一个函数中用了相同名字的变量而造成数据的混乱。因此，必须小心的使用变量，要保证变量是可追踪的。同样不需要指定变量类型，变量类型取决于给变量赋的值，灵活性较高。

变量赋值：

1.赋值改变

2.改变表域

多个变量同时赋值时赋值变量列表和值列表的各个元素用逗号分开，依次赋值。

a,b=1,2

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

x,y=y,x

当变量个数与值个数不一致时，Lua会以变量个数为基础，采取不足补nil,多的忽略。

例：

a,b,c=0,1   --->0,1,nil

a,b,c=0,1,2,3 --->0,1,2

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

例：

a, b = f()

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

应该尽可能的使用局部变量，有两个好处：

1. 避免命名冲突。

2. 访问局部变量的速度比全局变量更快。

索引

对 table 的索引使用方括号 []。Lua 也提供了 . 操作。

t[i]

t.i                 -- 当索引为字符串类型时的一种简化写法

gettable_event(t,i) -- 采用索引访问本质上是一个类似这样的函数调用

例如：

> site = {}

> site["key"] = "www.w3cschool.cc"

> print(site["key"])

www.w3cschool.cc

> print(site.key)

www.w3cschool.cc

变量类型：

注：可以使用Type函数测试变量的类型。

3.1 nil

nil 表示没赋值的变量，实际上可以表示删除变量。

3.2Boolean

Boolean类型的变量只有两种值 ：true和false.

3.3string

3.3.1用两个方括号也可以表示一块字符串

特殊字符串：

\a    响铃    \v    垂直指标

\b    退格    \\    反斜杠

\f    换页符    \"    双引号

\n    换行符    \'    单引号

\r    换行符    \[    左方括号

\t    制表符    \]    右方括号

\o    空字符    \ddd    八进制

\xhh    十六进制

3.3.2在对一个数字字符串进行操作时，Lua会将这个数字字符串转换成一个数字。

例子：

print(2+6)--8

print("2"+6)--8

print("2"+"6")--8

print("2+6")--2+6

print("abc"+6)--报错，字符串连接不是用+而是两点 ..

print("2"..6)--26

注：..(连接字符串)
       #（计算字符串长度，置于字符串前或者变量名前）

3.4Number

双精度浮点数，无整数类型

myNumber=7

myNumber=0.765

myNumber=7.65e8(7.65x10^8,765 000 000)

myNumber=7.65e-2(7.65x10^-2,0.0765)

3.5table

3.5.1实质是关联数组（associative arrays）索引为数字或字符串，初始索引为1.

3.5.2table的创建

3.5.2.1空表

local tab1={}

3.5.2.2初始表

local tab2={"apple","pear"}

注：table不会固定长度大小，有新数据添加时,table会自动增长，没有初始值都为nil.

3.6局部变量和全局变量

Lua变量默认是全局的，也就是说，变量的值在整个会话中是保持不变的，除非脚本改变了它。

当使用全局变量时，变量名前加一个g字母会更加明确，便于调试。

局部变量可以给设定一个初始值，也可以不用赋值。

语法：

local 变量名

变量的有效范围取决于声明变量的位置。

4.运算符

4.1算术运算符

+-*/%^-

4.2关系运算符

==

~=

>

<

>=

<=

注：如果使用关系运算符比较两个table,只有两个table是同一个对象的时候才能得到预期的结果，因为变量只是table对象的引用（像指针一样），不能直接比较存在于table中的值。

实例：

tableA={1,2,3}

tableB={1,2,3}

if tableA=tableB then
     print("相等")

else
     print("不相等")

end

-->不相等（结构不同）

tableA={1,2,3}

tableB=tableA

if tableA=tableB then
     print("相等")

else
     print("不相等")

end

-->相等（tableB指向了同样的对象tableA）

4.3逻辑运算符

and(比较两个参数时，第一个false则返回flase,否则返回第二个参数的值)

or

not

注：官方解释的是一坨屎，就和C一样理解就行。

4.4其他运算符

.. 连接字符串

#一元运算符，返回字符串或表的长度

4.5运算符的优先级

从高到低的顺序：

^

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)

实例

我们可以通过以下实例来更加透彻的了解 Lua 语言运算符的优先级：

a = 20

b = 10

c = 15

d = 5

e = (a + b) * c / d;-- ( 30 * 15 ) / 5

print("(a + b) * c / d 运算值为  :",e )

e = ((a + b) * c) / d; -- (30 * 15 ) / 5

print("((a + b) * c) / d 运算值为 :",e )

e = (a + b) * (c / d);-- (30) * (15/5)

print("(a + b) * (c / d) 运算值为 :",e )

e = a + (b * c) / d;  -- 20 + (150/5)

print("a + (b * c) / d 运算值为   :",e )

以上程序执行结果为：

(a + b) * c / d 运算值为  :    90.0

((a + b) * c) / d 运算值为 :    90.0

(a + b) * (c / d) 运算值为 :    90.0

a + (b * c) / d 运算值为   :    50.0

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

笔记：

1.在Lua中实现C/C++中的三目运算。

condition?  result1:result2

|

if  condition then

return result1

else

return result2

end

三目运算

熟悉 C/C++ 的老司机都知道三目运算 a ? b : c，这种写法替换简单的条件判断语句可以在不增加阅读难度的情况下，使代码尽量保持简洁。

int a, b, ret;

//if-else

if (a > b)
     ret = a;

else
     ret = b;

//三目运算符

ret = a > b ? a : b;

Lua 中的三目运算

Lua 原生的语义并没有实现三目运算，一般是通过逻辑运算符 and 和 or 来模拟三目运算符的。

Lua 中 and 和 or 都使用"短路求值(short_cur evaluation)"，也就是说，它们只会在需要时才去评估第二个操作数。（《Lua程序设计》）

local a, b, ret;

ret = a > b and a or b

穷举所有可能性：

a > b 时:

a > b and a –> true

a or b –> a

a <= b时:

a > b and a –> false

a or b –> b

完美！

Lua 中的三目运算符陷阱

按照从特殊到一般的原则:

三目运算的一般形式a ? b : c

a = true,结果为b

a = false,结果为c

对应Lua中的a and b or c

b = true

a = true

a and b –> true

b or c –> b

a = false

a and b –> false

b or c –> c

b = false

a = true

a and b –> false

b or c –> c

a = false

a and b –> false

b or c –> c

可以看到当 b = false 时，Lua模拟的 a and b or c 始终返回 c 并不能还原三目运算符的原貌。

《Lua程序设计》也建议这种情况使用 if-else 来避免。

一般化的 a and b or c

那么有没有办法可以解决 b = false 失效的问题呢？

由此我联想到 C 语言有一道常规的考题：请使用宏定义写一个返回两个值中较小值的方法。

在校时第一次看到本题，第一反应如下：

#define MIN(A,B) A < B ? A : B

然而这种写法在很多嵌套的使用环境中都不能返回正确的结果。比如：2 * MIN(3, 4)展开为 2 * 3 < 4 ? 3 : 4 = 6 < 4 ? 3 : 4,结果为4。

更"工程师"的写法是：

#define MIN(A,B) ((A) < (B) ? (A) : (B))

还有好奇心的同学可以参考：宏定义的正确写法，三目运算的宏定义

从这个示例中，我就在想如何能保证 a and b or c 中 b 为真或者 b 不产生歧义呢？

and的运算优先级高于or，简单的改变运算顺序并没有用。

这时就想到了lua中万能的table，能不能把a,b,c都放到table中来改变b的存在呢？要注意{nil}也是一个为true的对象。

a,b,c都替换为table：{a} and {b} or {c}。

三目运算中a是条件，结果是b或者c。其实a并不需要放入table中，否则{a}就始终为true了，失去了条件的意义。而{b} or

{c}的结果也必然是一个table，该table只有一个元素。那么通过[1]即可访问。

综上所述，更一般化的Lua三目运算为：(a and {b} or {c})[1]

2.其他运算符 —— #

在获取表的长度时，根据的是表的最大索引的值:

tab1 = {"1","2"}

print("tab1长度"..#tab1)

tab2 = {key1="1","2"}

print("tab2长度"..#tab2)

tab3 = {}

tab3[1]="1"

tab3[2]="2"

tab3[4]="4"

print("tab3长度"..#tab3)

输出:

tab1长度2

tab2长度1

tab3长度4

3. 下标越过 1 位以上，长度还是为 2：

tab3={}

tab3[1]="1"

tab3[2]="2"

tab3[5]="5"

print("tab3的长度",#tab3)

输出：

tab3的长度    2

4.取长度操作符写作一元操作 #

table t 的长度被定义成一个整数下标 n 。 它满足 t[n] 不是 nil 而 t[n+1] 为 nil； 此外，如果 t[1] 为 nil ，n 就可能是零。 对于常规的数组，里面从 1 到 n 放着一些非空的值的时候， 它的长度就精确的为 n，即最后一个值的下标。 如果数组有一个“空洞” （就是说，nil 值被夹在非空值之间）， 那么 #t 可能是指向任何一个是 nil 值的前一个位置的下标 （就是说，任何一个nil 值都有可能被当成数组的结束）。

tab4 = {}

tab4[1] = "1"

tab4[2] = nil

tab4[3] = "2"

tab4[4] = nil

print("tab4的长度", #tab4)

--tab4的长度    1

tab5 = {}

tab5[1] = "1"

tab5[2] = nil

tab5[3] = "2"

tab5[4] = "4"

print("tab5的长度", #tab5)

--tab5的长度    4

tab6 = {1, nil, 3}

print("tab6的长度", #tab6)

--tab6的长度    3

tab6 = {1, nil, 3, nil}

print("tab6的长度", #tab6)

--tab6的长度    1

5.控制结构

注：

控制结构的条件表达式结果可以是任何值，Lua认为false和nil为假，true和非nil为真。

要注意的是Lua中 0 为 true：

5.1if 语句

if 语句 由一个布尔表达式作为条件判断，其后紧跟其他语句组成。

Lua if 语句语法格式如下：

if(布尔表达式)

then
    --[ 在布尔表达式为 true 时执行的语句 --]

end

在布尔表达式为 true 时会if中的代码块会被执行，在布尔表达式为 false 时，紧跟在 if 语句 end 之后的代码会被执行。

Lua认为false和nil为假，true 和非nil为真。要注意的是Lua中 0 为 true。

5.2if...else 语句

if 语句 可以与 else 语句搭配使用, 在 if 条件表达式为 false 时执行 else 语句代码。

if...else 语句

Lua if 语句可以与 else 语句搭配使用, 在 if 条件表达式为 false 时执行 else 语句代码块。

Lua if...else 语句语法格式如下：

if(布尔表达式)

then
    --[ 布尔表达式为 true 时执行该语句块 --]

else
    --[ 布尔表达式为 false 时执行该语句块 --]

end

在布尔表达式为 true 时会if中的代码块会被执行，在布尔表达式为 false 时，else 的代码块会被执行。

Lua认为false和nil为假，true 和非nil为真。要注意的是Lua中 0 为 true。

if...elseif...else 语句

Lua if 语句可以与 elseif...else 语句搭配使用, 在 if 条件表达式为 false 时执行 elseif...else 语句代码块，用于检测多个条件语句。

Lua if...elseif...else 语句语法格式如下：

if( 布尔表达式 1)

then
    --[ 在布尔表达式 1 为 true 时执行该语句块 --]

elseif( 布尔表达式 2)

then
    --[ 在布尔表达式 2 为 true 时执行该语句块 --]

elseif( 布尔表达式 3)

then
    --[ 在布尔表达式 3 为 true 时执行该语句块 --]

else
    --[ 如果以上布尔表达式都不为 true 则执行该语句块 --]

end

5.3if 嵌套语句

你可以在if 或 else if中使用一个或多个 if 或 else if 语句 。

if...else 语句

Lua if 语句允许嵌套, 这就意味着你可以在一个 if 或 else if 语句中插入其他的 if 或 else if 语句。

Lua if 嵌套语句语法格式如下：

if( 布尔表达式 1)

then
    --[ 布尔表达式 1 为 true 时执行该语句块 --]
    if(布尔表达式 2)
    then
       --[ 布尔表达式 2 为 true 时执行该语句块 --]
    end

end

你可以用同样的方式嵌套 else if...else 语句。

注：Lua不支持case语句因此可以用elseif语句

5.4循环

Lua 语言提供了以下几种循环处理方式：

while 循环

在条件为 true 时，让程序重复地执行某些语句。执行语句前会先检查条件是否为 true。

for 循环

重复执行指定语句，重复次数可在 for 语句中控制。

repeat...until

重复执行循环，直到 指定的条件为真时为止

循环嵌套

可以在循环内嵌套一个或多个循环语句（while do ... end;for ... do ... end;repeat ... until;）

5.4.1while

注：

while和repeat 控制结构非常相似，它们都可以循环执行一段脚本直到满足某个条件。

Lua 编程语言中 while 循环语句在判断条件为 true 时会重复执行循环体语句。

语法

Lua 编程语言中 while 循环语法：

while(condition)

do
    statements

end

5.4.2repeat

repeat...until 循环的条件语句在当前循环结束后判断。

语法

Lua 编程语言中 repeat...until 循环语法格式:

repeat
    statements

until( condition )

5.4.3for

Lua 编程语言中 for 循环语句可以重复执行指定语句，重复次数可在 for 语句中控制。

Lua 编程语言中 for语句有两大类：

数值for循环

泛型for循环

5.4.3.1数值for循环

Lua 编程语言中数值for循环语法格式:

for var=exp1,exp2,exp3 do 
     <执行体> 

end
  

var从exp1变化到exp2，每次变化以exp3为步长递增var，并执行一次"执行体"。exp3是可选的，如果不指定，默认为1。

示例：

for i=10,1,-1 do
     print(i)

end

从10变到1，每次减1

结果：10，9，8，7，6，5，4，3，2，1

5.4.3.2泛型for循环

泛型for循环通过一个迭代器函数来遍历所有值，类似java中的foreach语句。

Lua 编程语言中泛型for循环语法格式:

--打印数组a的所有值 

for i,v in ipairs(a)
     do print(v)

end 

i是数组索引值，v是对应索引的数组元素值。ipairs是Lua提供的一个迭代器函数，用来迭代数组。

days ={"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"} 

for i,v in ipairs(days) do 

print(v)
  end

结果略（ipairs(为表达式列表)，后面泛型for里有提到）

注：

1.循环次数只是在第一次执行时确定，因此就算用户更改了参数的值也不会影响最终的循环次数。

2.循环结构中的变量是局部变量，一旦循环结束就会被清除。如果想保存它们的值

，那么必须使用全局变量或者更高级的局部变量。

笔记:

1.

在lua中pairs与ipairs两个迭代器的用法相近，但有一点是不一样的：

pairs可以遍历表中所有的key，并且除了迭代器本身以及遍历表本身还可以返回nil;

但是ipairs则不能返回nil,只能返回数字0，如果遇到nil则退出。它只能遍历到表中出现的第一个不是整数的key

2.pairs遍历表中全部key，value

ipairs从下标为1开始遍历，然后下标累加1，如果某个下标元素不存在就终止遍历。这就导致如果下标不连续或者不是从1开始的表就会中断或者遍历不到元素。

3.

首先，ipairs 这个迭代器只能遍历所有数组下标的值，这是前提，也是和 pairs 的最根本区别，也就是说如果 ipairs 在迭代过程中是会直接跳过所有手动设定key值的变量。

特别注意一点，和其他多数语言不同的地方是，迭代的下标是从1开始的。

3.1

例如：

tab = {1,2,a= nil,"d"}

for i,v in ipairs(tab) do
     print(i,v)

end

输出结果为：

1  1

2  2

3  d

这里是直接跳过了a=nil这个变量

3.2

ipairs在迭代过程中如果遇到nil时会直接停止。

例如：

tab = {1,2,a= nil,nil,"d"}

for i,v in ipairs(tab) do
     print(i,v)

end

输出结果为：

1  1

2  2

4.

for 循环中，循环的索引 i 为外部索引，修改循环语句中的内部索引 i，不会影响循环次数:

for i=1,10 do
     i = 10
     print("one time,i:"..i)

end

仍然循环 10 次，只是 i 的值被修改了。

5.5嵌套循环

语法

Lua 编程语言中 for 循环嵌套语法格式:

for init,max/min value, increment

do
    for init,max/min value, increment
    do
       statements
    end
    statements

end

Lua 编程语言中 while 循环嵌套语法格式:

while(condition)

do
    while(condition)
    do
       statements
    end
    statements

end

Lua 编程语言中 repeat...until 循环嵌套语法格式:

repeat
    statements
    repeat
       statements
    until( condition )

until( condition )

除了以上同类型循环嵌套外，我们还可以使用不同的循环类型来嵌套，如 for 循环体中嵌套 while 循环。

实例

以下实例使用了for循环嵌套:

j =2

for i=2,10 do
    for j=2,(i/j) , 2 do
       if(not(i%j))
       then
          break
       end
       if(j > (i/j))then
          print("i 的值为：",i)
       end
    end

end

以上代码执行结果为：

i 的值为：    8

i 的值为：    9

i 的值为：    10

5.6循环控制语句

循环控制语句用于控制程序的流程， 以实现程序的各种结构方式。

Lua 支持以下循环控制语句：

break 语句

退出当前循环或语句，并开始脚本执行紧接着的语句。

5.7无限循环

在循环体中如果条件永远为 true 循环语句就会永远执行下去，以下以 while 循环为例：

while( true )

do
    print("循环将永远执行下去")

end