不依赖yacc如何实现表达式按优先级解析

总结

无意发现一个非常有意思的简单语法解析器,不依赖lex/yacc,本文对其中比较难理解的表达式解析(带优先级)部分做一些分析和记录。

(理解本文需要调试后面的代码部分,have fun!)

理解表达式解析部分

这段代码的功能是解析a+b+(c+d)*e*f+g;,包含符号优先级处理的功能。

static ExprAST *ParseBinOpRHS(int ExprPrec, ExprAST *LHS) {// If this is a binop, find its precedence.while (1) {int TokPrec = GetTokPrecedence();// If this is a binop that binds at least as tightly as the current binop,// consume it, otherwise we are done.if (TokPrec < ExprPrec)return LHS;// Okay, we know this is a binop.int BinOp = CurTok;getNextToken();  // eat binop// Parse the primary expression after the binary operator.ExprAST *RHS = ParsePrimary();if (!RHS) return 0;// If BinOp binds less tightly with RHS than the operator after RHS, let// the pending operator take RHS as its LHS.int NextPrec = GetTokPrecedence();if (TokPrec < NextPrec) {RHS = ParseBinOpRHS(TokPrec+1, RHS);if (RHS == 0) return 0;}// Merge LHS/RHS.LHS = new BinaryExprAST(BinOp, LHS, RHS);}
}

解析流程:

  1. 解析:a+b+(c+d)*e*f+g;
  2. 进入函数时,ExprPrec为0,LHS是a。
  3. 第一轮:解析+b
    1. TokPrec < ExprPrec 即 20 < 0:不退出递归
    2. TokPrec < NextPrec 即 20 < 20:不进入递归
    3. 符号+、RHS=b被合入LHS=a,LHS变为a+b
  4. 第二轮:解析+(c+d)
    1. TokPrec < ExprPrec 即 20 < 0:不退出递归
    2. TokPrec < NextPrec 即 20 < 40:进入递归,当前RHS=(c+d)、符号为+
      1. 递归ParseBinOpRHS第一轮:当前LHS被设为外面的RHS=(c+d)也就是(c+d)被当做后面乘号的左值了。
        1. 解析*e
        2. 进入后ExprPrec=21(因为加1后面在遇到+可以退出递归,后面在遇到比加号高的不会退出递归,很巧妙的做法),TokPrec < ExprPrec 即 40 < 21:不进入
        3. TokPrec < NextPrec 即 40 < 40:不退出递归
        4. 符号*、RHS=e被合入LHS=(c+d),LHS变为(c+d)*e
      2. 递归ParseBinOpRHS第二轮:当前LHS变为(c+d)*e、符号为*
        1. TokPrec < ExprPrec 即 40 < 21:不退出递归
        2. TokPrec < NextPrec即 40 < 20:不进入递归
        3. 符号*、RHS=f被合入LHS=(c+d)*e,LHS变为(c+d)*e*f
      3. 递归ParseBinOpRHS第三轮:当前LHS变为(c+d)*e*f、符号为+
        1. TokPrec < ExprPrec 即 20 < 21:退出递归!(非常重要)
        2. 返回(c+d)*e*f
    3. 外层还在处理第二个加号,通过递归得到RHS=(c+d)*e*f
    4. 合并+、LHS=a+b、RHS=(c+d)*e*f得到:a+b+(c+d)*e*f
  5. 第三轮:解析+g
    1. TokPrec < ExprPrec 即 20 < 0:不退出递归
    2. TokPrec < NextPrec 即 20 < 20:不进入递归
    3. 符号+、RHS=g被合入LHS=a+b+(c+d)*e*f,LHS变为a+b+(c+d)*e*f+g

解析流程总结:

a+b+(c+d)*e*f+g;的解析过程分了三部分,循环一次解析一组,一组的定义是:【符号+数字】或【符号+(表达式)】,也就是{+b}{+(c+d)}{*e}{*f}{+g},解析每一组的时候,都是不断把rhs拼入lhs的过程,rhs到底是什么,需要判断是否递归解析,比如前面是+b+(c+d)*e,在解析第二个加号的时候,rhs就不能是(c+d)了,需要递归的把后面乘号也解了,rhs应该是(c+d)*e*f

