add：增加了模块化功能展示，增加了快速读取等功能展示

module/Air8000/demo/zbuff/main.lua

@@ -1,72 +1,64 @@
--- LuaTools需要PROJECT和VERSION这两个信息
-PROJECT = "zbuffdemo"
-VERSION = "1.0.0"
+--[[
+@module  main
+@summary LuatOS用户应用脚本文件入口，总体调度应用逻辑
+@version 003.000.000
+@date    2025.08.08
+@author  王棚嶙
+@usage
+本 Demo 完整覆盖了 zbuff 的核心到高级操作，包括：
+​基础​：创建、读写、指针控制、元信息查询
+​进阶​：结构化数据打包/解包、类型化操作、浮点处理
+​内存管理​：动态调整、块操作、数据比对、Base64 编码
+适用于嵌入式开发中高效处理二进制数据流、协议解析、内存优化等场景。
 
-log.info("main", PROJECT, VERSION)
+]]
 
--- 引入必要的库文件(lua编写), 内部库不需要require
-sys = require("sys")
+--[[
+必须定义PROJECT和VERSION变量，Luatools工具会用到这两个变量，远程升级功能也会用到这两个变量
+PROJECT：项目名，ascii string类型
+        可以随便定义，只要不使用,就行
+VERSION：项目版本号，ascii string类型
+        如果使用合宙iot.openluat.com进行远程升级，必须按照"XXX.YYY.ZZZ"三段格式定义：
+            X、Y、Z各表示1位数字，三个X表示的数字可以相同，也可以不同，同理三个Y和三个Z表示的数字也是可以相同，可以不同
+            因为历史原因，YYY这三位数字必须存在，但是没有任何用处，可以一直写为000
+        如果不使用合宙iot.openluat.com进行远程升级，根据自己项目的需求，自定义格式即可
+]]
+PROJECT = "zbuff"
+VERSION = "003.000.000"
+log.info("main", "项目启动", PROJECT, VERSION)
 
-sys.taskInit(function()
-    sys.wait(3000)
-    -- zbuff可以理解为char[], char*, uint8_t*
-    -- 为了与lua更好的融合, zbuff带长度,带指针位置,可动态扩容
-    local buff = zbuff.create(1024)
-    -- 可当成数组直接赋值和取值
-    buff[0] = 0xAE
-    log.info("zbuff", "buff[0]", buff[0])
 
-    -- 以io形式操作
-    
-    -- 写数据write, 操作之后指针会移动,跟文件句柄一样
-    buff:write("123") -- 字符串
-    buff:write(0x12, 0x13, 0x13, 0x33) -- 直接写数值也可以
-    
-    -- 设置指针位置, seek
-    buff:seek(5, zbuff.SEEK_CUR) -- 指针位置+5
-    buff:seek(0)                 -- 绝对地址
 
-    -- 读数据read, 指针也会移动
-    local data = buff:read(3)
-    log.info("zbuff", "data", data)
+-- 如果内核固件支持errDump功能，此处进行配置，【强烈建议打开此处的注释】
+-- 因为此功能模块可以记录并且上传脚本在运行过程中出现的语法错误或者其他自定义的错误信息，可以初步分析一些设备运行异常的问题
+-- 以下代码是最基本的用法，更复杂的用法可以详细阅读API说明文档
+-- 启动errDump日志存储并且上传功能，600秒上传一次
+--示例：
+-- if errDump then
+--     errDump.config(true, 600)
+-- end
 
-    -- 清除全部数据,但指针位置不变
-    buff:clear() -- 默认填0
-    buff:clear(0xA5) -- 也可以指定填充的内容
 
-    -- 支持以pack库的形式写入或读取数据
-    buff:seek(0)
-    buff:pack(">IIHA", 0x1234, 0x4567, 0x12,"abcdefg")
-    buff:seek(0)
-    local cnt,a,b,c,s = buff:unpack(">IIHA10")
+-- 使用LuatOS开发的任何一个项目，都强烈建议使用远程升级FOTA功能
+-- 可以使用合宙的iot.openluat.com平台进行远程升级
+-- 也可以使用客户自己搭建的平台进行远程升级
+-- 远程升级的详细用法，可以参考fota的demo进行使用
 
-    -- 也可以直接按类型读写数据
-    local len = buff:writeI8(10)
-    local len = buff:writeU32(1024)
-    local i8data = buff:readI8()
-    local u32data = buff:readU32()
 
-    -- 取出指定区间的数据
-    local fz = buff:toStr(0,5)
+-- 启动一个循环定时器
+-- 每隔3秒钟打印一次总内存，实时的已使用内存，历史最高的已使用内存情况
+-- 方便分析内存使用是否有异常
+--示例：
+-- sys.timerLoopStart(function()
+--     log.info("mem.lua", rtos.meminfo())
+--     log.info("mem.sys", rtos.meminfo("sys"))
+-- end, 3000)
 
-    -- 获取其长度
-    log.info("zbuff", "len", buff:len())
-    -- 获取其指针位置
-    log.info("zbuff", "len", buff:used())
 
-    -- 测试writeF32, 注意, EC618系列(Air8000等), V1106会死机, 在V1107修复
-    buff:seek(0, zbuff.SEEK_SET)
-    buff:writeF32(1.2)
-    buff:seek(0, zbuff.SEEK_SET)
-    log.info("buff", "rw", "f32", buff:readF32())
+-- 加载zbuff应用功能模块
+require "zbuff_core"
+require "zbuff_advanced"
+require "zbuff_memory"
 
-    -- 更多用法请查阅api文档
-
-    log.info("zbuff", "demo done")
-end)
-
-
--- 用户代码已结束---------------------------------------------
--- 结尾总是这一句
-sys.run()
--- sys.run()之后后面不要加任何语句!!!!!
+-- 启动系统调度
+sys.run()

