1 基础知识
标识符:标识符的定义和 C语言相同:字母和下划线_ 开头, 下划线_ + 大写字母一般是lua保留字, 如_VERSION
全局变量:默认情况下,变量总是认为是全局的,不需要申明,给一个变量赋值后即创建了这个全局变量,访问一个没有初始化的全局变量也不会出错,只不过得到的结果是:nil
2 数据类型
数据类型:lua是动态型语言,变量不需要类型定义,直接赋值即可。 值可以存储在变量中,作为参数传递或者结果return
--nil : 无效值, 在条件表达式中相当于false
-- boolean : true false, 注意: false 和 nil 看作是 false,其他的都为 true,数字 0 也是 true
-- number : 双精度类型的实浮点数 相当于double, 注意:Lua 默认只有一种 number 类型 -- double(双精度)类型(默认类型可以修改 luaconf.h 里的定义)
-- string :字符串,由一对双引号或者单引号表示
-- funtcion : 由c或者lua编写的函数
-- userdata :表示任意存储在变量中的c数据结构
-- thread :表示执行的独立线路,用于执行协同程序
-- table :Lua 中的表(table)其实是一个"关联数组"(associative arrays),数组的索引可以是数字、字符串或表类型。
-- 在 Lua 里,table 的创建是通过"构造表达式"来完成,最简单构造表达式是{},用来创建一个空表。
--可以使用type函数测试给定变量或者值的类型:
print(type("Hello world"))
print(type(66))
print(type('66'))
print(type("66"))
print(type(nil))
2.1 多重赋值
Lua
可以对多个变量同时赋值,变量用逗号
分开,赋值
语句右边的值
会依次赋给左边的变量
。
n = 1
a, b = 10, 2*n
2.2 交换变量
lua
a = 34
b = 12
a, b = b, a
print(a, b) --输出:12 34
3 运算符
3.1 算数运算符
+ 加法
- 减法
* 乘法
/ 除法
% 取余,求出除法的余数
^ 乘幂,计算次方
- 负号,取负值
3.2 逻辑运算符
lua
a = true
b = false
c = nil
print(a and b) -- 与 输出:false
print(a or b) -- 或 输出:true
print(not a) -- 非 输出:false
4 字符串相关
字符串的三种表示方式:
- 单引号间的一串字符
- 双引号间的一串字符
- [[...]] 间的一串字符, 支持换行
4.1 字符串操作
4.1.1字符串拼接: ...
lua
print("d" .. "cj")
4.1.2字符串转换
lua
c = tostring(10) -- 数字 转 字符串
print(c)
d = tonumber("666") --字符串转数字,若转换失败返回nil
print(d)
e = tonumber("abc")
print(e)
输出:
4.1.3 获取字符串长度
lua
str = "dcj666"
print(#str)
print(#"dcj666")
输出:
5 函数
lua
function lua_func_test(n)
if 0 == n then
print("0 == n")
return 0
else
print("1 == n")
return n
end
end
--这与上述是一样的
lua_func_test2 = function(n)
if 0 == n then
print("0 == n")
return 0
else
print("1 == n")
return n
end
end
ret = lua_func_test(5)
print(ret)
输出:
函数支持多值返回:
lua
function lua_func_test_02(a, b, c)
return a, b, c
end
local i, j, k = lua_func_test_02(11, 22, 33)
print(i, j, k)
输出:
6 Table
lua的table中可以放置任意类型的数据:如number,string,function等
6.1 数字下标:从 1 开始
注意:lua中数组下标从 1 开始
lua
a = {112, {}, function () end, "dcj"}
print(a[1])
print(#a) --获取table元素个数
a[1] = 666
print(a[1])
table.insert(a, 2, "666") --在a[2]处插入"666"
local s = table.remove(a, 2) --删除a[2]这个元素, 并将删除的元素返回给s
输出:
function做table的元素
lua
funcList = {
function(a, b) return a*b end,
function(a, b) return a-b end,
function(a) return (-a) end
}
print(funcList[1](3,4))
print(funcList[2](3,4))
print(funcList[3](3))
输出:
6.2 table下标:指定下标
前面例子中的table
都只是一些简单的List(列表),每个元素的下标
都是自动从1排列的
实际上,Lua中,下标可以直接在声明时进行指定,像下面这样:
lua
t = {6,7,8,9}
--上面和下面的代码等价
t = {
[1] = 6,
[2] = 7,
[3] = 8,
[4] = 9,
}
--甚至你可以跳过某些下标
t = {
[1] = 6,
[3] = 7,
[5] = 8,
[7] = 9,
}
print(t[7]) --输出9
--在声明后赋予元素值也是可以的
t = {}--空的table
t[101] = 10
print(t[101]) --输出10
lua
t = {
[1] = 123,
[13] = "abc",
[666] = "666",
}
print("下标为1的元素:",t[1],type(t[1]))
print("下标为13的元素:",t[13],type(t[13]))
print("下标为666的元素:",t[666],type(t[666]))
输出:
下标为1的元素: 123 number
下标为13的元素: abc string
下标为666的元素: 666 string
6.3 字符串做下标
前面学习的table下标都是数字,在lua中,下标也可以是字符串:
lua
t = {
a1 = "aa",
["666"] = "666", -- 666 = "666", 这样会报错
["apple"] = 10,
banana = 12,
pear = 6,
}
--使用["下标"] = 值 和 下标 = 值 都是正确写法, 当第二种方式有歧义时,应该用第一种方式
t["new"] = "new values" -- 也可以新增
--可以用下面两种方式访问:
print(t["apple"]) --输出10
print(t.apple) --输出10
print(t["666"]) --输出666
--print(t.666) --报错
print(t["banana"]) --输出12
print(t.banana) --输出12
print(t["new"]) --输出new values
lua
t = {
apple = {
price = 7.52,
weight = 2.1,
},
banana = {
price = 8.31,
weight = 1.4,
year = '2018'
},
year = '2019',
{
price = 6.21,
weight = 2.5,
},
}
print(
t.price, --输出nil
t.apple.price, --输出7.52
t.banana.weight, --输出1.4
t.year, --输出2019
t[1].price, --输出6.21
t[1].weight --输出2.5
)
print(
t["price"], --输出nil
t["apple"]["price"], --输出7.52
t["banana"]["weight"], --输出1.4
t["year"] --输出2019
)
7 全局表 _G
lua中所有的全局变量都在** _G** 这个table中
例如定义一个全局变量a, 在_G这个table中打印出来:
lua
dcj = 666;
print(_G["dcj"])
table自身也是个全局变量,也在_G中, 并且table.insert中的insert函数是table的下标,也可以将insert打印出来:
lua
print(_G["table"])
print(_G["table"]["insert"])
输出:
8 boolean类型
注意:lua中只有false和nil表示假, 其余都为真(0也表示真)
lua
a = true
b = false
c = nul
print(1 < 2)
print(1 > 2)
print(1 >= 2)
print(1 <= 2)
print(1 == 2)
print(1 ~= 2) -- 注意:~=表示不等于
print(a and b) -- 与
print(a or b) -- 或
print(not a) -- 非
输出:
lua
b = 1
print(b > 10 and "yes" or "no")
b = 11
print(b > 10 and "yes" or "no")
输出:no
yes
9 分支判断
lua
a = 2
if a == 1 then
print("a == 1")
elseif a == 2 then
print("a == 2")
elseif a == 3 then
print("a == 3")
else
print(a)
end
if 0 then
print("0 is true")
end
输出:
a == 2
0 is true
10 循环
10.1 for循环
临时变量名
可以直接在代码区域使用(但不可更改),每次循环会自动加步长值
,并且在到达结束值
后停止循环。
lua
for i = 1, 10, 2 do -- 1表示循环储值,10表示结束值, 2表示步长, i的作用域仅仅在for循环内部
print(i)
end
print(i) -- 输出nil,i的作用域仅仅在for循环内部
10.2 while循环
lua
local n = 10
while n >= 1 do
if n==5 then
break --跳出循环
end
print(n)
n = n - 1 -- lua 不支持 n-- 这种操作
end
输出:
11 迭代器
pairs和ipairs的区别:
:::info
同 :都是能遍历集合(表、数组),两者均优先按顺序输出没有key的值;
:::
:::info
异 :对于有key的集合:
ipairs从第一个数字key开始,依次输出所有的key+1的键值,遇到字符下标并不会结束遍历,只是不输出而已,如果遇到nil则退出;
pairs无序输出字符类型key或者数字类型key的键值,遇到nil不输出,但不会停止遍历;
:::
11.1 ipairs
lua
t = {"aa", "bb", "cc", "dd", "ee"}
for i = 1, #t do --从下标1开始,到下标#t结束(#t表示t的元素个数)
print(i, t[i])
end
--针对数字下标的数组,可以使用ipairs迭代器
--等同于下面
for i, j in ipairs(t) do -- i表示下标, j存放下标i对应的值
print(i, j)
end
输出:
lua
t = {
[1] = "aaaaaa",
[2] = "bbbbbbb",
[3] = "ccccccc",
[5] = "ddddddddd" --下标不连续,t[4]为nil,遇到nil会自动停止
}
for i, j in ipairs(t) do -- i表示下标, j表示下标i对应的值
print(i, j)
end
for i, j in pairs(t) do -- i表示下标, j表示下标i对应的值
print(i, j)
end
输出:
结论:
1、ipairs会按照key的顺序输出数据,遇到不连续的数据停止输出;
2、pairs会无序输出所有数据;
lua
table = {
[3] = "test3",
["test"] = "val1",
"val3" ,
[4] = "val2",
"val4"
}
print("-----------ipairs----------------")
for k,v in ipairs(table) do
print(k,v)
end
print("-----------pairs----------------")
for k,v in pairs(table) do
print(k,v)
end
结论:
1、pairs和ipairs均优先输出没有key的value;
2、pairs会输出所有的数据,不带key的值按顺序输出,带key的值无序输出;
3、ipairs会跳过字符串的key,按顺序输出数字型key的值;
lua
table = {
[6] = "test3",
["test"] = "val1",
"val3" ,
[11] = "val2",
nil,
"val4"
}
print("-----------ipairs----------------")
for k,v in ipairs(table) do
print(k,v)
end
print("-----------pairs----------------")
for k,v in pairs(table) do
print(k,v)
end
输出:
结论:
1、ipairs遇到nil会停止输出;
2、pairs遇到nil不会停止输出;
11.2 pairs
针对字符串做数组下标的数组迭代,使用pairs迭代器
lua
t = {
apple = "aa",
banana = "bb",
water = "cc",
}
for i, j in pairs(t) do -- i表示下标, j存放下标i对应的值
print(i, j)
end
输出:
12 多文件调用require
require:
- 运行指定文件
- 末尾不带拓展名
- 目录层级用"."分隔
- 只会运行一次
- 从package.path中的路径里查找
13 元表、面向对象
lua
t = {
a = 66,
}
mt = {
__add = function(a, b)
return a.a + b
end,
__index = function(table, key)
return 123
end
}
setmetatable(t, mt)
print(t+1) --输出67
print(t["dcj"]) --访问一个不存在的下标,会调用__index元方法, 输出123
t = {
a = 66,
}
mt = {
__add = function(a, b)
return a.a + b
end,
__index = {
abc = 123,
def = 456,
},
}
setmetatable(t, mt)
print(t["dcj"]) --__index也可以是个table, 在__index也可以是个table找"dcj"元素,输出nil
print(t["abc"]) --__index也可以是个table, 在__index也可以是个table找"abc"元素, 输出123
print(t["def"]) --__index也可以是个table, 在__index也可以是个table找"def"元素, 输出456
13.1 语法糖:
lua
t = {
a = 66,
add = function(tab, sum)
tab.a = tab.a + sum
end,
}
t:add(10) -- 等价于 t.add(t, 10), 输出:76
print(t.a)
13.2 面向对象
需要好好理解!!!
lua
bag = {
}
bagmt = {
put = function(t, item)
table.insert(t.items, item)
end,
take = function(t)
return table.remove(t.items, item)
end,
list = function(t)
return table.concat(t.items, ", ")
end,
clear = function(t)
t.items = {}
end,
}
bagmt["__index"] = bagmt
function bag.new()
local t = {
items = {}
}
setmetatable(t, bagmt) --当调用t中不存在的函数的时候,就回去t的metatable中去找
return t
end
--bag.new()函数中会新建一个表t,t设置了元表bagmt, bagmt中有四个元方法(put,take,list,clear)
--由于b中没有put这些方法,所以回去bagmt中找
local b = bag.new()
b:put("apple1") --等价于b.put(b, "apple1"), 将"apple1"放入b的items表中
b:put("apple2")
b:put("apple3")
b:put("apple4")
print(b:take())
print(b:list())
14 数据打包和解包
lua
aaa = 0x11223344
bbb = 0x55667788
data = string.pack(">LL", aaa, bbb) --数据打包
print("len:", #data)
for i=1, #data do
print(i, data:byte(i))
end
a, b = string.unpack(">LL", data) --数据解包
str_a = string.format("0x%x", a)
str_b = string.format("0x%x", b)
print("str_a: ", str_a)
print("str_b: ", str_b)
输出:
15 C语言与lua的相关调用
15.1 C语言中调用lua
c代码只需要编译一次,lua可以随时改动;因为lua是动态语言。嵌入lua的好处是c只需要写一次代码,编译一次程序,所有的变化都可以通过修改lua的代码.
main.c 中调用math.lua中的函数
c
/*
* @Descripttion: xx模块
* @Author: cjDong
* @Date: 2024-07-15 11:30:05
* @LastEditors: cjDong
* @LastEditTime: 2024-07-17 14:07:04
*/
#include <stdio.h>
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
static int call_func(lua_State *L, const char* funcname, int x, int y)
{
int ret;
lua_getglobal(L, funcname); // 查找lua文件中的全局函数,并压入虚拟栈
/* 压栈,传入参数 */
lua_pushnumber(L, x);
lua_pushnumber(L, y);
lua_call(L, 2, 1); /* 执行函数,lua_call 的参数中第二个是参入参数个数,第三个是返回值个数 */
/* 取出返回值 */
ret = (int)lua_tonumber(L, -1);
/*清除返回值的栈*/
lua_pop(L, 1);
return ret;
}
int main(int argc, char *argv[])
{
lua_State *L = luaL_newstate(); /* 创建lua虚拟机 */
luaL_openlibs(L); /* 加载lua库,比如math库、table库等 */
/* 加载lua文件到c语言内存中,进行语法检查,不会编译 */
luaL_dofile(L, "math.lua");
/* 调用C函数,这个里面会调用lua函数 */
call_func(L, "add", 2, 3);
call_func(L, "sub", 2, 3);
call_func(L, "mul", 2, 3);
call_func(L, "div", 2, 3);
/* 清除Lua */
lua_close(L);
return 0;
}
lua
function add(x, y)
print("lua: add function\r\n")
return x + y
end
function sub(x, y)
print("lua: sub function\r\n")
return x - y
end
function mul(x, y)
print("lua: mul function\r\n")
return x * y
end
function div(x, y)
print("lua: div function\r\n")
return x / y
end
shell
#!/bin/bash
gcc -o out main.c -llua -ldl -lm
./out
15.2 lua中调用c语言
Q:Lua调用C函数的两种方式?
A:
1、程序主体在C中运行,C函数注册到Lua中。C调用Lua,Lua调用C注册的函数,C得到函数的执行结果。
2、程序主体在Lua中运行,C函数作为库函数供Lua使用。
第一种方式看起来很罗嗦,也很奇怪。既然程序主体运行在C中,而且最终使用的也是C中定义的函数,那么为何要将函数注册给Lua,然后再通过Lua调用函数呢?
相比于第一种方式,第二种方式使用的更加普遍。
一个Lua库(Lua本身所提供的库)实际上是一个定义了若干Lua函数的"chunk",这些函数通常作为"table"的域来保存。一个C库(C语言编写,注册给Lua使用的库)的实现方式类似于Lua库的实现方式。首先C库中定义提供给Lua使用的函数,其次还需要一个"特殊函数",它的作用是注册所有C库中的函数,并将它们存储在适当的位置(类似于Lua库中的函数作为"table"的域来保存)。
Lua可以调用C库中的函数,就是通过这个注册的过程实现的。一旦C函数注册到Lua中,Lua就可以直接通过C函数的引用获取到C函数的地址(这也是我们注册的意义,将C函数的地址提供给Lua)。换句话说,一旦C函数注册,Lua调用他们不依赖于函数名,"package"位置,或者是可见规则。
以上两种方式下面都会列举对应的例子,理解第一种方式,将有助于你理解第二种方式的实现流程。
Q:从Lua中调用C所遵循的规则?
A:当C调用Lua函数的时候,必须遵循一些简单的协议来传递参数和获取返回结果。同样的,从Lua中调用C函数,也必须遵循一些协议来传递参数和获得返回结果。此外,从Lua调用C函数我们必须注册函数,也就是说,我们必须把C函数的地址以一个适当的方式传递给Lua解释器。
任何在Lua中注册的C函数必须有同样的原型,
typedef int (*lua_CFunction) (lua_State *L); // 定义在"lua.h"中。
被注册的C函数接收一个单一的lua_State类型的参数,同时返回一个表示返回值个数的数字。函数在将返回值入栈之前无需清理栈,在函数返回之后,Lua会自动清除栈中返回结果下面的所有内容。
15.2.1 方式1:程序主体在C中运行
该方式看起来很罗嗦,也很奇怪。既然程序主体运行在C中,而且最终使用的也是C中定义的函数,那么为何要将函数注册给Lua,然后再通过Lua调用函数呢?
15.2.2 方式2:程序主体在Lua中运行
该方式使用的更加普遍
c
#include <stdio.h>
#include <math.h>
#include <stdarg.h>
#include <stdlib.h>
#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>
/* 所有注册给Lua的C函数具有
* "typedef int (*lua_CFunction) (lua_State *L);"的原型。
*/
static int l_sin(lua_State *L)
{
// 如果给定虚拟栈中索引处的元素可以转换为数字,则返回转换后的数字,否则报错。
double d = luaL_checknumber(L, 1);
lua_pushnumber(L, sin(d)); /* push result */
/* 这里可以看出,C可以返回给Lua多个结果,
* 通过多次调用lua_push*(),之后return返回结果的数量。
*/
return 1; /* number of results */
}
/* 需要一个"luaL_Reg"类型的结构体,其中每一个元素对应一个提供给Lua的函数。
* 每一个元素中包含此函数在Lua中的名字,以及该函数在C库中的函数指针。
* 最后一个元素为"哨兵元素"(两个"NULL"),用于告诉Lua没有其他的函数需要注册。
*/
static const struct luaL_Reg mylib[] = {
{"mysin", l_sin},
{NULL, NULL}
};
/* 此函数为C库中的"特殊函数"。
* 通过调用它注册所有C库中的函数,并将它们存储在适当的位置。
* 此函数的命名规则应遵循:
* 1、使用"luaopen_"作为前缀。
* 2、前缀之后的名字将作为"require"的参数。
*/
extern int luaopen_mylib(lua_State* L)
{
/* void luaL_newlib (lua_State *L, const luaL_Reg l[]);
* 创建一个新的"table",并将"mylib"中所列出的函数注册为"table"的域。
*/
luaL_newlib(L, mylib);
return 1;
}
lua
--[[
这里"require"的参数对应C库中"luaopen_mylib()"中的"mylib"。
C库就放在"main.lua"的同级目录,"require"可以找到。
]]
local mylib = require "mylib"
-- 结果与上面的例子中相同,但是这里是通过调用C库中的函数实现。
print(mylib.mysin(3.14 / 2)) --> 0.99999968293183
gcc math.c -fPIC -shared -o mylib.so -Wall
lua main.lua