maple

深浅模式

Lua ​

前言 ​

Lua 官网

Lua 稳定版本

LuaRocks 官网 **LuaRocks **是 Lua 模块的包管理器。

LuaRocks GitHub地址

参照资料

软件清单 ​

软件名称版本说明windowslinux
lua5.4.2lualua-5.4.2_Win64_bin.ziplua-5.4.2_Linux68_64_lib.tar.gz
lua 动态库5.4.2动态库lua-5.4.2_Win64_dll17_lib.ziplua-5.4.2_Linux68_64_bin.tar.gz
luarocks3.12.2Lua 模块的包管理器luarocks-3.12.2-windows-64.zipluarocks-3.12.2-linux-x86_64.zip
mingw6415.2.0-rt_v13-rev0gcc 编译环境mingw64 下载

安装Lua ​

windows-Lua安装

解压mingw64压缩包，添加环境变量

image-20251024144629993

验证

cmd
gcc --version

解压上述软件清单的3个.zip压缩包

image-20251024135827461

复制luarocks-3.12.2-windows-64跟lua-5.4.2_Win64_dll17_lib 目录里面所有文件到 lua-5.4.2_Win64_bin

image-20251024140008839

复制之后如图

image-20251024140142761

改名为 lua-5.4.2 ,非必须

image-20251024140237638

添加环境变量

image-20251024140416086

验证

cmd
lua -v

luarocks --version

lua 上运行 redis ​

由于网络原因，这里需要科学上网,我的科学软件 代理的端口是 7897

image-20251024145616062

打开 cmd ，设置代理

cmd
set https_proxy=127.0.0.1:7897

image-20251024150400916

在同个cmd窗口执行

cmd
luarocks install stringy --tree=rocks

视频参照

linux-lua安装
bash
mkdir -p /usr/local/download && \
wget -O "/usr/local/download/"

Lua基本语法 ​

注释 ​

行单注释 ​

lua
-- 我是注释

多行注释 ​

lua
--[[
 我是多行注释
 我是多行注释
--]]

数据类型 ​

Lua 是动态类型语言，变量不要类型定义,只需要为变量赋值。 值可以存储在变量中，作为参数传递或结果返回。

Lua 中有 8 个基本类型分别为：nil、boolean、number、string、userdata、function、thread 和 table。

类型描述
nil这个最简单，只有值nil属于该类，表示一个无效值（在条件表达式中相当于false）。
boolean包含两个值：false true
number表示双精度类型的实浮点数
string字符串由一对双引号或单引号来表示
function由 C 或 Lua 编写的函数
userdata表示任意存储在变量中的C数据结构
thread表示执行的独立线路，用于执行协同程序
tableLua 中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字、字符串或表类型。
在 Lua 里，table 的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。
例1：{'java','nginx','lua'}
例2：{id=1001,name='tom',age=18}

nil ​

nil 是值 nil 的类型， 其主要特征就是和其它值区别开；通常用来表示一个有意义的值不存在时的状态。例如打印一个没有赋值的变量，便会输出一个 nil 值：

lua脚本test.lua

lua
local a=nil

print(type(a))
print(type(nil))
print(type(b))

print(a)
print(nil)
print(b)

以上代码执行结果如下

bash
root@ubuntu-dev:/tmp/lua_demo# lua test.lua
nil
nil
nil
nil
nil
nil

boolean ​

boolean 是 false 与 true 两个值的类型。 nil 和 false 都会导致条件判断为假； 而其它任何值都表示为真，数字 0 也是 true。

lua脚本test.lua

lua
print(type(true))
print(type(false))
print(type(nil))
 
if false or nil then
    print("至少有一个是 true")
else
    print("false 和 nil 都为 false")
end
 
if 0 then
    print("数字 0 是 true")
else
    print("数字 0 为 false")
end

以上代码执行结果如下

bash
root@ubuntu-dev:/tmp/lua_demo# lua test.lua
boolean
boolean
nil
false 和 nil 都为 false
数字 0 是 true

number ​

