Lua踩坑记录(持续更新)

置顶幻冬

已于 2023-09-09 09:55:25 修改

阅读量2.8k

点赞数 10

分类专栏： Unity 游戏开发文章标签： lua unity unity3d

于 2020-10-17 18:01:54 首次发布

本文链接：https://blog.csdn.net/weixin_43994445/article/details/109135215

版权

Unity 同时被 2 个专栏收录

35 篇文章 5 订阅

订阅专栏

游戏开发

29 篇文章 3 订阅

订阅专栏

callback容易递归

if self._callback then
	self._callback()
	self._callback = nil
end

以下方式可以避免递归

if self._callback then
	local callback = self._callback
	self._callback = nil
	callback()
end

遍历字典是无序的

t = {}
t.a = '1'
t.b = '2'
t.c = '3'
t.d = '4'
for i,v in pairs(t) do
   print(v)
end

-- 每次输出都是乱序的!!!

Lua的遍历和C#不同

– Lua里Cnt()方法只会执行一次, 而C#会执行多次

function Cnt()
    print('执行Cnt方法')
    return 3
end
for i = 1, Cnt() do
   print(i)
end

输出:
执行Cnt方法
1
2
3

同名传参和同名字段

同名传参, 第1个传参无效

function Do(arg, arg)
    print(arg)
end
Do(1, 2)

输出:
2

同名字段, 第2个字段无效

a, a = 1, 2
print(a)

输出:
1

传参是引用传递

表作为参数传递时, 是引用传递, 传的是地址/指针
如下↓, 改变"作为参数的表"(argTab)的内容, “原来的表”(oldTab)也会改变

function ReName(argTab)
	-- 黑暗迪迦移情别恋, 抛弃了卡蜜拉, 跟着幽怜跑了
    argTab.name = '光明迪迦'
end

oldTab = {name = '黑暗迪迦'}
ReName(oldTab)
print(oldTab.name)

输出:
光明迪迦

在C#里同样,把 List列表作为参数传递时, 是引用传递, 传的是地址, 由于argTab和oldTab指向同一处内存, 一改都改, 即浅拷贝
呐, 值传递呢, 则相当于复制了一份, 在方法内改变值的内容, 原本的值不变

一般, 值类型是值传递
引用类型是引用传递
只有string是个例外, 她明明是引用类型, 却是值传递

但是, 改变arg表自身, tab却不会变

function ReName(argTab)
	-- 黑暗迪迦移情别恋, 抛弃了卡蜜拉, 跟着幽怜跑了
    argTab = {name = '光明迪迦'}
end

oldTab = {name = '黑暗迪迦'}
ReName(oldTab)
print(oldTab.name)

输出:
黑暗迪迦

即, 赋值操作是新开内存, 对原表无效

再做个实验

改变attr.name, 会同时改变ultraman.attr.name
置空attr.name, 会同时置空ultraman.attr.name
如下↓

ultraman = {attr = {name = '黑暗迪迦'}}
attr = ultraman.attr

attr.name = '光明迪迦'
print(ultraman.attr.name)

attr.name = nil
print(ultraman.attr.name)

输出:
光明迪迦
nil

改变attr, 不会同时改变ultraman.attr
置空attr, 不会同时置空ultraman.attr
如下↓

ultraman = {attr = {name = '黑暗迪迦'}}
attr = ultraman.attr

attr = {name = '光明迪迦'}
print(ultraman.attr.name)

attr = nil
print(ultraman.attr.name)

输出:
黑暗迪迦
黑暗迪迦

结论:
改变attr内部字段, ultraman.attr会同时改变
但是改变attr自身, ultraman.attr不变 (赋值操作无效)

在lua中, 如果我想置空attr怎么办呢? 答: 用attr.clear()

在C#中是同样的, list = new List<>(); 只能把方法内的list置空, 对原本的list无效
怎么才能有效呢? 答: 用list.Clear(), 或者给传参添加ref关键字

rawget()和rawset()

