mm_cachebase 1.8.4 → 1.8.5

package/compatibility_table.md

@@ -7,19 +7,15 @@
 | set | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
 | get | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
 | del | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| has | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| has | ✅ | ✅ | ✅ | ✅ | 所有方式都支持 |
 | clear | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| keys | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| keys | ✅ | ✅ | ✅ | ✅ | 所有方式都支持 |
 | ttl | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
 | add | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| addInt | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| addStr | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| sort | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| list_set | ✅ | ⚠️ | ⚠️ | ⚠️ | 所有方式均通过通用实现支持，但底层可能需要各自实现 |
-| list_add | ✅ | ⚠️ | ⚠️ | ⚠️ | 所有方式均通过通用实现支持，但底层可能需要各自实现 |
-| list_has | ✅ | ⚠️ | ⚠️ | ⚠️ | 所有方式均通过通用实现支持，但底层可能需要各自实现 |
-| list_get | ✅ | ⚠️ | ⚠️ | ⚠️ | 所有方式均通过通用实现支持，但底层可能需要各自实现 |
-| list_clear | ✅ | ⚠️ | ⚠️ | ⚠️ | 所有方式均通过通用实现支持，但底层可能需要各自实现 |
+| addInt | ✅ | ❌ | ✅ | ✅ | CacheBase和Memory支持，Redis支持，MongoDB不支持 |
+| addStr | ✅ | ❌ | ✅ | ✅ | CacheBase和Memory支持，Redis支持，MongoDB不支持 |
+| sort | ✅ | ✅ | ❌ | ❌ | Redis和MongoDB支持，其他方式不支持 |
+| exists | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
 
 ## Redis兼容方法 - 哈希表操作
 
@@ -27,176 +23,79 @@
 |-------|-------|---------|-----------|--------|----------|
 | hset | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
 | hget | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| hgetall | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| hdel | ⚠️ | ⚠️ | ⚠️ | ⚠️ | 所有方式均返回0，但实际能删除字段 |
-| hmset | ✅ | ✅ | ✅ | ✅ | 哈希表批量设置，所有方式均正常工作 |
-| hmget | ✅ | ✅ | ✅ | ✅ | 哈希表批量获取，所有方式均正常工作 |
-| hlen | ✅ | ✅ | ✅ | ✅ | 获取哈希表长度，所有方式均正常工作 |
+| hgetall | ✅ | ✅ | ✅ | ✅ | 所有方式都支持 |
+| hdel | ✅ | ✅ | ✅ | ✅ | 所有方式都支持 |
+| hmset | ✅ | ✅ | ❌ | ❌ | Redis和MongoDB支持，其他方式不支持 |
+| hmget | ❌ | ✅ | ❌ | ❌ | 仅MongoDB支持 |
+| hlen | ✅ | ✅ | ❌ | ❌ | Redis和MongoDB支持，其他方式不支持 |
 
 ## Redis兼容方法 - 其他常用命令
 
 | 方法名 | Redis | MongoDB | CacheBase | Memory | 状态说明 |
 |-------|-------|---------|-----------|--------|----------|
-| expire | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| incr | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作，返回正确数值 |
-| decr | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作，返回正确数值 |
-| exists | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| mget | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作，返回正确的结果数组 |
-| mset | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| pexpire | ✅ | ✅ | ✅ | ✅ | 毫秒级过期时间设置，所有方式均正常工作 |
-| persist | ✅ | ✅ | ✅ | ✅ | 移除过期时间，所有方式均正常工作 |
-| strlen | ✅ | ✅ | ✅ | ✅ | 字符串长度获取，所有方式均正常工作 |
-| type | ✅ | ✅ | ✅ | ✅ | 数据类型检测，所有方式均正常工作 |
-| rename | ✅ | ✅ | ✅ | ✅ | 键重命名，所有方式均正常工作 |
+| expire | ✅ | ✅ | ✅ | ✅ | 所有方式都支持 |
+| incr | ✅ | ✅ | ✅ | ✅ | 所有方式都支持 |
+| decr | ✅ | ❌ | ✅ | ✅ | Redis、CacheBase和Memory支持，MongoDB不支持 |
+| mget | ✅ | ✅ | ✅ | ✅ | 所有方式都支持 |
+| mset | ✅ | ✅ | ✅ | ✅ | 所有方式都支持 |
+| pexpire | ❌ | ❌ | ❌ | ❌ | 所有方式都不支持 |
+| persist | ✅ | ❌ | ✅ | ✅ | Redis、CacheBase和Memory支持，MongoDB不支持 |
+| strlen | ✅ | ❌ | ✅ | ❌ | Redis和CacheBase支持，其他方式不支持 |
+| addFloat | ✅ | ❌ | ✅ | ✅ | Redis、CacheBase和Memory支持，MongoDB不支持 |
+| type | ❌ | ❌ | ❌ | ❌ | 所有方式都不支持 |
+| rename | ❌ | ❌ | ❌ | ❌ | 所有方式都不支持 |
 
 ## Redis兼容方法 - 集合操作
 
 | 方法名 | Redis | MongoDB | CacheBase | Memory | 状态说明 |
 |-------|-------|---------|-----------|--------|----------|
-| sadd | ✅ | ✅ | ✅ | ✅ | 集合添加元素，所有方式均正常工作 |
-| srem | ✅ | ✅ | ✅ | ✅ | 集合移除元素，所有方式均正常工作 |
-| sismember | ✅ | ✅ | ✅ | ✅ | 检查元素是否在集合中，所有方式均正常工作 |
-| smembers | ✅ | ✅ | ✅ | ✅ | 获取集合所有元素，所有方式均正常工作 |
+| sadd | ✅ | ❌ | ❌ | ❌ | 仅Redis支持 |
+| srem | ✅ | ❌ | ❌ | ❌ | 仅Redis支持 |
+| sismember | ✅ | ✅ | ❌ | ❌ | Redis和MongoDB支持，其他方式不支持 |
+| smembers | ✅ | ✅ | ❌ | ❌ | Redis和MongoDB支持，其他方式不支持 |
 
 ## 数组/列表操作方法
 
 | 方法名 | Redis | MongoDB | CacheBase | Memory | 状态说明 |
 |-------|-------|---------|-----------|--------|----------|
-| list_set | ✅ | ✅ | ✅ | ✅ | 已实现并测试通过 |
-| list_add | ✅ | ✅ | ✅ | ✅ | 已实现并测试通过 |
-| list_has | ✅ | ✅ | ✅ | ✅ | 已实现并测试通过 |
-| list_get | ✅ | ✅ | ✅ | ✅ | 已实现并测试通过 |
-| list_clear | ✅ | ✅ | ✅ | ✅ | 已实现并测试通过 |
+| list_set | ✅ | ❌ | ✅ | ✅ | Redis、CacheBase和Memory支持，返回列表长度，MongoDB不支持 |
+| list_add | ✅ | ❌ | ✅ | ✅ | Redis、CacheBase和Memory支持，返回列表长度，MongoDB不支持 |
+| list_has | ✅ | ❌ | ✅ | ✅ | Redis、CacheBase和Memory支持，返回1或0，MongoDB不支持 |
+| list_get | ✅ | ❌ | ✅ | ✅ | Redis、CacheBase和Memory支持，支持范围获取，MongoDB不支持 |
+| list_clear | ✅ | ❌ | ✅ | ✅ | MongoDB不支持，其他方式支持 |
 
 ## 兼容性报告总结
 
-基于全面测试，以下是四种缓存方式的兼容性报告：
+基于实际功能测试，以下是四种缓存方式的兼容性报告：
 
 | 方法类别 | CacheBase | Redis | MongoDB | Memory | 状态说明 |
 |---------|-----------|-------|---------|--------|----------|
-| 基础键值操作 | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| 数组操作 | ⚠️ | ✅ | ⚠️ | ⚠️ | 所有方式通过通用实现支持，但底层可能需要各自实现 |
-| 过期时间操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
-| 原子递增操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
-| 批量操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
-| 哈希表基本操作 | ⚠️ | ⚠️ | ⚠️ | ⚠️ | hdel方法返回0，但实际能删除字段，其他方法正常 |
-| 哈希表批量操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
-| 集合操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
-| 字符串操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
-| 类型检测 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
-| 键重命名 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
-| 清理操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
+| 基础键值操作 | ✅ | ✅ | ✅ | ✅ | 所有缓存方式均正常工作 |
+| 数组操作 | ✅ | ✅ | ❌ | ✅ | Redis、CacheBase和Memory支持，MongoDB完全不支持 |
+| 过期时间操作 | ✅ | ✅ | ✅ | ✅ | 基本过期时间操作支持，但MongoDB不支持persist |
+| 原子递增操作 | ✅ | ✅ | ✅ | ✅ | incr和decr都支持，但MongoDB不支持decr |
+| 批量操作 | ✅ | ✅ | ✅ | ✅ | 所有方式都支持mset和mget方法 |
+| 哈希表基本操作 | ✅ | ✅ | ✅ | ✅ | 基本操作均支持 |
+| 哈希表批量操作 | ❌ | ✅ | ✅ | ❌ | Redis和MongoDB支持，其他方式不支持 |
+| 集合操作 | ❌ | ✅ | ⚠️ | ❌ | Redis完整支持，MongoDB支持部分方法，其他方式不支持 |
+| 字符串操作 | ✅ | ✅ | ❌ | ✅ | Redis、CacheBase和Memory支持字符串操作方法 |
+| 类型检测 | ❌ | ❌ | ❌ | ❌ | 所有方式都不支持 |
+| 键重命名 | ❌ | ❌ | ❌ | ❌ | 所有方式都不支持 |
+| 清理操作 | ✅ | ✅ | ✅ | ✅ | clear操作正常工作 |
 
 ### 测试统计
 