三步解析:

  1. (外侧函数解析a)
  2. 解析+b
  3. 递归解析+(c+d)ef
  4. 解析+g

整个解析流程就是不断把RHS拼到LHS中,最终返回LHS的过程。

中间比较重要的就是乘号和+号的优先级问题,上述代码中,进入递归的含义为:把优先级高于当前符号的所有后续表达式一块解析出来,直到遇到当前符号为止,那么这里就涉及递归进入条件和递归退出条件了:

  • 递归进入条件:遇到的符号优先级比上一个符号高:if (TokPrec < NextPrec)
  • 递归退出条件:遇到的符号优先级和上一个符号相同:if (TokPrec < ExprPrec)

假设当前符号为+遇到*后,TokPrec=20、NextPrec=40会进入递归。
假设当前符号为*遇到+后,TokPrec=20、ExprPrec=21会退出递归,而遇到*的话ExprPrec=40无法退出递归,代码比较巧妙,不容易理解。

语法解析器

gcc或clang编译均可,下面makefile是clang的。

main.c

#include <cstdio>
#include <cstdlib>
#include <string>
#include <map>
#include <vector>
/** def foo(x y) x+foo(y, 4.0);* * def foo(x y) x+y y;* * def foo(x y) x+y );* * extern sin(a);** def foo(x y) a+b+(c+d)*e*f+g;*///===----------------------------------------------------------------------===//
// Lexer
//===----------------------------------------------------------------------===//// The lexer returns tokens [0-255] if it is an unknown character, otherwise one
// of these for known things.
enum Token {tok_eof = -1,// commandstok_def = -2, tok_extern = -3,// primarytok_identifier = -4, tok_number = -5
};static std::string IdentifierStr;  // Filled in if tok_identifier
static double NumVal;              // Filled in if tok_number/// gettok - Return the next token from standard input.
static int gettok() {static int LastChar = ' ';// Skip any whitespace.while (isspace(LastChar))LastChar = getchar();if (isalpha(LastChar)) { // identifier: [a-zA-Z][a-zA-Z0-9]*IdentifierStr = LastChar;while (isalnum((LastChar = getchar())))IdentifierStr += LastChar;if (IdentifierStr == "def") return tok_def;if (IdentifierStr == "extern") return tok_extern;return tok_identifier;}if (isdigit(LastChar) || LastChar == '.') {   // Number: [0-9.]+std::string NumStr;do {NumStr += LastChar;LastChar = getchar();} while (isdigit(LastChar) || LastChar == '.');NumVal = strtod(NumStr.c_str(), 0);return tok_number;}if (LastChar == '#') {// Comment until end of line.do LastChar = getchar();while (LastChar != EOF && LastChar != '\n' && LastChar != '\r');if (LastChar != EOF)return gettok();}// Check for end of file.  Don't eat the EOF.if (LastChar == EOF)return tok_eof;// Otherwise, just return the character as its ascii value.int ThisChar = LastChar;LastChar = getchar();return ThisChar;
}//===----------------------------------------------------------------------===//
// Abstract Syntax Tree (aka Parse Tree)
//===----------------------------------------------------------------------===///// ExprAST - Base class for all expression nodes.
class ExprAST {
public:virtual ~ExprAST() {}
};/// NumberExprAST - Expression class for numeric literals like "1.0".
class NumberExprAST : public ExprAST {double Val;
public:NumberExprAST(double val) : Val(val) {}
};/// VariableExprAST - Expression class for referencing a variable, like "a".
class VariableExprAST : public ExprAST {std::string Name;
public:VariableExprAST(const std::string &name) : Name(name) {}
};/// BinaryExprAST - Expression class for a binary operator.
class BinaryExprAST : public ExprAST {char Op;ExprAST *LHS, *RHS;
public:BinaryExprAST(char op, ExprAST *lhs, ExprAST *rhs): Op(op), LHS(lhs), RHS(rhs) {}
};/// CallExprAST - Expression class for function calls.
class CallExprAST : public ExprAST {std::string Callee;std::vector<ExprAST*> Args;
public:CallExprAST(const std::string &callee, std::vector<ExprAST*> &args): Callee(callee), Args(args) {}
};/// PrototypeAST - This class represents the "prototype" for a function,
/// which captures its name, and its argument names (thus implicitly the number
/// of arguments the function takes).
class PrototypeAST {std::string Name;std::vector<std::string> Args;
public:PrototypeAST(const std::string &name, const std::vector<std::string> &args): Name(name), Args(args) {}};/// FunctionAST - This class represents a function definition itself.
class FunctionAST {PrototypeAST *Proto;ExprAST *Body;
public:FunctionAST(PrototypeAST *proto, ExprAST *body): Proto(proto), Body(body) {}};//===----------------------------------------------------------------------===//
// Parser
//===----------------------------------------------------------------------===///// CurTok/getNextToken - Provide a simple token buffer.  CurTok is the current
/// token the parser is looking at.  getNextToken reads another token from the
/// lexer and updates CurTok with its results.
static int CurTok;
static int getNextToken() {return CurTok = gettok();
}/// BinopPrecedence - This holds the precedence for each binary operator that is
/// defined.
static std::map<char, int> BinopPrecedence;/// GetTokPrecedence - Get the precedence of the pending binary operator token.
static int GetTokPrecedence() {if (!isascii(CurTok))return -1;// Make sure it's a declared binop.int TokPrec = BinopPrecedence[CurTok];if (TokPrec <= 0) return -1;return TokPrec;
}/// Error* - These are little helper functions for error handling.
ExprAST *Error(const char *Str) { fprintf(stderr, "Error: %s\n", Str);return 0;}
PrototypeAST *ErrorP(const char *Str) { Error(Str); return 0; }
FunctionAST *ErrorF(const char *Str) { Error(Str); return 0; }static ExprAST *ParseExpression();/// identifierexpr
///   ::= identifier
///   ::= identifier '(' expression* ')'
static ExprAST *ParseIdentifierExpr() {std::string IdName = IdentifierStr;getNextToken();  // eat identifier.if (CurTok != '(') // Simple variable ref.return new VariableExprAST(IdName);// Call.getNextToken();  // eat (std::vector<ExprAST*> Args;if (CurTok != ')') {while (1) {ExprAST *Arg = ParseExpression();if (!Arg) return 0;Args.push_back(Arg);if (CurTok == ')') break;if (CurTok != ',')return Error("Expected ')' or ',' in argument list");getNextToken();}}// Eat the ')'.getNextToken();return new CallExprAST(IdName, Args);
}/// numberexpr ::= number
static ExprAST *ParseNumberExpr() {ExprAST *Result = new NumberExprAST(NumVal);getNextToken(); // consume the numberreturn Result;
}/// parenexpr ::= '(' expression ')'
static ExprAST *ParseParenExpr() {getNextToken();  // eat (.ExprAST *V = ParseExpression();if (!V) return 0;if (CurTok != ')')return Error("expected ')'");getNextToken();  // eat ).return V;
}/// primary
///   ::= identifierexpr
///   ::= numberexpr
///   ::= parenexpr
static ExprAST *ParsePrimary() {switch (CurTok) {default: return Error("unknown token when expecting an expression");case tok_identifier: return ParseIdentifierExpr();case tok_number:     return ParseNumberExpr();case '(':            return ParseParenExpr();}
}/// binoprhs
///   ::= ('+' primary)*
// 函数ParseBinOpRHS用于解析有序对列表(其中RHS是Right Hand Side的缩写,表示“右侧”;与此相对应,LHS表示“左侧”——译者注)。
// 它的参数包括一个整数和一个指针,其中整数代表运算符优先级,指针则指向当前已解析出来的那部分表达式。注意,单独一个“x”也是合法的表达式:
// 也就是说binoprhs有可能为空;碰到这种情况时,函数将直接返回作为参数传入的表达式。在上面的例子中,传入ParseBinOpRHS的表达式是“a”,当前语元是“+”。
// 传入ParseBinOpRHS的优先级表示的是该函数所能处理的最低运算符优先级。假设语元流中的下一对是“[+, x]”,且传入ParseBinOpRHS的优先级是40,
// 那么该函数将直接返回(因为“+”的优先级是20)。搞清楚这一点之后,我们再来看ParseBinOpRHS的定义,函数的开头是这样的:// a+b+(c+d)*e*f+g
// a    [+, b]、[+, (c+d)]、[*, e]、[*, f]和[+, g]
static ExprAST *ParseBinOpRHS(int ExprPrec, ExprAST *LHS) {// If this is a binop, find its precedence.while (1) {int TokPrec = GetTokPrecedence();// If this is a binop that binds at least as tightly as the current binop,// consume it, otherwise we are done.if (TokPrec < ExprPrec)return LHS;// Okay, we know this is a binop.int BinOp = CurTok;getNextToken();  // eat binop// Parse the primary expression after the binary operator.ExprAST *RHS = ParsePrimary();if (!RHS) return 0;// If BinOp binds less tightly with RHS than the operator after RHS, let// the pending operator take RHS as its LHS.int NextPrec = GetTokPrecedence();if (TokPrec < NextPrec) {RHS = ParseBinOpRHS(TokPrec+1, RHS);if (RHS == 0) return 0;}// Merge LHS/RHS.LHS = new BinaryExprAST(BinOp, LHS, RHS);}
}/// expression
///   ::= primary binoprhs
///
// def foo(x y) x+y y;
// 这里开始解析x+y部分:
static ExprAST *ParseExpression() {ExprAST *LHS = ParsePrimary();if (!LHS) return 0;return ParseBinOpRHS(0, LHS);
}/// prototype
///   ::= id '(' id* ')'
static PrototypeAST *ParsePrototype() {if (CurTok != tok_identifier)return ErrorP("Expected function name in prototype");std::string FnName = IdentifierStr;getNextToken();if (CurTok != '(')return ErrorP("Expected '(' in prototype");std::vector<std::string> ArgNames;while (getNextToken() == tok_identifier)ArgNames.push_back(IdentifierStr);if (CurTok != ')')return ErrorP("Expected ')' in prototype");// success.getNextToken();  // eat ')'.return new PrototypeAST(FnName, ArgNames);
}/// definition ::= 'def' prototype expression
static FunctionAST *ParseDefinition() {getNextToken();  // eat def.PrototypeAST *Proto = ParsePrototype();if (Proto == 0) return 0;if (ExprAST *E = ParseExpression())return new FunctionAST(Proto, E);return 0;
}/// toplevelexpr ::= expression
static FunctionAST *ParseTopLevelExpr() {if (ExprAST *E = ParseExpression()) {// Make an anonymous proto.PrototypeAST *Proto = new PrototypeAST("", std::vector<std::string>());return new FunctionAST(Proto, E);}return 0;
}/// external ::= 'extern' prototype
static PrototypeAST *ParseExtern() {getNextToken();  // eat extern.return ParsePrototype();
}//===----------------------------------------------------------------------===//
// Top-Level parsing
//===----------------------------------------------------------------------===//static void HandleDefinition() {if (ParseDefinition()) {fprintf(stderr, "Parsed a function definition.\n");} else {// Skip token for error recovery.getNextToken();}
}static void HandleExtern() {if (ParseExtern()) {fprintf(stderr, "Parsed an extern\n");} else {// Skip token for error recovery.getNextToken();}
}static void HandleTopLevelExpression() {// Evaluate a top-level expression into an anonymous function.if (ParseTopLevelExpr()) {fprintf(stderr, "Parsed a top-level expr\n");} else {// Skip token for error recovery.getNextToken();}
}/// top ::= definition | external | expression | ';'
static void MainLoop() {while (1) {fprintf(stderr, "ready> ");switch (CurTok) {case tok_eof:    return;case ';':        getNextToken(); break;  // ignore top-level semicolons.case tok_def:    HandleDefinition(); break;case tok_extern: HandleExtern(); break;default:         HandleTopLevelExpression(); break;}}
}//===----------------------------------------------------------------------===//
// Main driver code.
//===----------------------------------------------------------------------===//int main() {// Install standard binary operators.// 1 is lowest precedence.BinopPrecedence['<'] = 10;BinopPrecedence['+'] = 20;BinopPrecedence['-'] = 20;BinopPrecedence['*'] = 40;  // highest.// Prime the first token.fprintf(stderr, "ready> ");getNextToken();// Run the main "interpreter loop" now.MainLoop();return 0;
}

Makefile


CC = llvm-g++ -stdlib=libc++ -std=c++14
CFLAGS = -g -O0 -I llvm/include -I llvm/build/include -I ./
LLVMFLAGS = `llvm-config --cxxflags --ldflags --system-libs --libs all`.PHONY: mainmain: main.cpp${CC} ${CFLAGS} ${LLVMFLAGS} $< -o $@clean:rm -r main main.o%.o: %.cpp${CC} ${CFLAGS} ${LLVMFLAGS} -c $< -o $@

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/5127.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

219. 存在重复元素 II

给你一个整数数组 nums 和一个整数 k &#xff0c;判断数组中是否存在两个 不同的索引 i 和 j &#xff0c;满足 nums[i] nums[j] 且 abs(i - j) < k 。如果存在&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 示例 1&#xff1a; 输入&#xff1a;num…

React、Vue3中父组件如何调用子组件内部的方法

React 当父组件需要调用子组件的方法时&#xff0c;可以通过useImperativeHandle钩子函数实现。以下例子是ts实现方式。 在子组件中使用 useImperativeHandle 钩子&#xff0c;将指定的方法暴露给父组件&#xff0c;以便父组件可以通过子组件的引用来调用该方法。 在子组件中…

Type-C PD显示器方案简介

方案概述 LDR6020 Type-C PD显示器方案可以给显示器提供一个全功能C口&#xff0c;支持手机&#xff0c;电脑&#xff0c;游戏主机等一线投屏功能&#xff0c;同时支持PD快充输出。LDR6020内置了 USB Power Delivery 控制器和 PD BMC PHY 收发器&#xff0c;支持PD2.0/3.0等快充…

Low-Light Image Enhancement via Self-Reinforced Retinex Projection Model 论文阅读笔记

这是马龙博士2022年在TMM期刊发表的基于改进的retinex方法去做暗图增强&#xff08;非深度学习&#xff09;的一篇论文 文章用一张图展示了其动机&#xff0c;第一行是估计的亮度层&#xff0c;第二列是通常的retinex方法会对估计的亮度层进行RTV约束优化&#xff0c;从而产生…

ceph----应用

文章目录 一、创建 CephFS 文件系统 MDS 接口1.1 服务端操作1.2 客户端操作 二、创建 Ceph 块存储系统 RBD 接口三、OSD 故障模拟与恢复四、创建 Ceph 对象存储系统 RGW 接口 一、创建 CephFS 文件系统 MDS 接口 1.1 服务端操作 1&#xff09;在管理节点创建 mds 服务 cd /et…

Unity游戏源码分享-Third Person Controller - Shooter Template v1.3.1

Unity游戏源码分享-Third Person Controller - Shooter Template v1.3.1 功能非常齐全 AI格斗 2.5D 完整工程地址&#xff1a;https://download.csdn.net/download/Highning0007/88057824

node自主学习——fs文件操作模块

目录 读文件 读文件是否成功的判定 写文件 写文件是否成功的判定 备注&#xff1a;VsCode、node v18.17.0 读文件 fs.readFile(文件路径, 编码格式&#xff08;可选&#xff09;, 回调函数)// 回调函数可以打印失败和成功的结果 // 若成功&#xff0c;err的值为null // 若…

Spring【AOP】

AOP-面向切面编程 AOP&#xff1a;面向切面编程&#xff0c;通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 SpringAop中&#xff0c;通过Advice定义横切逻辑&#xff0c;并支持5种类型的Advice&#xff1a; 导入依赖 <dependency><groupId>…

前端JavaScript入门-day06

(创作不易&#xff0c;感谢有你&#xff0c;你的支持&#xff0c;就是我前行的最大动力&#xff0c;如果看完对你有帮助&#xff0c;请留下您的足迹&#xff09; 目录 作用域 局部作用域 全局作用域 作用域链 JS垃圾回收机制 1. 什么是垃圾回收机制 2.内存的生命周…

缕析条分Scroll属性 | 京东云技术团队

最近有项目需要使用js原生开发滑动组件&#xff0c;频繁要用到dom元素的各种属性&#xff0c;其中以各种类型的height和top属性居多&#xff0c;名字相近&#xff0c;含义也很容易搞混。因此特地总结归纳了一下常用的知识点&#xff0c;在文末我们来挑战实现一个简易的移动端Sc…

行为型模式 - 责任链模式

概述 在现实生活中&#xff0c;常常会出现这样的事例&#xff1a;一个请求有多个对象可以处理&#xff0c;但每个对象的处理条件或权限不同。例如&#xff0c;公司员工请假&#xff0c;可批假的领导有部门负责人、副总经理、总经理等&#xff0c;但每个领导能批准的天数不同&a…

无参数读文件和RCE总结

什么是无参数&#xff1f; 顾名思义&#xff0c;就是只使用函数&#xff0c;且函数不能带有参数&#xff0c;这里有种种限制&#xff1a;比如我们选择的函数必须能接受其括号内函数的返回值&#xff1b;使用的函数规定必须参数为空或者为一个参数等 接下来&#xff0c;从代码…

Redis : zmalloc.h:50:31: 致命错误:jemalloc/jemalloc.h:没有那个文件或目录

In file included from adlist.c:34:0: zmalloc.h:50:31: 致命错误&#xff1a;jemalloc/jemalloc.h&#xff1a;没有那个文件或目录 #include <jemalloc/jemalloc.h> 解决 : 如上图使用命令 make MALLOClibc

分库分表,可能真的要退出历史舞台了!

即使是不懂编程的玩家&#xff0c;在对比 NAS 的时候&#xff0c;也会两眼放光&#xff0c;考虑很多因素&#xff0c;比如 RAID 级别、速度、易用程度等。作为时时刻刻与代码打交道的我们&#xff0c;更需要关注数据的存取问题。 一开始&#xff0c;开箱即用的 MySQL&#xff…

经典java面试题6

什么是Java中的泛型&#xff08;Generics&#xff09;&#xff1f;它的作用是什么&#xff1f; 泛型是Java中的一种类型参数化机制&#xff0c;用于在编译时实现类型安全性。 它允许在定义类、接口和方法时使用类型参数&#xff0c;以便在使用时指定具体的类型。 泛型可以提高…

linux之Ubuntu系列(三)远程管理指令☞Scp

cp scp cp 复制文件 是限制在本地操作 scp&#xff1a; 远程拷贝文件 cp [options] 源文件or 目录 目标文件or 目录 如果复制目录&#xff0c;要加 -r 选项 &#xff0c;同时如果目标目录不存在&#xff0c;会会创建 scp scp就是 secure copy&#xff0c;是一个在linux下用来…

122、仿真-基于51单片机的电量监测电压电流和温度报警系统设计(Proteus仿真+程序+流程图+配套资料等)

方案选择 单片机的选择 方案一&#xff1a;STM32系列单片机控制&#xff0c;该型号单片机为LQFP44封装&#xff0c;内部资源足够用于本次设计。STM32F103系列芯片最高工作频率可达72MHZ&#xff0c;在存储器的01等等待周期仿真时可达到1.25Mip/MHZ(Dhrystone2.1)。内部128k字节…

vue3后台管理系统实现动态侧边导航菜单管理(ElementPlus组件)

记住 一级(el-sub-menu)的都是只是展示的 点击跳转的都是一级下的子级(el-menu-item) 完整展示 1:在登陆功能进行登陆 获取menu列表 注册路由表的时候 把文件进行创建好 因为注册的方法需要获取这个路径 整个router下的main product等等都要创建 //1:发送你的用户名和密码获…

k8s1.18.20通过cert-manager、kubed实现三个月免费证书自动续签

k8s1.18.20通过cert-manager、kubed实现三个月免费证书自动续签 一、cert-manager部署 参考&#xff1a;k8s1.18.20:cert-manager 1.8 安装部署 二、申请免费证书-letsencrypt 2.1、创建ClusterIssuer 向letsencrypt申请三个月免费证书 [rootk8s-node ~]# cat clusteriss…

Redis 从入门到精通【进阶篇】之Lua脚本详解

文章目录 0. 前言1. Redis Lua脚本简介1.1 Lua脚本介绍Lua语言概述&#xff1a;Lua脚本的特点&#xff1a; 1.2 Redis中为何选择LuaLua与Redis的结合优势Lua脚本在Redis中的应用场景 2. Redis Lua脚本的执行流程1. 加载脚本&#xff1a;1.1 脚本缓存机制&#xff1a;1.2 脚本加…