lua语言快速入门

缺乏、安全感 2023-01-02 06:27 149阅读 0赞

### lua语言快速入门 ###

*   *  1. Lua快速入门
     *   *  1.1 数据类型
         *  1.1.2 字符串
         *  1.1.3 布尔值
         *  1.1.4 数字
         *  1.1.5 函数
         *  1.1.6 table
         *  1.1.7 空值
         *  1.2 常用标准库
         *   *  1.2.1 string 库
             *  1.2.2 table 库
         *  1.2.3 math 库
         *  1.3 虚变量
     *  2. Lua 语言比较特别的几个地方
     *   *  2.1 Lua 的下标从 1 开始
         *  2.2 使用 .. 来拼接字符串
         *  2.3 只有 table 这一种数据结构
         *  2.4 默认是全局变量

## 1. Lua快速入门 ##

### 1.1 数据类型 ###

Lua 中的数据类型不多，可以通过 type 函数来返回一个值的类型

print(type(print))
    print(type(true))
    print(type(360.0))
    print(type({ }))
    print(type(nil))
    --function
    --boolean
    --number
    --table
    --nil

### 1.1.2 字符串 ###

在 Lua 中，字符串是不可变的值，如果要修改某个字符串，就等于创建了一个新的字符串。这种做法显然有利有弊：好处是即使同一个字符串出现了很多次，在内存中也只有一份；但劣势也很明显，如果想修改、拼接字符串，会额外地创建很多不必要的字符串。

下面这段代码来说明这个弊端。把 1 到 10 这些数字当作字符串拼接起来，在 Lua 中，使用两个点号来表示字符串的相加

local s = ""
    for i = 1, 10 do
        s = s .. tostring(i)
    end print(s)

这里循环了 10 次，但只有最后一次是想要的，而中间新建的 9 个字符串都是无用的。它们不仅占用了额外的空间，也消耗了不必要的 CPU 运算。

另外，在 Lua 中，有三种方式可以表达一个字符串：单引号、双引号，以及长括号（\[\[\]\]）。  
长括号中的字符串不会做任何的转义处理，如果字符串中包括了长括号本身，则在长括号中间增加一个或者多个 = 符号

print([[string has \n and \r]])
    -- string has \n and \r
    print([=[string has a [[]].]=])
    -- string has a [[]].

### 1.1.3 布尔值 ###

在 Lua 中，只有 nil 和 false 为假，其他都为真，包括 0 和空字符串也为真。

local a = 0
    if a then
        print("true")
    end
    a = ""
    if a then
        print("true")
    end

这种判断方式和很多常见的开发语言并不一致，所以，为了避免在这种问题上出错，可以显式地写明比较的对象，比如下面这样：

local a = 0
    if a == false then
        print("true")
    end

### 1.1.4 数字 ###

Lua 的 number 类型，是用双精度浮点数来实现的。值得一提的是，LuaJIT 支持 dual-number（双数）模式，也就是说， LuaJIT 会根据上下文来用整型来存储整数，而用双精度浮点数来存放浮点数。

此外，LuaJIT 还支持长长整型的大整数，比如下面的例子  
resty(OpenResty命令)

$ resty -e 'print(9223372036854775807LL - 1)'
    9223372036854775806LL

### 1.1.5 函数 ###

可以把函数存放在一个变量中，也可以当作另外一个函数的入参和出参  
比如，下面两个函数的声明是完全等价的：

function foo()
     end

和

foo = function ()
     end

### 1.1.6 table ###

table 是 Lua 中唯一的数据结构

local color = {  first = "red" }
    print(color["first"])
    --red

### 1.1.7 空值 ###

在 Lua 中，空值就是 nil。如果定义了一个变量，但没有赋值，它的默认值就是 nil：

local a
    print(type(a))
    --nil

### 1.2 常用标准库 ###

Lua 比较小巧，内置的标准库并不多

#### 1.2.1 string 库 ####

字符串操作是最常用到的，也是坑最多的地方。Lua 的正则独树一帜，不符合 PCRE 的规范。

其中 string.byte(s \[, i \[, j \]\])，是比较常用到的一个 string 库函数，它返回字符 s\[i\]、s\[i + 1\]、s\[i + 2\]、······、s\[j\] 所对应的 ASCII 码。i 的默认值为 1，即第一个字节，j 的默认值为 i。

