Lua: 核心机制解析之函数的多维魔法与模块化封装艺术

Lua重点:面向对象 (封装、继承、多态) 【代码】Lua重点:面向对象 (封装、继承、多态) 阅读详情

函数定义:灵活性与效率并存


Lua 函数是第一类值(first-class value),支持动态创建和传递

1 ) 基础定义与特性

1.1 示例1:全局与局部

--- 全局函数  
function add(a, b)  
    return a + b  
end

--- 局部函数(推荐:避免污染全局作用域)  
local function multiply(a, b)  
    return a * b  
end  
 
print(add(3, 5))     -- 输出: 8  
print(multiply(3, 5)) -- 输出: 15  

1.2 示例2:最大值函数

function max(num1, num2)
    if num1 > num2 then 
        result = num1 
    else 
        result = num2 
    end 
    return result 
end 

--- 调用示例 
print("两值比较最大值为", max(10, 4))  -- 输出:两值比较最大值为 10 
print("两值比较最大值为", max(5, 6))   -- 输出:两值比较最大值为 6 

关键点:

  • 使用 local 限制作用域,提升性能
  • 函数可存储在变量、表中,或作为参数传递

多返回值:突破单一限制


调用场景示例代码输出结果
多重赋值(末尾表达式)x,y = string.find(“hello Lua”, “Lua”)7 9
单一变量接收x = string.find(“hello Lua”, “Lua”)7
参数列表末尾传递print(string.find(“hello Lua”, “Lua”), “找到啦”)7 9 找到啦
括号强制单返回值print((string.find(“hello Lua”, “Lua”)))7

Lua 函数可返回多个值,需注意接收场景的规则

多返回值的使用

1 ) 示例1:

function min_max(arr)  
    local min, max = math.maxinteger, math.mininteger  
    for _, v in ipairs(arr) do  
        if v < min then min = v end  
        if v > max then max = v end  
    end  
    return min, max  
end  
--- 接收多返回值  
local min, max = min_max({5, 2, 9, 1})  
print(min, max) -- 输出: 1 9  

--- 仅取首返回值  
print(min_max({1, 2, 3})) -- 输出: 1  

规则:

  • 若函数调用非表达式末尾,仅第一个返回值生效(如 print(min_max()))
  • 用括号 () 强制取单值:(min_max({1,2})) 返回 1

2 ) 示例2:

function getMaxAndIndex(arr) 
    local maxVal, maxIdx = arr[1],1 
    for idx,val in ipairs(arr) do 
        if val > maxVal then 
            maxVal = val 
            maxIdx = idx 
        end 
    end 
    return maxVal,maxIdx 
end 
max,index = getMaxAndIndex({3,5,1,7}) 

3 ) 示例3:查找数组最大值及其索引

function maxinum(arr)
    local max_val = arr[1]
    local max_i = 1

    for i = 2, #arr do
        if arr[i] > max_val then
            max_val = arr[i]
            max_i = i
        end
    end
    return max_val, max_i
end

local maxVal, maxIndex = maxinum({8, 10, 23, 12, 5});
print('最大值: ', maxVal, '索引: ', maxIndex); -- 最大值: 	23	索引: 	3

多返回值的调整规则:

  • 当函数调用作为单独语句时,所有返回值被丢弃
  • 当函数调用作为表达式时,只保留第一个返回值
  • 当函数调用是多重赋值或函数参数列表的最后一个元素时,保留所有返回值

变长参数:动态输入的优雅处理


通过 … 接收不定数量参数,结合 select 或 table.pack 处理

安全处理变长参数

--- 基础变长参数函数
function sum(...)
    local total = 0
    for i, v in ipairs({...}) do
        total = total + v
    end
    return total
end

--- 使用select函数处理变长参数
function average(...)
    local args = {...}
    local sum = 0
    local count = select('#', ...)  -- 获取参数个数
    
    for i = 1, count do 
        sum = sum + select(i, ...)   -- 获取第i个参数 
    end 
    
    return sum / count 
end