-- **总测试用例**：43个
-- **通过数**：43个测试用例
-- **整体成功率**：100%
-- **注意事项**：hdel方法在所有缓存方式下返回0，但实际能删除字段
-
-### 所有缓存方式都支持的功能：
-- **核心键值操作**：set, get, exists, del, has, keys, sort（add除外）
-- **哈希表操作**：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. **错误处理**：
-   - 对已移除的方法添加更友好的错误提示
-   - 考虑在代码中添加方法兼容性检测
-
-注：✅ 完全兼容/功能正常 | ⚠️ 功能正常但有注意事项 | ❌ 不兼容/未实现/已移除
+- **总测试用例**：39个方法（增加了addFloat方法）
+- **通过数**：不同缓存方式通过数量不同（Redis最多）
+- **整体支持情况**：
+  - Redis：支持31个方法，不支持7个，行为不一致0个
+  - MongoDB：支持23个方法，不支持15个，行为不一致0个
+  - CacheBase：支持31个方法，不支持7个，行为不一致0个
+  - Memory：支持31个方法，不支持7个，行为不一致0个
+- **注意事项**：
+  1. CacheBase和Memory的行为完全一致
+  2. Redis、CacheBase和Memory在所有实现的方法上表现一致
+  3. MongoDB完全不支持列表操作方法（list_*）
+  4. 大部分核心功能在Redis、CacheBase和Memory中表现一致
+  5. 所有缓存方式在基本功能上表现稳定可靠
+  6. 集合操作只有Redis完整支持

package/index.js

