Lua入门使用与基础语法

目的

Lua是一种非常小巧的脚本语言，基于C构建并且完全开源，可以方便的嵌入到各种项目中，当然也可以单独使用。Lua经常被用在很多非脚本语言的项目中，用来扩展脚本功能，提供一定的灵活性。最常见的应用场景就是各类游戏中（比如魔兽世界和愤怒的小鸟）。这篇文章将对相关内容做个入门介绍。

官网：https://www.lua.org/

基础说明

Lua is a powerful, efficient, lightweight, embeddable scripting language. It supports procedural programming, object-oriented programming, functional programming, data-driven programming, and data description.
Lua是一种强大、高效、轻量级、可嵌入的脚本语言。它支持程序化编程、面向对象编程、函数式编程、数据驱动编程和数据描述。

Lua is dynamically typed, runs by interpreting bytecode with a register-based virtual machine, and has automatic memory management with a generational garbage collection, making it ideal for configuration, scripting, and rapid prototyping.
Lua 是动态类型的， 通过使用基于寄存器的解释字节码来运行虚拟机，并具有自动内存管理和垃圾收集， 使其成为配置、脚本编写、 和快速原型制作。

As an extension language, Lua has no notion of a “main” program: it works embedded in a host client, called the embedding program or simply the host. The host program can invoke functions to execute a piece of Lua code, can write and read Lua variables, and can register C functions to be called by Lua code. Through the use of C functions, Lua can be augmented to cope with a wide range of different domains, thus creating customized programming languages sharing a syntactical framework.
作为一种扩展语言，Lua没有“主”程序的概念： 它嵌入在主机客户端中工作， 称为嵌入程序或简称为主机。 宿主程序可以调用函数来执行一段 Lua 代码， 可以写入和读取Lua变量， 并且可以注册要由Lua代码调用的C函数。 通过使用 C 函数，Lua 可以增强以应对 广泛的不同领域， 从而创建共享语法框架的自定义编程语言。

Lua语法相关的使用手册可以在下面链接中获得：
https://www.lua.org/manual/

开发环境

可以直接在线体验Lua：
http://www.lua.org/demo.html

也可以下载对应的编译好的Lua解释器来使用：
https://luabinaries.sourceforge.net/

当然官方推荐可以使用下面这个IDE（ZeroBrane Studio）：
https://studio.zerobrane.com/

目前版本该软件设置中文和解释器版本方式如下：

现在来说也可以使用VS Code加扩展的方式来使用，在这里就先不介绍了。

基础语法

注释

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

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

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

-- 在ZeroBrane Studio中注释中使用 [text](url) 方式将成为一个超链接
1
2
3
4
5
6
7
8
9

数据类型

Lua是动态类型语言，变量声明时无需指定类型，类型会在赋值时自动确定。

Lua中有8中基本类型：

下面代码可以直接测试相关内容：

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

print(type(nil))


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

变量

下面代码可以直接测试相关内容：

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

流程控制

下面代码可以直接测试相关内容：

var1 = 10

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

print(var1)


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

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


-- repeat
print("repeat:")

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


-- 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


-- 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


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

print("for pairs:")
for k, v in pairs(tbl1) do -- pairs适合用来遍历键值对
  print(k, v)              -- 注意输出是乱序的
end

print("for ipairs:")
for i, v in ipairs(tbl1) do -- ipairs适合用来遍历数组
  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
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
115
116

函数

下面代码可以直接测试相关内容：

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
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

总结

Lua的入门使用和基础语法本身还是挺简单的。