--- 使用table.pack处理变长参数 
function print_args(...)
    local args = table.pack(...)
    print("参数个数:", args.n)
    for i = 1, args.n do 
        print(string.format("参数%d: %s", i, tostring(args[i])))
    end 
end 

--- 调用示例 
print("总和:", sum(1, 2, 3, 4, 5))           -- 输出:总和: 15 
print("平均值:", average(10, 20, 30))         -- 输出:平均值: 20 
print_args("Lua", 2025, true, {key="value"}) -- 输出参数信息 

模块加载:require 的深度剖析


require 是 Lua 模块化的核心,其加载机制包含 缓存检查 → 路径搜索 → 执行封装

1 ) 模块定义与加载流程

模块文件 mymath.lua:

local M = {}  -- 局部表封装模块  
 
function M.add(a, b)  
    return a + b  
end  
 
return M  -- 必须返回模块表  

主程序加载模块:

local mymath = require "mymath"  -- 省略 .lua 后缀  
print(mymath.add(3, 5))         -- 输出: 8  

2 ) require 的底层步骤

检查缓存:查找 package.loaded[“mymath”],存在则直接返回
路径搜索:按 package.path(Lua 文件)和 package.cpath(C 库)顺序查找文件
执行模块:加载文件并调用,返回值存入 package.loaded, 默认返回true以避免重复加载

3 ) 热更新技巧

强制重新加载模块(开发调试用):

package.loaded["mymath"] = nil  -- 清除缓存  
local mymath = require "mymath"  -- 重新加载  

作用域管理:模块的封装哲学


1 ) 避免全局污染

  • 模块内:所有函数/变量用 local 定义,仅导出公有接口
  • 模块间:通过 require 隔离环境,避免命名冲突

2 ) 沙箱环境控制

限制模块访问权限(如禁用文件操作):

local sandbox_env = {  
    print = print,  
    math = math,  
    _G = nil  -- 禁用全局访问  
}

setfenv(loaderfunc, sandboxenv)  -- 设置函数环境  

注意,这里 setfenv 是Lua 5.1的环境控制函数,在Lua 5.2+已被移除(被_ENV机制替代)

当代码在5.2+环境运行时,setfenv会变为nil导致attempt to call a nil value错误

模块化沙箱(适合复杂场景)

local function create_sandbox(allowed_libs)
    local env = {}
    for lib_name in pairs(allowed_libs) do 
        env[lib_name] = _G[lib_name]  -- 按需导入 
    end
    return setmetatable(env, { __index = function(_, k)
        error("禁止访问: "..k, 2)
    end})
end 
 
-- 初始化沙箱 
local sandbox = create_sandbox{ print=true, math=true }
local loader = load("print(math.sin(0))", "sandbox", "t", sandbox)
loader()  -- 输出: 0.0

三种加载函数对比


下表清晰对比Lua常见加载函数差异,助力按需选择合适的加载方式:

特性\函数requiredofileloadfile
核心功能加载模块+缓存管理加载并直接执行代码编译代码返回函数不执行
执行次数首次加载后复用缓存每次调用均重新执行仅编译一次可重复执行
返回值模块返回表/缓存值文件最后表达式结果编译后的匿名函数
适用场景稳定模块导入+依赖管理简单脚本快速执行动态按需执行代码

1 ) require:模块化加载与缓存管理

基础模块加载

--- 文件: math_tools.lua
local M = {}
function M.add(a, b) return a + b end
return M

--- 主程序
local tools = require "math_tools"  -- 首次加载并缓存
print(tools.add(2, 3))  -- 输出: 5

--- 示例2:验证缓存特性 
require "math_tools"  -- 二次调用直接读缓存,不重复执行文件 

关键特性验证

  • 路径搜索:自动搜索package.path路径
  • 缓存位置:模块存储在package.loaded表中
  • 依赖管理:递归加载模块依赖项

2 ) dofile:即时执行脚本工具

直接执行配置文件

--- 文件: config.lua 
APP_NAME = "LuaLoader"
MAX_SIZE = 1024 