number 代表了整数和实数（浮点数），也就是double（双精度）类型。

lua脚本test.lua

lua
print(type(2))
print(type(2.2))
print(type(0.2))
print(type(2e+1))
print(type(0.2e-1))
print(type(7.8263692594256e-06))
print(type(tonumber(1.2222)))
print(type(tonumber('1.2222')))
print(type(tonumber('3.1')+tonumber('2.22')))

以上代码执行结果如下

bash
root@ubuntu-dev:/tmp/lua_demo# lua test.lua
number
number
number
number
number
number
number
number
number

string ​

字符串（即string），就是一串文本数据，可以存储你要的文本。

  • Lua 语言中字符串可以使用以下三种方式来表示：
    1. 单引号间的一串字符
    2. 双引号间的一串字符
    3. [[和]]间的一串字符

lua脚本test.lua

lua
-- 单引号间的一串字符
str1 = "this is str1"
-- 双引号间的一串字符
str2 = 'this is str2'
-- [[和]]间的一串字符
str3 = [[this is str3 使用双括号时，甚至能包含换行数据
换行了
最后一行]]

print(str1)
print(str2)
print(str3)

以上代码执行结果如下

bash
root@ubuntu-dev:/tmp/lua_demo# lua test.lua
this is str1
this is str2
this is str3 使用双括号时，甚至能包含换行数据
换行了
最后一行

function ​

Lua 函数主要有两种用途：

  • 1.完成指定的任务，这种情况下函数作为调用语句使用；
  • 2.计算并返回值，这种情况下函数作为赋值语句的表达式使用。
示例1：计算2个值的和 ​

lua脚本test.lua

lua
-- 定义函数
function sum(a, b)
   -- 返回 a + b 的和
   return a + b
end
-- 调用函数并打印
print(sum(1,2))

以上代码执行结果如下

bash
root@ubuntu-dev:/tmp/lua_demo# lua test.lua
3
示例2：计算2个值的和,并返回多个值 ​

lua脚本test.lua

lua
-- 示例1
-- 定义函数1
function sum1(a, b)
    -- 定义变量，接受 a + b 的和
    local s = a + b
    -- 返回 三个参数
    return a, b, s
end
-- 调用函数1 ，并接受返回的三个返回参数
local data1,data2,data3 = sum1(1, 2)
-- 打印函数1返回的参数
print(data1)
-- 打印函数2返回的参数
print(data2)
-- 打印函数3返回的参数
print(data3)

print ('================ 分割线 ================')

-- 示例2
-- 定义函数3
function sum2(a, b)
    -- 定义变量，接受 a + b 的和
    local s = a + b
    -- 返回 数组，即table
    return {  a=a, b=b, res=s }
end
-- 调用函数1 ，并接受返回的参数
local data = sum2(1, 2)
-- 打印返回结果的类型
print(type(data))
print(data)
-- 单引号访问单个数组元素
print(data['a'],data['b'],data['res'])
-- 双引号访问单个数组元素
print(data["a"],data["b"],data["res"])
-- 类型java的对象调用方法
print(data.a,data.b,data.res)

-- 循环遍历
for key,value in pairs(data) do
   print(key,value) 
end
以上代码执行结果如下 ​
bash
root@ubuntu-dev:/tmp/lua_demo# lua test.lua
1
2
3
================ 分割线 ================
table
table: 0x644bae594f00
1       2       3
1       2       3
1       2       3
res     3
b       2
a       1
示例3：动态参数 ​

lua脚本test.lua

lua
function func(...)
    local arg = {...}
    return arg
end

-- 调用函数
arr = func('参数1', '参数2', '参数3', 1, false, true, nil, 123)

print('================= pairs 分割线  =================')
-- 使用 pairs 遍历所有数字索引
for index, value in pairs(arr) do
    if type(index) == "number" then
        print(index, value)
    end
end

print('================= ipairs 分割线  =================')
-- 使用 ipairs 遍历所有数字索引 ，如果数组有nil则会中断
for index, value in ipairs(arr) do
    if type(index) == "number" then
        print(index, value)
    end
