【Lua】十分钟入门

Lua是一种上手成本很低的脚本语言，本文简单阐述了lua的入门知识。

一、基本语法

1. 变量

Lua有8个基本类型：无效值nil、布尔值boolean、数number、字符串string、函数function、自定义类型userdata、线程thread、表table（key-value表）。

无需声明一个变量就可使用，不过在赋值之前，变量的值为nil，表示不存在。

Lua为动态类型语言，变量的类型可以动态改变。

print(a) -- nil
print(type(a)) -- nil
a= 1
print(a) -- 1
print(type(a)) -- number
a= "abc" 
print(a) -- abc
print(type(a)) -- string

一些要注意的点

• number
  所有数字都是双精度浮点数。

• nil
  虽然nil的类型是nil，但是type(nil)返回的是字符串"nil"。

• string
  拼接字符串使用..而不是加号。1+"1"会得到2.0。

• table
  table是key-value形式的表，可以嵌套。
  初始化格式tb = {[key1] = value1, [key2] = value2, ...}，如tb = {["a"] = "hello", ["b"] = {1, 2, 3}}。
  使用tb[key]来取对应的value值，表中没有的项会返回nil；使用tb[key] = value的形式来更新表。

• 数组
  Lua中数组的本质是一个table。
  使用tb = {"a", "b", "c"}的形式初始化一个数组，等同于tb = {[1] = "a", [2] = "b", [3] = "c"}。
  要注意数组的序号是从1开始的，并且数组中元素的数据类型不需要一致。

• 变量作用域
  变量默认是全局的，一处定义到处使用。
  使用local关键字修饰变量，可以将其变为局部变量。

2. 循环

2.1 for

循环有两种方式：数值循环和迭代循环。

2.1.1 数值循环
数值循环格式：

for i = 起始值, 结束值, 间隔值 do
    -- statements
end

其中，间隔值为1的时候可以省略。

2.1.2 迭代循环
遍历表tb：

tb = {["a"] = "hello", ["b"] = 2}
for k,v in pairs(tb) do
    print(k, v)
end

其中，pairs为内置函数，提供了table的迭代器。

2.2 while

while格式：

while(condition)
do
   -- statements
end

2.3 repeat-until

repeat-until格式：

repeat
   -- statements
until( condition )

3. 条件语句

格式：

if(cond1) then
    -- statements
elseif(cond2) then
    -- statements
elseif(cond3) then
    -- statements
...
else
    -- statements
end

4. 函数

function类型的变量有两种定义方式，二者等价。调用的时候记得加括号，不然就是一个普通的变量。

function a(num)
    print("hello "..num)
end
a(5) -- hello 5
print(a) -- 变量地址
print(type(a)) -- function
a = function()
    print("a")
end
a() -- a
print(a) -- 变量地址
print(type(a)) -- function
a -- 报错

有几点需要注意：

1. 函数可以嵌套；
2. 函数默认是全局的，即使是嵌套在其他函数中；如果要定义局部函数，使用local关键字。

例：

function a()
	print("a")
	function b()
		print("b")
	end
	c = function()
		print("c")
	end
	local function d()
		print("d")
	end
end

a() -- a
b() -- b
c() -- c
d() -- 报错，局部函数外部不能访问

可变长参数
使用...表示可变长的参数。
使用pairs{...}来获取变长参数的迭代器。
使用select("#", ...)来获取传入的可变长参数个数。

f = function(...) -- 可变参数函数
    print("一共有"..select("#", ...).."个参数")
    for k, v in pairs{...} do
        print(k..": "..v)
    end
end
f("a", "b", "c")

输出

一共有3个参数
1: a
2: b
3: c

5. 运算符

数学运算：
+、-、*、/：加减乘除
%：求余
^：求幂

关系运算：
==：等于
~=：不等于
>、<、>=、<=：大于、小于、大于等于、小于等于

逻辑运算：
and：与
or：或
not：否

其他：
…：字符串连接
#：返回字符串或表的长度

二、字符串和表

1. 字符串

1.1 字符串的初始化

字符串有三种定义方式：单引号、双引号、双方括号。

-- 以下三种等价
a = 'abc'
a = "abc"
a = [[abc]]

1.2 字符串的一些操作

以下列举了一些常用的字符串操作。

长度
使用#操作符或者string.len(s)函数。