只对自身get和set, 而不访问元表

otab = {a = '我是元表a'}
tab = {a = '我是a'}
setmetatable(tab, {__index = otab, __newindex = otab})

-- 获取tab的a, 与元表无瓜
print(rawget(tab, 'a'))
print(tab.a)
print(otab.a)

-- 给tab的b赋值, 与元表无瓜
rawset(tab, 'b', '我是b')
print(tab.b)
print(otab.b)

输出:
我是a
我是a
我是元表a

我是b
nil

在Windows上安装Lua

看这个文章就行了↓
https://blog.csdn.net/weixin_42735950/article/details/87778208

把数值转成16进制的格式

print(string.format('%x', 1221197823))

输出:
48c9ffff

把16进制色号转成三元数Color

比如色号是: FFA2FC, 先用string.sub()把她肢解为: 红FF, 绿A2, 蓝FC
再用tonumber(str, 16)把16进制转为10进制, (例如: FF转为255)
再用rgb分别除以255
最后new一个三元数Color

local colorString = 'FFA2FC'
local r = tonumber(string.sub(colorString, 1, 2), 16) / 255
local g = tonumber(string.sub(colorString, 3, 4), 16) / 255
local b = tonumber(string.sub(colorString, 5, 6), 16) / 255
return UnityEngine.Color(r, g, b)

去掉商里的小数

用"/"来做除法, 得到的结果中总会带有小数, 像这样:

print(700 / 100)
print(701 / 100)

输出:
7.0
7.01

需要实现:
当结果是7.0时, 去掉小数部分, 结果为7
当结果是7.01时, 保留小数部分, 结果为7.01

思路: 用math.modf(), 把整数部分与小数部分拆开

local t1, t2 = math.modf(700 / 100)
print(t1)
print(t2)

输出:
7
0.0

再加个判断"小数部分是否为0"就好了:

function GetFixedQuotient(num1, num2)
    quotient = num1 / num2
    local t1, t2 = math.modf(quotient)
    -- 去掉数字后面的.0
    if t2 == 0 then
        return t1
    else
        return quotient
    end
end

print(GetFixedQuotient(700, 100))
print(GetFixedQuotient(701, 100))

输出:
7
7.01

string.format() 保留3位小数

print(string.format('%.3f', 0.5))
print(string.format('%.3f', 0.0005))
print(string.format('%.3f', 0.0004))
print(string.format('%.3f', 500))

输出:
0.500
0.001(这里四舍五入了)
0.000(这里四舍五入了)
500.000

向上/下取整, 四舍五入

-- 取整
print('向上取整: 1 / 3 = ' .. math.ceil(1 / 3))
print('向下取整: 1 / 3 = ' .. math.floor(1 / 3))
-- 想实现四舍五入, 就+0.5
print('四舍五入: 1 / 3 = ' .. math.floor(1 / 3 + 0.5))
print('四舍五入: 2 / 3 = ' .. math.floor(2 / 3 + 0.5))
-- 保留3位小数的四舍五入, 就先*1000再+0.5再/1000
print('四舍五入: 1 / 3 = ' .. math.floor(1 / 3 * 1000 + 0.5) / 1000)
print('四舍五入: 2 / 3 = ' .. math.floor(2 / 3 * 1000 + 0.5) / 1000)

输出:
向上取整: 1 / 3 = 1
向下取整: 1 / 3 = 0
四舍五入: 1 / 3 = 0
四舍五入: 2 / 3 = 1
四舍五入: 1 / 3 = 0.333
四舍五入: 2 / 3 = 0.667

string拆成表, (不支持中文)

input = "2b*)我"
tabA = {}
for i = 1, #input do
    let = string.sub(input, i, i)
    table.insert(tabA, i, let)
    print(i, let)
end

输出:
1	2
2	b
3	*
4	)
5	�
6	�
7	�

敏感词过滤, 替换成*