end

print('================= 手动遍历到最大索引 分割线  =================')
-- 手动遍历到最大索引
for i = 1, #arr do
    print(i, arr[i])
end

以上代码执行结果如下

bash
root@ubuntu-dev:/tmp/lua_demo# lua test.lua
================= pairs 分割线  =================
1       参数1
2       参数2
3       参数3
4       1
5       false
6       true
8       123
================= ipairs 分割线  =================
1       参数1
2       参数2
3       参数3
4       1
5       false
6       true
================= 手动遍历到最大索引 分割线  =================
1       参数1
2       参数2
3       参数3
4       1
5       false
6       true
7       nil
8       123

userdata ​

userdata 是一种用户自定义数据，用于表示一种由应用程序或 C/C++ 语言库所创建的类型，可以将任意 C/C++ 的任意数据类型的数据（通常是 struct 和 指针）存储到 Lua 变量中调用。

用户数据类型的值是一个内存块， 有两种用户数据： 完全用户数据 ，指一块由 Lua 管理的内存对应的对象； 轻量用户数据 ，则指一个简单的 C 指针。 用户数据在 Lua 中除了赋值与相等性判断之外没有其他预定义的操作。

thread ​

thread 类型表示了一个独立的执行序列，被用于实现协程 。 Lua 的线程与操作系统的线程毫无关系。 Lua 为所有的系统，包括那些不支持原生线程的系统，提供了协程支持。

在 Lua 里，最主要的线程是协同程序（coroutine）。它跟线程（thread）差不多，拥有自己独立的栈、局部变量和指令指针，可以跟其他协同程序共享全局变量和其他大部分东西。

线程跟协程的区别：线程可以同时多个运行，而协程任意时刻只能运行一个，并且处于运行状态的协程只有被挂起（suspend）时才会暂停。

基本语法

协同程序由 coroutine 模块提供支持。

使用协同程序，你可以在函数中使用 coroutine.create 创建一个新的协同程序对象，并使用 coroutine.resume 启动它的执行。协同程序可以通过调用 coroutine.yield 来主动暂停自己的执行，并将控制权交还给调用者。

方法描述
coroutine.create()创建 coroutine，返回 coroutine， 参数是一个函数，当和 resume 配合使用的时候就唤醒函数调用
coroutine.resume()重启 coroutine，和 create 配合使用
coroutine.yield()挂起 coroutine，将 coroutine 设置为挂起状态，这个和 resume 配合使用能有很多有用的效果
coroutine.status()查看 coroutine 的状态
注：coroutine 的状态有三种：dead，suspended，running，具体什么时候有这样的状态请参考下面的程序
coroutine.wrap（）创建 coroutine，返回一个函数，一旦你调用这个函数，就进入 coroutine，和 create 功能重复
coroutine.running()返回正在跑的 coroutine，一个 coroutine 就是一个线程，当使用running的时候，就是返回一个 coroutine 的线程号
示例 ​

lua脚本test.lua

lua
function foo()
    print("协同程序 foo 开始执行")
    local value = coroutine.yield("暂停 foo 的执行")
    print("协同程序 foo 恢复执行，传入的值为: " .. tostring(value))
    print("协同程序 foo 结束执行")
end
 
-- 创建协同程序
local co = coroutine.create(foo)
 
-- 启动协同程序
local status, result = coroutine.resume(co)
print(result) -- 输出: 暂停 foo 的执行
 
-- 恢复协同程序的执行，并传入一个值
status, result = coroutine.resume(co, 42)
print(result) -- 输出: 协同程序 foo 恢复执行，传入的值为: 42

以上实例中，我们定义了一个名为 foo 的函数作为协同程序。在函数中，我们使用 coroutine.yield 暂停了协同程序的执行，并返回了一个值

。在主程序中，我们使用 coroutine.create 创建了一个协同程序对象，并使用 coroutine.resume 启动了它的执行。