s = "abcd"
print(#s) -- 4
print(string.len(s)) -- 4

拼接
使用..拼接两个字符串。

a = "hello, "
b = "world!"
c = a..b
print(c) -- hello, wolrd!

截取
使用string.sub(s, 起始位置, 结束位置)函数截取字符串，负号表示倒数的位置。其中结束位置可以省略，默认到字符串结尾。
注意这个位置是以1为起始的，并且包含结束位置的字符。一般来讲，Lua中的序号都是以1起始，并且起始位置都是包括（included）的。

s = "abcdefg"
a = string.sub(s, 2, 4)
print(a) -- bcd

查找
使用string.find(s, 查找内容, 起始位置, 结束位置)在字符串中查找内容，其中起始位置、结束位置可以省略。
这个函数会返回一个数对，表示查找内容的起始、结束位置。
使用string.gmatch(s, 查找内容)在字符串查找所有匹配的内容，返回一个列表。
以上2个函数都可以使用正则表达式。如果没有查找到，会返回nil。

s = "abcabc"
a, b = string.find(s, "ab")
print(a, b) -- 1  2

s = "abc123?{}_"
print(string.find(s, "b%a%d+")) -- 2, 6
print(string.find(s, "^.*%?")) -- 1, 7

替换
使用string.gsub(s, 被替换的内容, 替换的内容, 替换的次数)，其中替换次数可以省略，默认全部替换。
注意这个函数不改变原来的字符串。
被替换内容可以使用正则表达式。

s = "abcabc"
a = string.gsub(s, "ab", "d")
print(a) -- dcdc

与整数的转换
使用string.char(...)将一系列整数拼接为字符串；使用string.byte(s[,index])将字符串中的某个字符转换为整数。这里的整数指的是对应字符在ascii表中对应的编号。

s = string.char(97,98,99)
print(s) -- abc
print(string.byte(s, 1)) -- 97

格式化
使用string.format(s, ...)来进行格式化，类似于C的printf和java中的String.format()。

s = string.format("name is %s, age is %d", "bob", 18)
print(s) -- name is bob, age is 18

其他
使用string.reverse(s)来进行字符串反转。
使用string.upper(s)将字符串转换为大写；使用string.lower(s)将字符串转换为小写。

2. 表

2.1 表的初始化

使用t = {}建立一个空表。
使用t = {"a", "b", "c"}建立一个以序号为key的表，也就是数组；数组是一种特殊的表。
使用t = {["a"] = "hello", ["b"] = "world", "c" = 1}来建立key-value格式的表。

2.2 表的一些常用操作

增删改查
使用t[key]查找表中元素；如果不存在，返回nil。
使用t[key] = value来进行key-value对的赋值；如果这个key不存在，那么就在表中添加这个k-v对。
使用t[key] = nil删除这个kv对。
使用table.insert(t, 插入位置, 插入内容)在数组中插入；插入位置可以省略，默认在最尾部。
使用table.remove(t, 删除位置)删除数组中对应位置的元素；删除位置可以省略，则删除最后一项。

排序
使用table.sort(t[,comp])对数组进行排序，默认为升序。
其中comp为比较函数，需要传入两个参数，返回比较结果；如果希望第一个参数排在前面，返回true，否则返回false。例如，如果要将数组降序排列：

-- 降序排列数组
t = {3, 2, 5, 1, 4}
table.sort(t, function(a, b)
    return a > b
end)
-- 自定义的打印数组的函数
printArray(t) -- [5, 4, 3, 2, 1]

拼接
使用table.concat(t[,分隔符号[,起始位置[,结束位置]]])来将数组拼接为字符串；其中分隔符号、起始位置、结束位置可以省略，默认为直接拼接、数组头部、数组尾部。

t = {"hello", ",", "world", "!"}
print(concat(t)) -- hello, wolrd!

三、一些常用函数

print(…)函数
打印内容。

pairs(t)和ipairs(t)函数
pairs()和ipairs()都可以在遍历表的时候使用，会返回表的迭代器，使用方式几乎是一样的。区别在于，pairs()会列出表中的所有k-v对，而ipairs()只会列出key值从1开始依次递增的k-v对。

t= {[1] = 'a', [2] = 'b', [3] = 'c', [5] = 'e', ['nil'] = 'nil'}
print('-- pairs --')
for k, v in pairs(t) do
	print(k, v)
end
print('-- ipairs --')
for k, v in ipairs(t) do
	print(k, v)
end

如上例中，输出如下：

– pairs –
nil nil
1 a
2 b
3 c
5 e
– ipairs –
1 a
2 b
3 c

这么说有些拗口，简单来说的话，pairs()是用来遍历map的，而ipairs()是用来遍历数组的，并且不能有nil值，这样就行了。

type(v)函数
返回一个变量的类型。

local关键字
Lua中的变量默认都是全局变量。要定义局部变量，使用local关键字修饰。