module/Air8000/demo/zbuff/readme.md

@@ -0,0 +1,172 @@
+## **功能模块介绍：**
+
+本demo进行了一个完整的 zbuff 二进制数据处理库 的演示，示了在嵌入式环境中高效处理二进制数据的全流程。项目分为三个核心模块，覆盖了从基础到高级的二进制数据处理场景：
+
+1、main.lua:主程序入口
+
+2、zbuff_core.lua：为zbuff的基础操作模块，包含zbuff最常用的创建，读写高效查询等基础功能。
+
+3、zbuff_advanced.lua：为zbuff高级操作模块，包含zbuff较为复杂的结构化打包，类型化操作等数据处理功能。
+
+4、zbuff_memory.lua：为内存管理模块，核心业务逻辑为内存管理操作。
+
+## 演示功能概述
+
+### 1、核心功能模块 (zbuff_core.lua)
+
+#### 缓冲区管理:
+
+（1）创建固定大小(1024字节)的缓冲区 zbuff.create
+
+（2）索引直接访问(如 buff[0] = 0xAE)
+
+#### 基础IO操作:
+
+（1）写入字符串和数值数据(write("123"))
+
+（2）指针控制(seek()定位操作)
+
+（3）数据读取(read(3))
+
+#### 元信息查询
+
+（1）获取缓冲区总长度(len())
+
+（2）查询已使用空间(used())
+
+#### 高效数据查询
+
+（1）query()接口快速提取数据
+
+（2）自动格式转换(大端序处理)
+
+### 2、高级功能模块 (zbuff_advanced.lua)
+
+#### 结构化数据处理
+
+（1）数据打包(pack(">IIHA", ...))：支持大端序/多种数据类型
+
+（2）数据解包(unpack(">IIHA10"))：自动解析复合数据结构
+
+#### 类型化操作
+
+（1）精确类型读写：writeI8()/readU32()等
+
+#### 浮点处理
+
+（1）单精度浮点写入(writeF32(1.2))
+
+（2）浮点数据读取(readF32())
+
+### 3、内存管理模块 (zbuff_memory.lua)
+
+#### 动态内存管理
+
+（1）缓冲区动态扩容resize(2048)
+
+#### 块操作
+
+（1）内存块设置(set(10,0xaa,5))类似 memset
+
+（2）数据删除(del(2,3))及前移
+
+#### 数据工具
+
+（1）内存比较(isEqual())
+
+（2）Base64编码转换(toBase64())
+
+## **演示硬件环境**
+
+1、Air8000整机开发板一块/任意一款的Air8000核心板
+
+2、TYPE-C USB数据线一根
+
+3、Air8000整机开发板和数据线的硬件接线方式为
+
+- Air8000整机开发板通过TYPE-C USB口供电；（USB旁边的开关拨到USB供电）
+- TYPE-C USB数据线直接插到Air8000整机开发板的TYPE-C USB座子，另外一端连接电脑USB口；
+
+4、如果是Air8000系列核心板，需要将正面拨到USB供电，背面拨码拨到USB ON, 通过TYPE-C USB口供电，另外一端连接电脑USB口；
+
+## **演示软件环境**
+
+1、Luatools下载调试工具： https://docs.openluat.com/air780epm/common/Luatools/
+
+2、内核固件版本：https://docs.openluat.com/air8000/luatos/firmware/
+
+## **演示核心步骤**
+
+1、搭建好硬件环境
+
+2、通过Luatools将demo与内核固件烧录到核心板中
+
+3、烧录好后，板子开机将会在Luatools上看到如下打印：
+
+```Lua
+（1）开始打印项目信息正式开始展示。
+[2025-08-11 16:38:35.922][000000000.369] I/user.main 项目启动 zbuff 003.000.000
+[2025-08-11 16:38:35.932][000000000.379] I/user.zbuff_core 启动核心功能演示
+[2025-08-11 16:38:35.938][000000000.380] I/user.zbuff_core 缓冲区创建 长度: 1024
+
+
+（2）进行BUFF创建,初始化以及索引,读写,清除等基础功能演示操作
+[2025-08-11 16:38:35.950][000000000.380] I/user.zbuff_core === 缓冲区创建与初始化演示 ===
+[2025-08-11 16:38:35.955][000000000.380] I/user.zbuff_core 索引访问示例 buff[0] = 174
+
+[2025-08-11 16:38:35.965][000000000.381] I/user.zbuff_core === 基础IO操作演示 ===
+[2025-08-11 16:38:35.971][000000000.381] I/user.zbuff_core 写入字符串 123
+[2025-08-11 16:38:35.979][000000000.381] I/user.zbuff_core 写入数值 0x12, 0x13, 0x13, 0x33
+[2025-08-11 16:38:35.985][000000000.381] I/user.zbuff_core 指针当前位置 向后移动5字节 当前位置: 12
+[2025-08-11 16:38:35.991][000000000.382] I/user.zbuff_core 指针移动 重置到开头
+[2025-08-11 16:38:36.000][000000000.382] I/user.zbuff_core 读取数据 长度3: 123
+
+[2025-08-11 16:38:36.005][000000000.382] I/user.zbuff_core === 缓冲区清除操作 ===
+[2025-08-11 16:38:36.013][000000000.382] I/user.zbuff_core 清除操作 全部清零
+[2025-08-11 16:38:36.019][000000000.382] I/user.zbuff_core 清除操作 填充0xA5
+
+[2025-08-11 16:38:36.027][000000000.383] I/user.zbuff_core === 元信息查询 ===
+[2025-08-11 16:38:36.033][000000000.383] I/user.zbuff_core 元信息 总长度: 1024
+[2025-08-11 16:38:36.043][000000000.383] I/user.zbuff_core 元信息 已使用: 3
+
+[2025-08-11 16:38:36.048][000000000.383] I/user.zbuff_core === 高效数据查询 ===
+[2025-08-11 16:38:36.056][000000000.384] I/user.zbuff_core query查询 全部数据: 123456789ABC 12
+[2025-08-11 16:38:36.060][000000000.384] I/user.zbuff_core query查询 大端序格式: 305419896
+[2025-08-11 16:38:36.067][000000000.384] I/user.zbuff_core 核心功能演示完成
+
+
+（3）进行高级功能演示，包括数据打包与解包、类型化读写、浮点操作演示等。
+[2025-08-11 16:38:36.072][000000000.398] I/user.zbuff_advanced 启动高级功能演示
+
+[2025-08-11 16:38:36.078][000000000.398] I/user.zbuff_advanced === 数据打包与解包演示 ===
+[2025-08-11 16:38:36.088][000000000.399] I/user.zbuff_advanced 数据打包 格式: >IIHA 值: 0x1234, 0x4567, 0x12, 'abcdefg'
+[2025-08-11 16:38:36.092][000000000.399] I/user.zbuff_advanced 打包后数据 0000123400004567001261626364656667 34
+[2025-08-11 16:38:36.101][000000000.400] I/user.zbuff_advanced 数据解包 数量: 20 值: 4660 17767 18 abcdefg
+[2025-08-11 16:38:36.105][000000000.401] I/user.zbuff_advanced 解包输出内容 cnt: 20 a(32位): 0x1234 b(32位): 0x4567 c(16位): 0x12 s(字符串): abcdefg
+
+[2025-08-11 16:38:36.109][000000000.401] I/user.zbuff_advanced === 类型化读写演示 ===
+[2025-08-11 16:38:36.119][000000000.401] I/user.zbuff_advanced 类型化写入 I8: 10
+[2025-08-11 16:38:36.126][000000000.402] I/user.zbuff_advanced 类型化写入 U32: 1024
+[2025-08-11 16:38:36.135][000000000.402] I/user.zbuff_advanced 类型化读取 I8: 10
+[2025-08-11 16:38:36.140][000000000.402] I/user.zbuff_advanced 类型化读取 U32: 1024
+
+[2025-08-11 16:38:36.151][000000000.402] I/user.zbuff_advanced === 浮点数操作演示 ===
+[2025-08-11 16:38:36.156][000000000.403] I/user.zbuff_advanced 浮点数操作 写入F32: 1.200000
+[2025-08-11 16:38:36.165][000000000.403] I/user.zbuff_advanced 浮点数操作 读取F32: 1.200000
+[2025-08-11 16:38:36.171][000000000.403] I/user.zbuff_advanced 高级功能演示完成
+
+
+（4）内存管理演示:内存块设置(set(10,0xaa,5)),数据删除(del(2,3))及前移,内存比较,Base64编码转换等
+[2025-08-11 16:38:36.182][000000000.415] I/user.zbuff_memory 启动内存管理功能演示
+[2025-08-11 16:38:36.188][000000000.416] I/user.zbuff_memory 大小调整 原始大小: 1024 新大小: 2048
+[2025-08-11 16:38:36.198][000000000.417] I/user.zbuff_memory 内存设置 位置10-14设置为0xaa
+[2025-08-11 16:38:36.204][000000000.417] I/user.zbuff_memory 验证结果 位置10: 170 应为0xaa
+[2025-08-11 16:38:36.215][000000000.417] I/user.zbuff_memory 删除前数据 
+[2025-08-11 16:38:36.222][000000000.418] ABCDEFGH
+[2025-08-11 16:38:36.233][000000000.418] I/user.zbuff_memory 删除操作 删除位置2-4 结果: 
+[2025-08-11 16:38:36.244][000000000.418] ABFGH
+[2025-08-11 16:38:36.251][000000000.418] I/user.zbuff_memory 内存比较 结果: false 差异位置: 0
+[2025-08-11 16:38:36.258][000000000.419] I/user.zbuff_memory Base64编码 长度: 8 结果: QUJGR0g=
+[2025-08-11 16:38:36.264][000000000.419] I/user.zbuff_memory 内存管理功能演示完成
+```
+