在第一次调用 coroutine.resume 后，协同程序执行到 coroutine.yield 处暂停，并将值返回给主程序。然后，我们再次调用 coroutine.resume，并传入一个值作为协同程序恢复执行时的参数。

以上代码执行结果如下

bash
root@ubuntu-dev:/tmp/lua_demo# lua test.lua
协同程序 foo 开始执行
暂停 foo 的执行
协同程序 foo 恢复执行，传入的值为: 42
协同程序 foo 结束执行
nil

table ​

lua脚本test.lua

lua
-- 创建一个空的 table
local tb1 = {}
-- 直接初始表 【下标】
local tb2 = {"apple", "pear", "orange", "grape"}
-- 直接初始表 【Key】
local tb3 = {id = 1001, name = "tom" , age = 100 , enable = true}



-- 每个元素 都是 函数
t1 = {
    function() return 123 end,
    function() print("abc") end,
    function(a,b) return a+b end,
    function() print("hello world") end,
}
-- 输出  123
print(t1[1]())
-- 输出 abc
t1[2]()
-- 输出 3
print(t1[3](1,2))
-- 输出 hello world
t1[4]()


t2 = {6,7,8,9}
-- 上面和下面的代码等价
t2 = {
    [1] = 6,
    [2] = 7,
    [3] = 8,
    [4] = 9,
}


-- 甚至你可以跳过某些下标
t3 = {
    [1] = 6,
    [3] = 7,
    [5] = 8,
    [7] = 9,
}
-- 输出 9
print(t3[7])

 
-- 在声明后赋予元素值也是可以的
t = {} --空的table
t[101] = 10
-- 输出 10
print(t[101])
    
    
n = 123--新建变量
-- 输出 123
print(n)
-- 输出 123
print(_G.n)
 
_G.abc = 1--相当于新建全局变量
-- 输出 1
print(abc)
 
_G["def"] = 23--相当于新建全局变量
--输出 23
print(def)
 
--甚至你可以像下面这样
-- 输出 hello
_G.print("hello")
-- 输出 world
_G["print"]("world")

以上代码执行结果如下

bash
root@ubuntu-dev:/tmp/lua_demo# lua test.lua
123
abc
3
hello world
9
10
123
123
1
23
hello
world
table 操作 ​
函数语法
table.concattable.concat (table [, sep [, start [, end]]]):concat是concatenate(连锁, 连接)的缩写. table.concat()函数列出参数中指定table的数组部分从start位置到end位置的所有元素, 元素间以指定的分隔符(sep)隔开。
table.inserttable.insert (table, [pos,] value):在table的数组部分指定位置(pos)插入值为value的一个元素. pos参数可选, 默认为数组部分末尾.
table.maxntable.maxn (table)指定table中所有正数key值中最大的key值. 如果不存在key值为正数的元素, 则返回0。(Lua5.2之后该方法已经不存在了,本文使用了自定义函数实现)
table.removetable.remove (table [, pos])返回table数组部分位于pos位置的元素. 其后的元素会被前移. pos参数可选, 默认为table长度, 即从最后一个元素删起。
table.sorttable.sort (table [, comp])对给定的table进行升序排序。
concat(连接) ​

lua脚本test.lua

lua
local arr = {"java", "python", "nginx", "lua"}
-- 返回 table 连接后的字符串
print("连接后的字符串 " .. table.concat(arr))
 
-- 指定连接字符
print("连接后的字符串 " .. table.concat(arr,", "))
 
-- 指定索引来连接 table
print("连接后的字符串 " .. table.concat(arr,", ", 2,3))

以上代码执行结果如下

bash
root@ubuntu-dev:/tmp/lua_demo# lua test.lua
连接后的字符串 javapythonnginxlua
连接后的字符串 java, python, nginx, lua
连接后的字符串 python, nginx
insert(插入) ​

lua脚本test.lua

lua
local arr = {"banana","orange","apple"}
 
-- 在末尾插入
table.insert(arr,"mango")
print("索引为 4 的元素为 ",arr[4])
 
