【1】多重赋值
多重赋值规则：若值的个数少于变量的个数，那么多余的变量会被赋值为nil
若值的个数多余变量的个数，那么多余的值会被“悄悄地”丢弃掉。
多重赋值应用示例：
1 a, b = 10, 2*3
2 print(a, b) -- 10 6
3
4 a, b, c = 0, 1
5 print(a, b, c) -- 0 1 nil
6
7 a, b = a+1, b+1, b+2
8 print(a, b) -- 1 2
9
10 a, b, c = 0
11 print(a, b, c) -- 0 nil nil
【2】repeat
一条repeat-until语句，重复执行其循环体，直到条件为真时结束。
repeat控制语句示例：
1 local a = 10
2 repeat
3 a = a + 10
4 print(a)
5 until a == 100
6
7
8 --[[执行结果
9 20
10 30
11 40
12 50
13 60
14 70
15 80
16 90
17 100
18 ]]
【3】elseif结构
由于Lua不支持switch语句，所以这种一连串的if-elseif 代码是很常见的。
elseif应用示例：
1 if op == "+" then
2 r = a + b
3 elseif op == "-" then
4 r = a - b
5 elseif op == "*" then
6 r = a * b
7 elseif op == "/" then
8 r = a / b
9 else
10 error("invalid operation")
11 end
【4】数字型for 和 泛型for
（1）数字型for
数字型for语法如下：
1 for var = exp1, exp2, exp3 do
2 <执行体>
3 end
var从exp1开始，以步长exp3(step)递增至exp2，每次变化执行一次"执行体"
第三个表达式exp3是可选的，若不指定，默认步长为1。如下示例：
1 for i = 1, 10, 1 do
2 print("i =", i)
3 end
4
5 --[[
6 i = 1
7 i = 2
8 i = 3
9 i = 4
10 i = 5
11 i = 6
12 i = 7
13 i = 8
14 i = 9
15 i = 10
16 ]]
（2）泛型for
泛型for循环通过一个迭代器(iterator)函数来遍历所有值。示例如下：
1 --打印数组的所有值
2 a = {11, 12, 13, 14, 15}
3 for i, v in ipairs(a) do
4 print(i, v)
5 end
6
7 --[[
8 1 11
9 2 12
10 3 13
11 4 14
12 5 15
13 ]]
Lua标准库提供了几种迭代器，包括用于迭代文件中每行的io.lines、迭代table元素的pairs、迭代数组元素的ipairs、迭代字符串中单词的string.gmatch等
刚刚写示例时候，无意写了几个这样的for循环，开始懵圈了。。。。。。
1 --打印数组的所有值
2 a = {11, 12, 13, 14, 15}
3 for i, v in ipairs(a) do
4 print(i, v)
5 end
6
7 --[[
8 1 11
9 2 12
10 3 13
11 4 14
12 5 15
13 ]]
14
15 for v in ipairs(a) do
16 print(v)
17 end
18
19 --[[
20 1
21 2
22 3
23 4
24 5
25 ]]
26
27 for k in pairs(a) do
28 print(k)
29 end
30
31 --[[
32 1
33 2
34 3
35 4
36 5
37 ]]
38
39 for i, v in pairs(a) do
40 print(v)
41 end
42
43 --[[
44 11
45 12
46 13
47 14
48 15
49 ]]
那么，到底pairs和ipairs两个容器函数到底有什么区别呢？
请再看以下的分析：
1 local table1 = {
2 [3] = "abc",
3 [4] = "def",
4 [5] = "ghi"}
5
6 for k, v in ipairs(table1) do
7 print(k, v)
8 end
上面这个for循环，竟然没有输出任何东东，下面继续看，我们把容器函数改为pairs，如下所示：
1 local table1 = {
2 [3] = "abc",
3 [4] = "def",
4 [5] = "ghi"}
5
6 for k, v in pairs(table1) do
7 print(k, v)
8 end
9
10 --则会输出所有
11 --[[执行结果
12 3 abc
13 4 def
14 5 ghi
15 ]]
输出了所有内容。再改变一下表的内容，继续观察，如下示例：
1 --现在改变一下表内容
2 local table2 = {
3 [1] = "abc",
4 [2] = "def",
5 [7] = "ghi"}
6
7 for k, v in ipairs(table2) do
8 print(k, v)
9 end
10
11 --[[执行结果
12 1 abc
13 2 def
14 ]]
15
16 for k, v in pairs(table2) do
17 print(k, v)
18 end
19
20 --[[执行结果
21 1 abc
22 2 def
23 7 ghi
24 ]]
还记得这节时，我们谈及到“Lua标准库提供了迭代table元素的pairs、迭代数组元素的ipairs”这句话了么？
现在想想，ipairs容器函数遍历的是数组，既然是数组，那么就需要从索引为1开始遍历，如果某个索引对应的值为nil，直接视为数组结束，退出循环。
pairs容器函数遍历的是表，既然是表，那么就可以遍历表中所有的key。
下面再看几个验证示例：
1 local table3 = {
2 [1] = "liu",
3 [4] = "wang",
4 [5] = "zhao"}
5
6 for i, v in pairs(table3) do
7 print(table3[i])
8 end
9
10 --[[执行结果
11 liu
12 wang
13 zhao
14 ]]
15
16 for i, v in ipairs(table3) do
17 print(table3[i])
18 end
19
20 --[[执行结果
21 liu
22 ]]
23
24 -- [[示例2.]]
25
26 local table4 = {"alpha", "beta", [3] = "ios", ["two"] = "dos", [5] = "windows"}
27
28 for i, v in ipairs(table4) do
29 print(table4[i])
30 end
31
32 --[[执行结果
33 alpha
34 beta
35 ios
36 ]]
37
38 for i, v in pairs(table4) do
39 print(i, table4[i])
40 end
41
42 --[[执行结
43 1 alpha
44 2 beta
45 3 ios
46 5 windows
47 two dos
48 ]]
结论：pairs可以遍历表中所有key，而ipairs只可以遍历表中数组值。
其实，言归正传，针对泛型for的使用，下面这个例子很常见。代码如下：
1 days = {
2 "Sunday",
3 "Monday",
4 "Tuesday",
5 "Wednesday",
6 "Thursday",
7 "Friday",
8 "Saturday"
9 }
10
11 revDays = {}
12 for k, v in pairs(days) do
13 revDays[v] = k
14 end
15
16 for i, k in pairs(days) do
17 print(i, k)
18 end
19
20 --[[ 执行结果
21 1 Sunday
22 2 Monday
23 3 Tuesday
24 4 Wednesday
25 5 Thursday
26 6 Friday
27 7 Saturday
28 ]]
29
30 for i, k in pairs(revDays) do
31 print(i, k)
32 end
33
34 --[[ 执行结果
35 Saturday 7
36 Tuesday 3
37 Wednesday 4
38 Friday 6
39 Sunday 1
40 Thursday 5
41 Monday 2
42 ]]
仔细体会一下其中的便捷性。
【5】其他
Good Good Study，Day Day Up.
顺序 选择 循环 总结