--- 主程序
dofile("config.lua")
print(APP_NAME)  -- 输出: "LuaLoader"

--- 动态更新配置(无缓存)
-- 修改config.lua后重新执行
dofile("config.lua")  -- 立即生效

典型场景

  • 热重载配置/状态文件
  • 注意:污染全局环境,慎用大型项目

3 ) loadfile:编译代码并灵活控制执行

--- 示例1:延迟执行与错误处理
local chunk = loadfile("logic.lua")  -- 仅编译不执行 
if chunk then
  local success, result = pcall(chunk)  -- 安全执行
  print(result or "执行成功")
end

来看一个动态工厂的示例

-- factory.lua
local cache = {}
return function(name)
    if not cache[name] then 
        cache[name] = {
            type   = name,
            created = os.date("%Y-%m-%d %H:%M:%S")
        }
    end 
    return cache[name]
end

使用工厂

-- main.lua
local func_builder = loadfile("factory.lua")   -- 加载工厂文件 
local createWidget = func_builder()            -- 得到工厂函数 
local btn1 = createWidget("Button")
local btn2 = createWidget("Button")
local input = createWidget("Input")
 
print(btn1.type, btn1.created)   -- Button  2026-01-14 17:13:43 
print(btn2.type, btn2.created)   -- 与 btn1 相同(缓存生效)
print(input.type)                -- Input 

核心优势

  • 沙盒环境:通过setfenv控制执行环境
  • 重复利用:同一文件编译一次,多次调用返回的函数

场景决策指南(快速选择)

需求场景推荐函数原因说明
导入标准库/第三方模块require自动管理依赖与缓存
执行一次性初始化脚本dofile避免手动调用函数
动态加载用户自定义逻辑loadfile隔离环境+灵活控制执行时机
实现热更新机制dofile强制重新执行最新代码

避坑提示:

  • require 的缓存可能导致代码更新失效(可手动清除 package.loaded)
  • loadfile 需配合 pcall 捕获编译错误
  • dofile 在循环中频繁调用有性能开销

通过示例可直观看出:

  • require 适合架构级模块化
  • dofile 侧重快速脚本执行
  • 而 loadfile 为动态代码控制提供底层能力

三者形成Lua加载机制的黄金三角

工程示例


--- 文件名:module_system.lua (修复版)
local module_system = {}
local modules = {}
local dependencies = {}
 
function module_system.register(name, module_func, deps)
    modules[name] = module_func 
    dependencies[name] = deps or {}  -- 使用空表替代{{}}
end 
 
local function resolveDeps(name, resolved, resolving, ordered_list)
    if resolved[name] then return end
    if resolving[name] then error("循环依赖: " .. name) end 
    
    resolving[name] = true
    for _, dep in ipairs(dependencies[name] or {}) do  -- 修复边界 
        if not modules[dep] then 
            error("依赖模块未注册: " .. dep)
        end 
        resolveDeps(dep, resolved, resolving, ordered_list)
    end 
    
    resolving[name] = nil
    resolved[name] = true 
    table.insert(ordered_list, name)
end
 
function module_system.load(name)
    if package.loaded[name] then return package.loaded[name] end 
    if not modules[name] then error("模块未注册: " .. name) end
 
    local resolved = {}
    local resolving = {}
    local ordered_list = {}
    
    resolveDeps(name, resolved, resolving, ordered_list)
 
    -- 按拓扑顺序加载
    for _, mod_name in ipairs(ordered_list) do 
        if not package.loaded[mod_name] then
            package.loaded[mod_name] = modules[mod_name]()  -- 直接执行初始化 
        end 
    end 
 
    return package.loaded[name]
end
 
return module_system

使用示例

local modsys = require("module_system")
 
--- 注册数据库模块 (返回单层表)
modsys.register("database", function()
    return {
        connect = function(config)
            print("连接数据库:", config.host)
            return { connected = true }
        end,
        query = function(db, sql)
            print("执行查询:", sql)
            return { results = {} }
        end 
    }
end)
 