-- 在索引为 2 的键处插入
table.insert(arr,2,"grapes")
print("索引为 2 的元素为 ",arr[2])
 
print("最后一个元素为 ",arr[5])

以上代码执行结果如下

bash
root@ubuntu-dev:/tmp/lua_demo# lua test.lua
索引为 4 的元素为       mango
索引为 2 的元素为       grapes
最后一个元素为  mango
maxn(长度) ​

table.maxn 在 Lua5.2 之后该方法已经不存在了，我们定义了 table_maxn 方法来实现。

以下实例演示了如何获取 table 中的最大值：

lua脚本test.lua

lua
function table_maxn(t)
  local mn=nil;
  for k, v in pairs(t) do
    if(mn==nil) then
      mn=v
    end
    if mn < v then
      mn = v
    end
  end
  return mn
end
local arr = {[1] = 2, [2] = 6, [3] = 34, [26] =5}
print("arr 最大值：", table_maxn(arr))
print("arr 长度 ", #arr)

以上代码执行结果如下

bash
root@ubuntu-dev:/tmp/lua_demo# lua test.lua
arr 最大值：    34
arr 长度        3
remove(移除) ​

lua脚本test.lua

lua
local arr = {"banana","orange","apple"}

print(arr[3])
print("数组长度："..#arr)
table.remove(arr)
print("移除后 , 最后一个元素为 " , arr[3])
print("数组长度："..#arr)

以上代码执行结果如下

bash
root@ubuntu-dev:/tmp/lua_demo# lua test.lua
apple
数组长度：3
移除后 , 最后一个元素为         nil
数组长度：2

注意数组长度问题：

当我们获取 table 的长度的时候无论是使用 # 还是 table.getn 其都会在索引中断的地方停止计数，而导致无法正确取得 table 的长度。

可以使用以下方法来代替：

lua脚本test.lua

lua
function table_maxn(t)
  local mn=nil;
  for k, v in pairs(t) do
    if(mn==nil) then
      mn=v
    end
    if mn < v then
      mn = v
    end
  end
  return mn
end
function table_leng(t)
  local leng=0
  for k, v in pairs(t) do
    leng=leng+1
  end
  return leng;
end

local arr = {[1] = 2, [2] = 6, [3] = 34, [26] =5}
print("arr 最大值：", table_maxn(arr))
print("arr 长度 ", table_leng(arr))

以上代码执行结果如下

bash
root@ubuntu-dev:/tmp/lua_demo# lua test.lua
arr 最大值：    34
arr 长度        4
sort(排序) ​

lua脚本test.lua

lua
local arr = {"mongo","grapes","apple","orange","banana"}
print("排序前")
for k,v in ipairs(arr) do
	print(k,v)
end
 
table.sort(arr)
print("排序后")
for k,v in ipairs(arr) do
	print(k,v)
end

以上代码执行结果如下

bash
root@ubuntu-dev:/tmp/lua_demo# lua test.lua
排序前
1       mongo
2       grapes
3       apple
4       orange
5       banana
排序后
1       apple
2       banana
3       grapes
4       mongo
5       orange

流程控制 ​

Lua 提供了以下控制结构语句：

语句描述
if 语句if 语句 由一个布尔表达式作为条件判断，其后紧跟其他语句组成。
if...else 语句if 语句 可以与 else 语句搭配使用, 在 if 条件表达式为 false 时执行 else 语句代码。
if 嵌套语句你可以在if 或 else if中使用一个或多个 if 或 else if 语句 。

lua脚本test.lua

lua
-- n1,n2,n3 更改这个数多运行几次试试

-- 示例1 单if
local n1 = 5
if n1 < 10 then
    print('n小于10')
end

-- 示例2 if..else
local n2 = 5
if n2 < 10 then
    print('n2小于10')
else
	print('n2大于10')
end

-- 示例3 if嵌套语句
local n3 = 1
if n3 >= 0 and n3 < 5 then
    print('太小')
elseif n3 >= 5 and n3 < 10 then
    print('适中')
elseif n3 >= 10 then
    print('太大')
end


-- 示例4  多层嵌套

local m1=10
local m2=20

if m1 >= 10 then
   print('m1大于等于10')
   if(m2 >=20) then
	print('m2大于等于20')
   else
	print('m2小于20')
   end
else 
   print('m1小于10')
end

以上代码执行结果如下

bash
root@ubuntu-dev:/tmp/lua_demo# lua test.lua
n小于10
n2小于10
太小
m1大于等于10
m2大于等于20

算数运算 ​

下表列出了 Lua 语言中的常用算术运算符，设定 A 的值为10，B 的值为 20：

操作符描述实例
+加法A + B 输出结果 30
-减法A - B 输出结果 -10
*乘法A * B 输出结果 200
/除法B / A 输出结果 2
%取余B % A 输出结果 0
^乘幂A^2 输出结果 100
-负号-A 输出结果 -10
//整除运算符(>=lua5.3)5//2 输出结果 2

lua脚本test.lua

lua
local a = 21
local b = 10

local c = a + b
print(a.." + "..b.." = "..c )

c = a - b
print(a.." - "..b.." = "..c )

c = a * b
print(a.." * "..b.." = "..c )

c = a / b
print(a.." / "..b.." = "..c )

c = a % b
print(a.." % "..b.." = "..c )

c = a^2
print(a.."^2 ="..c )

c = -a
print("-"..a.." = "..c )

c = a +  tonumber("0.22") +  b 
print(a.." + tonumber('0.22') + "..b.." = "..c )

以上代码执行结果如下

bash
root@ubuntu-dev:/tmp/lua_demo# lua test.lua
21 + 10 = 31
21 - 10 = 11
21 * 10 = 210
21 / 10 = 2.1
21 % 10 = 1
21^2 =441.0
-21 = -21
21 + tonumber('0.22') + 10 = 31.22

关系运算 ​

下表列出了 Lua 语言中的常用关系运算符，设定 A 的值为21，B 的值为 10：

操作符描述实例
==等于，检测两个值是否相等，相等返回 true，否则返回 false(A == B) 为 false。
~=不等于，检测两个值是否相等，不相等返回 true，否则返回 false(A ~= B) 为 true。
>大于，如果左边的值大于右边的值，返回 true，否则返回 false(A > B) 为 false。
<小于，如果左边的值大于右边的值，返回 false，否则返回 true(A < B) 为 true。
>=大于等于，如果左边的值大于等于右边的值，返回 true，否则返回 false(A >= B) 返回 false。
<=小于等于， 如果左边的值小于等于右边的值，返回 true，否则返回 false(A <= B) 返回 true。

lua脚本test.lua

lua
local a = 21
local b = 10

print( a.."=="..b.." 结果: ", a == b)
print( a.."~="..b.." 结果: ", a ~= b)
print( a..">"..b.." 结果: ", a > b)
print( a.."<"..b.." 结果: ", a < b)
print( a..">="..b.." 结果: ", a >= b)
print( a.."<="..b.." 结果: ", a <= b)

local c = a
a = b
b = c

print( a..">"..b.." 结果: ", a > b)
print( a.."<"..b.." 结果: ", a < b)
print( a..">="..b.." 结果: ", a >= b)
print( a.."<="..b.." 结果: ", a <= b)

a = 20
b = 20

print( a.."=="..b.." 结果: ", a == b)
print( a.."~="..b.." 结果: ", a ~= b)

以上代码执行结果如下

bash
root@ubuntu-dev:/tmp/lua_demo# lua test.lua
21==10 结果:    false
21~=10 结果:    true
21>10 结果:     true
21<10 结果:     false
21>=10 结果:    true
21<=10 结果:    false
10>21 结果:     false
10<21 结果:     true
10>=21 结果:    false
10<=21 结果:    true
20==20 结果:    true
20~=20 结果:    false

逻辑运算 ​

逻辑运算符基于布尔型的值来进行计算，并给出结果，下表列出了 Lua 语言中的常用逻辑运算符：

符号含义
and逻辑与操作符。 若 A 为 false，则返回 A，否则返回 B
or逻辑或操作符。 若 A 为 true，则返回 A，否则返回 B
not逻辑非操作符。与逻辑运算结果相反，如果条件为 true，逻辑非为 false

lua脚本test.lua

lua
print('true and false 的结果 ',true and false)
print('true or false 的结果 ',true or false)
print('true and true 的结果 ',true and true)
print('false or false 的结果',false or false)
print('not false 的结果',not false)
print('123 and 345 的结果',123 and 345)
print('nil and true 的结果',nil and true)

以上代码执行结果如下

bash
root@ubuntu-dev:/tmp/lua_demo# lua test.lua
true and false 的结果   false
true or false 的结果    true
true and true 的结果    true
false or false 的结果   false
not false 的结果        true
123 and 345 的结果      345
nil and true 的结果     nil

其他运算符 ​

操作符描述实例
..连接两个字符串a..b ，其中 a 为 "Hello " ， b 为 "World", 输出结果为 "Hello World"。
#一元运算符，返回字符串或表的长度。#"Hello" 返回 5

lua脚本test.lua

lua
a = "Hello "
b = "World"
 
print("连接字符串 a 和 b ", a..b )
 
print("b 字符串长度 ", #b )
 
print("字符串 Test 长度 ", #"Test" )
 
print("菜鸟教程网址长度 ", #"www.runoob.com" )

以上代码执行结果如下

bash
root@ubuntu-dev:/tmp/lua_demo# lua test.lua
连接字符串 a 和 b       Hello World
b 字符串长度    5
字符串 Test 长度        4
菜鸟教程网址长度        14

循环 ​

在实际功能实现中，经常会遇到需要循环运行的代码，比如从1到100填充table数据，我们可以直接用循环语句来实现

Lua 语言提供了以下几种循环处理方式：

循环类型描述
while 循环在条件为 true 时，让程序重复地执行某些语句。执行语句前会先检查条件是否为 true。
for 循环重复执行指定语句，重复次数可在 for 语句中控制。
repeat...until重复执行循环，直到 指定的条件为真时为止
循环嵌套可以在循环内嵌套一个或多个循环语句（while do ... end;for ... do ... end;repeat ... until;）

while 循环 ​

**while**这个循环语法，整体的格式如下：

lua
while 继续循环判断依据 do
    执行的代码
end

示例

lua
local result = 0
local num = 1
 
while num <= 100 do
    result = result + num
    num = num + 1
end
 
print(result)

for 循环 ​

**for**这个循环语法，整体的格式如下：

lua
for 临时变量名=开始值,结束值,步长 do
    循环的代码
end

其中，步长可以省略，默认为1

临时变量名可以直接在代码区域使用（但不可更改），每次循环会自动加步长值，并且在到达结束值后停止循环. 如果需要倒序, 则步长设置为负数就可以,比如-1,代表每次减一.

示例

lua
local result = 0
 
for i=1,100 do
    result = result + i
end
 
print(result)

中断循环 ​

如果想跳出 while 或者 for 循环,则可以使用 break 关键字, 代码如下

lua
result = 0
for i=1,100 do
    result = result + i
    if result > 100 then
        result = result - i
        break
    end
end
 
print(result)

for 迭代器 ​

在 Lua 中迭代器是一种支持指针类型的结构，它可以遍历集合的每一个元素。

泛型 for 迭代器提供了集合的 key/value 对，语法格式如下：

lua
for k, v in pairs(t) do
    print(k, v)
end

上面代码中，k, v为变量列表；pairs(t)为表达式列表。

实例

lua脚本test.lua

lua
array = {"Google", "Runoob"}

for key,value in ipairs(array)
do
   print(key, value)
end

map = { id = 100 ,name = "tom" , age = 18}

for key,value in pairs(map)
do
   print(key, value)
end

以上代码执行结果如下

bash
root@ubuntu-dev:/tmp/lua_demo# lua test.lua
1       Google
2       Runoob
name    tom
age     18
id      100

上次更新: