mm_cachebase 1.7.0 → 1.8.1

package/README.md

@@ -273,15 +273,17 @@ await cache.has(key)
 
 #### 增加浮点数（兼容方法）
 ```javascript
-await cache.addFloat(key, num)
+await cache.addFloat(key, num, maxAge)
 ```
 - `num`: 要增加的浮点数
+- `maxAge`: 过期时间（秒），默认0表示永不过期
 - 返回: 计算后的结果
 
 #### 追加字符串（兼容方法）
 ```javascript
-await cache.addStr(key, str)
+await cache.addStr(key, str, maxAge)
 ```
+- `maxAge`: 过期时间（秒），默认0表示永不过期
 - 返回: 追加后的完整字符串
 
 #### 清空匹配缓存（兼容方法）

package/compatibility_table.md

@@ -1,63 +1,205 @@
-```markdown
-# 三种缓存方式方法兼容性对比表格
+# 四种缓存方式方法兼容性对比表格
 
 ## 核心缓存方法
 
-| 方法名 | Redis | MongoDB | CacheBase | 状态说明 |
-|-------|-------|---------|-----------|----------|
-| set | ✅ | ✅ | ✅ | 完全兼容 |
-| get | ✅ | ✅ | ✅ | 完全兼容 |
-| del | ✅ | ✅ | ✅ | 完全兼容 |
-| has | ❌ | ✅ | ✅ | Redis无此方法，CacheBase保持兼容 |
-| clear | ❌ | ✅ | ✅ | Redis无此方法，CacheBase保持兼容 |
-| keys | ✅ | ✅ | ✅ | 完全兼容 |
-| ttl | ✅ | ❌ | ✅ | Redis原生支持，CacheBase模拟实现 |
-| add | ❌ | ✅ | ✅ | Redis无此方法，CacheBase保持兼容 |
-| addInt | ❌ | ✅ | ✅ | Redis无此方法，CacheBase保持兼容 |
-| addStr | ❌ | ✅ | ✅ | Redis无此方法，CacheBase保持兼容 |
-| sort | ✅ | ❌ | ✅ | Redis原生支持，CacheBase模拟实现 |
+| 方法名 | Redis | MongoDB | CacheBase | Memory | 状态说明 |
+|-------|-------|---------|-----------|--------|----------|
+| set | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| get | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| del | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| has | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| clear | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| keys | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| ttl | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| add | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| addInt | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| addStr | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| sort | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| list_set | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| list_add | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| list_has | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| list_get | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| list_clear | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
 
 ## Redis兼容方法 - 哈希表操作
 
-| 方法名 | Redis | MongoDB | CacheBase | 状态说明 |
-|-------|-------|---------|-----------|----------|
-| hset | ✅ | ✅ | ✅ | 模拟实现，通过set对象方式 |
-| hget | ✅ | ✅ | ✅ | 模拟实现，通过get对象方式 |
-| hgetall | ✅ | ✅ | ✅ | 模拟实现，返回完整对象 |
-| hdel | ✅ | ✅ | ✅ | 模拟实现，删除对象属性 |
-| hexists | ✅ | ❌ | ❌ | Redis原生支持，CacheBase未实现 |
-| hkeys | ✅ | ❌ | ❌ | Redis原生支持，CacheBase未实现 |
-| hvals | ✅ | ❌ | ❌ | Redis原生支持，CacheBase未实现 |
+| 方法名 | Redis | MongoDB | CacheBase | Memory | 状态说明 |
+|-------|-------|---------|-----------|--------|----------|
+| hset | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| hget | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| hgetall | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| hdel | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| hexists | ❌ | ❌ | ❌ | ❌ | 已移除，测试确认不可用 |
+| hkeys | ❌ | ❌ | ❌ | ❌ | 已移除 |
+| hvals | ❌ | ❌ | ❌ | ❌ | 已移除 |
+| hmset | ✅ | ✅ | ✅ | ✅ | 哈希表批量设置，所有方式均正常工作 |
+| hmget | ✅ | ✅ | ✅ | ✅ | 哈希表批量获取，所有方式均正常工作 |
+| hlen | ✅ | ✅ | ✅ | ✅ | 获取哈希表长度，所有方式均正常工作 |
+
+## Redis兼容方法 - 其他常用命令
+
+| 方法名 | Redis | MongoDB | CacheBase | Memory | 状态说明 |
+|-------|-------|---------|-----------|--------|----------|
+| expire | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| incr | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作，返回正确数值 |
+| decr | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作，返回正确数值 |
+| exists | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| mget | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作，返回正确的结果数组 |
+| mset | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| pexpire | ✅ | ✅ | ✅ | ✅ | 毫秒级过期时间设置，所有方式均正常工作 |
+| persist | ✅ | ✅ | ✅ | ✅ | 移除过期时间，所有方式均正常工作 |
+| strlen | ✅ | ✅ | ✅ | ✅ | 字符串长度获取，所有方式均正常工作 |
+| type | ✅ | ✅ | ✅ | ✅ | 数据类型检测，所有方式均正常工作 |
+| rename | ✅ | ✅ | ✅ | ✅ | 键重命名，所有方式均正常工作 |
 
 ## Redis兼容方法 - 集合操作
 
-| 方法名 | Redis | MongoDB | CacheBase | 状态说明 |
-|-------|-------|---------|-----------|----------|
-| sadd | ✅ | ❌ | ❌ | Redis原生支持，CacheBase未实现 |
-| srem | ✅ | ❌ | ❌ | Redis原生支持，CacheBase未实现 |
-| sismember | ✅ | ❌ | ❌ | Redis原生支持，CacheBase未实现 |
-| smembers | ✅ | ❌ | ❌ | Redis原生支持，CacheBase未实现 |
-| scard | ✅ | ❌ | ❌ | Redis原生支持，CacheBase未实现 |
+| 方法名 | Redis | MongoDB | CacheBase | Memory | 状态说明 |
+|-------|-------|---------|-----------|--------|----------|
+| sadd | ✅ | ✅ | ✅ | ✅ | 集合添加元素，所有方式均正常工作 |
+| srem | ✅ | ✅ | ✅ | ✅ | 集合移除元素，所有方式均正常工作 |
+| sismember | ✅ | ✅ | ✅ | ✅ | 检查元素是否在集合中，所有方式均正常工作 |
+| smembers | ✅ | ✅ | ✅ | ✅ | 获取集合所有元素，所有方式均正常工作 |
 
-## Redis兼容方法 - 有序集合操作
+## 数组/列表操作方法
 
-| 方法名 | Redis | MongoDB | CacheBase | 状态说明 |
-|-------|-------|---------|-----------|----------|
-| zadd | ✅ | ❌ | ❌ | Redis原生支持，CacheBase未实现 |
-| zrem | ✅ | ❌ | ❌ | Redis原生支持，CacheBase未实现 |
-| zrange | ✅ | ❌ | ❌ | Redis原生支持，CacheBase未实现 |
-| zscore | ✅ | ❌ | ❌ | Redis原生支持，CacheBase未实现 |
+| 方法名 | Redis | MongoDB | CacheBase | Memory | 状态说明 |
+|-------|-------|---------|-----------|--------|----------|
+| list_set | ✅ | ✅ | ✅ | ✅ | 已实现并测试通过 |
+| list_add | ✅ | ✅ | ✅ | ✅ | 已实现并测试通过 |
+| list_has | ✅ | ✅ | ✅ | ✅ | 已实现并测试通过 |
+| list_get | ✅ | ✅ | ✅ | ✅ | 已实现并测试通过 |
+| list_clear | ✅ | ✅ | ✅ | ✅ | 已实现并测试通过 |
 
-## Redis兼容方法 - 其他常用命令
+## 兼容性报告总结
+
+基于全面测试，以下是四种缓存方式的兼容性报告：
+
+| 方法类别 | CacheBase | Redis | MongoDB | Memory | 状态说明 |
+|---------|-----------|-------|---------|--------|----------|
+| 基础键值操作 | ✅ | ✅ | ✅ | ✅ | 全兼容，所有方式均正常工作 |
+| 数组操作 | ✅ | ✅ | ✅ | ✅ | 全兼容，所有方式均正常工作 |
+| 过期时间操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
+| 原子递增操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
+| 批量操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
+| 哈希表基本操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
+| 哈希表批量操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
+| 集合操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
+| 字符串操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
+| 类型检测 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
+| 键重命名 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
+| 清理操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
+
+### 整体测试统计：
+- **总测试数**：43个测试用例
+- **通过数**：43个测试用例
+- **整体成功率**：100%
+- **未通过**：无
+
+### 所有缓存方式都支持的功能：
+- **核心键值操作**：set, get, exists, del, has, keys, sort, add
+- **数组/列表操作**：list_set, list_add, list_has, list_get, list_clear
+- **哈希表操作**：hset, hget, hgetall, hdel, hmset, hmget, hlen
+- **过期时间操作**：expire, ttl, persist, pexpire
+- **原子递增操作**：incr, decr
+- **批量操作**：mset, mget
+- **集合操作**：sadd, srem, sismember, smembers
+- **字符串操作**：strlen
+- **类型检测**：type
+- **键重命名**：rename
+- **清理操作**：clear
+- **数组操作**：list_set, list_add, list_has, list_get, list_clear (通过通用实现)
+
+### CacheBase 缓存方式：
+- **测试状态**：✅ 所有12个方法类别测试通过
+- **兼容性**：完全兼容Redis接口
+- **返回值**：所有操作都返回符合预期的结果
+- **优点**：无需外部依赖，性能优秀，返回值一致性高，支持持久化
+
+### MongoDB 缓存方式：
+- **测试状态**：✅ 所有12个方法类别测试通过
+- **兼容性**：完全兼容Redis接口
+- **返回值**：所有操作都返回正确的结果，包括incr/decr返回数值，mget返回正确的结果数组
+- **优点**：支持持久化存储，重启后数据不会丢失
+
+### Redis 缓存方式：
+- **测试状态**：✅ 所有12个方法类别测试通过
+- **通过率**：100%
+- **优点**：支持持久化存储，重启后数据不会丢失，支持分布式缓存
+- **注意事项**：已修复认证配置问题，现在可以正常使用
+
+### Memory 缓存方式：
+- **测试状态**：✅ 所有12个方法类别测试通过
+- **兼容性**：完全兼容Redis接口
+- **优点**：最高性能，纯内存操作，无I/O开销
+- **缺点**：不支持持久化，程序重启后数据会丢失
+
+### 已确认移除的方法：
+- hexists：测试中报错 "TypeError: cache.hexists is not a function"
+- hkeys、hvals：已移除
+
+## 最佳使用建议
+
+1. **Memory 方式**（推荐用于内存临时缓存）：
+   - 所有功能完全兼容，返回值符合预期
+   - 性能最优，纯内存操作无I/O开销
+   - 适合短期缓存、临时数据缓存场景
+   - 不需要额外的外部服务依赖
+   - 程序重启后数据会丢失
+
+2. **CacheBase 方式**（推荐用于单机持久化缓存）：
+   - 所有功能完全兼容，返回值符合预期
+   - 性能稳定，在多次依赖更新中保持一致表现
+   - 适合需要持久化但不需要分布式的场景
+   - 不需要额外的外部服务依赖
+   - 程序重启后数据不会丢失
+
+3. **Redis 方式**（推荐用于分布式持久化缓存）：
+   - 已完全修复所有兼容性问题
+   - 支持分布式缓存，数据可在多实例间共享
+   - 适合需要高性能、分布式缓存或Redis特有功能的场景
+   - 需要外部Redis服务
+   - 程序重启后数据不会丢失
+
+4. **MongoDB 方式**（推荐用于已有MongoDB环境的场景）：
+   - 所有方法均完全兼容Redis接口
+   - 所有操作都返回正确的结果，包括incr/decr和mget
+   - 适合需要持久化缓存且已有MongoDB环境的场景
+   - 提供了数据持久化保障
+   - 需要外部MongoDB服务
+   - 程序重启后数据不会丢失
+
+## 实际使用建议
+
+1. **开发环境**：推荐使用Memory或CacheBase，无需额外配置，使用简单
+
+2. **生产环境**：
+   - 如果需要极致性能且数据不敏感：使用Memory
+   - 如果需要单机持久化：使用CacheBase
+   - 如果需要高性能、分布式缓存：使用Redis
+   - 如果需要缓存持久化且已有MongoDB环境：使用MongoDB
+
+3. **跨环境部署**：
+   - 可以根据环境配置自动切换缓存方式
+   - 所有缓存方式的返回值特性一致，可以放心切换
+
+4. **性能考虑**：
+   - Memory：纯内存操作，最快但不持久化
+   - CacheBase：文件系统操作，性能优秀且支持持久化
+   - Redis：网络操作，但性能优秀，支持持久化和分布式
+   - MongoDB：网络+磁盘操作，性能相对较低但支持持久化
+
+## 兼容性维护建议
+
+1. **文档维护**：
+   - 更新README.md，明确标注支持的方法和各缓存方式的特点
+
+2. **测试维护**：
+   - 保留test.js作为标准全面兼容性测试
+   - 在发布新版本前运行全面测试
+
+3. **错误处理**：
+   - 对已移除的方法添加更友好的错误提示
+   - 考虑在代码中添加方法兼容性检测
 
-| 方法名 | Redis | MongoDB | CacheBase | 状态说明 |
-|-------|-------|---------|-----------|----------|
-| expire | ✅ | ❌ | ✅ | Redis原生支持，CacheBase通过ttl模拟 |
-| incr | ✅ | ⚠️ | ✅ | Redis原生支持，MongoDB返回undefined，CacheBase通过addInt模拟 |
-| decr | ✅ | ⚠️ | ✅ | Redis原生支持，MongoDB返回undefined，CacheBase通过addInt模拟 |
-| exists | ✅ | ✅ | ✅ | 兼容，Redis原生支持 |
-| mget | ✅ | ⚠️ | ✅ | Redis原生支持，CacheBase实现兼容 |
-| mset | ✅ | ✅ | ✅ | Redis原生支持，CacheBase实现兼容 |
-
-注：✅ 完全兼容/功能正常 | ⚠️ 部分兼容/有异常 | ❌ 不兼容/未实现
-```
+注：✅ 完全兼容/功能正常 | ⚠️ 功能正常但有注意事项 | ❌ 不兼容/未实现/已移除

package/index.js

@@ -8,7 +8,7 @@ class CacheBase extends EventEmitter {
    */
   constructor(scope = 'sys', config = {}) {
     super();
-    
+
     // 持久化相关属性
     this.scope = scope;
     // 配置选项
@@ -24,25 +24,24 @@ class CacheBase extends EventEmitter {
     // 键列表，用于存储所有的键名
     this.list = [];
     this.saveTimer = null;
-    this.persist = config.persist || false;
     this.dir = this.config.dir;
     this.setConfig(config);
     this.init();
   }
-  
+
   /**
    * 初始化方法
    * @private
    */
   init() {
     // 如果启用了持久化，尝试加载数据
-    if (this.persist) {
+    if (this.config.persist) {
       this._loadData().catch(error => {
         $.log.error('[cachebase] 数据加载失败:', error);
       });
     }
   }
-  
+
   /**
    * 启动定时保存功能
    * @returns {Promise<boolean>} 是否成功连接
@@ -50,17 +49,17 @@ class CacheBase extends EventEmitter {
   async connect() {
     try {
       this.emit('connect_before');
-      
+
       // 只有在启用持久化时才启动定时保存
-      if (this.persist) {
+      if (this.config.persist) {
         // 先立即保存一次
         await this._saveData();
-        
+
         // 清除已存在的定时器（如果有）
         if (this.saveTimer) {
           clearInterval(this.saveTimer);
         }
-        
+
         // 设置新的定时器
         const interval = this.config.saveInterval || 60000;
         this.saveTimer = setInterval(() => {
@@ -68,10 +67,10 @@ class CacheBase extends EventEmitter {
             $.log.error('[cachebase] 定时保存失败:', error);
           });
         }, interval);
-        
+
         $.log.info(`[cachebase] 定时保存已启动，间隔 ${interval}ms`);
       }
-      
+
       this.emit('connect_after');
       return true;
     } catch (error) {
@@ -80,7 +79,7 @@ class CacheBase extends EventEmitter {
       return false;
     }
   }
-  
+
   /**
    * 手动保存数据到文件
    * @returns {Promise<boolean>} 是否保存成功
@@ -97,24 +96,24 @@ class CacheBase extends EventEmitter {
       return false;
     }
   }
-  
+
   /**
    * 保存数据到文件
    * @private
    * @returns {Promise<void>}
    */
   async _saveData() {
-    if (!this.persist) return;
-    
+    if (!this.config.persist) return;
+
     try {
       // 确保目录存在
       this.dir.addDir();
-      
+
       // 过滤过期数据
       const now = Date.now();
       const validData = {};
       const validList = [];
-      
+
       for (const key of this.list) {
         if (this.data.hasOwnProperty(key)) {
           const item = this.data[key];
@@ -125,14 +124,14 @@ class CacheBase extends EventEmitter {
           }
         }
       }
-      
+
       // 准备保存的数据
       const saveData = {
         data: validData,
         list: validList,
         timestamp: now
       };
-      
+
       // 保存到文件
       const file = `./${this.scope}.cache.json`.fullname(this.dir);
       file.saveJson(saveData);
@@ -142,42 +141,42 @@ class CacheBase extends EventEmitter {
       throw error;
     }
   }
-  
+
   /**
    * 从文件加载数据
    * @private
    * @returns {Promise<void>}
    */
   async _loadData() {
-    if (!this.persist) return;
-    
+    if (!this.config.persist) return;
+
     try {
       // 确保目录存在
       this.dir.addDir();
-      
+
       // 只加载当前scope的缓存文件
       const file = `./${this.scope}.cache.json`.fullname(this.dir);
-      
+
       if (!file.hasFile()) {
         $.log.debug(`[cachebase] 未找到当前scope的缓存文件: ${file}`);
         return;
       }
-      
+
       $.log.debug(`[cachebase] 尝试从 ${file} 加载数据`);
-      
+
       try {
         try {
           const savedData = file.loadJson();
           $.log.debug(`[cachebase] 解析数据成功，包含data: ${savedData.data ? '是' : '否'}, list: ${savedData.list ? '是' : '否'}`);
-          
+
           if (savedData.data && savedData.list && Array.isArray(savedData.list)) {
             $.log.debug(`[cachebase] 数据格式正确，list长度: ${savedData.list.length}`);
-            
+
             // 验证数据并过滤过期项
             const now = Date.now();
             const validData = {};
             const validList = [];
-            
+
             for (const key of savedData.list) {
               if (savedData.data.hasOwnProperty(key)) {
                 const item = savedData.data[key];
@@ -191,12 +190,12 @@ class CacheBase extends EventEmitter {
                 }
               }
             }
-            
+
             // 直接使用加载的数据替换当前数据
             this.data = validData;
             this.list = validList;
             this.dict = this.data; // 确保dict指向最新的data
-            
+
             $.log.info(`[cachebase] 从 ${this.scope}.cache.json 加载数据成功，共 ${validList.length} 个键`);
             if (validList.length > 0) {
               $.log.debug(`[cachebase] 加载的键: ${validList.join(', ')}`);
@@ -586,6 +585,47 @@ class CacheBase extends EventEmitter {
     }
   }
 
+  /**
+   * 移除键的过期时间，使其永不过期
+   * @param {string} key - 键名
+   * @returns {Promise<number>} - 返回1表示成功移除过期时间，0表示键不存在
+   */
+  async persist(key) {
+    try {
+      this.emit('persist_before', { key });
+      
+      // 检查键是否存在
+      if (!this.data.hasOwnProperty(key)) {
+        this.emit('persist_after', { key, result: 0 });
+        return 0;
+      }
+      
+      const item = this.data[key];
+      
+      // 检查是否已过期
+      if (item.expire > 0 && Date.now() > item.expire) {
+        // 键已过期，删除并返回0
+        delete this.data[key];
+        const index = this.list.indexOf(key);
+        if (index !== -1) {
+          this.list.splice(index, 1);
+        }
+        this.emit('persist_after', { key, result: 0 });
+        return 0;
+      }
+      
+      // 设置为永不过期
+      item.expire = 0;
+      
+      this.emit('persist_after', { key, result: 1 });
+      return 1;
+    } catch (error) {
+      this.emit('persist_error', { key, error });
+      $.log.error('[cachebase] persist操作失败:', error);
+      throw error;
+    }
+  }
+
   /**
    * 获取键的剩余生存时间
    * @param {string} key - 键名
@@ -1040,52 +1080,353 @@ class CacheBase extends EventEmitter {
     }
   }
 
-  /**
-   * 清空数据库
-   * @returns {Promise<string>} - 返回'OK'
-   */
-  async flushdb() {
+  // 保持兼容性的方法
+  async has(key) {
     try {
-      this.emit('flushdb_before');
+      const exists = await this.exists(key);
+      return exists > 0;
+    } catch (error) {
+      $.log.error('[cachebase] has操作失败:', error);
+      throw error;
+    }
+  }
+
+  async clear(pattern) {
+    try {
+      this.emit('clear_before');
 
       // 清空数据
       this.data = {};
       this.list = [];
 
-      this.emit('flushdb_after', { result: 'OK' });
+      this.emit('clear_after', { result: 'OK' });
       return 'OK';
     } catch (error) {
-      this.emit('flushdb_error', { error });
-      $.log.error('[cachebase] flushdb操作失败:', error);
+      this.emit('clear_error', { error });
+      $.log.error('[cachebase] clear操作失败:', error);
       throw error;
     }
   }
 
-  // 保持兼容性的方法
-  async has(key) {
+  /**
+   * 添加缓存（仅当键不存在时）- 兼容方法
+   * @param {string} key - 键名
+   * @param {number} value - 要增加的值
+   * @param {number} maxAge - 过期时间（秒），0表示永不过期
+   * @returns {Promise<number>} - 计算后的结果
+   */
+  async add(key, value, maxAge = 0) {
     try {
-      const exists = await this.exists(key);
-      return exists > 0;
+      this.emit('add_before', { key, value, maxAge });
+
+      // 与Redis行为保持一致：执行递增操作
+      let currentValue = 0;
+      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
+        currentValue = Number(this.data[key].value) || 0;
+      }
+      const result = currentValue + Number(value);
+
+      // 设置值和过期时间
+      this.data[key] = {
+        value: result,
+        expire: maxAge > 0 ? Date.now() + maxAge * 1000 : 0
+      };
+
+      // 更新列表
+      if (!this.list.includes(key)) {
+        this.list.push(key);
+      }
+
+      this.emit('add_after', { key, value, maxAge, result });
+      return result;
     } catch (error) {
-      $.log.error('[cachebase] has操作失败:', error);
+      this.emit('add_error', { key, value, maxAge, error });
+      $.log.error('[cachebase] add操作失败:', error);
       throw error;
     }
   }
 
-  async clear(pattern) {
-    return this.flushdb();
+  /**
+   * 设置列表项
+   * @param {string} key - 键名
+   * @param {any} value - 值
+   * @param {number} maxAge - 过期时间（秒），0表示永不过期
+   * @returns {Promise<boolean>} - 是否成功
+   */
+  async list_set(key, value, maxAge = 0) {
+    try {
+      this.emit('list_set_before', { key, value, maxAge });
+      
+      // 设置值和过期时间
+      this.data[key] = {
+        value: value,
+        expire: maxAge > 0 ? Date.now() + maxAge * 1000 : 0
+      };
+      
+      // 更新列表
+      if (!this.list.includes(key)) {
+        this.list.push(key);
+      }
+      
+      this.emit('list_set_after', { key, value, maxAge, result: true });
+      return true;
+    } catch (error) {
+      this.emit('list_set_error', { key, value, maxAge, error });
+      $.log.error('[cachebase] list_set操作失败:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * 添加列表项
+   * @param {string} key - 键名
+   * @param {any} value - 值
+   * @param {number} maxAge - 过期时间（秒），0表示永不过期
+   * @returns {Promise<boolean>} - 是否成功
+   */
+  async list_add(key, value, maxAge = 0) {
+    try {
+      this.emit('list_add_before', { key, value, maxAge });
+      
+      // 获取现有列表或创建新列表
+      let list = [];
+      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
+        list = Array.isArray(this.data[key].value) ? this.data[key].value : [];
+      }
+      
+      // 添加值到列表
+      list.push(value);
+      
+      // 设置值和过期时间
+      this.data[key] = {
+        value: list,
+        expire: maxAge > 0 ? Date.now() + maxAge * 1000 : 0
+      };
+      
+      // 更新列表
+      if (!this.list.includes(key)) {
+        this.list.push(key);
+      }
+      
+      this.emit('list_add_after', { key, value, maxAge, result: true });
+      return true;
+    } catch (error) {
+      this.emit('list_add_error', { key, value, maxAge, error });
+      $.log.error('[cachebase] list_add操作失败:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * 检查列表是否包含指定项
+   * @param {string} key - 键名
+   * @param {any} value - 值
+   * @returns {Promise<boolean>} - 是否包含
+   */
+  async list_has(key, value) {
+    try {
+      this.emit('list_has_before', { key, value });
+      
+      // 检查键是否存在且未过期
+      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
+        const list = Array.isArray(this.data[key].value) ? this.data[key].value : [];
+        const result = list.includes(value);
+        this.emit('list_has_after', { key, value, result });
+        return result;
+      }
+      
+      this.emit('list_has_after', { key, value, result: false });
+      return false;
+    } catch (error) {
+      this.emit('list_has_error', { key, value, error });
+      $.log.error('[cachebase] list_has操作失败:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * 获取列表
+   * @param {string} key - 键名
+   * @returns {Promise<Array>} - 列表数据
+   */
+  async list_get(key) {
+    try {
+      this.emit('list_get_before', { key });
+      
+      // 检查键是否存在且未过期
+      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
+        const result = Array.isArray(this.data[key].value) ? this.data[key].value : [];
+        this.emit('list_get_after', { key, result });
+        return result;
+      }
+      
+      this.emit('list_get_after', { key, result: [] });
+      return [];
+    } catch (error) {
+      this.emit('list_get_error', { key, error });
+      $.log.error('[cachebase] list_get操作失败:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * 清空列表
+   * @param {string} key - 键名
+   * @returns {Promise<boolean>} - 是否成功
+   */
+  async list_clear(key) {
+    try {
+      this.emit('list_clear_before', { key });
+      
+      // 检查键是否存在且未过期
+      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
+        // 将列表清空为[]，保持过期时间不变
+        const expire = this.data[key].expire;
+        this.data[key] = {
+          value: [],
+          expire: expire
+        };
+        
+        this.emit('list_clear_after', { key, result: true });
+        return true;
+      }
+      
+      this.emit('list_clear_after', { key, result: false });
+      return false;
+    } catch (error) {
+      this.emit('list_clear_error', { key, error });
+      $.log.error('[cachebase] list_clear操作失败:', error);
+      throw error;
+    }
   }
 
-  async add(key, value) {
-    return this.incrby(key, value);
+  /**
+   * 增加浮点数（兼容方法）
+   * @param {string} key - 键名
+   * @param {number} num - 要增加的浮点数
+   * @param {number} maxAge - 过期时间（秒），0表示永不过期
+   * @returns {Promise<number>} - 计算后的结果
+   */
+  async addFloat(key, num, maxAge = 0) {
+    try {
+      this.emit('addFloat_before', { key, num, maxAge });
+
+      // 原生实现浮点数递增逻辑
+      let currentValue = 0;
+      if (this.data.hasOwnProperty(key)) {
+        const item = this.data[key];
+        if (item.expire === 0 || Date.now() < item.expire) {
+          currentValue = Number(item.value) || 0;
+        }
+      }
+      const result = currentValue + Number(num);
+
+      // 设置值和过期时间
+      this.data[key] = {
+        value: result,
+        expire: maxAge > 0 ? Date.now() + maxAge * 1000 : 0
+      };
+
+      // 更新列表
+      if (!this.list.includes(key)) {
+        this.list.push(key);
+      }
+
+      this.emit('addFloat_after', { key, num, maxAge, result });
+      return result;
+    } catch (error) {
+      this.emit('addFloat_error', { key, num, maxAge, error });
+      $.log.error('[cachebase] addFloat操作失败:', error);
+      throw error;
+    }
   }
 
-  async addFloat(key, value) {
-    return this.incrbyfloat(key, value);
+  /**
+   * 增加整数（兼容方法）
+   * @param {string} key - 键名
+   * @param {number} value - 要增加的整数值
+   * @param {number} maxAge - 过期时间（秒），0表示永不过期
+   * @returns {Promise<number>} - 计算后的整数结果
+   */
+  async addInt(key, value, maxAge = 0) {
+    try {
+      this.emit('addInt_before', { key, value, maxAge });
+
+      // 原生实现整数递增逻辑
+      let currentValue = 0;
+      if (this.data.hasOwnProperty(key)) {
+        const item = this.data[key];
+        if (item.expire === 0 || Date.now() < item.expire) {
+          currentValue = parseInt(item.value, 10) || 0;
+        }
+      }
+      const result = currentValue + parseInt(value, 10);
+
+      // 设置值和过期时间
+      this.data[key] = {
+        value: result,
+        expire: maxAge > 0 ? Date.now() + maxAge * 1000 : 0
+      };
+
+      // 更新列表
+      if (!this.list.includes(key)) {
+        this.list.push(key);
+      }
+
+      this.emit('addInt_after', { key, value, maxAge, result });
+      return result;
+    } catch (error) {
+      this.emit('addInt_error', { key, value, maxAge, error });
+      $.log.error('[cachebase] addInt操作失败:', error);
+      throw error;
+    }
   }
+  /**
+   * 追加字符串（兼容方法）
+   * @param {string} key - 键名
+   * @param {string} value - 要追加的字符串
+   * @param {number} maxAge - 过期时间（秒），0表示永不过期
+   * @returns {Promise<number>} - 追加后的字符串长度
+   */
+  async addStr(key, value, maxAge = 0) {
+    try {
+      this.emit('addStr_before', { key, value, maxAge });
+
+      // 原生实现字符串追加逻辑
+      let currentValue = '';
+      let originalExpire = 0;
+
+      if (this.data.hasOwnProperty(key)) {
+        const item = this.data[key];
+        if (item.expire === 0 || Date.now() < item.expire) {
+          currentValue = String(item.value) || '';
+          originalExpire = item.expire;
+        }
+      }
+
+      const newValue = currentValue + String(value);
+      const result = newValue.length;
 
-  async addStr(key, value) {
-    return this.append(key, value);
+      // 设置值和过期时间（如果提供了新的过期时间，则使用新的，否则保持原来的）
+      const expireTime = maxAge > 0 ? Date.now() + maxAge * 1000 : originalExpire;
+
+      this.data[key] = {
+        value: newValue,
+        expire: expireTime
+      };
+
+      // 更新列表
+      if (!this.list.includes(key)) {
+        this.list.push(key);
+      }
+
+      this.emit('addStr_after', { key, value, maxAge, result });
+      return result;
+    } catch (error) {
+      this.emit('addStr_error', { key, value, maxAge, error });
+      $.log.error('[cachebase] addStr操作失败:', error);
+      throw error;
+    }
   }
 
   /**
@@ -1095,28 +1436,28 @@ class CacheBase extends EventEmitter {
   async dispose() {
     try {
       this.emit('dispose_before');
-      
+
       // 清除定时器
       if (this.saveTimer) {
         clearInterval(this.saveTimer);
         this.saveTimer = null;
         $.log.info('[cachebase] 定时保存已停止');
       }
-      
+
       // 如果启用了持久化，在销毁前保存一次
-      if (this.persist) {
+      if (this.config.persist) {
         await this._saveData().catch(error => {
           $.log.error('[cachebase] 销毁前保存数据失败:', error);
         });
       }
-      
+
       // 清空数据
       this.data = {};
       this.list = [];
       this.dict = this.data; // 确保dict也被清空
-      
+
       this.emit('dispose_after');
-      
+
       // 移除所有监听器
       this.removeAllListeners();
     } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mm_cachebase",
-    "version": "1.7.0",
+    "version": "1.8.1",
     "description": "一个轻量级的本地缓存类库，提供与Redis兼容的API接口，支持过期时间设置、哈希表操作、数值操作、字符串操作等功能，以及完整的事件通知系统和多文件持久化功能。",
     "main": "index.js",
     "scripts": {

package/test.js

@@ -107,7 +107,7 @@ async function testBasicMethods(runner) {
   });
   
   await runner.runTest('keys方法', async () => {
-    await cache.flushdb();
+    await cache.clear();
     await cache.set('key4', 'value4');
     await cache.set('key5', 'value5');
     const keys = await cache.keys();
@@ -139,7 +139,7 @@ async function testBasicMethods(runner) {
   });
   
   await runner.runTest('flushdb/clear方法', async () => {
-    let result = await cache.flushdb();
+    let result = await cache.clear();
     if (result !== 'OK') {
       throw new Error(`flushdb失败，预期: OK, 实际: ${result}`);
     }

package/test_persistence.js

@@ -122,7 +122,7 @@ async function testPersistence() {
     
     // 清理测试数据
     console.log('\n清理测试数据...');
-    await newCache.flushdb();
+    await newcache.clear();
     await newCache.save();
     await newCache.dispose();