module/Air8000/demo/zbuff/zbuff_advanced.lua

@@ -0,0 +1,108 @@
+--[[
+    @module  zbuff_advanced
+    @summary zbuff的高级操作模块
+    @version 1.0.0
+    @date    2025.08.08
+    @author  王棚嶙
+    @usage
+    本文件为本部分为zbuff高级操作模块，包含zbuff的复杂数据处理功能,包括：
+    1. 数据打包/解包
+    2. 类型化读写
+    3. 浮点数操作
+    本文件没有对外接口，直接在main.lua中require "zbuff_advanced"就可以加载运行
+    ]]
+
+local function zbuff_advanced_task_func()
+    log.info("zbuff_advanced", "启动高级功能演示")
+    
+    -- 创建1024字节的缓冲区
+    local buff = zbuff.create(1024)
+    
+    -- === 数据打包与解包演示 ===
+    log.info("zbuff_advanced", "=== 数据打包与解包演示 ===")
+    
+    -- 清空缓冲区
+    buff:clear()
+    -- 重置指针到开头
+    buff:seek(0)
+    
+    -- 打包数据：大端序，2个32位整数，1个16位整数，1个字符串
+    buff:pack(">IIHA", 0x1234, 0x4567, 0x12, "abcdefg")
+    log.info("zbuff_advanced", "数据打包", "格式: >IIHA", "值: 0x1234, 0x4567, 0x12, 'abcdefg'")
+    -- 显示打包后的二进制内容
+    local packed = buff:toStr(0, buff:used())--按照起始位置和长度，取出数据，并转换为字符串
+    log.info("zbuff_advanced", "打包后数据", packed:toHex())
+    
+    
+    -- 重置指针到开头
+    buff:seek(0)
+    
+    -- 解包数据：大端序，2个32位整数，1个16位整数，1个10字节字符串
+    local cnt, a, b, c, s = buff:unpack(">IIHA10")
+    log.info("zbuff_advanced", "数据解包", "数量:", cnt, "值:", a, b, c, s)
+     -- 显示解包后的输出内容
+     -- string.forma是Lua的格式化字符串函数，按照格式化参数formatstring，返回后面...内容的格式化版本。string.format("0x%X", a)表示将整数a转换为十六进制字符串。
+    log.info("zbuff_advanced", "解包输出内容", 
+        "cnt:", cnt, 
+        "a(32位):", string.format("0x%X", a),
+        "b(32位):", string.format("0x%X", b),
+        "c(16位):", string.format("0x%X", c),
+        "s(字符串):", s)
+    -- === 类型化读写演示 ===
+    --[[
+    类型化读写演示
+    展示I8和U32两种类型操作
+    @param buff zbuff对象
+    --]]
+    log.info("zbuff_advanced", "=== 类型化读写演示 ===")
+
+    -- 重置指针到开头
+    buff:seek(0)
+    
+    -- 写入8位有符号整数
+    buff:writeI8(10)
+    log.info("zbuff_advanced", "类型化写入", "I8:", 10)
+    
+    -- 写入32位无符号整数
+    buff:writeU32(1024)
+    log.info("zbuff_advanced", "类型化写入", "U32:", 1024)
+    
+    -- 重置指针到开头
+    buff:seek(0)
+    
+    -- 读取8位有符号整数
+    local i8data = buff:readI8()
+    log.info("zbuff_advanced", "类型化读取", "I8:", i8data)
+    
+    -- 读取32位无符号整数
+    local u32data = buff:readU32()
+    log.info("zbuff_advanced", "类型化读取", "U32:", u32data)
+
+
+
+    --[[
+    浮点数操作演示
+    @param buff zbuff对象
+    --]]
+    log.info("zbuff_advanced", "=== 浮点数操作演示 ===")
+    -- 重置指针到开头
+    buff:seek(0)
+    
+    -- 写入32位浮点数
+    buff:writeF32(1.2)
+    log.info("zbuff_advanced", "浮点数操作", "写入F32:", 1.2)
+    
+    -- 重置指针到开头
+    buff:seek(0)
+    
+    -- 读取32位浮点数
+    local f32data = buff:readF32()
+    log.info("zbuff_advanced", "浮点数操作", "读取F32:", f32data)
+
+    -- 清空缓冲区
+    buff:clear()
+    -- 重置指针到开头
+    buff:seek(0)
+    log.info("zbuff_advanced", "高级功能演示完成")
+end
+sys.taskInit(zbuff_advanced_task_func)

