Lua实现矩阵的加减乘除

于 2023-02-01 10:33:32 发布
阅读量694 收藏 3
点赞数
分类专栏： Lua 文章标签： lua 矩阵 面向对象编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq135595696/article/details/128827673
版权

Lua实现矩阵的加减乘除

参考文章：

https://blog.csdn.net/qq_54180412/article/details/122943327

https://www.bilibili.com/video/BV1434y187uj/?spm_id_from=333.337.search-card.all.click&vd_source=c52914e7c156e681a9f8a7825139815d

  矩阵的加、减、乘无需多说，主要是矩阵的除法，我使用的是伴随矩阵以及结合行列式的思路求解矩阵之间的除法。

版本一

Matrix = {
    __add = function(tbSource, tbDest)
        assert(tbSource,"tbSource not exist")
        assert(tbDest,  "tbDest not exist")
        if tbSource.nRow ~= tbDest.nRow 
            or tbSource.nColumn ~= tbDest.nColumn then
            print("row or column not equal...")
            return tbSource
        else
            for rowKey,rowValue in ipairs(tbSource.tbData) do
                for colKey,colValue in ipairs(tbSource.tbData[rowKey]) do
                    tbSource.tbData[rowKey][colKey] = 
                        tbSource.tbData[rowKey][colKey] + tbDest.tbData[rowKey][colKey]
                end
            end 
            return tbSource
        end
    end,

    __sub = function(tbSource, tbDest)
        assert(tbSource,"tbSource not exist")
        assert(tbDest,  "tbDest not exist")
        if tbSource.nRow ~= tbDest.nRow 
            or tbSource.nColumn ~= tbDest.nColumn then
            print("row or column not equal...")
            return tbSource
        else
            for rowKey,rowValue in ipairs(tbSource.tbData) do
                for colKey,colValue in ipairs(tbSource.tbData[rowKey]) do
                    tbSource.tbData[rowKey][colKey] = 
                        tbSource.tbData[rowKey][colKey] - tbDest.tbData[rowKey][colKey]
                end
            end 
            return tbSource
        end
    end,

    __mul = function(tbSource, tbDest)
        return Matrix:_MartixMul(tbSource, tbDest)
    end,

    __div = function(tbSource, tbDest)
        assert(tbSource,"tbSource not exist")
        assert(tbDest,  "tbDest not exist")
        
        local nDet = Matrix:_GetDetValue(tbDest)
        if nDet == 0 then
            print("matrix no inverse matrix...")
            return nil
        end
        local tbInverseDest = Matrix:_MatrixNumMul(Matrix:_GetCompanyMatrix(tbDest), 1 / nDet)
        -- Matrix:_GetCompanyMatrix(tbDest):Print()
        -- print(nDet)
        -- tbInverseDest:Print()
        return Matrix:_MartixMul(tbSource, tbInverseDest)
    end
}

