notepad 编码方式 ansi
cmd：lua54.exe 文件全名.lua

一、数据结构

1、table

遍历

tab1 = { key1 = "val1", key2 = "val2", "val3" }
for k, v in pairs(tab1) do
    print(k .. " - " .. v)
end
-- 给全局变量或者 table 表里的变量赋一个 nil 值，等同于把它们删掉
tab1.key1 = nil
for k, v in pairs(tab1) do
    print(k .. " - " .. v)
end
1
2
3
4
5
6
7
8
9

结果
1 - val3
key1 - val1
key2 - val2

1 - val3
key2 - val2

新建表

-- 创建一个空的 table
local tbl1 = {}
 
-- 直接初始表
local tbl2 = {"apple", "pear", "orange", "grape"}
1
2
3
4
5

索引

Lua 中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字或者是字符串。
默认初始索引一般以 1 开始

a = {}
a["key"] = "value"
key = 10
a[key] = 22
a[key] = a[key] + 11
for k, v in pairs(a) do
    print(k .. " : " .. v)
end
1
2
3
4
5
6
7
8

结果
key : value
10 : 33

一些操作

操作

2、基本操作

nil比较要加双引号，type(X) 实质是返回的是一个 string 类型

type(X)==nil
false
type(X)=="nil"
true
1
2
3
4

#来计算字符串的长度

> len = "www.runoob.com"
> print(#len)
14
1
2
3

字符连接 ..

> print("a" .. 'b')
ab
> print(157 .. 428)
157428
1
2
3
4

3、if-else，boolean

if false or nil then
    print("至少有一个是 true")
else
    print("false 和 nil 都为 false")
end

if 0 then
    print("数字 0 是 true")
else
    print("数字 0 为 false")
end
1
2
3
4
5
6
7
8
9
10
11

false 和 nil 都为 false

数字 0 是 true

4、number

print(type(2))
print(type(2.2))
print(type(0.2))
print(type(2e+1))
print(type(0.2e-1))
print(type(7.8263692594256e-06))
1
2
3
4
5
6

在对一个数字字符串上进行算术操作时，Lua 会尝试将这个数字字符串转成一个数字

> print("2" + 6)
8.0
> print("2" + "6")
8.0
> print("2 + 6")
2 + 6
> print("-2e2" * "6")
-1200.0
1
2
3
4
5
6
7
8

5、string

https://www.runoob.com/lua/lua-strings.html

用 " " 或者 [[ ]]

html = [[



    菜鸟教程


]]
print(html)
1
2
3
4
5
6
7
8
9

6、函数

-- function_test.lua 脚本文件
function factorial1(n)
    if n == 0 then
        return 1
    else
        return n * factorial1(n - 1)
    end
end
print(factorial1(5))
factorial2 = factorial1
print(factorial2(5))
1
2
3
4
5
6
7
8
9
10
11

$ lua function_test.lua 
120
120
1
2
3

匿名函数

-- function_test2.lua 脚本文件
function testFun(tab,fun)
        for k ,v in pairs(tab) do
                print(fun(k,v));
        end
end


tab={key1="val1",key2="val2"};
testFun(tab,
function(key,val)--匿名函数
        return key.."="..val;
end
);
1
2
3
4
5
6
7
8
9
10
11
12
13
14

可变参数

function average(...)
   result = 0
   local arg={...}    --> arg 为一个表，局部变量
   for i,v in ipairs(arg) do
      result = result + v
   end
   print("总共传入 " .. #arg .. " 个数")
   return result/#arg
end

print("平均值为",average(10,5,3,4,5,6))
1
2
3
4
5
6
7
8
9
10
11

7、变量赋值

local 的作用域到语句块结束

do
    local a = 6     -- 局部变量
    b = 6           -- 对局部变量重新赋值
    print(a,b);     --> 6 6
end

print(a,b)      --> 5 6
1
2
3
4
5
6
7

table索引

t[i]
t.i  
1
2

a = "hello" .. "world"
t.n = t.n + 1

-- 交换，个数不同时，按变量个数补足nil，或多余的值会被忽略
x, y = y, x 

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

-- 函数多返回值
a, b = f()
1
2
3
4
5
6
7
8
9
10
11

二、循环

1、while 循环

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

a=10
while( a < 20 )
do
   print("a 的值为:", a)
   a = a+1
end
1
2
3
4
5
6

2、for 循环

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

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

for var=exp1,exp2,exp3 do  
    <执行体>  
end  
1
2
3

for的三个表达式在循环开始前一次性求值，以后不再进行求值。比如上面的f(x)只会在循环开始前执行一次，其结果用在后面的循环中。

function f(x)  
    print("function")  
    return x*2  
end  

for i=1,f(5) do print(i)  
end
1
2
3
4
5
6
7

结果：function 只打印一次

function
1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10
11

循环数组

a = {"one", "two", "three"}
for i, v in ipairs(a) do
    print(i, v)
end 
1
2
3
4

3、repeat…until

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

a = 10
repeat
   print("a的值为:", a)
   a = a + 1
until( a > 15 )
1
2
3
4
5

a的值为:    10
a的值为:    11
a的值为:    12
a的值为:    13
a的值为:    14
a的值为:    15
1
2
3
4
5
6

4、循环嵌套

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

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
1
2
3
4
5
6
7
8
9
10
11
12

i 的值为：    8
i 的值为：    9
i 的值为：    10
1
2
3

5、break

a = 10

--[ while 循环 --]
while( a < 20 )
do
   print("a 的值为:", a)
   a=a+1
   if( a > 15)
   then
      break
   end
end
1
2
3
4
5
6
7
8
9
10
11
12

6、goto、continue

i = 0
::s1:: do
  print(i)
  i = i+1
end
if i>3 then
  os.exit()   -- i 大于 3 时退出
end
goto s1
1
2
3
4
5
6
7
8
9

结果

0
1
2
3
1
2
3
4

continue

for i=1, 3 do
    if i <= 2 then
        print(i, "yes continue")
        goto continue
    end
    print(i, " no continue")
    ::continue::
    print([[i'm end]])
end
1
2
3
4
5
6
7
8
9

1   yes continue
i'm end
2   yes continue
i'm end
3    no continue
i'm end
1
2
3
4
5
6

7、无限循环

while( true )
do
   print("循环将永远执行下去")
end
1
2
3
4

8、if-else

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

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

elseif( 布尔表达式 3)
then
   --[ 在布尔表达式 3 为 true 时执行该语句块 --]
else 
   --[ 如果以上布尔表达式都不为 true 则执行该语句块 --]
end
1
2
3
4
5
6
7
8
9
10
11
12
13
14

三、面向对象

我们可以使用点号(.)来访问类的属性：

print(r.length)
1

我们可以使用冒号 : 来访问类的成员函数：

r:printArea()
1

-- 元类
Shape = {area = 0}

-- 基础类方法 new
function Shape:new (o,side)
  o = o or {}
  setmetatable(o, self)
  self.__index = self
  side = side or 0
  self.area = side*side;
  return o
end

-- 基础类方法 printArea
function Shape:printArea ()
  print("面积为 ",self.area)
end

-- 创建对象
myshape = Shape:new(nil,10)

myshape:printArea()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

继承

-- Meta class
Shape = {area = 0}
-- 基础类方法 new
function Shape:new (o,side)
  o = o or {}
  setmetatable(o, self)
  self.__index = self
  side = side or 0
  self.area = side*side;
  return o
end
-- 基础类方法 printArea
function Shape:printArea ()
  print("面积为 ",self.area)
end

-- 创建对象
myshape = Shape:new(nil,10)
myshape:printArea()

Square = Shape:new()
-- 派生类方法 new
function Square:new (o,side)
  o = o or Shape:new(o,side)
  setmetatable(o, self)
  self.__index = self
  return o
end

-- 派生类方法 printArea
function Square:printArea ()
  print("正方形面积为 ",self.area)
end

-- 创建对象
mysquare = Square:new(nil,10)
mysquare:printArea()

Rectangle = Shape:new()
-- 派生类方法 new
function Rectangle:new (o,length,breadth)
  o = o or Shape:new(o)
  setmetatable(o, self)
  self.__index = self
  self.area = length * breadth
  return o
end

-- 派生类方法 printArea
function Rectangle:printArea ()
  print("矩形面积为 ",self.area)
end

-- 创建对象
myrectangle = Rectangle:new(nil,10,20)
myrectangle:printArea()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

面积为     100
正方形面积为     100
矩形面积为     200
1
2
3