# 一、 Lua介绍
`lua`是一种轻量小巧的脚本语言，用标准C语言编写并以源代码形式开放，其设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。
官网：[www.lua.org/](https://www.lua.org/)
官方手册[ Lua 5.5 参考手册](https://www.lua.org/manual/5.5/)

# 二、Lua安装
mac可以使用Homebrew ,详细见[环境安装](https://www.runoob.com/lua/lua-environment.html)

```bash
brew install lua
```
# 三、Lua程序及运行方式
详细见[Lua 教程](https://www.runoob.com/lua/lua-tutorial.html)
## 3.1 第一个程序
```lua
print("Hello World！")
```
## 3.2 程序运行方式
### 方式一、交互执行
在终端中直接执行
Lua 提供了交互式编程模式。我们可以在命令行中输入程序并立即查看效果。
Lua 交互式编程模式可以通过命令 lua -i 或 lua 来启用
```lua
$ lua -i                                                                                                                                                              [11:43:20]
Lua 5.5.0  Copyright (C) 1994-2025 Lua.org, PUC-Rio
> print("Hello World!")
Hello World!
```
### 方式二、脚本执行
将 Lua 程序代码保存到一个以 lua 结尾的文件，并执行，该模式称为脚本式编程，如我们将如下代码存储在名为 hello.lua 的脚本文件中
```
lua hello.lua
```
### 方式三、编辑器执行
使用VSCode打开文件 点击Cmd+Shift+B 进行运行[Lua编辑器](https://www.runoob.com/lua/lua-editor.html) 
![image.png](https://developer.qcloudimg.com/http-save/yehe-9980940/d875795467a637772fd3e7b1c86c9d1f.png)

# 四、 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|表示执行的独立线路，用于执行协同程序|
|table|Lua 中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字、字符串或表类型。在 Lua 里，table 的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。|

##  nil
nil 类型表示一种没有任何有效值，它只有一个值 -- nil
nil 作比较时应该加上双引号 "
```请在此输入代码块语言
type(X)
print(type(X)==nil) --false
print(type(X)=="nil") --true
```
 
## boolean(布尔)
boolean 类型只有两个可选值：true（真） 和 false（假），Lua 把 false 和 nil 看作是 false，其他的都为 true，数字 0 也是 true

## number(数字)
Lua 默认只有一种 number 类型 -- double（双精度）类型
```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))
```
结果都是number
## string(字符串)
字符串或串(String)是由数字、字母、下划线组成的一串字符。
在 Lua 中，字符串是一种基本的数据类型，用于存储文本数据。Lua 中的字符串可以包含任意字符，包括字母、数字、符号、空格以及其他特殊字符

- 可以使用单引号、双引号、**[[** 与 **]]**来标记字符串
```lua
string1 = "this is string1"
string2 = 'this is string2'
string3 = [[this 
is 
string3]]
print(string1)
print(string2)
print(string3)
```
代码执行结果为：
```txt
this is string1
this is string2
this 
is 
string3
```
- 在对一个**数字字符串进行算术操作**时，Lua 会尝试将这个数字字符串转成一个数字，如果不能转为数字，则会报错
```lua
print("2" + 6) --结果是8.0
```
- 可以用..来拼接字符串
 ```Lua
print("Hello".." World!")  --Hello World!
```
## table(表/数组)
在 Lua 里，table 的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。也可以在表里添加一些数据，直接初始化表。

- Lua 中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字或者是字符串
```Lua
local tbl3 = {}
tbl3["key"] = "hello"   --有点类似于Java的Map
tbl3["test1"] = "hi"
tbl3[10] = 22

for k, v in pairs(tbl3) do
    print(k .. " : " .. v)
end

```
输出结果
```bash
test1 : hi
10 : 22
key : hello
```
- 不同于其他语言的数组把 0 作为数组的初始索引，在 Lua 里表的默认初始`索引一般以 1` 开始
- table 不会固定长度大小，有新数据添加时 table 长度会自动增长，没初始的 table 都是 nil

```Lua
-- 创建一个数组
local tbl1 = {"10", "20", "30", "40", "50", "60"}

-- 访问数组元素
print(tbl1[1])  -- 输出 10
print(tbl1[3])  -- 输出 30

print（tbl2）--输出nil
```
- 可以使用#来统计table长度
```Lua
local length = #tbl1
print(length) -- 输出 6
```
- 遍历数组
```Lua
-- 循环遍历数组
for i = 1, #tbl1 do
    print(tbl1[i])
end
```

- 可以以负数为数组索引值
```请在此输入代码块语言
array = {}
for i= -2, 2 do
   array[i] = i *2
end
for i = -2,2 do
   print(array[i])
end
```
输出结果
```
-4
-2
0
2
4
```

## function(函数)
[# Lua 函数](https://www.runoob.com/lua/lua-functions.html) 
在Lua中，函数是对语句和表达式进行抽象的主要方法。既可以用来处理一些特殊的工作，也可以用来计算一些值。
Lua 提供了许多的内建函数，你可以很方便的在程序中调用它们，如print()函数可以将传入的参数打印在控制台上。
Lua 函数主要有两种用途：
- 1.完成指定的任务，这种情况下函数作为调用语句使用；
- 2.计算并返回值，这种情况下函数作为赋值语句的表达式使用。
Lua 函数特点：
- 1. 可以将函数作为参数传递给函数
- 2. Lua函数可以返回多个结果值
### 函数格式
```lua
optional_function_scope function function_name( argument1, argument2, argument3..., argumentn)
&nbsp;&nbsp;&nbsp;&nbsp;function_body
&nbsp;&nbsp;&nbsp;&nbsp;return result_params_comma_separated
end
```
- **optional_function_scope:** 该参数是可选的指定函数是全局函数还是局部函数，未设置该参数默认为全局函数，如果你需要设置函数为局部函数需要使用关键字 **local**。
- **function_name: **指定函数名称。
- **argument1, argument2, argument3..., argumentn: **函数参数，多个参数以逗号隔开，函数也可以不带参数。
- **function_body: **函数体，函数中需要执行的代码语句块。
- **result_params_comma_separated: **函数返回值，Lua语言函数可以返回多个值，每个值以逗号隔开
```请在此输入代码块语言
--[[ 函数返回两个值的最大值 --]]
function max(num1, num2)

   if (num1 > num2) then
      result = num1;
   else
      result = num2;
   end

   return result;
end
-- 调用函数
print("两值比较最大值为 ",max(10,4))
print("两值比较最大值为 ",max(5,6))
```
## thread(线程)
参考[Lua协同程序](https://www.runoob.com/lua/lua-coroutine.html) 
Lua 虚拟机本身一次只跑一个 Lua 栈。没有内置的「多个 OS 线程同时执行同一份 Lua 代码」这种模型。
Lua 中的"线程"实际上是通过**协程（Coroutine）**来实现的，它与操作系统级别的线程有本质区别。它跟线程（thread）差不多，拥有自己独立的栈、局部变量和指令指针，可以跟其他协同程序共享全局变量和其他大部分东西。
线程跟协程的区别：线程可以同时多个运行，而协程任意时刻只能运行一个，并且处于运行状态的协程只有被挂起（suspend）时才会暂停。
|函数|说明|
|:-:|:-:|
|`coroutine.create(f)`|创建协程，返回协程对象|
|`coroutine.resume(co, ...)`|启动/恢复协程，传入参数|
|`coroutine.yield(...)`|协程内部让出执行权，可返回值|
|`coroutine.status(co)`|查看状态：`running` / `suspended` / `dead` / `normal`|
|`coroutine.wrap(f)`|类似 create，但返回一个函数，调用即 resume|

### 典型用法（生产者消费者）
流程是：
- 1. `resume` → 协程开始/继续跑
- 2. 遇到 `yield` → 协程挂起，控制权回到调用方
- 3. 再次 `resume` → 从上次 `yield` 处继续
关键点： 同一时刻只有一个协程在跑，不会自动切到另一个，必须你显式 `resume`
```Lua
function producer()
    for i = 1, 3 do
        print("produce", i)
        coroutine.yield(i)  -- 主动让出
    end
end

local co = coroutine.create(producer)

while coroutine.status(co) ~= "dead" do
    local ok, value = coroutine.resume(co)
    print("consume", value)
end
```
## userdata(自定义类型)
userdata 是一种用户自定义数据，用于表示一种由应用程序或 C/C++ 语言库所创建的类型，可以将任意 C/C++ 的任意数据类型的数据（通常是 struct 和 指针）存储到 Lua 变量中调用。
# 五、Lua语法
## 5.1 注释
单行注释 --
```lua
--这是一个lua单行注释
```
多行注释 `--[[` 开始，并以 `]]`
```lua
--[[这是一个
lua
多行
注释]]
```
## 5.2 Lua变量
[Lua变量](https://www.runoob.com/lua/lua-variables.html) 
Lua 变量有三种类型：全局变量、局部变量、表中的域
### (1)全局变量
- 在默认情况下，变量总是认为是全局的。
全局变量不需要声明，给一个变量赋值后即创建了这个全局变量，访问一个没有初始化的全局变量也不会出错，只不过得到的结果是：nil
```lya
a = 5               -- 全局变量
local b = 5         -- 局部变量

function joke()
    c = 5           -- 全局变量
    local d = 6     -- 局部变量
end
```
- 如果想删除一个全局变量，只需要将变量赋值为nil
```请在此输入代码块语言
> print(b)
nil
> b=10
> print(b)
10
```
- 赋值
可以给多个变量赋值，注意：如果要对多个变量赋值必须依次对每个变量赋值
```
a, b = 10, 2*x       <-->       a=10; b=2*x
a, b, c = 0, 1
print(a,b,c)             --> 0   1   nil
```
### (2)局部变量
如果需要创建一个局部变量，可以使用关键字 `local`，
局部变量的作用范围限定在声明它的代码块内，而全局变量在整个程序中可见
### (3)表中的域
表（table）是 Lua 唯一的复合数据结构，域即键值对：
```
local person = {}

-- 方式一：点号访问（键为字符串）
person.name = "张三"
person.age  = 25

-- 方式二：方括号访问（任意类型作键）
person["address"] = "北京"
person[1]         = "第一条记录"

-- 方式三：初始化时直接定义
local student = {
    name  = "李四",
    score = 90,
    [0]   = "特殊索引",   -- 数字索引
}
```
**访问表中的域**：
```
print(person.name)        -- 张三
print(person["address"])  -- 北京
print(person.phone)       -- nil（不存在的域返回 nil）
```
**遍历表中的域**：
```
local tbl = { a = 1, b = 2, [10] = "hi" }

for k, v in pairs(tbl) do
    print(k, v)
end
-- 输出（顺序不保证）：
-- a   1
-- b   2
-- 10  hi
```

### (4)变量遮蔽（Shadowing）

内层局部变量会覆盖外层同名变量：
```
local x = "外层"

do
    local x = "内层"   -- 遮蔽外层的 x
    print(x)            -- 内层
end

print(x)  -- 外层（未受影响）
```
## 5.3 循环
|类型|描述|语法|判断时机|最少执行次数|
|:-:|:-:|:-:|:-:|:-:|
|数值 for|重复执行指定语句，重复次数可在 for 语句中控制|`for i=a,b,step`|循环前|0 次|
|泛型 for|重复执行指定语句，重复次数可在 for 语句中控制|`for k,v in func`|循环前|0 次|
|while|在条件为 true 时，让程序重复地执行某些语句。执行语句前会先检查条件是否为 true|`while cond do`|循环前|0 次|
|repeat..until|重复执行循环，直到 指定的条件为真时为止|`repeat...until cond`|循环后|**1 次**|

- 数值 for 循环

```
for i = 1, 10 do        -- 步长默认 1
    print(i)
end

for i = 10, 1, -2 do    -- 指定步长 -2
    print(i)
end
```
- 泛型 for 循环（遍历表）

```
-- pairs：遍历所有键值对（含字符串键、数字键）
for k, v in pairs(tbl) do
    print(k, v)
end

-- ipairs：只按顺序遍历数字索引（1,2,3...）
for i, v in ipairs(tbl) do
    print(i, v)
end
```
- while 循环
先判断条件，条件为假时**不执行**
```
local x = 1
while x <= 5 do
    print(x)
    x = x + 1
end
```
- repeat...until 循环
先执行一次，再判断条件，条件为真时**退出**
```
local x = 1
repeat
    print(x)
    x = x + 1
until x > 5
```

## 5.4 流程控制
### if...then...end
```
local age = 18
if age >= 18 then
    print("成年")
end
```
### if...elseif...else...end

```
local score = 85
if score >= 90 then
    print("优秀")
elseif score >= 60 then
    print("及格")
else
    print("不及格")
end
```

# 六、Lua和Redis

Redis 内置了 Lua 解释器，可以在服务端原子性地执行 Lua 脚本，这是 Redis 高级用法中非常重要的能力
## 6.1 为什么要在 Redis 中用 Lua？

- **原子性**：整个脚本作为一个整体执行，不会被其他命令插入
- **减少网络开销**：多步操作在服务端一次完成，无需多次往返
- **复用逻辑**：复杂逻辑封装在脚本中，客户端只需调用
- **服务端计算**：在 Redis 内做判断、循环、聚合，少传数据
## 6.2 基本用法
Redis内嵌 Lua 解释器，允许在服务端原子性地执行 Lua 脚本。核心命令有两个：
|命令|作用|
|:-:|:-:|
|**EVAL**|直接执行 Lua 脚本|
|**EVALSHA**|通过脚本的 SHA1 摘要执行已被缓存的脚本|
 ### 1.EVAL
语法
```请在此输入代码块语言
EVAL script numkeys key [key ...] arg [arg ...]
```
- `script`：Lua 脚本原文字符串
- `numkeys`：后面**键的数量**（必须显式指定，0/1/N）
- `key [key...]`：所有操作的 Redis Key，在脚本内通过 `KEYS[1], KEYS[2]...` 获取
- `arg [arg...]`：自定义参数，脚本内通过 `ARGV[1], ARGV[2]...` 获取
示例：自增计数
redis
```
# 脚本：KEYS[1]自增，增量为 ARGV[1]
EVAL "return redis.call('INCRBY', KEYS[1], ARGV[1])" 1 counter 10
```

- `numkeys=1`，key：`counter`，参数：`10`

- 返回结果：counter 自增后数
### 2. EVALSHA
先用 `SCRIPT LOAD` 上传脚本到 Redis 服务端，Redis 返回脚本 SHA1 40 位哈希
后续使用 `EVALSHA sha1 numkeys ...` 执行，不用传完整脚本，大幅减少网络流量。

```bash
# 1. 加载脚本，获取sha
SCRIPT LOAD "return redis.call('GET', KEYS[1])"
# 返回类似："a42059b356c875f0717db19a59fcb346e970f0de"
# 2. EVALSHA 执行
EVALSHA a42059b356c875f0717db19a59fcb346e970f0de 1 testkey
```

注意  ` 脚本丢失场景` （缓存失效）
Redis 重启、执行 `SCRIPT FLUSH` 后，服务端缓存的脚本会清空，此时执行 EVALSHA 报错：NOSCRIPT No matching script. Please use EVAL
 标准业务容错方案（客户端通用逻辑）
- 优先调用 EVALSHA
- 捕获 NOSCRIPT 错误
- 捕获到后执行 SCRIPT LOAD 重新上传脚本，再重试 EVALSHA
## 6.3 经典实用场景Java代码实现
基于 Redis 滑动窗口的限流器
```java
public class SlidingWindowRateLimiter {

    private static final String LUA_SCRIPT =
            "local key = KEYS[1] " +
            "local windowMs = tonumber(ARGV[1]) " +
            "local maxRequests = tonumber(ARGV[2]) " +
            "local now = tonumber(ARGV[3]) " +
            "local member = now .. ':' .. ARGV[4] " +

            // 1. 移除窗口外的过期请求记录
            "redis.call('ZREMRANGEBYSCORE', key, 0, now - windowMs) " +

            // 2. 统计当前窗口内的请求数
            "local current = redis.call('ZCARD', key) " +

            // 3. 判断是否允许通过
            "if current < maxRequests then " +
            "    redis.call('ZADD', key, now, member) " +
            "    redis.call('PEXPIRE', key, windowMs) " +
            "    return {1, maxRequests - current - 1} " +   // {允许, 剩余配额}
            "else " +
            "    return {0, 0} " +                           // {拒绝, 0}
            "end";

    private final JedisPool jedisPool;
    private final String scriptSha;

    public SlidingWindowRateLimiter(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
        // 启动时预加载脚本到 Redis 缓存
        try (Jedis jedis = jedisPool.getResource()) {
            this.scriptSha = jedis.scriptLoad(LUA_SCRIPT);
            System.out.println("[初始化] 脚本已加载，SHA1: " + scriptSha);
        }
    }

    /**
     * 尝试获取访问许可
     *
     * @param key          限流键，建议格式：rate_limiter:{业务}:{用户ID}
     * @param windowMs     滑动窗口大小（毫秒）
     * @param maxRequests  窗口内最大请求数
     * @return 许可结果
     */
    public RateLimitResult tryAcquire(String key, long windowMs, int maxRequests) {
        try (Jedis jedis = jedisPool.getResource()) {
            long now = System.currentTimeMillis();
            String randomId = UUID.randomUUID().toString().replace("-", "").substring(0, 8);

            // 优先使用 EVALSHA，失败则回退 EVAL
            List<Long> result;
            try {
                result = (List<Long>) jedis.evalsha(scriptSha,
                        List.of(key),
                        List.of(String.valueOf(windowMs), String.valueOf(maxRequests), String.valueOf(now), randomId));
            } catch (redis.clients.jedis.exceptions.JedisNoScriptException e) {
                // 脚本缓存被清空（如 SCRIPT FLUSH、重启），回退 EVAL
                System.err.println("[回退] EVALSHA 失败 (NOSCRIPT)，使用 EVAL 重新执行");
                result = (List<Long>) jedis.eval(LUA_SCRIPT,
                        List.of(key),
                        List.of(String.valueOf(windowMs), String.valueOf(maxRequests), String.valueOf(now), randomId));
            }

            boolean allowed = result.get(0) == 1;
            long remaining = result.get(1);
            return new RateLimitResult(allowed, remaining, maxRequests, windowMs);
        }
    }

    /**
     * 限流结果
     */
    public record RateLimitResult(boolean allowed, long remainingQuota, long maxRequests, long windowMs) {

        public long retryAfterMs() {
            if (allowed) return 0;
            // 粗略估算：窗口剩余时间后可以再试
            return windowMs;
        }

        @Override
        public String toString() {
            if (allowed) {
                return "✅ 允许通过 | 剩余配额: " + remainingQuota + "/" + maxRequests;
            } else {
                return "❌ 请求被限流 | 配额已用完 (" + maxRequests + "/" + maxRequests + ")";
            }
        }
    }
}

```



lua是一种轻量小巧的脚本语言，用标准C语言编写并以源代码形式开放，其设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。官网：www.lua.org/官方手册 Lua 5.5 参考手册

Lua是什么以及为啥在Redis中使用Lua？

lua是一种轻量小巧的脚本语言，用标准C语言编写并以源代码形式开放，其设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。

编程语言

Lua是一种轻量级脚本语言，专为嵌入应用设计，支持多种数据类型和灵活语法。本文详细介绍Lua安装、基础语法、变量类型、流程控制及与Redis的集成应用，包含代码示例和实用技巧，适合开发者快速掌握Lua编程。

数据结构

代码解释

虚拟机

解释器

Lua语言

Redis

Java

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

Lua是什么以及为啥在Redis中使用Lua？-腾讯云开发者社区-腾讯云

Lua是什么以及为啥在Redis中使用Lua？

Lua是什么以及为啥在Redis中使用Lua？

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