print(string.byte("abc", 1, 3))
    print(string.byte("abc", 3)) -- 缺少第三个参数，第三个参数默认与第二个相同，此时为 3
    print(string.byte("abc"))    -- 缺少第二个和第三个参数，此时这两个参数都默认为 1
    --97 98 99
    --99
    --97

#### 1.2.2 table 库 ####

table.concat一般用在字符串拼接的场景下，比如下面这个例子。它可以避免生成很多无用的字符串。

local a = { "A", "b", "C"}
    print(table.concat(a))

### 1.2.3 math 库 ###

Lua math 库由一组标准的数学函数构成。数学库的引入，既丰富了 Lua 编程语言的功能，同时也方便了程序的编写。

比如下面的这段代码，它可以在指定的范围内，随机地生成两个数字。

math.randomseed(os.time())
    print(math.random())
    print(math.random(100))

### 1.3 虚变量 ###

Lua 提供了一个虚变量（dummy variable）的概念，以一个下划线来命名，用来表示丢弃不需要的数值，仅仅起到占位的作用。

下面以 string.find 这个标准库函数为例，来看虚变量的用法。这个标准库函数会返回两个值，分别代表开始和结束的下标。

如果只需要获取开始的下标，那么很简单，只声明一个变量来接收 string.find 的返回值即可：

local start = string.find("hello", "he") 
    print(start)
    --1

但如果只想获取结束的下标，那就必须使用虚变量了：

local _, end_pos = string.find("hello", "he")
    print(end_pos)
    --2

除了在返回值里使用，虚变量还经常用于循环中，比如下面这个例子：

for _, v in ipairs({  4, 5, 6 }) do
        print(v)
    end
    --4
    --5
    --6

## 2. Lua 语言比较特别的几个地方 ##

### 2.1 Lua 的下标从 1 开始 ###

t={ 100};
    print(type(t[0]))
    print(type(t[1]))
    --nil
    --number

下标0打印出来是空值

### 2.2 使用 … 来拼接字符串 ###

和大部分语言使用 + 不同，Lua 中使用两个点号来拼接字符串：

print('hello' .. ', world')

### 2.3 只有 table 这一种数据结构 ###

Lua 中只有一种数据结构，那就是 table，它里面可以包括数组和哈希表：

local color = { first = "red", "blue", third = "green", "yellow"}
    print(color["first"])                 --> output: red
    print(color[1])                         --> output: blue
    print(color["third"])                --> output: green
    print(color[2])                         --> output: yellow
    print(color[3])                         --> output: nil

如果不显式地用\_键值对\_的方式赋值，table 就会默认用数字作为下标，从 1 开始。所以 color\[1\] 就是 blue。

另外，想在 table 中获取到正确长度，也是一件不容易的事情

local t1 = {  1, 2, 3 }
    print("Test1 " .. table.getn(t1))
    
    local t2 = {  1, a = 2, 3 }
    print("Test2 " .. table.getn(t2))
    
    local t3 = {  1, nil }
    print("Test3 " .. table.getn(t3))
    --Test1 3
    --Test2 2
    --Test3 1

想要在 Lua 中获取 table 长度，必须注意到，只有在 table 是 ‘序列’ 的时候，才能返回正确的值。

那什么是序列呢？首先序列是数组（array）的子集，也就是说，table 中的元素都可以用正整数下标访问到，不存在键值对的情况。对应到上面的代码中，除了 t2 外，其他的 table 都是 array。

其次，序列中不包含空洞（hole），即 nil。综合这两点来看，上面的 table 中， t1 是一个序列，而 t3 是 array，却不是序列（sequence）。

### 2.4 默认是全局变量 ###

在 Lua 中声明变量时，前面都要加上 local

local s = 'hello'

这是因为在 Lua 中，变量默认是全局的，会被放到名为 \_G 的 table 中。不加 local 的变量会在全局表中查找，这是昂贵的操作。如果再加上一些变量名的拼写错误，就会造成难以定位的 bug。

所以，强烈建议总是使用 local 来声明变量，即使在 require module 的时候也是一样：

-- Recommended 
    local xxx = require('xxx')
    -- Avoid
    require('xxx')