input = 'ABc大大大'
word = 'bc大'
lower = string.lower(input)
result = lower
if string.find(lower, tostring(word)) ~= nil then
    -- 汉字占3个字符, 所以不能直接用string.len()
    local _, count = string.gsub(word, '[^\128-\193]', '')
    local stars = string.rep('*', count)
    result = string.gsub(lower, tostring(word), stars)
end
print(result)

输出: A***大大

通配符, 正则表达式

s = "abc \"it's a cat\""
_, _, _, d = string.find(s, "([\"'])(.-)%1")
print(d) -----输出： it's a cat

用正则实现trim()

name = '   蒂纳  奥特曼  '
local _name = string.gsub(name, '^%s*(.-)%s*$', '%1')
print(_name)

输出:蒂纳  奥特曼

字符串截取string.sub()

s = 'abcde'

print(string.sub(s, 1, 3)) -- 从1数到3
print(string.sub(s, 3, 3)) -- 从3数到3
print(string.sub(s, 3)) -- 从3数到末尾
print(string.sub(s, 8)) -- 没有8,直接空了
print(string.sub(s, 3, -1)) -- 从3数到5(末尾)
print(string.sub(s, 3, -2)) -- 从3数到4(末尾-1)
print(string.sub(s, -4, -2)) --从2(末尾-3)数到4(末尾-1)
print(string.sub(s, -9))-- 从头数到尾

-- 输出:
abc
c
cde

cde
cd
bcd
abcde

数组增删

数组能用, 字典不行

table.insert(list, [pos, ]value), -- 不给pos就是#list+1
table.remove(list[, pos]), -- 不给pos就是#list

注意: 在for的时候, 要从后往前删
注意: 在foreach里删掉一个key, 同时再添加这个key, 会报错

if后面跟一个方法, 这个方法会运行

function fun()
    print(2)
end
if fun() then
end

输出: 2

↓写成这样则不执行

if fun then
end

匿名函数

注意: 直接 a = fun(), fun会立即执行, 不想立即执行的话, 就用个匿名方法把它包起来, 或者像delegate的+=一样

function foo(arg)
    print(arg)
end

---------1----------
arg1 = 1
-- 直接执行, 输出1
fun = foo(arg1)

---------2----------
arg2 = 2
-- 不执行
fun = function()
    foo(arg2)
end
-- 执行, 输出2
fun()

---------3----------
arg3 = 3
-- 不执行
fun = foo
-- 执行, 输出3
fun(arg3)

进阶: 2个不同来源的传参:

function fooo(arg1, arg2)
    print(arg1, arg2)
end

a = 2
-- 不执行
fun = function(b)
    fooo(a, b)
end
-- 执行, 输出2,3
fun(3)

死循环

这样写就是死循环↓

for i = 1, i + 10 do
    print(i)
end

正确写法↓

local endNum = i + 10
for i = 1, endNum do
    print(i)
end

右移: “>>”, 按位与: “&”

print(0x0000ffff)
print(32794992 >> 16)
print(500 & 65535)
print(500 & 63)

输出:
65535
500
500
52

---------------------------------------------------------------
先看: 0x0000ffff   (得: 65535)
16进制的: 0x0000ffff, 就是10进制的: 65535, 就是2进制的: 11111111111111111111(16个1)
(10进制的: 65536, 就是2进制的: 1000000000000000000(16个0), 就是 1>>16)

再看: 32794992 >> 16   (得: 500)
10进制的: 32794992, 就是2进制的: ‭1111101000110100101110000‬
左移16位, 后面16位就被丢掉了, 只剩下111110100, 就是10进制的: 500
(计算器算 32794992 ÷ 65536 = 500.41186523438)

再看 500 & 65535   (得: 500)
一个2进制数, 只要小于16个1, 它和 11111111111111(16个1) 做按位与, 还是它自己
所以 500(111110100) 和 11111111111111(16个1) 做按位与, 还是它自己

再看 500 & 63
10进制的: 63, 就是2进制的: 111111
500(111110100) 和 111111 做按位与
就相当于高于6位的都丢掉了, 结果是 110100, 也就是10进制的 52