--- 注册缓存模块 (修复依赖声明)
modsys.register("cache", function()
    local db = modsys.load("database")
    return {  -- 返回单层表
        get = function(key) print("从缓存获取:"..key) end,
        set = function(key, val) print("设置缓存:"..key) end 
    }
end, {"database"})  -- 单层依赖表 
 
--- 使用模块
local cache = modsys.load("cache")
cache.set("user:123", { name = "张三", age = 25 })

函数与模块的共生关系


Lua 通过 多返回值 和 变长参数 赋予函数动态能力,而 require 机制 结合作用域控制,实现了高效的模块化设计。掌握这些特性,可构建出灵活、可维护的 Lua 应用

参考:

最佳实践与性能优化


1 )函数设计最佳实践

  • 合理使用局部函数:局部函数比全局函数性能更好,且避免命名空间污染
  • 避免过多返回值:虽然Lua支持多返回值,但超过3个返回值时建议使用表或结构体
  • 善用尾调用优化:在递归函数中使用尾调用可以避免栈溢出

2 ) 模块管理最佳实践

  • 明确模块边界:每个模块应该有明确的职责和接口
  • 避免全局变量:使用局部变量和模块表来管理状态
  • 延迟加载:对于大型模块,考虑实现延迟加载机制
  • 版本管理:在模块中包含版本信息,便于兼容性管理

总结


Lua的函数机制和模块系统为开发者提供了强大而灵活的代码组织能力。通过深入理解多返回值、变长参数、require机制和作用域管理,开发者可以构建出结构清晰、性能优异的Lua应用。在实际开发中,应该根据项目需求选择合适的模式,遵循最佳实践,充分利用Lua的语言特性来提高代码质量和开发效率

Lua表核心机制与嵌入式工程实践指南 Lua表是其唯一复合数据结构,本质为哈希表,统一支撑数组、字典、对象等多种抽象。其索引从1开始是语言级契约,非实现细节;#操作符语义为‘最长连续正整数键序列长度’,而非元素计数,易在动态修改时引发静默逻辑错误。ipairs()基于值存在性终止,比for i1,#t do更鲁棒;type()函数提供O(1)零成本类型守卫,是嵌入式场景下防御非法输入、保障脚本稳定性的关键技术手段。本文聚焦Lua表在ESP32、STM32等资源受限平台的落地陷阱与最佳实践。 阅读详情

相关推荐

从LUA脚本到MATLAB:AWR2243毫米波雷达数据处理全链路解析与避坑指南

本文深入解析AWR2243毫米波雷达从LUA脚本控制到MATLAB数据处理的全链路技术细节,涵盖硬件配置、参数优化、校准流程与后处理脚本定制。重点探讨LUA脚本参数耦合关系、校准距离选取原则及CFAR算法优化,提供实用避坑指南,帮助开发者构建稳定高效的数据处理流水线。

d6e7f8的博客 877

Lua : 函数封装好,用起来就是爽

目录 1、Lua函数的格式 2、Lua可变参数函数 3、多个返回值的函数 Lua中函数比较简单,只是相比较c/c++来说,lua函数的返回值比较特殊,他可以返回一个或者多个值,且值的类型可不相同。 1、Lua函数的格式 --[[ Lua 函数语法格式: function func(arg) body end --]] -- 计算table中所有number元素的和 function sum_tab(tab) sum = 0 for i,v in ipairs(tab)

Mr.Sugarcane 1061

Lua VM与JavaScript引擎核心对比:事件循环、内存模型与执行效率

在嵌入式系统、游戏引擎和高性能网关等场景中,脚本运行时的选型是架构设计的关键。理解脚本引擎的核心机制,如事件循环和垃圾回收,对于构建高并发、低延迟的应用至关重要。事件循环是处理异步非阻塞I/O的基石,它决定了程序如何高效响应外部事件;而垃圾回收策略则直接影响内存使用效率和系统停顿时间。从技术价值看,不同的内存模型和执行模式适配了从资源受限的嵌入式环境到复杂Web服务的多样化需求。本文聚焦于Lua虚拟机与JavaScript引擎(以V8为例)在这三个维度的深度对比,剖析其设计哲学差异如何导致在事件驱动、内存管