module/Air8000/demo/zbuff/zbuff_core.lua

@@ -0,0 +1,88 @@
+ --[[
+    @module  zbuff_core
+    @summary zbuff的基础操作模块
+    @version 1.0.0
+    @date    2025.08.08
+    @author  王棚嶙
+    @usage
+    本文件为zbuff的基础操作模块，包含zbuff最常用的基础功能：
+
+    1. 缓冲区创建与初始化
+    2. 基础功能操作（读写）
+    3. 指针控制
+    4. 元信息查询
+    5. 高效数据查询（query接口）
+    本文件没有对外接口，直接在main.lua中require "zbuff_core"就可以加载运行
+    ]]
+    
+       
+local function zbuff_core_task_func()
+    log.info("zbuff_core", "启动核心功能演示")
+    
+    -- 创建1024字节的缓冲区
+    local buff = zbuff.create(1024)
+    log.info("zbuff_core", "缓冲区创建", "长度:", buff:len()) -- 打印缓冲区长度
+    -- === 缓冲区创建与初始化演示 ===
+    log.info("zbuff_core", "=== 缓冲区创建与初始化演示 ===")
+    buff[0] = 0xAE -- 通过索引直接访问和修改数据（索引从0开始）
+    log.info("zbuff_core", "索引访问示例", "buff[0] =", buff[0])
+
+
+    
+    -- === 基础读写操作演示 ===
+    log.info("zbuff_core", "=== 基础IO操作演示 ===")
+    --此处的读写操作只作为演示，具体的读取数据看后续的buff:query接口
+    --buff：write()中的参数可以是任意类型，zbuff会自动进行类型转换，写入buff的数据，string时为一个参数，number时可为多个参数
+
+    buff:write("123")
+    log.info("zbuff_core", "写入字符串", "123")
+    buff:write(0x12, 0x13, 0x13, 0x33)
+    log.info("zbuff_core", "写入数值", "0x12, 0x13, 0x13, 0x33")
+    
+    buff:seek(5, zbuff.SEEK_CUR)
+    log.info("zbuff_core", "指针当前位置", "向后移动5字节","当前位置:", buff:used())
+    
+    buff:seek(0)
+    log.info("zbuff_core", "指针移动", "重置到开头")
+    
+    local data = buff:read(3)
+    log.info("zbuff_core", "读取数据", "长度3:",data)
+   
+    
+
+    -- === 缓冲区清除操作 ===
+    log.info("zbuff_core", "=== 缓冲区清除操作 ===")
+    buff:clear()
+    log.info("zbuff_core", "清除操作", "全部清零")
+    
+    buff:clear(0xA5)
+    log.info("zbuff_core", "清除操作", "填充0xA5")
+    
+
+
+    -- === 元信息查询 ===
+    log.info("zbuff_core", "=== 元信息查询 ===")
+    local len = buff:len()
+    log.info("zbuff_core", "元信息", "总长度:", len)
+    
+    local used = buff:used()
+    log.info("zbuff_core", "元信息", "已使用:", used)
+    
+
+
+    -- === 高效数据查询 ===
+    log.info("zbuff_core", "=== 高效数据查询 ===")
+    buff:clear()
+    buff:seek(0)
+    buff:write(0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC)
+    
+    local all_data = buff:query(0, 6)
+    log.info("zbuff_core", "query查询", "全部数据:" ,all_data:toHex())
+     -- 查询部分数据并转换格式,查询1,2，4,8字节的时候会自动根据后续参数进行转换（大端序、无符号）
+    -- 参数：起始位置0，长度4，大端序，无符号，非浮点
+    local part_data = buff:query(0, 4, true, false, false)
+    log.info("zbuff_core", "query查询", "大端序格式:", part_data)
+    
+    log.info("zbuff_core", "核心功能演示完成")
+end
+sys.taskInit(zbuff_core_task_func)

