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
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100

--[[ 以下是nil类型相关测试 ]]
print(type(nil))

-- 字符串连接
print("a" .. 'b')

--[[ 以下是boolean类型相关测试 ]]

print(type(true))
print(type(false))

if nil then
    print("nil 为 true")
else
    print("nil 为 false")
end

if NaN then -- NaN用于表示未定义的运算结果，如0/0
    print("NaN 为 true")
else
    print("NaN 为 false")
end

if 0 then
    print("数字 0 为 true")
else
    print("数字 0 为 false")
end

if '' then
    print("空字符串 为 true")
else
    print("空字符串 为 false")
end


--[[ 以下是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))


--[[ 以下是string类型相关测试 ]]

str1 = "This is str1." -- 声明变量，字符串写法1
str2 = 'This is str2.' -- 声明变量，字符串写法2
str3 = [[
This is str3.
]] -- 声明变量，字符串写法3

print(str1)
print(str2)
print(str3)

print("2" + 6) -- 数字类型字符串算术运算时认为会当作数字
print("2" + "6") -- 数字类型字符串算术运算时认为会当作数字
print("2 + 6") -- 这是一个单纯的字符串
-- print("error" + 1) -- 这会报错
print("error" .. 1) -- 使用 .. 拼接字符串
print("Hello" .. " " .. "Naisu" .. "!") -- 使用 .. 拼接字符串
print(#"naisu") -- 使用 # 计算字符串长度
print(#str1) -- 使用 # 计算字符串长度


--[[ 以下是table类型相关测试 ]]
-- Lua中的table是一个关联数组（associative arrays）
-- 可以当作常见的数组使用，也可以当作键值对使用，或者也可以混合使用
-- 当作键值对使用时，键可以是除nil和NaN外的任意值，值可以是除nil外的任意值

tbl1 = {} -- 创建一个空表
tbl2 = {"apple", "pear", "orange", "grape"} -- 创建一个带初值的数组类型的表
tbl3 = { c1=1, c2=2, c3=3 } -- 创建一个带初值的键值对类型的表

for key, val in pairs(tbl2) do
    print(key .. " : " .. val) -- 遍历输出表中元素，数组形式会顺序输出
end

for key, val in pairs(tbl3) do
    print(key .. " : " .. val) -- 遍历输出表中元素，键值对形式并不一定按照顺序输出
end

print(tbl2[-1]) -- 默认索引是从1开始的，但可以手动添加负索引元素
print(tbl2[0]) -- Lua的索引并非从0开始，而是从1开始 !!!
print(tbl2[1]) 
print(tbl2[4])

tbl2[5] = 233 -- 直接添加新元素
print(#tbl2) -- 计算数组长度，如果元素中有值是nil该方式使用时需要当心
print(tbl2[5])

print(tbl3["c1"]) -- 键值对通过键名获取元素
print(tbl3.c1) -- 键值对也可以通过这种方式获取元素
tbl3["c4"] = 233
tbl3.c5 = 777
print(tbl3.c4)
print(tbl3.c5)

1
2
3
4
5
6
7
8
9

-- 双横线及后面的内容是单行注释

--[[ 这是多行注释
这是多行注释 ]]

--[=[ 这也是多行注释
这也是多行注释 ]=]

-- 在ZeroBrane Studio中注释中使用 [text](url) 方式将成为一个超链接

 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

-- 字符串全部转为大写字母。
string.upper(argument)

-- 字符串全部转为小写字母。
string.lower(argument)

-- 在字符串中替换。。
---- mainString 为要操作的字符串
---- findString 为被替换的字符
---- replaceString 要替换的字符
---- num 替换次数（可以忽略，则全部替换）
string.gsub(mainString,findString,replaceString,num)

-- 在一个指定的目标字符串中搜索指定的内容(第三个参数为索引),返回其具体位置。不存在则返回 nil。
string.find (str, substr, [init, [end]])

-- 字符串反转
string.reverse(arg)

-- 返回一个类似printf的格式化字符串
string.format(...)

-- char 将整型数字转成字符并连接
string.char(...) 

-- byte 转换字符为整数值(可以指定某个字符，默认第一个字符)
string.byte(arg[,int])

-- 计算字符串长度。
string.len(arg)

-- 返回字符串string的n个拷贝(重复n次)
string.rep(string, n)

-- 链接两个字符串
str1 .. str2

-- 返回一个迭代器函数，每一次调用这个函数，返回一个在字符串 str 找到的下一个符合 pattern 描述的子串。如果参数 pattern 描述的字符串没有找到，迭代函数返回nil。
string.gmatch(str, pattern)

-- 只寻找源字串str中的第一个配对. 参数init可选, 指定搜寻过程的起点, 默认为1。
-- 在成功配对时, 函数将返回配对表达式中的所有捕获结果; 如果没有设置捕获标记, 则返回整个配对字符串. 当没有成功的配对时, 返回nil。
string.match(str, pattern, init)

-- 截取字符串。j：截取结束位置，默认为 -1，最后一个字符。
string.sub(s, i [, j])

 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
57
58
59
60
61
62
63
64
65
66
67

a = "hello" .. "world"

-- 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[j]'

var1 = 777 -- 全局变量

function func1()
  var2 = 233 -- 全局变量
  local var3 = "naisu" -- local修饰的是局部变量
  return var2, var3
end

func1() -- 运行函数

print(var1, var2, var3) -- var3在这里不存在，会打印为nil

a, b = 22, 33 -- 可以同时对多个变量赋值
print(a, b)

a, b = b, a -- 利用这个特性可以方便的交换两个元素
print(a, b)

a, b = func1() -- 或者接收函数的多个返回值
print(a, b)

c, d = 0 -- 需要注意的是多个变量需要分别赋值
print(c, d)

-- Lua 5.2 及其之后所有的全局变量等都是挂在 _ENV 这个表中的
-- Lua 5.2 之前是相似的表是 _G，不过新版本也做了兼容 _ENV[‘_G’]=_ENV
 
print(_ENV.var1)

function func2()
    local _ENV={print = print, abb = "robot"} -- 函数内部自己的全局环境
    print(_ENV.abb)
end

func2()

-- Lua 5.4中新增的常量定义
local var <const> = "value" -- 必须在声明时赋值，之后无法修改

--[[
算数运算符
+: 加
-: 减
*: 乘
/: 除
//: 整除
%: 取余
^: 幂乘
-: 符号
]]

--[[
位运算符
&: 按位与
|: 按位或
~: 按位异或（两个值时）；按位取反（一个值时）
>>: 右移
<<: 左移
]]

  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
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

var1 = 10

-- Lua中 do ... end 之间是一个代码块
do
  local var1 = 666
  print(var1)
end

print(var1)

-- if
print("if:")

if 0 then
  print("Lua中数值 0 为 true")
end

if nil then
  print("nil is true" )
else
  print("nil is false" )
end

if nil then
  print("nil is true" )
elseif false then
  print("false is false")
else
  print("both nil and false is false" )
end

-- while演示
print("while:")

while var1 < 13 do 
  var1 = var1 + 1
  print(var1)
end

-- repeat 类似其他语言 do ...  while。
print("repeat:")

repeat
  var1 = var1 + 1
  print(var1) 
until var1 > 15


-- for
print("for:")

for i = 0, 2 do -- i从0到2，每次以步进1递增
  print(i)      -- 注意会打印2
end

for i = 10, 1, -3 do -- i从10到1，每次以步进-3递增
  print(i)
end

-- 数值循环：var 从 exp1 变化到 exp2，每次变化以 exp3 为步长递增 var，并执行一次 "执行体"。exp3 是可选的，如果不指定，默认为1。
for var=exp1,exp2,exp3 do  
    print(var)
end  

tbl1 = {22, 33, x=666, y=777, 888 }

print("for pairs:")
for k, v in pairs(tbl1) do -- pairs是Lua提供的一个迭代器函数,适合用来遍历键值对
  print(k, v)              -- 注意输出是乱序的
end

print("for ipairs:")
for i, v in ipairs(tbl1) do -- ipairs是Lua提供的一个迭代器函数,适合用来遍历数组
  print(i, v)
end

-- break
print("break:")

for i = 0, 5 do
  print(i)      
  if i > 1 then
    break
  end
end

-- goto
print("goto:")

for i=1, 3 do
    if i <= 2 then
        goto continue -- 调至标签
    end
    print("no goto")
    ::continue:: -- 标签两边用::
    print(i)
end

--[[
关系运算符
==: 等于
~=: 不等于
<:  小于
>:  大于
<=: 小于等于
>=: 大于等于
]]

--[[
逻辑运算符
and: 逻辑与
or:  逻辑或
not: 逻辑非
]]

1
2
3
4

optional_function_scope function function_name( argument1, argument2, argument3..., argumentn)
    function_body
    return result_params_comma_separated
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

function maximum (a)
    local mi = 1             -- 最大值索引
    local m = a[mi]          -- 最大值
    for i,val in ipairs(a) do
       if val > m then
           mi = i
           m = val
       end
    end
    return m, mi
end

print(maximum({8,10,23,12,5}))

1
2
3
4
5
6
7
8

function add(...)  
local s = 0  
  for i, v in ipairs{...} do   --> {...} 表示一个由所有变长参数构成的数组 。inpairs没有使用括号，应该是语法编译。
    s = s + v  
  end  
  return s  
end  
print(add(3,4,5,6,7))  ---> 25

 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

function func1() -- 无参数无返回值函数
  -- 语句
end

function func2(arg1, arg2) -- 带参数无返回值函数
  -- 语句
end

function func2() -- 无参数，带多个返回值的函数
  return 22, 33
end

func3 = function() -- 匿名函数直接赋值给变量
  -- 语句
end

function func4() -- 闭包
  local i = 0
  return function()
    i = i + 1
    print(i)
  end
end

f1 = func4()
f1()
f1()

f2 = func4()
f2()
f2()  

function func5(...) -- 带可变参数的函数
  local arg={...} -- 接收可变参数为表
  for i,v in ipairs(arg) do
    print(i, v)
  end
end

func5("naisu", 233, 666)

local function func6() -- 本地函数
  -- 语句
end

1
2
3
4
5
6
7
8

^
not    - (unary)
*      /       %
+      -
..    #
<      >      <=     >=     ~=     ==
and
or

1
2
3
4
5

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)          ：：：：右结合的：：：，注意顺序

1

array = {"Lua", "Tutorial"}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

array = {}

for i= -2, 2 do
   array[i] = i *2
end

for i = -2,2 do
   print(array[i])
end
--[[ 
OUTPUT:
-4
-2
0
2
4
]]

1
2
3
4
5
6
7
8

-- 初始化数组
array = {}
for i=1,3 do
   array[i] = {}
      for j=1,3 do
         array[i][j] = i*j
      end
end

1
2
3

for k, v in pairs(t) do
    print(k, v)
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

--迭代函数
function square(iteratorMaxCount,currentNumber)
   if currentNumber<iteratorMaxCount
   then
      currentNumber = currentNumber+1
   return currentNumber, currentNumber*currentNumber
   end
end

for i,n in square,3,0
do
   print(i,n)
end

--OUTPUT：
1    1
2    4
3    9

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

--迭代函数。参数a：是状态常量，i：控制变量
function iter (a, i)
    i = i + 1
    local v = a[i]
    if v then
       return i, v
    end
end
 
function ipairs (a)
    return iter, a, 0
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

array = {"Google", "Runoob"}

function elementIterator (collection)
   local index = 0
   local count = #collection   --collectioin 长度
   -- 闭包函数
   return function ()
      index = index + 1
      if index <= count
      then
         --  返回迭代器的当前元素
         return collection[index]
      end
   end
end

for element in elementIterator(array)  -- elementIterator(array) 调用的返回值（闭包） ，作为一个迭代函数。
do
   print(element)
end
--OUTPUT：
Google
Runoob

1
2
3
4
5
6
7
8
9

-- 初始化表
mytable = {}

-- 指定值
mytable[1]= "Lua"

-- 移除引用
mytable = nil
-- lua 垃圾回收会释放内存