【Lua】十分钟入门

旧城等待， 2022-10-24 01:37 36阅读 0赞

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

### 文章目录 ###

*  一、基本语法
 *   *  1. 变量
     *  2. 循环
     *   *  2.1 for
         *  2.2 while
         *  2.3 repeat-until
     *  3. 条件语句
     *  4. 函数
     *  5. 运算符
 *  二、字符串和表
 *   *  1. 字符串
     *   *  1.1 字符串的初始化
         *  1.2 字符串的一些操作
     *  2. 表
     *   *  2.1 表的初始化
         *  2.2 表的一些常用操作
 *  三、一些常用函数

# 一、基本语法 #

## 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`关键字修饰。