Lua速通

速通
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
<!-- wp:paragraph -->
<p>-- 单段注释</p>
<!-- /wp:paragraph -->

<!-- wp:paragraph -->
<p>--[[多段注释]]--</p>
<!-- /wp:paragraph -->

<!-- wp:paragraph -->
<p>一个汉字占3个字符：a = 'abc字符串' #a = 12</p>
<!-- /wp:paragraph -->

### lua中的数据类型

<!-- wp:paragraph -->
<p>数字number 、 字符串string 、布尔boollean 、 空nil</p>
<!-- /wp:paragraph -->

<!-- wp:paragraph -->
<p>函数function 、 表table 、数据结构 userdata、 协同程序thread</p>
<!-- /wp:paragraph -->

### 三目运算符(模拟)

<!-- wp:paragraph -->
<p>(1 > 2) and "1大于2" or "1不大于2"</p>
<!-- /wp:paragraph -->

### 循环

#### while循环

```lua
num = 0
while num < 5 do
    print(num)
    num = num + 1
end

repeat until

1
2
3
4
5
num = 0
repeat
    print(num)
    num = num + 1
until num > 10 --满足条件跳出

for循环

1
2
3
for i = 1, 10, 1 do --默认每次递增1
    print(i)
end

函数

没有函数的重载

形参，多了少了不会报错，可以用多个临时变量接取

1
2
3
function helloWorld()
    print("Hello World!")
end

table表

推荐用pairs

1
2
3
4
5
6
7
8
9
--迭代器索引表通过ipairs()函数来迭代，中间断了就无法遍历出后面的内容
for i, v in ipairs(arr) do
    print(i, v)
end

--迭代器通过pairs()来遍历所有的键值对，可以得到所有的信息
for k, v in pairs(t) do
    print(k, v)
end

用table实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
student = {
    name = "xuzhuo",
    age = 20,
    gender = "male",
    fun = function()
        print("My name is " .. student.name)
    end
}

--函数的第三种声明方式
function student:speek()
    print("My name is " .. self.name)
end

点和冒号的区别：冒号在访问函数的时候，会将自己当作第一个参数传入进去

多脚本执行

全局变量和局部变量

a = 10 全局变量

local c = "aaaa" 局部变量

多脚本执行

require("对应的脚本")

卸载脚本

package.loaded["text"] = nil

大G表

所有的全局变量都以键值对的形式存在于大G表中 _G

特殊用法

多变量赋值

多返回值

1
2
3
4
5
function test()
    return 1, 2, 3, 4
end
a, b, c = test()
print(a, b, c)

and or

--在lua中只有 uil 和 false才是假

--短路：对于and来说 有假则假 对于or来说 有真则真

--所以 它们只要判断出第一个 是否满足 就会停止计算了

协程

协程的本质是一个线程

协程创建

1.coroutine.create(函数) 返回值是一个thread对象

2.coroutine.wrap(函数) 返回值 一个函数

协程的运行

coroutine.resume(协程对象)

直接调用函数（用wrap创建的）

协程挂起

 coroutine.yield(返回值)

协程状态

coroutine.status(协程或者协程函数)

--dead表示协程已经执行完毕，没有挂起的状态

--suspended表示协程正在挂起，没有执行完毕的状态

--running表示协程正在执行的状态

元表

概念

--任何表变量都可以有自己的元表(爸爸)

--当我们子表中进行特定操作时，会执行元表中的方法

设置元表

--第一个参数子表、第二个参数元表（爸爸）

setmetatable(MyTable, meta)

特定操作

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
meta = {
    -- __index当成子表中 找不到某一个属性时
    -- 会到元表中 __index中找
    __index = {
        age = 190
    },

    -- __newindex 当赋值时，如果赋值一个不存在的索引
    -- 那么就会把这个值赋值到newindex所指的表中，不会修改自己原有的表
    __newindex = {

    },

    --把子表当成字符串打印
    __tostring = function(str)
        return "我是爸爸：" .. str.name
    end,

    --把子表当成函数使用就会调用__call方法
    __call = function()
        print("我是爸爸，我正在给你打电话...")
    end,

    --运算符重载
    __add = function(a, b)
        return a.name + b.name
    end,

    __sub = function(a, b)
        return a.name - b.name
    end
}

--rawset 该方法会忽略newindex的设置，只会该自己的变量

rawset(MyTable, "age", 180)

print(MyTable.age)

面向对象

封装

1.表就是类的表现方法

2.修改创建出来的成岩变量时，就为了这个空表对象新建了一个成员属性

继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
function Object:subClass(className)
    --在大G表中创建子类
    _G[className] = {}
    --获取引用
    local subClass = _G[className]
    --记录父类
    subClass.base = self
    --设置__index
    subClass.__index = subClass
    --继承父类
    setmetatable(subClass, { __index = self })
end

function Object:new()
    --创建对象
    local obj = {}
    --设置__index
    self.__index = self
    --继承父类
    setmetatable(obj, self)
    return obj
end

setmetatable(subClass, { __index = self }) 用于子类的继承，通过一个新元表实现当子类查找不到属性时，到父类中查找；

setmetatable(obj, self) 用于实例化对象，直接将类作为元表，使对象继承类的方法和属性（前提是类中要设置好 __index）。

多态

直接重写方法

1
2
3
4
5
6
7
8
9
10
11
12
function GameObject:move()
    self.Posx = self.Posx + 1
    self.Posy = self.Posy + 1
    print("GameObject move to:", self.Posx, self.Posy)
end

GameObject:subClass("Player")

--子类重写方法
function Player:move()
    self.base.move(self)
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
--时间
print(os.time())

print(os.time { year = 2021, month = 3, day = 25, hour = 13, min = 30, sec = 0 })

print(os.date())

--数学
print(math.abs(-10))           --绝对值

print(math.deg(math.pi / 2))   --弧度转角度制

print(math.cos(math.pi / 4))   --三角函数

print(math.floor(2.6))         --向下取整

print(math.ceil(2.4))          --向上取整

print(math.max(1, 2, 3, 4, 5)) --最大值

print(math.min(1, 2, 3, 4, 5)) --最小值

print(math.random())           --随机数

print(math.random(1, 10))      --指定范围随机数

print(math.sqrt(9))            --平方根

--字符串
print(string.byte("hello"))      --字符转ASCII码

print(string.char(97, 98, 99))   --ASCII码转字符

print(string.len("hello"))       --字符串长度

print(string.lower("HELLO"))     --转小写

print(string.upper("hello"))     --转大写

print(string.rep("hello", 3))    --重复字符串

print(string.sub("hello", 2, 4)) --截取字符串

垃圾回收

collectgarbage("count") --获取当前lua占用的内存

collectgarbage("collect") -- 启动一次自动的垃圾回收

```