实例: id是64位, 其组成为:14位没用 - 8位大区id - 10位服务器id - 32位玩家id
需求: 取服务器id
分析: 先右移32位, 去除玩家id, 再和1111111111(10个1)做按位与, 就能得到10位的服务器id

local id = 3063948711696181930
zoneID = (id >> 32) & 1023
print(zoneID)

左移数值越界

local id = 3063948711696181930
-- 即‭为2进制的: 10 1010 1000 0101 0101 0101 0001 1110 1010 1010 1010 1010 1010 1010 1010 1010
zoneID = (id << 2)
-- 左移2位, 即后面填2个0, 即为2进制的: ‭10 1010 1000 0101 0101 0101 0001 1110 1010 1010 1010 1010 1010 1010 1010 1010 00
-- 共64位, 其首位是1, 代表负号
print(zoneID)
-- 所以打印出负数: -6190949226924823896

可变参数: ‘…’

如果直接用表{…}来接收, 将会丢失传参中的nil
解决: 用table.pack(…)来接收, 会给一个’n’作为index

function Foo1(...)
	-- 用表{...}来接收, 将会丢失传参中的nil
    local arg = {...}
    for k, v in pairs(arg) do
        print(v)
    end
end
Foo1('奥特曼', nil)

输出:
奥特曼
----------------------------------

function Foo2(...)
	-- 用table.pack(...)来接收, 会给一个'n'作为index
    local arg = table.pack(...)
    for i = 1, arg.n do
        print(arg[i])
    end
end
Foo2('奥特曼', nil)

输出:
奥特曼
nil

浅拷贝表

我预言: 这玩意早晚有一天会坑到我

list = {name = 1}
temp = list -- 浅拷贝
temp.name = 2 -- temp改变, list也会变
print(list.name) -- 输出2

半年后某天:
卧槽! 我激动得拍了一下桌子, 果然! 浅拷贝!
(半年后果然遇到这个坑了, 查了半小时)

字典用table.sort()排序

table.sort()只能排数组, 不能排字典
解决方法: 把字典放进数组里

dic = {
    a = {['id'] = 12, ['order'] = 20001},
    b = {['id'] = 435, ['order'] = 545},
    c = {['id'] = 6, ['order'] = 2004501},
    d = {['id'] = 768, ['order'] = 2},
    e = {['id'] = 87, ['order'] = 22222}
}

array = {}
index = 0
for k, v in pairs(dic) do
    index = index + 1
    v.name = k
    array[index] = v
end
table.sort(
    array,
    function(a, b)
        return a.order < b.order
    end
)
for i = 1, #array do
    local fmt = '%s: name:%s, id:%s, order:%s'
    print(string.format(fmt, i, array[i].name, array[i].id, array[i].order))
end

输出:
1: name:d, id:768, order:2
2: name:b, id:435, order:545
3: name:a, id:12, order:20001
4: name:e, id:87, order:22222
5: name:c, id:6, order:2004501

就排好啦
注意: table.sort()里面只能写小于和大于: < >, 不能带等号: <= =>

多条件排序

local tab = {
    {arg1 = 5, arg2 = 2},
    {arg1 = 0, arg2 = 5},
    {arg1 = 2, arg2 = 1},
    {arg1 = 1, arg2 = 3},
    {arg1 = 1, arg2 = 4}
}
table.sort(
    tab,
    function(a, b)
        if a.arg1 == b.arg1 then
        	-- 如果条件1相等, 则判断条件2
            return a.arg2 < b.arg2
        end
        return a.arg1 < b.arg1
    end
)
for i = 1, #tab do
    print(tab[i].arg1, tab[i].arg2)
end

输出:
0	5
1	3
1	4
2	1
5	2

Lua里没有string.split()

方法1, 会保留nil

function string.split(str, delimiter)
    if str == nil or str == '' or delimiter == nil then
        return nil
    end
    local result = {}
    for match in (str .. delimiter):gmatch('(.-)' .. delimiter) do
        table.insert(result, match)
    end
    return result