weixin_30682415的博客 424

LUA常用的封装函数(汇总)

LUA常用的封装函数封装四舍五入封装角度封装读取文件封装分割字符串 封装四舍五入 function getDecimalInteger(data) data = tonumber(data) local a,b=math.modf(data) --a整数,小数 local c =0; if b<=0.5 then c = math.floor(data) else c = math.ceil(data) end return c end 封装角度 function get

weixin_42955336的博客 868

lua类封装方法

在lua中实现类,以及继承的方法,包括了一些例子

lua功能封装

string to table table to string class function

【Lua学习笔记】Lua进阶——Table(4)继承,封装,多态

我们在封装Object类的时候可完全没有name这个索引,而在Lua中我们new了一个新对象,还能新加入一些变量和方法,这些特性明显是继承了父类的子类才有的。现在我们确实实现封装了,既能访问基类的方法和变量,又能阻止新加的其他东西,但是还得把垃圾及时清理,这点我们将在后文垃圾回收中讲解。面向对象重要的特性之继承,光new一个新对象无法满足全部需要,我们想要重写父类的一些方法而非直接使用它们,就需要继承。重写固然可以实现,问题在于继承了父类之后的重写是无法保留父类的同名方法的,那我想要访问父类的方法怎么办?

milu_ELK的博客 2803

Lua UnPack函数用法实例

主要介绍了Lua UnPack函数用法实例,unpack它接受一个数组(table)作为参数,并默认从下标1开始返回数组的所有元素,需要的朋友可以参考下

Lua封装&C++实践(二)—— C++调用Lua函数的封装

在上篇博客中,记录了Lua与C/C++的基本交互,但是如果按照那样来使用的话,实在太麻烦了,所以我们开始进行封装。本篇博客主要记录C++调用Lua函数的封装。 封装目标 C++调用Lua,复杂的地方主要在于需要去理解Lua的堆栈,函数、参数都需要依次加入堆栈,结果也需要从堆栈里面取,Lua支持返回多个值,取值就需要按照在堆栈中的顺序多次去取。实际上呢,我们需要的就是调用一个lua函数,返回函数执行...

偶尔记录的一些学习笔记 2328

MySQL 8.0数据库崩了别慌!手把手教你仅凭一个.ibd文件找回数据(附Go工具包)

本文详细介绍了在MySQL 8.0数据库崩溃后,如何仅凭.ibd文件恢复数据的完整流程。通过使用Go语言工具包和ALTER TABLE技巧,即使没有备份也能实现数据重生。文章包含从环境准备到数据验证的全方位指导,帮助DBA和开发者应对紧急数据恢复场景。

weixin_29235923的博客 422

UE5 GAS实战:从零构建一个MOBA英雄技能系统

本文详细介绍了如何利用UE5的Gameplay Ability System(GAS)构建MOBA英雄技能系统,涵盖核心组件如Ability System Component和GameplayEffect的使用,以及技能冷却、资源管理和连招系统等高级功能的实现。通过实战案例和代码示例,帮助开发者快速掌握GAS在MOBA游戏开发中的应用。

weixin_29012765的博客 529

深入解析 todo-comments.nvim 核心组件:高亮、搜索与跳转机制

todo-comments.nvim 是一款专为 Neovim 用户设计的高效任务管理插件,能够自动高亮、列表化和搜索项目中的 TODO 注释,帮助开发者快速定位和管理代码中的待办事项。本文将深入剖析其三大核心组件——高亮系统、搜索功能和跳转机制,带你掌握这款工具的工作原理与实用技巧。 ## 🌟 高亮系统:让 TODO 注释一目了然 高亮功能是 todo-comments.nvim 的核心特

gitblog_02825的博客 1029