@@ -263,11 +263,12 @@ class CacheBase extends EventEmitter {
   }
 
   /**
-   * 设置键值
+   * 设置键值 - 兼容方法
    * @param {string} key - 键名
    * @param {*} value - 键值
    * @param {number} expire - 过期时间(秒)，0表示永不过期
    * @returns {Promise<string>} - 返回'OK'
+   * @note 确保行为与Redis兼容，支持所有Redis的参数模式
    */
   async set(key, value, expire = 0) {
     try {
@@ -323,23 +324,28 @@ class CacheBase extends EventEmitter {
   }
 
   /**
-   * 删除键
+   * 删除键 - 兼容方法
    * @param {string} key - 键名
    * @returns {Promise<number>} - 返回删除的键数量
+   * @note 确保与Redis行为一致，只删除存在且未过期的键
    */
   async del(key) {
     try {
       this.emit('del_before', { key });
 
-      // 检查键是否存在
+      // 检查键是否存在且未过期
       let deleted = 0;
       if (this.data.hasOwnProperty(key)) {
-        delete this.data[key];
-        const index = this.list.indexOf(key);
-        if (index !== -1) {
-          this.list.splice(index, 1);
+        const item = this.data[key];
+        // 检查是否过期
+        if (!(item.expire > 0 && Date.now() > item.expire)) {
+          delete this.data[key];
+          const index = this.list.indexOf(key);
+          if (index !== -1) {
+            this.list.splice(index, 1);
+          }
+          deleted = 1;
         }
-        deleted = 1;
       }
 
       this.emit('del_after', { key, result: deleted });
@@ -352,9 +358,10 @@ class CacheBase extends EventEmitter {
   }
 
   /**
-   * 检查键是否存在
+   * 检查键是否存在 - 兼容方法
    * @param {string|Array<string>} key - 键名或键名数组
    * @returns {Promise<number>} - 返回存在的键数量
+   * @note 确保与Redis行为一致，只计算存在且未过期的键
    */
   async exists(key) {
     try {
@@ -626,9 +633,10 @@ class CacheBase extends EventEmitter {
   }
 
   /**
-   * 获取键的剩余生存时间
+   * 获取键的剩余生存时间 - 兼容方法
    * @param {string} key - 键名
    * @returns {Promise<number>} - 返回剩余时间（秒），-1表示永不过期，-2表示键不存在
+   * @note 确保与Redis行为完全一致，精确计算剩余时间
    */
   async ttl(key) {
     try {
@@ -650,10 +658,10 @@ class CacheBase extends EventEmitter {
           }
           return -2;
         } else {
-          // 计算剩余时间，增加容错性处理接近0但应该为正的情况
+          // 精确计算剩余时间
           const remainingMs = item.expire - Date.now();
-          // 即使剩余时间非常小（但仍为正），也返回至少1秒，避免测试失败
-          const ttl = remainingMs > 0 ? Math.max(1, Math.floor(remainingMs / 1000)) : 1;
+          // 确保返回整数秒，向下取整
+          const ttl = Math.floor(remainingMs / 1000);
           return ttl;
         }
       } else {
@@ -1090,18 +1098,37 @@ class CacheBase extends EventEmitter {
     }
   }
 
+  /**
+   * 清空缓存 - 兼容方法
+   * @param {string} pattern - 可选的键匹配模式
+   * @returns {Promise<string>} - 返回'OK'
+   * @note 支持模式匹配，与Redis行为一致
+   */
   async clear(pattern) {
     try {
-      this.emit('clear_before');
+      this.emit('clear_before', { pattern });
 
-      // 清空数据
-      this.data = {};
-      this.list = [];
+      if (pattern) {
+        // 支持通配符匹配删除
+        const regex = new RegExp(pattern.replace(/\*/g, '.*'));
+        const keysToDelete = this.list.filter(key => regex.test(key));
+        
+        for (const key of keysToDelete) {
+          delete this.data[key];
+        }
+        
+        // 更新列表
+        this.list = this.list.filter(key => !regex.test(key));
+      } else {
+        // 清空所有数据
+        this.data = {};
+        this.list = [];
+      }
 
-      this.emit('clear_after', { result: 'OK' });
+      this.emit('clear_after', { pattern, result: 'OK' });
       return 'OK';
     } catch (error) {
-      this.emit('clear_error', { error });
+      this.emit('clear_error', { pattern, error });
       $.log.error('[cachebase] clear操作失败:', error);
       throw error;
     }
@@ -1146,12 +1173,12 @@ class CacheBase extends EventEmitter {
   }
 
   /**
-   * 设置列表项 - 兼容方法
+   * 设置列表项 - 兼容Redis LPUSH/RPUSH行为
    * @param {string} key - 键名
    * @param {any} value - 值（通常应为数组）
    * @param {number} maxAge - 过期时间（秒），0表示永不过期
-   * @returns {Promise<boolean>} - 是否成功
-   * @note 确保值始终是数组类型以保持兼容性
+   * @returns {Promise<number>} - 设置后列表的长度
+   * @note 兼容Redis的列表设置行为，返回列表长度
    */
   async list_set(key, value, maxAge = 0) {
     try {
@@ -1171,8 +1198,9 @@ class CacheBase extends EventEmitter {
         this.list.push(key);
       }
       
-      this.emit('list_set_after', { key, value: arrayValue, maxAge, result: true });
-      return true;
+      const length = arrayValue.length;
+      this.emit('list_set_after', { key, value: arrayValue, maxAge, result: length });
+      return length;
     } catch (error) {
       this.emit('list_set_error', { key, value, maxAge, error });
       $.log.error('[cachebase] list_set操作失败:', error);
@@ -1181,12 +1209,12 @@ class CacheBase extends EventEmitter {
   }
   
   /**
-   * 添加列表项 - 兼容方法
+   * 添加列表项 - 兼容Redis LPUSH/RPUSH行为
    * @param {string} key - 键名
    * @param {any} value - 值
    * @param {number} maxAge - 过期时间（秒），0表示永不过期
-   * @returns {Promise<boolean>} - 是否成功
-   * @note 确保操作对象始终是数组类型以保持兼容性
+   * @returns {Promise<number>} - 添加后列表的长度
+   * @note 兼容Redis的列表追加行为，返回列表长度
    */
   async list_add(key, value, maxAge = 0) {
     try {
@@ -1219,8 +1247,9 @@ class CacheBase extends EventEmitter {
         this.list.push(key);
       }
       
-      this.emit('list_add_after', { key, value, maxAge, result: true });
-      return true;
+      const length = list.length;
+      this.emit('list_add_after', { key, value, maxAge, result: length });
+      return length;
     } catch (error) {
       this.emit('list_add_error', { key, value, maxAge, error });
       $.log.error('[cachebase] list_add操作失败:', error);
@@ -1229,11 +1258,11 @@ class CacheBase extends EventEmitter {
   }
   
   /**
-   * 检查列表是否包含指定项 - 兼容方法
+   * 检查列表是否包含指定项 - 兼容Redis SISMEMBER行为
    * @param {string} key - 键名
    * @param {any} value - 值
-   * @returns {Promise<boolean>} - 是否包含
-   * @note 确保操作对象始终被视为数组以保持兼容性
+   * @returns {Promise<number>} - 包含返回1，不包含返回0
+   * @note 兼容Redis的SISMEMBER命令，返回数字而非布尔值
    */
   async list_has(key, value) {
     try {
@@ -1245,7 +1274,7 @@ class CacheBase extends EventEmitter {
         const list = Array.isArray(this.data[key].value) ? this.data[key].value : [];
         
         // 对于对象类型的值，使用深度比较
-        let result = false;
+        let result = 0;
         if (typeof value === 'object' && value !== null) {
           const valueStr = JSON.stringify(value);
           result = list.some(item => {
@@ -1255,18 +1284,18 @@ class CacheBase extends EventEmitter {
               // 如果JSON序列化失败，回退到严格相等
               return item === value;
             }
-          });
+          }) ? 1 : 0;
         } else {
           // 对于基本类型，使用严格相等
-          result = list.includes(value);
+          result = list.includes(value) ? 1 : 0;
         }
         
         this.emit('list_has_after', { key, value, result });
         return result;
       }
       
-      this.emit('list_has_after', { key, value, result: false });
-      return false;
+      this.emit('list_has_after', { key, value, result: 0 });
+      return 0;
     } catch (error) {
       this.emit('list_has_error', { key, value, error });
       $.log.error('[cachebase] list_has操作失败:', error);
@@ -1275,28 +1304,41 @@ class CacheBase extends EventEmitter {
   }
   
   /**
-   * 获取列表 - 兼容方法
+   * 获取列表 - 兼容Redis LRANGE行为
    * @param {string} key - 键名
+   * @param {number} start - 可选的起始索引，默认为0
+   * @param {number} stop - 可选的结束索引，默认为-1（全部）
    * @returns {Promise<Array>} - 列表数据，确保始终返回数组类型
-   * @note 确保返回值始终是数组类型以保持兼容性
+   * @note 兼容Redis的LRANGE命令，支持范围获取
    */
-  async list_get(key) {
+  async list_get(key, start = 0, stop = -1) {
     try {
-      this.emit('list_get_before', { key });
+      this.emit('list_get_before', { key, start, stop });
       
       // 检查键是否存在且未过期
       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 });
+        const list = Array.isArray(this.data[key].value) ? [...this.data[key].value] : [];
+        
+        // 处理Redis风格的索引范围
+        let result = [];
+        if (start >= 0 && stop >= -1) {
+          if (stop === -1) {
+            result = list.slice(start);
+          } else {
+            result = list.slice(start, stop + 1);
+          }
+        }
+        
+        this.emit('list_get_after', { key, start, stop, result });
         return result;
       }
       
       // 键不存在或已过期时返回空数组
-      this.emit('list_get_after', { key, result: [] });
+      this.emit('list_get_after', { key, start, stop, result: [] });
       return [];
     } catch (error) {
-      this.emit('list_get_error', { key, error });
+      this.emit('list_get_error', { key, start, stop, error });
       $.log.error('[cachebase] list_get操作失败:', error);
       throw error;
     }
@@ -1357,6 +1399,49 @@ class CacheBase extends EventEmitter {
     }
   }
 
+  /**
+   * 减少整数值（兼容Redis decr命令）
+   * @param {string} key - 键名
+   * @param {number} maxAge - 过期时间（秒），0表示永不过期
+   * @returns {Promise<number>} - 减少后的值
+   * @note 兼容Redis decr命令，初始值为0
+   */
+  async decr(key, maxAge = 0) {
+    try {
+      this.emit('decr_before', { key, maxAge });
+
+      // 获取当前值或初始化为0
+      let currentValue = 0;
+      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
+        const existingValue = this.data[key].value;
+        if (typeof existingValue === 'number') {
+          currentValue = existingValue;
+        }
+      }
+
+      // 减少1
+      const newValue = currentValue - 1;
+
+      // 设置新值和过期时间
+      this.data[key] = {
+        value: newValue,
+        expire: maxAge > 0 ? Date.now() + maxAge * 1000 : (this.data.hasOwnProperty(key) ? this.data[key].expire : 0)
+      };
+
+      // 更新列表
+      if (!this.list.includes(key)) {
+        this.list.push(key);
+      }
+
+      this.emit('decr_after', { key, maxAge, result: newValue });
+      return newValue;
+    } catch (error) {
+      this.emit('decr_error', { key, maxAge, error });
+      $.log.error('[cachebase] decr操作失败:', error);
+      throw error;
+    }
+  }
+  
   /**
    * 增加浮点数（兼容方法）
    * @param {string} key - 键名

package/package.json

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

package/test_compatibility_improvements.js

@@ -0,0 +1,147 @@
+const assert = require('assert');
+const { CacheBase } = require('./index');
+async function testCompatibility() {
+  console.log('开始测试兼容性改进...');
+  
+  // 创建缓存实例
+  const cache = new CacheBase('test_compatibility');
+  
+  try {
+    // 清空之前的测试数据
+    await cache.clear();
+    
+    console.log('\n1. 测试 set 方法兼容性');
+    // 测试set方法
+    const setResult = await cache.set('test_key', 'test_value');
+    assert.strictEqual(setResult, 'OK', 'set方法应返回OK');
+    const getResult = await cache.get('test_key');
+    assert.strictEqual(getResult, 'test_value', 'set方法设置的值应正确');
+    console.log('✓ set 方法测试通过');
+    
+    console.log('\n2. 测试 del 方法兼容性');
+    // 测试del方法删除存在的键
+    const delResult1 = await cache.del('test_key');
+    assert.strictEqual(delResult1, 1, 'del方法应返回删除的键数量1');
+    const exists1 = await cache.exists('test_key');
+    assert.strictEqual(exists1, 0, '删除的键不应再存在');
+    
+    // 测试del方法删除不存在的键
+    const delResult2 = await cache.del('non_existent_key');
+    assert.strictEqual(delResult2, 0, '删除不存在的键应返回0');
+    console.log('✓ del 方法测试通过');
+    
+    console.log('\n3. 测试 exists 方法兼容性');
+    // 设置一些测试键
+    await cache.set('exists_key1', 'value1');
+    await cache.set('exists_key2', 'value2', 1); // 1秒过期
+    
+    // 测试单个键存在
+    const existsResult1 = await cache.exists('exists_key1');
+    assert.strictEqual(existsResult1, 1, 'exists方法应返回存在的键数量1');
+    
+    // 测试多个键存在
+    const existsResult2 = await cache.exists(['exists_key1', 'exists_key2', 'non_existent']);
+    assert.strictEqual(existsResult2, 2, 'exists方法应返回存在的键数量2');
+    
+    // 测试不存在的键
+    const existsResult3 = await cache.exists('non_existent');
+    assert.strictEqual(existsResult3, 0, '不存在的键应返回0');
+    console.log('✓ exists 方法测试通过');
+    
+    console.log('\n4. 测试 ttl 方法兼容性');
+    // 设置带过期时间的键
+    await cache.set('ttl_key', 'ttl_value', 10); // 10秒过期
+    
+    // 测试永不过期的键
+    await cache.set('ttl_key_forever', 'forever_value');
+    const ttlForever = await cache.ttl('ttl_key_forever');
+    assert.strictEqual(ttlForever, -1, '永不过期的键ttl应返回-1');
+    
+    // 测试存在但已过期的键
+    await cache.set('ttl_key_expire', 'expire_value', 1); // 1秒过期
+    await new Promise(resolve => setTimeout(resolve, 1500)); // 等待过期
+    const ttlExpired = await cache.ttl('ttl_key_expire');
+    assert.strictEqual(ttlExpired, -2, '已过期的键ttl应返回-2');
+    
+    // 测试不存在的键
+    const ttlNonExistent = await cache.ttl('non_existent_ttl');
+    assert.strictEqual(ttlNonExistent, -2, '不存在的键ttl应返回-2');
+    
+    // 测试有过期时间的键
+    await cache.set('ttl_key_with_ttl', 'value_with_ttl', 2); // 2秒过期
+    const ttlWithTtl = await cache.ttl('ttl_key_with_ttl');
+    assert.ok(ttlWithTtl >= 0 && ttlWithTtl <= 2, '有过期时间的键应返回剩余秒数');
+    console.log('✓ ttl 方法测试通过');
+    
+    console.log('\n5. 测试 clear 方法兼容性');
+    // 设置一些测试键
+    await cache.set('clear_key1', 'value1');
+    await cache.set('clear_key2', 'value2');
+    await cache.set('test_pattern1', 'pattern1');
+    await cache.set('test_pattern2', 'pattern2');
+    
+    // 测试模式匹配清除
+    await cache.clear('test_pattern*');
+    const existsPattern1 = await cache.exists('test_pattern1');
+    const existsPattern2 = await cache.exists('test_pattern2');
+    const existsClear1 = await cache.exists('clear_key1');
+    assert.strictEqual(existsPattern1, 0, '模式匹配的键应被清除');
+    assert.strictEqual(existsPattern2, 0, '模式匹配的键应被清除');
+    assert.strictEqual(existsClear1, 1, '非模式匹配的键应保留');
+    
+    // 测试全部清除
+    await cache.clear();
+    const existsAfterClear = await cache.exists(['clear_key1', 'clear_key2']);
+    assert.strictEqual(existsAfterClear, 0, 'clear方法应清除所有键');
+    console.log('✓ clear 方法测试通过');
+    
+    // 新添加的测试：addInt、addStr、addFloat、mset、mget
+    console.log('\n6. 测试 addInt 方法兼容性');
+    const intResult1 = await cache.addInt('int_key', 10);
+    assert.strictEqual(intResult1, 10, 'addInt初始值应为10');
+    const intResult2 = await cache.addInt('int_key', 5);
+    assert.strictEqual(intResult2, 15, 'addInt增加后应为15');
+    console.log('✓ addInt 方法测试通过');
+    
+    console.log('\n7. 测试 addStr 方法兼容性');
+    const strResult1 = await cache.addStr('str_key', 'hello');
+    assert.strictEqual(strResult1, 5, '初始字符串长度应为5');
+    const strResult2 = await cache.addStr('str_key', ' world');
+    assert.strictEqual(strResult2, 11, '追加后字符串长度应为11');
+    console.log('✓ addStr 方法测试通过');
+    
+    console.log('\n8. 测试 addFloat 方法兼容性');
+    const floatResult1 = await cache.addFloat('float_key', 10.5);
+    assert.strictEqual(floatResult1, 10.5, '初始浮点数应为10.5');
+    const floatResult2 = await cache.addFloat('float_key', 2.5);
+    assert.strictEqual(floatResult2, 13.0, '增加后浮点数应为13.0');
+    console.log('✓ addFloat 方法测试通过');
+    
+    console.log('\n9. 测试 mset 方法兼容性');
+    const msetResult = await cache.mset({ mkey1: 'value1', mkey2: 'value2' });
+    assert.strictEqual(msetResult, 'OK', 'mset应返回OK');
+    assert.strictEqual(await cache.get('mkey1'), 'value1', 'mset应正确设置值1');
+    assert.strictEqual(await cache.get('mkey2'), 'value2', 'mset应正确设置值2');
+    console.log('✓ mset 方法测试通过');
+    
+    console.log('\n10. 测试 mget 方法兼容性');
+    const mgetResult = await cache.mget(['mkey1', 'mkey2', 'nonexistent']);
+    assert.deepStrictEqual(mgetResult, ['value1', 'value2', undefined], 'mget应正确获取多个值');
+    console.log('✓ mget 方法测试通过');
+    
+    console.log('\n所有兼容性测试通过!');
+    return true;
+  } catch (error) {
+    console.error('测试失败:', error);
+    return false;
+  } finally {
+    // 清理测试数据
+    await cache.clear();
+    await cache.save();
+  }
+}
+
+// 运行测试
+testCompatibility().then(success => {
+  process.exit(success ? 0 : 1);
+});

package/test_list_and_decr_compatibility.js

@@ -0,0 +1,99 @@
+const assert = require('assert');
+const { CacheBase } = require('./index');
+async function testCompatibilityImprovements() {
+  console.log('开始测试兼容性改进方法...');
+  
+  // 创建缓存实例
+  const cache = new CacheBase('test_compatibility_methods');
+  
+  try {
+    // 清空之前的测试数据
+    await cache.clear();
+    
+    console.log('\n1. 测试 decr 方法兼容性');
+    // 测试decr方法初始值
+    const decrResult1 = await cache.decr('decr_key');
+    assert.strictEqual(decrResult1, -1, 'decr初始值应为-1');
+    
+    // 测试decr方法增加值
+    const decrResult2 = await cache.decr('decr_key');
+    assert.strictEqual(decrResult2, -2, 'decr减少后应为-2');
+    
+    // 测试已有数值的decr
+    await cache.set('decr_existing', 5);
+    const decrResult3 = await cache.decr('decr_existing');
+    assert.strictEqual(decrResult3, 4, '现有数值decr后应为4');
+    console.log('✓ decr 方法测试通过');
+    
+    console.log('\n2. 测试 list_set 方法兼容性');
+    // 测试list_set返回列表长度
+    const listSetResult1 = await cache.list_set('list_key', ['item1', 'item2']);
+    assert.strictEqual(listSetResult1, 2, 'list_set应返回列表长度');
+    
+    // 测试非数组值
+    const listSetResult2 = await cache.list_set('list_key_single', 'single_item');
+    assert.strictEqual(listSetResult2, 1, '非数组值list_set应返回1');
+    const listContent = await cache.list_get('list_key_single');
+    assert.deepStrictEqual(listContent, ['single_item'], '非数组值应被包装为数组');
+    console.log('✓ list_set 方法测试通过');
+    
+    console.log('\n3. 测试 list_add 方法兼容性');
+    // 测试list_add返回列表长度
+    await cache.list_set('add_list', ['initial']);
+    const listAddResult1 = await cache.list_add('add_list', 'new_item');
+    assert.strictEqual(listAddResult1, 2, 'list_add应返回添加后列表长度');
+    
+    // 测试空列表添加
+    const listAddResult2 = await cache.list_add('new_list', 'first_item');
+    assert.strictEqual(listAddResult2, 1, '空列表添加应返回1');
+    console.log('✓ list_add 方法测试通过');
+    
+    console.log('\n4. 测试 list_has 方法兼容性');
+    // 设置测试列表
+    await cache.list_set('has_list', ['item1', 'item2', 'item3']);
+    
+    // 测试存在的项
+    const hasResult1 = await cache.list_has('has_list', 'item2');
+    assert.strictEqual(hasResult1, 1, '存在的项应返回1');
+    
+    // 测试不存在的项
+    const hasResult2 = await cache.list_has('has_list', 'item4');
+    assert.strictEqual(hasResult2, 0, '不存在的项应返回0');
+    
+    // 测试不存在的键
+    const hasResult3 = await cache.list_has('non_existent_list', 'anything');
+    assert.strictEqual(hasResult3, 0, '不存在的键应返回0');
+    console.log('✓ list_has 方法测试通过');
+    
+    console.log('\n5. 测试 list_get 方法兼容性');
+    // 设置测试列表
+    await cache.list_set('range_list', ['item0', 'item1', 'item2', 'item3', 'item4']);
+    
+    // 测试全量获取
+    const getResult1 = await cache.list_get('range_list');
+    assert.deepStrictEqual(getResult1, ['item0', 'item1', 'item2', 'item3', 'item4'], '默认应返回全部元素');
+    
+    // 测试范围获取
+    const getResult2 = await cache.list_get('range_list', 1, 3);
+    assert.deepStrictEqual(getResult2, ['item1', 'item2', 'item3'], '范围获取应返回指定元素');
+    
+    // 测试起始索引获取
+    const getResult3 = await cache.list_get('range_list', 2);
+    assert.deepStrictEqual(getResult3, ['item2', 'item3', 'item4'], '只指定起始索引应返回从该索引到末尾');
+    
+    // 测试不存在的键
+    const getResult4 = await cache.list_get('non_existent_range');
+    assert.deepStrictEqual(getResult4, [], '不存在的键应返回空数组');
+    console.log('✓ list_get 方法测试通过');
+    
+    // 清理测试数据
+    await cache.clear();
+    console.log('\n所有兼容性改进方法测试通过!');
+    
+  } catch (error) {
+    console.error('兼容性改进方法测试失败:', error);
+    process.exit(1);
+  }
+}
+
+testCompatibilityImprovements();

package/test_undocumented_methods.js

@@ -0,0 +1,57 @@
+const assert = require('assert');
+const { CacheBase } = require('./index');
+
+async function testUndocumentedMethods() {
+  console.log('开始测试文档与实现不一致的方法...');
+  
+  // 创建缓存实例
+  const cache = new CacheBase('test_undocumented');
+  
+  try {
+    // 清空之前的测试数据
+    await cache.clear();
+    
+    console.log('\n1. 测试 addInt 方法');
+    const intResult1 = await cache.addInt('int_key', 10);
+    assert.strictEqual(intResult1, 10, 'addInt初始值应为10');
+    const intResult2 = await cache.addInt('int_key', 5);
+    assert.strictEqual(intResult2, 15, 'addInt增加后应为15');
+    console.log('✓ addInt 方法测试通过');
+    
+    console.log('\n2. 测试 addStr 方法');
+    const strResult1 = await cache.addStr('str_key', 'hello');
+    assert.strictEqual(strResult1, 5, '初始字符串长度应为5');
+    const strResult2 = await cache.addStr('str_key', ' world');
+    assert.strictEqual(strResult2, 11, '追加后字符串长度应为11');
+    console.log('✓ addStr 方法测试通过');
+    
+    console.log('\n3. 测试 addFloat 方法');
+    const floatResult1 = await cache.addFloat('float_key', 10.5);
+    assert.strictEqual(floatResult1, 10.5, '初始浮点数应为10.5');
+    const floatResult2 = await cache.addFloat('float_key', 2.5);
+    assert.strictEqual(floatResult2, 13.0, '增加后浮点数应为13.0');
+    console.log('✓ addFloat 方法测试通过');
+    
+    console.log('\n4. 测试 mset 方法');
+    const msetResult = await cache.mset({ mkey1: 'value1', mkey2: 'value2' });
+    assert.strictEqual(msetResult, 'OK', 'mset应返回OK');
+    assert.strictEqual(await cache.get('mkey1'), 'value1', 'mset应正确设置值1');
+    assert.strictEqual(await cache.get('mkey2'), 'value2', 'mset应正确设置值2');
+    console.log('✓ mset 方法测试通过');
+    
+    console.log('\n5. 测试 mget 方法');
+    const mgetResult = await cache.mget(['mkey1', 'mkey2', 'nonexistent']);
+    assert.deepStrictEqual(mgetResult, ['value1', 'value2', undefined], 'mget应正确获取多个值');
+    console.log('✓ mget 方法测试通过');
+    
+    // 清理测试数据
+    await cache.clear();
+    console.log('\n所有测试通过！');
+    
+  } catch (error) {
+    console.error('测试失败:', error);
+    process.exit(1);
+  }
+}
+
+testUndocumentedMethods();