end

-- 测试
local str = "1::3";
local list = string.split(str, ":");
for key, value in pairs(list) do
    print(key, value)
end

输出:
1	1
2	
3	3

方法2, 不保留nil

function string:split(sep)
	local sep, fields = sep or "\t", { };
	local pattern = string.format("([^%s]+)", sep);
	self:gsub(pattern, function(c) fields[#fields + 1] = c; end)
	return fields;
end

-- 测试
local str = "1::3";
local list = string.split(str, ":");
for key, value in pairs(list) do
    print(key, value)
end

输出:
1	1
2	3

lua特殊写法:

print (“Hello World”)阔以写成:
print “Hello World”
括号可以被省略

lua… 你可真是怎么写都行啊…

变量名

lua你真是太随便了! 一点都不知道检点!
这样写:

table = '奥特曼'

于是table就被重新定义了

true, false, nil 没法重定义
type, string, print 都能被重新定义

今天星期几

os.date(“%w”)
1是星期一, 0是星期天

os.time(): 秒

os.time()没参数, 返回从1970年1月1日到现在的秒数 1604374105
os.time({year=2020,month=1,day=1})返回从1970年1月1日到指定时间的秒数 1577851200
os.time({year=2008,month=1,day=1,hour=8,min=0,sec=0,isdst=false}) 1199145601
其中, 时/分/秒/夏令时都是可选参数, 不填按0算, 也可以写负数就是算减法

裆下日期转成表, 再把表转成秒

-- 把裆下日期转化为表: year = 2080 ...
tab = os.date('*t')
tab.hour = 5
tab.min = 20
-- 再把表转化成秒
sec = os.time(tab)

看身份证满18没有

function IsAdult(idNum)
    local function CheckYearOld(idNum)
        local dt = os.date('*t', os.time())
        local year = tonumber(string.sub(idNum, 7, 10))
        local month = tonumber(string.sub(idNum, 11, 12))
        local day = tonumber(string.sub(idNum, 13, 14))

        if month > dt.month then
            return dt.year - year - 1
        elseif month == dt.month and day >= dt.day then
            return dt.year - year - 1
        else
            return dt.year - year
        end
    end
    return CheckYearOld(idNum) >= 18
end

Lua没有"继承"的弊端

Lua这门语言, 因为没有"继承", 所以连IDE都骗过了
IDE没法给你提示基类的方法, 因为IDE不知道谁是基类
想用基类方法, 你就得掀开基类的衣服, 从头到脚看一遍

用过一次就好了
聪明的IDE会记住这个"你曾用过的方法", 并给你提示

取字符串的长度

string.len()里面可以写数字:

string.len(123456)

#的后面只能跟字符串:

#'123456'

#号

#号只能取数组的长度, 字典不行

tab = {
    [1] = 1,
    [2] = 1,
    [3] = 1,
    [4] = 1,
    [7] = 1
}
print(#tab)

你猜多少?
输出: 4
#号的实现原理是什么? 这篇文章写的很好:
https://blog.csdn.net/u011040361/article/details/76222989

身份证验证

问: 既然有身份证验证的网络接口, 为什么仍需要前端验证呢?
答: 需要先过滤掉一些奇葩(长度不对, 特殊字符, 生日2222年13月32日), 减轻服务器的压力

人家写的很好的文章!
https://www.cnblogs.com/cheerupforyou/p/lua.html

逻辑运算符的优先级

^
not
* /
+ -
..
> < >= <= ~= ==
and
or

注意: and 优先级大于 or，同时出现and和or时，先执行and
比如:

A or B and C 等同于 A or (B and C）

还要注意: not 的优先级大于 ==
比如:

print(1 == 2) -- false
print(not 1 == 2) -- 还是false
-- 都是false, 我还以为是Lua或者VSCode出bug了
-- 其实是因为not优先
print(not (1 == 2)) -- true

虚变量

(虚设变量/ 虚拟变量/ 名义变量/ 哑元变量/ 哑变量叫啥玩意都行)

t = {'迪迦', '戴拿', '蒂格', '蒂纳'}
for k, v in pairs(t) do
    print(v)
end

这时, 我们只需要v, 而不需要k
这时, 按照约定俗成, 把 k 写成 _
↓此写法表示: 我不需要理会k这个变量 , 即, 虚变量

t = {'迪迦', '戴拿', '蒂格', '蒂纳'}
for _, v in pairs(t) do
    print(v)
end

(小时候看的一个光盘中, 迪迦和戴拿就叫做:咸蛋超人蒂格和咸蛋超人蒂纳, 是特设片, 怪兽比奥特曼大好几倍, 他的肚子是笼子, 奥特曼被困在里面, 死掉了, 童年的我, 感到深深的绝望)

匹配字母和数字

function isMatch(str)
    match = string.match(str, '%w+')
    return str == match
end

if not a

不用写 if a == false or a == nil then
直接写 if not a then 就好了

墙裂推荐一个VS Code的插件: Rainbow Fart

你敲代码时候, 她会说话

敲个if, 她说: 你就是因为想太多"如果", 才找不到女朋友的
现在是晚上9点, 她说: 怎么还没下班呀

数组洗牌打乱

function shuffle(tbl)
    local n = #tbl
    for i = 1, n do
        local j = math.random(i, n)
        if j > i then
            tbl[i], tbl[j] = tbl[j], tbl[i]
        end
    end
end

JavaBean的要求规范

1、所有属性为private
2、提供默认构造方法
3、提供getter和setter
4、实现serializable接口
这是为了向后兼容, 改的时候只改方法内部就好了
便于封装重用, 便于让其他程序员或者框架使用

实现Switch

记得多看几遍这个myMetaTable干了什么

table[4] = print('我是4')

local table = {
    [1] = print('我是1'),
    a = print('我是a'),
    b = print('我是b'),
    __default = print('我是default')
}

myMetaTable = {
    __index = function(t, k)
        print(t == table, k)
        return rawget(t, '__default')
    end
}

setmetatable(table, myMetaTable)

function switch(case)
    return table[case]
end

table.c = print('我是c')

switch(1)
switch(4)
switch(a)
switch('b')
switch('c')
switch(d)
print('卧槽, 这Lua的调用顺序好乱啊')


输出:

我是4
我是1
我是a
我是b
我是default
我是c
true	1
true	4
true	nil
true	b
true	c
true	nil
卧槽, 这Lua的调用顺序好乱啊

实现continue

思路: 用一次性while里的if-break作为continue

for i = 1, 10 do
    while true do
        if i > 3 and i < 8 then
            break
        end
        print(i)
        break
    end
end
输出:
1 2 3 8 9 10

string.format

必须记住的: %d: 整数, %f: 浮点数, %s: 字符串
其他的不太重要, 等用到的时候再查

0.前面加加号: "+"
print(string.format("%+d", 1234))
输出: +1234

1.前面补0: "08d"
string.format("%08d", 1234))
输出: 00001234

2.截取小数, 4舍5入: ".3f"
string.format("%.3f", math.pi) 
输出: 3.142

3.截取字符串: ".3s"
string.format("%.3s", "abcdefg") 
输出: abc

三元表达式

(在Lua中false和nil为假, 其他都是真, 0也是真, {}也是真)
(a and b: 如果a假, 则返回a, 否则返回b)
(a or b: 如果a真, 则返回a, 否则返回b)

C#的三元表达式ret = a ? b : c 在Lua中可以写成:

ret = a and b or c

但是, 上式中b一定不能为假, 若b为假, 就会始终返回c
解决: 把b放进表里, 因为{false}为真, {nil}也为真
注意: 不能把a放进表里, 那样的话a恒为真, 会始终返回b
最终, 严谨的写法为:

ret = (a and {b} or {c})[1]

当然, 当我们确认b不可能为假时, 就可以直接写: ret = a and b or c

"逻辑与"的截断机制

在C#里:
a && b
先判断a是否为真
如果a为真, 再判断b是否为真, b为真则返回true, b为假则返回false
如果a为假, 就截断了, b不看了, 直接返回false

在Lua里:
a and b
先判断a是否为真
直接截断!
b不看了, a为假则返回a, a为真则返回b

可以看出, lua比C#更省劲

问题：Lua的输出乱码：

输出为: ‘lua‘ ��ڲ��ⲿ��Ҳ��ǿ��еĳ�� ļ��
解决: 改系统字体为 utf-8，控制面板 区域设置：Bate版UTF8全球支持

问题：Lua不是内部或外部命令，也不是可运行的程序或批处理文件

输出为: ‘lua‘ is not recognized as an internal or external command, operable program or batch file
解决:下载Lua，配Lua的环境变量：将Lua.exe所在路径添加至系统变量的Path中

判断table里有没有某元素

判断表里有没有一个value, 需要遍历表, 挨个判断是否相等
判断表里有没有一个key, 只需要: return t[key] ~= nil

需要注意的是判断空表:

--这样是不行的
if a == {}
--要这样:
if next(a) == nil

弹出表中的下一个元素, 结果它弹出来个nil, 不就证明了是空表嘛

(不)连续表的遍历

连续表(类似数组)遍历用 ipairs,
非连续表(类似字典)遍历用 pairs,

正则表达式

Lua的正则表达式:
string.gmatch(%d+)

取模和取余

正好前几天教外甥二年级数学
被除数 ÷ 除数 = 商 … 余数

local line = math.modf(9 / 4) -- 取整数
local mod = math.fmod(9, 4) -- 取模
local remain = 9 % 4 -- 取余数

在数学中, 取模和取余基本上说的是同一个事
在计算机中, 却不大一样 (在有负号的时候)

算一算就知道是怎么回事了:

print('取模: ' .. math.fmod(9, 4))
print('取余: ' .. 9 % 4)
print('---------------')
print('取模: ' .. math.fmod(-9, 4))
print('取余: ' .. -9 % 4)
print('---------------')
print('取模: ' .. math.fmod(9, -4))
print('取余: ' .. 9 % -4)

输出:
取模: 1
取余: 1
---------------
取模: -1
取余: 3
---------------
取模: 1
取余: -3

#汉字长度

一个汉字占3个长度

print(#"四个汉字")

输出:
12

赋值多个值

a, a= 3, 4, 5
print(a)

输出:
3

交换2个值

不需要开辟额外的temp空间, 也不用巧妙的加减运算或是位运算
Lua的写法贼简单, 直接 a, b = b, a

a = 1
b = 2
a, b = b, a

交换数组的元素也可以

arr = {'a', 'b', 'c'}
arr[1], arr[3] = arr[3], arr[1]
for i, v in pairs(arr) do
    print(i .. v)
end

输出:
1c
2b
3a

返回多个值

function fun()
    return 1, 2, 3
end
print("额", fun()) 
print(fun(), "额") -- 因为fun不是最后一个, 所以只返回一个值
print((fun())) -- 强制仅返回一个值

输出:
额	1	2	3
1	额
1

方法后面不加小括号

a = aaa{"a", "b"}

看到这个写法我当时蒙了, 这是什么写法? 表? 不对啊, 它为什么不报错呢?

哦, 原来aaa是个方法啊

function aaa(t)
    print(t[1])
end
--因为传参是table， 所以可省略小括号
--正常写法为:
a = aaa({2, 3})
--省略写法为:
a = aaa {2, 3}

按位运算

a~b 按位异或
~a 按位取反

// 运算, 取商

不知道为什么, 网上查不到这个操作符号"//"
我猜是取商运算

print(5 // 2)
print(5.0 // 2)
print(5 // 2.0)

输出:
2
2.0
2.0
注意: 当被除数或除数为浮点数时, 结果也是浮点数