固定资产报废的损失鉴定怎么做?

在社会生产的日常中,企业经常会遇到固定资产报废的损失鉴定,那么怎么去做鉴定?哪些情况下能申请固定资产报废损失鉴定呢? 今天,华碧鉴定就和大家说一说固定资产报废损失鉴定那些事儿。 符合下列条件之一的固定资产可申请报废: 1、使用年限过长,功能丧失,完全失去使用价值,或不能使用并无修复价值的; 2、产品技术落后,质量差,耗能高,效率低,已属淘汰且不适于继续使用,或技术指标已达不到使用要求的; 3、严重损坏,无法修复的或虽能修复,但累计修理费已接近或超过市场价值的; 4、主要附件损坏,无.

weixin_50362670的博客 2118

Path of Building架构揭秘:如何用Lua构建流放之路的离线计算引擎

Path of Building(PoB)作为《流放之路》最权威的离线构建规划工具,其技术架构深度重塑了ARPG角色构建的思维方式。这个开源项目通过复杂的计算引擎和可视化系统,将游戏内数千个交互机制转化为可预测的数学模型,为进阶玩家提供了从直觉猜测到科学分析的革命性转变。本文将深入解析PoB的核心技术架构、算法实现和设计哲学,揭示这个Lua驱动的离线计算引擎如何实现复杂的游戏机制模拟。 ## 问

gitblog_00918的博客 707

【域控制器EMC】域控制器EMC设计总结

汇总项目设计当中关于EMC的设计要点,主要从原理设计、Layout、结构、外设部分总结。满足要求的器件和合理的电路能降低电磁干扰;正确的布局、接地、信号路径、屏蔽等可以减少电磁辐射。结构件设计也会对EMC性能产生影响。

weixin_42098658的博客 1261

使用 Simulink + Simscape Electrical 对基于VSG控制的背靠背变流器整流侧进行建模与仿真

本文介绍了基于Simulink的直驱风电系统背靠背变流器整流侧虚拟同步发电机(VSG)建模方法。首先阐述了直驱风电系统结构和VSG控制的作用,然后详细指导了模型搭建过程:从创建项目、添加PMSG和变流器模块,到搭建主电路拓扑和实现VSG控制逻辑。重点说明了VSG控制器如何模拟传统同步发电机的特性,并提供了仿真设置和结果分析方法。该模型可用于研究风电系统在不同工况下的响应特性,为新能源发电系统设计提供重要参考。

amy_mhd的博客 182

Path of Building深度解析:流放之路Build计算的终极突破

Path of Building作为《流放之路》最强大的离线Build规划工具,为玩家提供了超越游戏内计算的精确数值分析能力。这款开源工具通过复杂的伤害计算引擎和天赋树模拟系统,让玩家能够深入理解游戏机制,优化角色构建,实现从理论到实战的无缝转换。 ## 🔍 核心理念:从数据驱动到实战验证 ### 精确计算引擎:超越游戏内显示的深度分析 Path of Building的核心价值在于其**

gitblog_01150的博客 1019

SpringBoot4.0+JDK25+GraalVM实战:云原生新纪元,微服务性能翻倍的落地指南

三者的组合不是偶然,而是“框架优化+JDK升级+虚拟机革新”的必然结果——SpringBoot4.0完善了对GraalVM原生镜像的支持,JDK25强化了云原生与AOT编译能力,GraalVM则提供了极致的启动速度和资源利用率,三者协同,刚好命中云原生微服务的核心痛点。SpringBoot4.0+JDK25+GraalVM的组合,不是简单的版本升级,而是云原生微服务的一次性能革命。

2601_94871597的博客 1144

Path of Building PoE2:流放之路2离线构建引擎架构深度解析

Path of Building PoE2(PoB2)作为流放之路2社区最强大的离线构建规划工具,其核心价值在于构建了一个完整的角色模拟计算引擎。不同于简单的数值计算器,PoB2通过模块化的Lua架构实现了游戏机制的精确模拟,为玩家提供了从天赋规划、装备优化到技能组合的全面构建解决方案。本文将深入解析PoB2的技术架构、核心模块设计以及实际应用中的最佳实践。 ## 技术架构与核心设计理念 Po