module/Air8000/demo/zbuff/zbuff_memory.lua

@@ -0,0 +1,62 @@
+    --[[
+    @module  zbuff_memory
+    @summary zbuff的内存管理模块
+    @version 1.0.0
+    @date    2025.08.08
+    @author  王棚嶙
+    @usage
+    本文件为zbuff的内存管理模块，核心业务逻辑为内存管理操作,包括：
+    1.缓冲区大小调整 
+    2.内存块设置 
+    3.数据删除
+    4.内存比较 
+    5.Base64编码转换功能
+    本文件没有对外接口，直接在main.lua中require "zbuff_memory"就可以加载运行
+    ]]
+local function zbuff_memory_task_func()
+    --[[内存管理操作演示@param buff zbuff对象]]
+    log.info("zbuff_memory", "启动内存管理功能演示")
+
+
+    -- 1. 调整缓冲区大小
+    local buff = zbuff.create(1024)
+    local original_size = buff:len()
+    buff:resize(2048)  -- 扩容到2048字节
+    log.info("zbuff_memory", "大小调整", "原始大小:", original_size, "新大小:", buff:len())
+    
+    -- 2. 内存块设置（类似memset）
+    -- 从位置10开始设置5个字节为0xaa
+    buff:set(10,0xaa,5)
+    log.info("zbuff_memory", "内存设置", "位置10-14设置为0xaa")
+    -- 验证设置结果
+    log.info("zbuff_memory", "验证结果", "位置10:", buff[10], "应为0xaa")
+    
+    -- 3. 数据删除操作
+    -- 写入测试数据
+    buff:clear()
+    buff:seek(0)
+    buff:write("ABCDEFGH")
+    log.info("zbuff_memory", "删除前数据", buff:toStr())
+    
+    -- 删除位置2开始的3个字节
+    buff:del(2, 3)
+    log.info("zbuff_memory", "删除操作", "删除位置2-4", "结果:", buff:toStr())
+    
+    -- 4. 内存比较
+    local buff2 = zbuff.create(10)
+    buff2:write("12345")
+    
+    -- 比较两个缓冲区前5字节内容
+    local equal, offset = buff:isEqual(0, buff2, 0, 5)
+    log.info("zbuff_memory", "内存比较", "结果:", equal, "差异位置:", offset)
+    
+    -- 5. Base64编码转换
+    local dst = zbuff.create(buff:used() * 2)  -- 创建足够大的目标缓冲区
+    
+    -- 进行Base64编码
+    local len = buff:toBase64(dst)
+    log.info("zbuff_memory", "Base64编码", "长度:", len, "结果:", dst:toStr(0, len))
+
+    log.info("zbuff_memory", "内存管理功能演示完成")
+end
+sys.taskInit(zbuff_memory_task_func)