-- 构建一个Matrix对象
function Matrix:New(data)
    assert(data,"data not exist")
    local tbMatrix = {}
    setmetatable(tbMatrix, self)
    self.__index    = self

    tbMatrix.tbData = data
    tbMatrix.nRow   = #data
    if tbMatrix.nRow > 0 then
        tbMatrix.nColumn = (#data[1])
    else
        tbMatrix.nColumn = 0
    end
    return tbMatrix
end

-- 输出当前Matrix数据信息
function Matrix:Print()
    for rowKey,rowValue in ipairs(self.tbData) do
        for colKey,colValue in ipairs(self.tbData[rowKey]) do
            io.write(self.tbData[rowKey][colKey],',')
        end
        print('')
    end
end

-- 切割，切去第rowIndex以及第colIndex列
function Matrix:_CutoffMatrix(tbMatrix, rowIndex, colIndex)
    assert(tbMatrix,"tbMatrix not exist")
    assert(rowIndex >= 1,"rowIndex < 1")
    assert(colIndex >= 1,"colIndex < 1")
    local tbRes   = Matrix:New({})
    tbRes.nRow    = tbMatrix.nRow    - 1
    tbRes.nColumn = tbMatrix.nColumn - 1
    for i = 1, tbMatrix.nRow - 1 do
        for j = 1, tbMatrix.nColumn - 1 do
            if tbRes.tbData[i] == nil then
                tbRes.tbData[i] = {}
            end
            
            local nRowDir = 0
            local nColDir = 0
            if i >= rowIndex then
                nRowDir = 1
            end

            if j >= colIndex then
                nColDir = 1
            end

            tbRes.tbData[i][j] = tbMatrix.tbData[i + nRowDir][j + nColDir]
        end
    end
    return tbRes
end


-- 获取矩阵的行列式对应的值
function Matrix:_GetDetValue(tbMatrix)
    assert(tbMatrix,"tbMatrix not exist")
    -- 当矩阵为一阶矩阵时，直接返回A中唯一的元素
    if tbMatrix.nRow == 1 then
        return tbMatrix.tbData[1][1]
    end

    local nAns = 0
    for i = 1, tbMatrix.nColumn do
        local nFlag = -1
        if i % 2 ~= 0 then
            nFlag = 1
        end

        nAns = 
            nAns + tbMatrix.tbData[1][i] * 
                Matrix:_GetDetValue(Matrix:_CutoffMatrix(tbMatrix, 1, i)) * nFlag
        -- print("_GetDetValue nflag:",nFlag)
    end
    return nAns
end


-- 获取矩阵的伴随矩阵
function Matrix:_GetCompanyMatrix(tbMatrix)
    assert(tbMatrix,"tbMatrix not exist")
    local tbRes   = Matrix:New({})
    -- 伴随矩阵与原矩阵存在转置关系
    tbRes.nRow    = tbMatrix.nColumn
    tbRes.nColumn = tbMatrix.nRow

    for i = 1, tbMatrix.nRow do
        for j = 1, tbMatrix.nColumn do
            local nFlag = 1
            if ((i + j) % 2) ~= 0 then
                nFlag = -1
            end       
            
            if tbRes.tbData[j] == nil then
                tbRes.tbData[j] = {}
            end
            -- print(Matrix:_GetDetValue(Matrix:_CutoffMatrix(tbMatrix, i, j)))
            -- Matrix:_CutoffMatrix(tbMatrix, i, j):Print()
            -- print("---11----")

            tbRes.tbData[j][i] = 
                Matrix:_GetDetValue(Matrix:_CutoffMatrix(tbMatrix, i, j)) * nFlag
        end
    end
    return tbRes
end


-- 矩阵数乘
function Matrix:_MatrixNumMul(tbMatrix, num)
    for i = 1, tbMatrix.nRow do
        for j = 1, tbMatrix.nColumn do
            tbMatrix.tbData[i][j] = tbMatrix.tbData[i][j] * num
        end
    end
    return tbMatrix
end


-- 矩阵相乘
function Matrix:_MartixMul(tbSource, tbDest)
    assert(tbSource,"tbSource not exist")
    assert(tbDest,  "tbDest not exist")
    if tbSource.nColumn ~= tbDest.nRow then
        print("column not equal row...")
        return tbSource
    else
        local tbRes = Matrix:New({})
        for i = 1, tbSource.nRow do
            for j = 1, tbDest.nColumn do
                if tbRes.tbData[i] == nil then
                    tbRes.tbData[i] = {}
                end
                
                if tbRes.tbData[i][j] == nil then
                    tbRes.tbData[i][j] = 0
                end

                for k = 1, tbSource.nColumn do
                    tbRes.tbData[i][j] = 
                        tbRes.tbData[i][j] + (tbSource.tbData[i][k] * tbDest.tbData[k][j])
                end
            end
        end
        tbRes.nRow    = tbSource.nRow
        tbRes.nColumn = tbDest.nColumn
        return tbRes
    end
end









-- 矩阵加法
local matrix1 = Matrix:New({{1,2,3},{4,5,6}})
local matrix2 = Matrix:New({{2,3,4},{5,6,7}})

matrix1 = matrix1 + matrix2
matrix1:Print()
print("-----------------------------------")

-- 矩阵减法
local matrix3 = Matrix:New({{1,1,1},{1,1,1}})
matrix1 = matrix1 - matrix3
matrix1:Print()
print("-----------------------------------")


-- 矩阵乘法
local matrix4 = Matrix:New({{1,2,3},{4,5,6}})
local matrix5 = Matrix:New({{7,8},{9,10},{11,12}})

local matrix6 = matrix4 * matrix5
matrix6:Print()
print("-----------------------------------")


-- 矩阵除法
local matrix7 = Matrix:New({{1,2,3},{4,5,6},{7,8,0}})
local matrix8 = Matrix:New({{1,2,1},{1,1,2},{2,1,1}})
local matrix9 = matrix7 / matrix8
matrix9:Print()

  输出结果：

效果图

版本二

  在使用第一版实现后，发现对Lua面向对象的思维不够清晰，顾查阅网上资料实现以下版本。

  Lua面向对象类的封装这里不做过多阐述，可参考文章：https://blog.csdn.net/qq135595696/article/details/128827618

local _class = {}

function class(super)
    local tbClassType = {}
    tbClassType.Ctor  = false
    tbClassType.super = super
    tbClassType.New   = function(...)
        local tbObj   = {}
        do
            local funcCreate
            funcCreate = function(tbClass,...)
                if tbClass.super then
                    funcCreate(tbClass.super,...)
                end
                
                if tbClass.Ctor then
                    tbClass.Ctor(tbObj,...)
                end
            end
            funcCreate(tbClassType,...)
        end
        -- 防止调用Ctor初始化时，在Ctor内部设置了元表的情况发生
        if getmetatable(tbObj) then
            getmetatable(tbObj).__index = _class[tbClassType] 
        else
            setmetatable(tbObj, { __index = _class[tbClassType] })
        end
        return tbObj
    end

    local vtbl          = {} 
    _class[tbClassType] = vtbl

    setmetatable(tbClassType, { __newindex = 
        function(tb,k,v)
            vtbl[k] = v
        end
    })

    if super then
        setmetatable(vtbl, { __index = 
            function(tb,k)
                local varRet = _class[super][k]
                vtbl[k]      = varRet
                return varRet
            end
        })
    end
    return tbClassType
end







Matrix = class()

function Matrix:Ctor(data)
    self.tbData = data
    self.nRow   = #data
    if self.nRow > 0 then
        self.nColumn = (#data[1])
    else
        self.nColumn = 0
    end

    setmetatable(self,{
        __add = function(tbSource, tbDest)
            assert(tbSource,"tbSource not exist")
            assert(tbDest,  "tbDest not exist")
            if tbSource.nRow ~= tbDest.nRow 
                or tbSource.nColumn ~= tbDest.nColumn then
                print("row or column not equal...")
                return tbSource
            else
                for rowKey,rowValue in ipairs(tbSource.tbData) do
                    for colKey,colValue in ipairs(tbSource.tbData[rowKey]) do
                        tbSource.tbData[rowKey][colKey] = 
                            tbSource.tbData[rowKey][colKey] + tbDest.tbData[rowKey][colKey]
                    end
                end 
                return tbSource
            end
        end,
    
        __sub = function(tbSource, tbDest)
            assert(tbSource,"tbSource not exist")
            assert(tbDest,  "tbDest not exist")
            if tbSource.nRow ~= tbDest.nRow 
                or tbSource.nColumn ~= tbDest.nColumn then
                print("row or column not equal...")
                return tbSource
            else
                for rowKey,rowValue in ipairs(tbSource.tbData) do
                    for colKey,colValue in ipairs(tbSource.tbData[rowKey]) do
                        tbSource.tbData[rowKey][colKey] = 
                            tbSource.tbData[rowKey][colKey] - tbDest.tbData[rowKey][colKey]
                    end
                end 
                return tbSource
            end
        end,
    
        __mul = function(tbSource, tbDest)
            return self:_MartixMul(tbSource, tbDest)
        end,
    
        __div = function(tbSource, tbDest)
            assert(tbSource,"tbSource not exist")
            assert(tbDest,  "tbDest not exist")
            
            local nDet = self:_GetDetValue(tbDest)
            if nDet == 0 then
                print("matrix no inverse matrix...")
                return nil
            end
            local tbInverseDest = self:_MatrixNumMul(self:_GetCompanyMatrix(tbDest), 1 / nDet)
            -- Matrix:_GetCompanyMatrix(tbDest):Print()
            -- print(nDet)
            -- tbInverseDest:Print()
            return self:_MartixMul(tbSource, tbInverseDest)
        end
    }
)


end

function Matrix:Print()
    for rowKey,rowValue in ipairs(self.tbData) do
        for colKey,colValue in ipairs(self.tbData[rowKey]) do
            io.write(self.tbData[rowKey][colKey],',')
        end
        print('')
    end
end

-- 切割，切去第rowIndex以及第colIndex列
function Matrix:_CutoffMatrix(tbMatrix, rowIndex, colIndex)
    assert(tbMatrix,"tbMatrix not exist")
    assert(rowIndex >= 1,"rowIndex < 1")
    assert(colIndex >= 1,"colIndex < 1")
    local tbRes   = Matrix.New({})
    tbRes.nRow    = tbMatrix.nRow    - 1
    tbRes.nColumn = tbMatrix.nColumn - 1
    for i = 1, tbMatrix.nRow - 1 do
        for j = 1, tbMatrix.nColumn - 1 do
            if tbRes.tbData[i] == nil then
                tbRes.tbData[i] = {}
            end
            
            local nRowDir = 0
            local nColDir = 0
            if i >= rowIndex then
                nRowDir = 1
            end

            if j >= colIndex then
                nColDir = 1
            end

            tbRes.tbData[i][j] = tbMatrix.tbData[i + nRowDir][j + nColDir]
        end
    end
    return tbRes
end

-- 获取矩阵的行列式对应的值
function Matrix:_GetDetValue(tbMatrix)
    assert(tbMatrix,"tbMatrix not exist")
    -- 当矩阵为一阶矩阵时，直接返回A中唯一的元素
    if tbMatrix.nRow == 1 then
        return tbMatrix.tbData[1][1]
    end

    local nAns = 0
    for i = 1, tbMatrix.nColumn do
        local nFlag = -1
        if i % 2 ~= 0 then
            nFlag = 1
        end

        nAns = 
            nAns + tbMatrix.tbData[1][i] * 
                self:_GetDetValue(self:_CutoffMatrix(tbMatrix, 1, i)) * nFlag
        -- print("_GetDetValue nflag:",nFlag)
    end
    return nAns
end


-- 获取矩阵的伴随矩阵
function Matrix:_GetCompanyMatrix(tbMatrix)
    assert(tbMatrix,"tbMatrix not exist")
    local tbRes   = Matrix.New({})
    -- 伴随矩阵与原矩阵存在转置关系
    tbRes.nRow    = tbMatrix.nColumn
    tbRes.nColumn = tbMatrix.nRow

    for i = 1, tbMatrix.nRow do
        for j = 1, tbMatrix.nColumn do
            local nFlag = 1
            if ((i + j) % 2) ~= 0 then
                nFlag = -1
            end       
            
            if tbRes.tbData[j] == nil then
                tbRes.tbData[j] = {}
            end
            -- print(Matrix:_GetDetValue(Matrix:_CutoffMatrix(tbMatrix, i, j)))
            -- Matrix:_CutoffMatrix(tbMatrix, i, j):Print()
            -- print("---11----")

            tbRes.tbData[j][i] = 
                self:_GetDetValue(self:_CutoffMatrix(tbMatrix, i, j)) * nFlag
        end
    end
    return tbRes
end


-- 矩阵数乘
function Matrix:_MatrixNumMul(tbMatrix, num)
    for i = 1, tbMatrix.nRow do
        for j = 1, tbMatrix.nColumn do
            tbMatrix.tbData[i][j] = tbMatrix.tbData[i][j] * num
        end
    end
    return tbMatrix
end


-- 矩阵相乘
function Matrix:_MartixMul(tbSource, tbDest)
    assert(tbSource,"tbSource not exist")
    assert(tbDest,  "tbDest not exist")
    if tbSource.nColumn ~= tbDest.nRow then
        print("column not equal row...")
        return tbSource
    else
        local tbRes = Matrix.New({})
        for i = 1, tbSource.nRow do
            for j = 1, tbDest.nColumn do
                if tbRes.tbData[i] == nil then
                    tbRes.tbData[i] = {}
                end
                
                if tbRes.tbData[i][j] == nil then
                    tbRes.tbData[i][j] = 0
                end

                for k = 1, tbSource.nColumn do
                    tbRes.tbData[i][j] = 
                        tbRes.tbData[i][j] + (tbSource.tbData[i][k] * tbDest.tbData[k][j])
                end
            end
        end
        tbRes.nRow    = tbSource.nRow
        tbRes.nColumn = tbDest.nColumn
        return tbRes
    end
end



-- 矩阵加法
local matrix1 = Matrix.New({{1,2,3},{4,5,6}})
local matrix2 = Matrix.New({{2,3,4},{5,6,7}})

matrix1 = matrix1 + matrix2
matrix1:Print()
print("-----------------------------------")

-- 矩阵减法
local matrix3 = Matrix.New({{1,1,1},{1,1,1}})
matrix1 = matrix1 - matrix3
matrix1:Print()
print("-----------------------------------")


-- 矩阵乘法
local matrix4 = Matrix.New({{1,2,3},{4,5,6}})
local matrix5 = Matrix.New({{7,8},{9,10},{11,12}})

local matrix6 = matrix4 * matrix5
matrix6:Print()
print("-----------------------------------")


-- 矩阵除法
local matrix7 = Matrix.New({{1,2,3},{4,5,6},{7,8,0}})
local matrix8 = Matrix.New({{1,2,1},{1,1,2},{2,1,1}})
local matrix9 = matrix7 / matrix8
matrix9:Print()

  输出结果：

效果图

ufgnix0802
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Lua语言快速入门
feima9999的博客
12-13 492
目录Lua语言快速入门前言Lua语言的特性Lua语言的不足Lua推荐库Lua的数据类型 Lua语言快速入门 本教程服务于在CoppeliaSim中使用Lua语言编写脚本的小伙伴快速掌握Lua语言。 前言 Lua语言使用越来越广泛，在最新的编程语言排行榜上逐渐靠前，它用途广泛，尤其是游戏行业，几乎就是游戏开发的标准逻辑语言，被众多知名游戏和引擎所采用，比如：魔兽世界，CryEngine等。机器人和自动化环境的仿真也可以认为是某种“游戏”，所以CoppeliaSim(VREP)使用Lua语言来编写脚本。 本教程
C++与Lua交互实例 -- 矩阵的加减乘除（版本一）
田螺姑娘的博客
02-09 1248
该案例的主要目的是使用矩阵的加减乘除这个功能来练习C++与Lua之间的交互（在这个过程中，CppToLua表示矩阵的数据来源于C++端，然后让Lua使用Lua的矩阵运算逻辑进行计算并返回结果给C++端。C++端使用自己定义的C++矩阵类进行本地矩阵运算，然后与lua端返回的矩阵运算结果进行比对展示。LuaToCpp同理，与CppToLua相反。表示矩阵的数据来源于lua端，然后调用C++端暴露给Lua端的API创建C++矩阵类实例，并进行矩阵运算。
Lua基础---运算符
weixin_33972649的博客
07-13 184
众所周知，C，C++，python等语言都有运算符，那么Lua也不例外，因为它是C写的嘛! Lua分为主要三类运算符，分别是算术运算符，关系运算符，逻辑运算符，还有特殊运算符。 1、算术运算符有: + (加) -(减) *(乘) /(除) %(取模) ^(求幂) -(符号) 来看一个例子：test6.lua num1 = 4 ; ...
Lua实现矩阵的方式
Morris-w的专栏
08-23 1036
一.嵌套表 local mt={} for i=1,10 do local row={} mt[i]=row for j=1,10 do row[j]=0 end end mt是一个大表，在这个表中有10个小表，每个表中有10个元素 二.索引合并 for i=1,10 do local aux=(i-1)*10 for j=1,10 do mt[aux+j]=0 end end 通过将第一个索引乘以一个合适的常量
lua实现大数字的四则运算
leiax00
01-07 1413
local a = "1234567891234567890" local b = "1234000000000000220" local c = "asd123" local function build(str) local n, c = math.floor(#str/4), {} if #str%4 ~= 0 then c[n + 1] = tonumbe...
MatrixLUA:LUA矩阵
05-11
矩阵LUA LUA矩阵
NGINX+LUA实现复杂的控制
01-27
lua_nginx_module可以一步步的安装，也可以直接用淘宝的OpenRestyCentos和debian的安装就简单了。。这里说下freebsd的安装：安装完成后，我们体验一下luangx.say是打印的打印输出的意思。。。控制经过判断之后，才能...
Lua中类的实现
09-22
Lua中没有类的概念,但我们可以利用Lua本身的语言特性来实现类。 下文将详细的解释在Lua中实现类的原理
lua对Vector3的简单实现
08-05
功能不完善，不能直接使用，只能作为帖子的参考一起使用
lua实现basse64
03-16
lua实现 basse64 lua lua实现 basse64 lua lua实现 basse64 lua
lua学习笔记－－－运算符
Jarlen的专栏
02-13 4071
和其他语言一样，包括 算术，关系，逻辑运算符算术略过。关系运算符～＝ 是 不等于(取反)的意思逻辑运算符and or not 其中，and 和or采用一种”短路”计算策略。and中若第一个参数的值为false或nil的话，则直接返回，否则返回第二个参数；也就是说，and是以第一个参数为基准，如果是假，就返回第一个，如果为真就返回第二个参数值。对于or来说，当地一个判断结果不是false或nil，
lua实现大数运算
weixin_33743880的博客
05-29 1075
lua实现的大数运算，代码超短，眼下仅仅实现的加减乘运算 ------------------------------------------------ --name: bigInt --create: 2015-4-1 --author: 闲云 --blog: blog.csdn.net/xianyun2009 --QQ: 836663997 --QQ group: ...
Lua语法简介
whereismatrix的专栏
05-17 463
Lua的语法简介
矩阵运算_加减乘除
热门推荐
BrandoLv
04-27 1万+
1. 矩阵加法 ( 对应位置依次相加 ) 注:同形矩阵才能进行加法运算A = 1  2       3  4B = 4    5       6    7A + B = 1+4    2+5              3+6    4+7结果矩阵:    5   7                  9   112. 矩阵减法 ( 对应位置依次相减 ) 注:同形矩阵才能进行减法运算A = 1  2...
Unity3D 矩阵运算
Arboo Blog
03-11 2319
前言：今天在项目中运用到了矩阵的旋转，于是就把矩阵的运算仔细查了一下，顿时觉得自己的离散、线代学的很差劲啊，矩阵也是3D数学中十分重要的基础，在Unity中，我们很多时候都会用到，掌握一下很有必要。 矩阵的概念： m x nde 矩阵是一个具有m行、n列的矩形数组，行数和列数分别为矩阵的维度。在游戏引擎中使用的矩阵通常都是4 x 4矩阵，因为他可以描述向量的平移、旋转和缩放等所有的线性变换。 主要来
lua学习：lua程序设计的一些笔记
——
06-01 6506
词法规范： Lua执行的每段代码，例如一个源代码文件或在交互模式中输入的一行代码，都称为一个“程序块”。在lua的语法中，代码中的换行不起任何作用。 Lua – i xxx 调试和手工测试 不要用下画划线跟着大写字母的标识符，lua将这类标识用于特殊用途。 Lua是有大小写之分的。 --注释 --[[ Xxxxxx --]] 全局变量： 全局变量没有初始
lua中给表（table）重载运算符，使table之间可以互相加减乘除
zwcwu31的专栏
10-08 5722
1. 元表简介 lua中的每个值都有一个元表，table和userdata可以有各自的元表，而其他类型的值则共享类型中所属的单一元表，lua在创建新的table时不会创建元表。 例如：local t = {} print(getmetatable(t))    --nil 但是我们可以使用setmetatable来设置或者修改任何table的元表： local meta = {} se
Lua脚本编程：Lua语言入门
素履独行 | 元培的个人博客
03-03 8182
Lua是一门简单而强大的语言，其本身强大的扩展性使得这门语言在游戏设计等领域发挥着重要的作用。博主曾在Unity3D中使用过这门语言，并且针对Lua和Unity、C++等方面的内容进行了学习和讨论。最近因为在【游戏脚本高级编程】这本书中详细介绍了Lua脚本的相关内容，因此在这里记录下博主的读书心得，方便以后在需要的时候查阅。 Lua系统构成Lua系统由Lua链接库、Luac编译器、Lua解释器三部
lua 操作redis 加减脚本
最新发布
05-30
以下是 Lua 操作 Redis 加减脚本的示例代码： ```lua -- 连接 Redis local redis = require "resty.redis" local red = redis:new() local ok, err = red:connect("127.0.0.1", 6379) if not ok then ngx.say("failed to connect: ", err) return end -- 定义加减脚本 local script = [[ local key = KEYS[1] local num = tonumber(ARGV[1]) local curr = tonumber(redis.call('get', key) or 0) local new = curr + num redis.call('set', key, new) return new ]] -- 执行加减脚本 local res, err = red:eval(script, 1, "mykey", "10") if not res then ngx.say("failed to execute script: ", err) return end -- 输出结果 ngx.say(res) -- 关闭 Redis 连接 red:close() ``` 该脚本实现了对 Redis 中指定 key 的值进行加法操作，并返回操作后的结果。其中，`KEYS[1]` 表示第一个参数为 Redis key，`ARGV[1]` 表示第二个参数为要加的数字。执行加减脚本的方式是使用 `eval` 命令，第一个参数为脚本内容，后面的参数为脚本中用到的参数。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ufgnix0802

总结不易，谢谢大家的支持

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值