gitblog_00740的博客 727

SQL进阶技巧:数据预处理如何对数据进行分桶【分箱】?

本文详细介绍了数据分析中常见的几种分桶方式:基于业务规则的分桶、等距分桶及等频分桶等,针对每种分桶方式给出了SQL实现

石榴姐yyds 4021

AI原生应用中的数据治理:从采集到应用的完整方案

当AI从"辅助工具"进化为"应用核心"(如ChatGPT、智能驾驶系统),传统数据管理方式已无法满足需求:模型需要更精准的训练数据、业务需要更实时的决策支持、法规需要更严格的隐私保护。本文聚焦AI原生应用的数据全生命周期治理(从采集→清洗→标注→存储→应用→归档的完整链路),覆盖技术方案、工具选择和实践要点。本文将按"场景引入→核心概念→技术方案→实战案例→未来趋势"的逻辑展开,重点通过"奶茶店原料管理"类比,解释数据治理的关键环节;结合Python代码演示核心技术(如异常值检测、主动学习标注);

SuperAGI2025 883

攻克GSE启动难题:LUA错误深度解析与实战修复指南

作为《魔兽世界》(World of Warcraft)玩家必备的宏编辑器,GSE-Advanced-Macro-Compiler(简称GSE)极大提升了宏编写效率。但LUA启动错误常导致插件加载失败,让玩家陷入"宏库空空如也"的窘境。本文将系统梳理GSE中常见LUA启动错误类型,提供从日志诊断到代码修复的全流程解决方案,助你5分钟内恢复宏功能。 ## 错误类型全景图:GSE启动失败的七大元凶 ...

gitblog_07509的博客 713

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

【Lua篇】《Lua程序设计》全书内容总结

这篇文章是《Lua程序设计》的读书笔记和概要。帮助没有看过的童鞋快速浏览书中内容,已经看过的可以也能借助这篇文章复习一遍。 第1章 开始 1.1 程序块 程序块,即chunk,由一行或多行lua可执行的代码构成。下面两段代码,一个是程序块一个不是。 -- 是程序块 function f(a,b) return a*a - b*b; end -- 不是程序块 do return 1; 一般使用dofile或require来执行程序块。 1.2 词法规范 lua变量不能以数字开头,也要

水鸡的游戏开发学习笔记 2264

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

ZeroBrane Studio:重塑Lua开发体验的智能编程平台

在当今快速发展的软件开发领域,寻找一款既轻量高效又功能全面的集成开发环境成为众多Lua程序员的共同追求。ZeroBrane Studio作为基于Lua语言构建的专业级IDE,以其独特的架构设计和卓越的性能表现,正在重新定义Lua开发的边界与可能。 ## 技术架构的革新设计 ZeroBrane Studio采用完全基于Lua的底层架构,这一设计理念使其在跨平台兼容性和资源利用效率方面展现出显著优

gitblog_00897的博客 968

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

Lua基础笔记

优化GC。

lzq的博客 1105

深度解析分布式CRDT存储:5个核心机制与实战应用

Roshi是SoundCloud开发的大规模CRDT集合实现,专为时间戳事件存储设计,提供高可用性、分区容错和最终一致性的分布式存储解决方案。本文将深入剖析Roshi的5个核心机制,揭示其在Go语言中的实现原理与生产级应用技巧。🚀 ## CRDT设计哲学:最终一致性的数学基础 Roshi基于LWW-element-set(最后写入者获胜元素集)CRDT实现,这种数据结构的核心优势在于其数学特

gitblog_00984的博客 1030
上一篇: Lua: 核心语法之变量、控制流与函数闭包实战精解
下一篇: Lua: 用 table 统一实现数组和字典
Wang's Blog
博客等级 码龄12年 7438粉丝 2422原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Wang's Blog

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明:

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

余额充值