mm_cachebase 1.4.6 → 1.6.0

package/index.js

@@ -1,2132 +1,939 @@
-require('mm_logs');
 const EventEmitter = require('events');
+require('mm_logs');
 
-// 简化版的CacheBase类，只包含事件触发核心功能
 class CacheBase extends EventEmitter {
-  constructor() {
+  /**
+   * 构造函数，初始化缓存
+   * @param {Object} options - 配置选项
+   */
+  constructor(options = {}) {
     super();
+    // 配置选项
+    this.options = options;
+    // 日志实例
+    this.log = options.log || $;
+    // 数据存储对象
     this.data = {};
-    this.dict = this.data; // 为了兼容test.js中的访问
-    this.list = []; // 为了兼容test.js，存储所有键
-  }
-
-  // 基本的set方法，包含事件触发
-  async set(key, value) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value, 
-          cancel: false 
-        };
-        this.emit('set_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(null);
-          return;
-        }
-
-        // 执行实际操作
-        this.data[key] = { value, expire: 0 };
-        
-        // 如果键不存在于列表中，添加到列表
-        if (!this.list.includes(key)) {
-          this.list.push(key);
+    // 键列表，用于存储所有的键名
+    this.list = [];
+    // 为了兼容旧版本，提供dict属性指向data
+    this.dict = this.data;
+  }
+
+  /**
+   * 检查键是否过期
+   * @private
+   * @param {string} key - 键名
+   * @returns {boolean} - 是否已过期
+   */
+  _checkExpire(key) {
+    if (this.data.hasOwnProperty(key)) {
+      const item = this.data[key];
+      if (item && typeof item === 'object' && item.expire > 0) {
+        // 检查是否过期
+        if (Date.now() > item.expire) {
+          // 删除过期键
+          this.del(key);
+          return true;
         }
-
-        // 触发后置事件
-        this.emit('set_after', { 
-          key, 
-          value, 
-          result: 1 
-        });
-        resolve(1);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('set_error', { 
-          key, 
-          value, 
-          error 
-        });
-        $.log.error('[cachebase] set操作失败:', error);
-        resolve(null);
       }
-    });
+    }
+    return false;
   }
 
-  // 基本的del方法，包含事件触发
-  async del(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          cancel: false 
-        };
-        this.emit('del_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 检查键是否存在
-        const exists = key in this.data;
-        
-        // 执行删除操作
-        if (exists) {
-          delete this.data[key];
-          // 从列表中移除
-          const index = this.list.indexOf(key);
-          if (index > -1) {
-            this.list.splice(index, 1);
-          }
-        }
-
-        // 触发后置事件
-        this.emit('del_after', { 
-          key, 
-          result: exists ? 1 : 0 
-        });
-        resolve(exists ? 1 : 0);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('del_error', { 
-          key, 
-          error 
-        });
-        $.log.error('[cachebase] del操作失败:', error);
-        resolve(0);
+  /**
+   * 设置键的过期时间
+   * @private
+   * @param {string} key - 键名
+   * @param {number} seconds - 过期时间（秒）
+   */
+  _setExpire(key, seconds) {
+    if (this.data.hasOwnProperty(key)) {
+      const item = this.data[key];
+      if (item && typeof item === 'object') {
+        item.expire = seconds > 0 ? Date.now() + seconds * 1000 : 0;
       }
-    });
+    }
   }
 
-  // 基本的get方法，包含事件触发
-  async get(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          cancel: false 
-        };
-        this.emit('get_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(null);
-          return;
-        }
-
-        // 执行实际操作
-        const obj = this.data[key];
-        let result = null;
-        if (obj) {
-          result = obj.value;
-        }
-
-        // 触发后置事件
-        this.emit('get_after', { 
-          key, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('get_error', { 
-          key, 
-          error 
-        });
-        $.log.error('[cachebase] get操作失败:', error);
-        resolve(null);
+  /**
+   * 设置键值
+   * @param {string} key - 键名
+   * @param {*} value - 键值
+   * @param {number} expire - 过期时间(秒)，0表示永不过期
+   * @returns {Promise<string>} - 返回'OK'
+   */
+  async set(key, value, expire = 0) {
+    try {
+      this.emit('set_before', { key, value, expire });
+      
+      // 设置值和过期时间
+      this.data[key] = { value, expire: expire > 0 ? Date.now() + expire * 1000 : 0 };
+      
+      // 如果键不存在于列表中，添加到列表
+      if (!this.list.includes(key)) {
+        this.list.push(key);
       }
-    });
+      
+      this.emit('set_after', { key, value, expire, result: 'OK' });
+      return 'OK';
+    } catch (error) {
+      this.emit('set_error', { key, value, expire, error });
+      this.log.error('[cachebase] set操作失败:', error);
+      throw error;
+    }
   }
 
-  // 哈希表设置方法
-  async hset(key, field, value) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件，将field作为value的一部分
-        const beforeEventData = { 
-          key, 
-          value: { field, value }, 
-          cancel: false 
-        };
-        this.emit('hset_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 确保哈希表存在
-        if (!this.data[key]) {
-          this.data[key] = { value: {}, expire: 0 };
-          // 添加到列表
-          if (!this.list.includes(key)) {
-            this.list.push(key);
-          }
-        } else if (typeof this.data[key].value !== 'object') {
-          this.data[key].value = {};
-        }
-
-        // 记录是否是新字段
-        const isNewField = !this.data[key].value.hasOwnProperty(field);
-        
-        // 设置字段值
-        this.data[key].value[field] = value;
-
-        // 触发后置事件
-        this.emit('hset_after', { 
-          key, 
-          value: { field, value }, 
-          result: isNewField ? 1 : 0 
-        });
-        resolve(isNewField ? 1 : 0);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('hset_error', { 
-          key, 
-          value: { field, value }, 
-          error 
-        });
-        $.log.error('[cachebase] hset操作失败:', error);
-        resolve(0);
+  /**
+   * 获取键值
+   * @param {string} key - 键名
+   * @returns {Promise<*>} - 返回键值，不存在返回undefined
+   */
+  async get(key) {
+    try {
+      // 检查键是否存在
+      if (!this.data.hasOwnProperty(key)) {
+        return undefined;
       }
-    });
-  }
-
-  // 列表头部推入方法
-  async lpush(key, ...values) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件，将values作为value的一部分
-        const beforeEventData = { 
-          key, 
-          value: { values }, 
-          cancel: false 
-        };
-        this.emit('lpush_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 确保列表存在
-        if (!this.data[key]) {
-          this.data[key] = { value: [], expire: 0 };
-          // 添加到列表
-          if (!this.list.includes(key)) {
-            this.list.push(key);
-          }
-        } else if (!Array.isArray(this.data[key].value)) {
-          this.data[key].value = [];
+      
+      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);
         }
-
-        // 将值添加到列表头部
-        this.data[key].value.unshift(...values);
-
-        // 触发后置事件
-        this.emit('lpush_after', { 
-          key, 
-          value: { values }, 
-          result: this.data[key].value.length 
-        });
-        resolve(this.data[key].value.length);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('lpush_error', { 
-          key, 
-          value: { values }, 
-          error 
-        });
-        $.log.error('[cachebase] lpush操作失败:', error);
-        resolve(0);
+        return undefined;
       }
-    });
+      
+      return item.value;
+    } catch (error) {
+      this.log.error('[cachebase] get操作失败:', error);
+      throw error;
+    }
   }
-
-  // 集合添加方法
-  async sadd(key, ...members) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件，将members作为value的一部分
-        const beforeEventData = { 
-          key, 
-          value: { members }, 
-          cancel: false 
-        };
-        this.emit('sadd_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 确保集合存在
-        if (!this.data[key]) {
-          this.data[key] = { value: new Set(), expire: 0 };
-          // 添加到列表
-          if (!this.list.includes(key)) {
-            this.list.push(key);
-          }
-        } else if (!(this.data[key].value instanceof Set)) {
-          this.data[key].value = new Set();
+  
+  /**
+   * 删除键
+   * @param {string} key - 键名
+   * @returns {Promise<number>} - 返回删除的键数量
+   */
+  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 beforeSize = this.data[key].value.size;
-        
-        // 添加成员
-        members.forEach(member => {
-          this.data[key].value.add(member);
-        });
-
-        // 计算新增的成员数
-        const addedCount = this.data[key].value.size - beforeSize;
-
-        // 触发后置事件
-        this.emit('sadd_after', { 
-          key, 
-          value: { members }, 
-          result: addedCount 
-        });
-        resolve(addedCount);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('sadd_error', { 
-          key, 
-          value: { members }, 
-          error 
-        });
-        $.log.error('[cachebase] sadd操作失败:', error);
-        resolve(0);
+        deleted = 1;
       }
-    });
+      
+      this.emit('del_after', { key, result: deleted });
+      return deleted;
+    } catch (error) {
+      this.emit('del_error', { key, error });
+      this.log.error('[cachebase] del操作失败:', error);
+      throw error;
+    }
   }
 
-  // 有序集合添加方法
-  async zadd(key, ...args) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件，将args作为value的一部分
-        const beforeEventData = { 
-          key, 
-          value: { args }, 
-          cancel: false 
-        };
-        this.emit('zadd_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 确保有序集合存在
-        if (!this.data[key]) {
-          this.data[key] = { value: { members: {}, sorted: [] }, expire: 0 };
-          // 添加到列表
-          if (!this.list.includes(key)) {
-            this.list.push(key);
+  /**
+   * 检查键是否存在
+   * @param {string|Array<string>} key - 键名或键名数组
+   * @returns {Promise<number>} - 返回存在的键数量
+   */
+  async exists(key) {
+    try {
+      let existsCount = 0;
+      
+      // 检查输入类型并处理
+      if (Array.isArray(key)) {
+        // 处理多键检查
+        for (const k of key) {
+          if (this.data.hasOwnProperty(k)) {
+            // 检查是否过期
+            const item = this.data[k];
+            if (!(item.expire > 0 && Date.now() > item.expire)) {
+              existsCount++;
+            }
           }
-        } else if (!this.data[key].value || !this.data[key].value.members) {
-          this.data[key].value = { members: {}, sorted: [] };
         }
-
-        let addedCount = 0;
-        
-        // 处理参数并添加成员
-        for (let i = 0; i < args.length; i += 2) {
-          const score = parseFloat(args[i]);
-          const member = args[i + 1];
-          
-          // 如果成员不存在，则计数增加
-          if (!this.data[key].value.members.hasOwnProperty(member)) {
-            addedCount++;
+      } else {
+        // 处理单键检查
+        if (this.data.hasOwnProperty(key)) {
+          // 检查是否过期
+          const item = this.data[key];
+          if (!(item.expire > 0 && Date.now() > item.expire)) {
+            existsCount = 1;
           }
-          
-          // 设置成员分数
-          this.data[key].value.members[member] = score;
         }
-
-        // 更新排序
-        this.data[key].value.sorted = Object.entries(this.data[key].value.members)
-          .sort((a, b) => a[1] - b[1])
-          .map(entry => entry[0]);
-
-        // 触发后置事件
-        this.emit('zadd_after', { 
-          key, 
-          value: { args }, 
-          result: addedCount 
-        });
-        resolve(addedCount);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('zadd_error', { 
-          key, 
-          value: { args }, 
-          error 
-        });
-        $.log.error('[cachebase] zadd操作失败:', error);
-        resolve(0);
       }
-    });
+      
+      return existsCount;
+    } catch (error) {
+      this.log.error('[cachebase] exists操作失败:', error);
+      throw error;
+    }
   }
 
-  // 修复的mset方法
-  async mset(...args) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件，将args作为value的一部分
-        const beforeEventData = { 
-          value: { args }, 
-          cancel: false 
-        };
-        this.emit('mset_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve('');
-          return;
-        }
-
-        // 参数校验
-        if (args.length % 2 !== 0) {
-          $.log.error('[cachebase] [cachebase] mset参数数量不正确');
-          resolve('ERR');
-          return;
-        }
-
-        // 执行实际操作
-        for (let i = 0; i < args.length; i += 2) {
-          const key = args[i];
-          const value = args[i + 1];
-          this.data[key] = { value, expire: 0 };
-          // 添加到列表
-          if (!this.list.includes(key)) {
-            this.list.push(key);
-          }
-        }
-
-        // 触发后置事件
-        this.emit('mset_after', { 
-          value: { args }, 
-          result: 'OK' 
-        });
-        resolve('OK');
-      } catch (error) {
-        // 触发错误事件
-        this.emit('mset_error', { 
-          value: { args }, 
-          error 
-        });
-        $.log.error('[cachebase] mset操作失败:', error);
-        resolve('ERR');
+  /**
+   * 设置哈希表字段
+   * @param {string} key - 键名
+   * @param {string} field - 字段名
+   * @param {*} value - 字段值
+   * @returns {Promise<number>} - 返回1表示新建字段，0表示更新字段
+   */
+  async hset(key, field, value) {
+    try {
+      this.emit('hset_before', { key, field, value });
+      
+      // 初始化哈希表
+      if (!this.data.hasOwnProperty(key)) {
+        this.data[key] = { value: {}, expire: 0 };
+        this.list.push(key);
+      } else if (this.data[key].expire > 0 && Date.now() > this.data[key].expire) {
+        // 键已过期，重新初始化
+        this.data[key] = { value: {}, expire: 0 };
+      } else if (typeof this.data[key].value !== 'object') {
+        // 类型错误
+        throw new Error(`[cachebase] 键 ${key} 不是哈希表类型`);
       }
-    });
+      
+      // 检查字段是否存在
+      const isNewField = !this.data[key].value.hasOwnProperty(field);
+      this.data[key].value[field] = value;
+      
+      const result = isNewField ? 1 : 0;
+      this.emit('hset_after', { key, field, value, result });
+      return result;
+    } catch (error) {
+      this.emit('hset_error', { key, field, value, error });
+      this.log.error('[cachebase] hset操作失败:', error);
+      throw error;
+    }
   }
 
-  // 浮点数加法方法
-  async addFloat(key, value) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件，将value作为浮点数
-        const beforeEventData = { 
-          key, 
-          value: parseFloat(value), 
-          cancel: false 
-        };
-        this.emit('addFloat_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 获取当前值或默认为0
-        let currentValue = 0;
-        if (this.data[key] && typeof this.data[key].value === 'number') {
-          currentValue = this.data[key].value;
-        }
-
-        // 执行加法
-        const result = currentValue + parseFloat(value);
-        
-        // 保存结果
-        this.data[key] = { value: result, expire: 0 };
-        // 添加到列表
-        if (!this.list.includes(key)) {
-          this.list.push(key);
-        }
-
-        // 触发后置事件
-        this.emit('addFloat_after', { 
-          key, 
-          value: parseFloat(value), 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('addFloat_error', { 
-          key, 
-          value: parseFloat(value), 
-          error 
-        });
-        $.log.error('[cachebase] addFloat操作失败:', error);
-        resolve(0);
+  /**
+   * 获取哈希表字段
+   * @param {string} key - 键名
+   * @param {string} field - 字段名
+   * @returns {Promise<*>} - 返回字段值，不存在返回undefined
+   */
+  async hget(key, field) {
+    try {
+      // 检查键是否存在且未过期
+      if (!this.data.hasOwnProperty(key) || 
+          (this.data[key].expire > 0 && Date.now() > this.data[key].expire) ||
+          typeof this.data[key].value !== 'object') {
+        return undefined;
       }
-    });
+      
+      return this.data[key].value[field];
+    } catch (error) {
+      this.log.error('[cachebase] hget操作失败:', error);
+      throw error;
+    }
   }
 
-  // 字符串添加方法
-  async addStr(key, value) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件，将value作为字符串
-        const beforeEventData = { 
-          key, 
-          value: String(value), 
-          cancel: false 
-        };
-        this.emit('addStr_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 获取当前值或默认为空字符串
-        let currentValue = '';
-        if (this.data[key] && typeof this.data[key].value === 'string') {
-          currentValue = this.data[key].value;
-        }
-
-        // 执行字符串拼接
-        const result = currentValue + value;
-        
-        // 保存结果
-        this.data[key] = { value: result, expire: 0 };
-        // 添加到列表
-        if (!this.list.includes(key)) {
-          this.list.push(key);
-        }
-
-        // 触发后置事件
-        this.emit('addStr_after', { 
-          key, 
-          value: String(value), 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('addStr_error', { 
-          key, 
-          value: String(value), 
-          error 
-        });
-        $.log.error('[cachebase] addStr操作失败:', error);
-        resolve(0);
+  /**
+   * 获取哈希表所有字段
+   * @param {string} key - 键名
+   * @returns {Promise<Object>} - 返回哈希表对象，不存在或不是哈希表返回{}
+   */
+  async hgetall(key) {
+    try {
+      // 检查键是否存在且未过期
+      if (!this.data.hasOwnProperty(key) || 
+          (this.data[key].expire > 0 && Date.now() > this.data[key].expire) ||
+          typeof this.data[key].value !== 'object') {
+        return {};
       }
-    });
+      
+      // 返回哈希表的副本
+      return { ...this.data[key].value };
+    } catch (error) {
+      this.log.error('[cachebase] hgetall操作失败:', error);
+      throw error;
+    }
   }
 
-  // 整数加法方法
-  async add(key, value) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件，将value作为整数
-        const beforeEventData = { 
-          key, 
-          value: parseInt(value, 10), 
-          cancel: false 
-        };
-        this.emit('add_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 获取当前值或默认为0
-        let currentValue = 0;
-        if (this.data[key] && typeof this.data[key].value === 'number') {
-          currentValue = this.data[key].value;
-        }
-
-        // 执行整数加法
-        const result = currentValue + parseInt(value, 10);
-        
-        // 保存结果
-        this.data[key] = { value: result, expire: 0 };
-        // 添加到列表
-        if (!this.list.includes(key)) {
-          this.list.push(key);
-        }
-
-        // 触发后置事件
-        this.emit('add_after', { 
-          key, 
-          value: parseInt(value, 10), 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('add_error', { 
-          key, 
-          value: parseInt(value, 10), 
-          error 
-        });
-        $.log.error('[cachebase] add操作失败:', error);
-        resolve(0);
+  /**
+   * 删除哈希表字段
+   * @param {string} key - 键名
+   * @param {string} field - 字段名
+   * @returns {Promise<number>} - 返回删除的字段数量
+   */
+  async hdel(key, field) {
+    try {
+      this.emit('hdel_before', { key, field });
+      
+      // 检查键是否存在且未过期
+      if (!this.data.hasOwnProperty(key) || 
+          (this.data[key].expire > 0 && Date.now() > this.data[key].expire) ||
+          typeof this.data[key].value !== 'object' ||
+          !this.data[key].value.hasOwnProperty(field)) {
+        this.emit('hdel_after', { key, field, result: 0 });
+        return 0;
       }
-    });
-  }
-
-  // 列表设置方法 - 修改为兼容test.js
-  async list_set(key, value) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value, 
-          cancel: false 
-        };
-        this.emit('list_set_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 确保值是数组
-        if (!Array.isArray(value)) {
-          this.emit('list_set_error', { 
-            key, 
-            value, 
-            error: new Error('值必须是数组') 
-          });
-          resolve(0);
-          return;
-        }
-
-        // 设置数组
-        this.data[key] = { value, expire: 0 };
-        // 添加到列表
-        if (!this.list.includes(key)) {
-          this.list.push(key);
+      
+      // 删除字段
+      delete this.data[key].value[field];
+      
+      // 检查哈希表是否为空
+      const hashKeys = Object.keys(this.data[key].value);
+      if (hashKeys.length === 0) {
+        // 删除空哈希表
+        delete this.data[key];
+        const index = this.list.indexOf(key);
+        if (index !== -1) {
+          this.list.splice(index, 1);
         }
-
-        // 触发后置事件
-        this.emit('list_set_after', { 
-          key, 
-          value, 
-          result: 1 
-        });
-        resolve(1);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('list_set_error', { 
-          key, 
-          value, 
-          error 
-        });
-        $.log.error('[cachebase] list_set操作失败:', error);
-        resolve(0);
       }
-    });
+      
+      this.emit('hdel_after', { key, field, result: 1 });
+      return 1;
+    } catch (error) {
+      this.emit('hdel_error', { key, field, error });
+      this.log.error('[cachebase] hdel操作失败:', error);
+      throw error;
+    }
   }
 
-  // 列表添加元素方法
-  async list_add(key, value) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value, 
-          cancel: false 
-        };
-        this.emit('list_add_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 确保列表存在
-        if (!this.data[key]) {
-          this.data[key] = { value: [], expire: 0 };
-          // 添加到列表
+  /**
+   * 批量设置键值
+   * @param {Object} keyValues - 键值对对象
+   * @returns {Promise<string>} - 返回'OK'
+   */
+  async mset(keyValues) {
+    try {
+      this.emit('mset_before', { keyValues });
+      
+      if (typeof keyValues !== 'object' || keyValues === null) {
+        throw new Error('[cachebase] mset参数必须是对象');
+      }
+      
+      // 批量设置键值
+      for (const key in keyValues) {
+        if (keyValues.hasOwnProperty(key)) {
+          this.data[key] = { value: keyValues[key], expire: 0 };
           if (!this.list.includes(key)) {
             this.list.push(key);
           }
-        } else if (!Array.isArray(this.data[key].value)) {
-          this.data[key].value = [];
         }
-
-        // 添加元素到列表末尾
-        this.data[key].value.push(value);
-
-        // 触发后置事件
-        this.emit('list_add_after', { 
-          key, 
-          value, 
-          result: this.data[key].value.length 
-        });
-        resolve(this.data[key].value.length);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('list_add_error', { 
-          key, 
-          value, 
-          error 
-        });
-        $.log.error('[cachebase] list_add操作失败:', error);
-        resolve(0);
       }
-    });
+      
+      this.emit('mset_after', { keyValues, result: 'OK' });
+      return 'OK';
+    } catch (error) {
+      this.emit('mset_error', { keyValues, error });
+      this.log.error('[cachebase] mset操作失败:', error);
+      throw error;
+    }
   }
 
-  // 列表清空方法
-  async list_clear(key, newValue) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          cancel: false 
-        };
-        this.emit('list_clear_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 检查键是否存在且值为数组
-        if (this.data[key] && Array.isArray(this.data[key].value)) {
-          // 如果提供了新值且是数组，则替换
-          if (newValue && Array.isArray(newValue)) {
-            this.data[key].value = newValue;
+  /**
+   * 批量获取键值
+   * @param {Array<string>} keys - 键名数组
+   * @returns {Promise<Array>} - 返回值数组
+   */
+  async mget(keys) {
+    try {
+      if (!Array.isArray(keys)) {
+        throw new Error('[cachebase] mget参数必须是数组');
+      }
+      
+      // 批量获取键值
+      const results = [];
+      for (const key of keys) {
+        if (this.data.hasOwnProperty(key)) {
+          // 检查是否过期
+          const item = this.data[key];
+          if (item.expire === 0 || Date.now() <= item.expire) {
+            results.push(item.value);
           } else {
-            // 否则清空数组
-            this.data[key].value = [];
-          }
-          
-          // 触发后置事件
-          this.emit('list_clear_after', { 
-            key, 
-            result: 1 
-          });
-          resolve(1);
-        } else {
-          // 键不存在或值不是数组，如果提供了新值，则设置
-          if (newValue && Array.isArray(newValue)) {
-            this.data[key] = { value: newValue, expire: 0 };
-            // 添加到列表
-            if (!this.list.includes(key)) {
-              this.list.push(key);
+            // 删除过期键
+            delete this.data[key];
+            const index = this.list.indexOf(key);
+            if (index !== -1) {
+              this.list.splice(index, 1);
             }
-            this.emit('list_clear_after', { 
-              key, 
-              result: 1 
-            });
-            resolve(1);
-          } else {
-            this.emit('list_clear_after', { 
-              key, 
-              result: 0 
-            });
-            resolve(0);
-          }
-        }
-      } catch (error) {
-        // 触发错误事件
-        this.emit('list_clear_error', { 
-          key, 
-          error 
-        });
-        $.log.error('[cachebase] list_clear操作失败:', error);
-        resolve(0);
-      }
-    });
-  }
-
-  // 仅当键不存在时设置值方法
-  async setnx(key, value) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value, 
-          cancel: false 
-        };
-        this.emit('setnx_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 检查键是否不存在
-        if (!this.data.hasOwnProperty(key)) {
-          // 设置值
-          this.data[key] = { value, expire: 0 };
-          // 添加到列表
-          if (!this.list.includes(key)) {
-            this.list.push(key);
+            results.push(undefined);
           }
-          
-          // 触发后置事件
-          this.emit('setnx_after', { 
-            key, 
-            value, 
-            result: 1 
-          });
-          resolve(1);
         } else {
-          // 键已存在
-          this.emit('setnx_after', { 
-            key, 
-            value, 
-            result: 0 
-          });
-          resolve(0);
+          results.push(undefined);
         }
-      } catch (error) {
-        // 触发错误事件
-        this.emit('setnx_error', { 
-          key, 
-          value, 
-          error 
-        });
-        $.log.error('[cachebase] setnx操作失败:', error);
-        resolve(0);
       }
-    });
+      
+      return results;
+    } catch (error) {
+      this.log.error('[cachebase] mget操作失败:', error);
+      throw error;
+    }
   }
 
-  // 设置带过期时间的键值对方法
-  async setex(key, seconds, value) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件，使用ttl替代seconds
-        const beforeEventData = { 
-          key, 
-          value, 
-          ttl: parseInt(seconds, 10), 
-          cancel: false 
-        };
-        this.emit('setex_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 计算过期时间
-        const expireTime = Date.now() + (parseInt(seconds, 10) * 1000);
-        
-        // 设置值和过期时间
-        this.data[key] = { value, expire: expireTime };
-        // 添加到列表
-        if (!this.list.includes(key)) {
-          this.list.push(key);
-        }
-
-        // 触发后置事件，使用ttl替代seconds
-        this.emit('setex_after', { 
-          key, 
-          value, 
-          ttl: parseInt(seconds, 10), 
-          result: "OK" 
-        });
-        resolve("OK");
-      } catch (error) {
-        // 触发错误事件，使用ttl替代seconds
-        this.emit('setex_error', { 
-          key, 
-          value, 
-          ttl: parseInt(seconds, 10), 
-          error 
-        });
-        $.log.error('[cachebase] setex操作失败:', error);
-        resolve(0);
+  /**
+   * 获取键的剩余生存时间
+   * @param {string} key - 键名
+   * @returns {Promise<number>} - 返回剩余时间（秒），-1表示永不过期，-2表示键不存在
+   */
+  async ttl(key) {
+    try {
+      // 检查键是否存在
+      if (!this.data.hasOwnProperty(key)) {
+        return -2;
       }
-    });
-  }
-
-  // 修复的setrange方法
-  async setrange(key, index, value) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件，将index和value作为value的一部分
-        const beforeEventData = { 
-          key, 
-          value: { index, value }, 
-          cancel: false 
-        };
-        this.emit('setrange_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve('ERR');
-          return;
-        }
-
-        const obj = this.data[key];
-        if (obj) {
-          // 确保值为字符串类型
-          let val = String(obj.value || '');
-          index = Math.max(0, parseInt(index) || 0);
-
-          // 处理index超出字符串长度的情况
-          if (index > val.length) {
-            // 填充空白字符
-            val = val.padEnd(index, '');
+      
+      const item = this.data[key];
+      
+      // 检查是否过期
+      if (item.expire > 0) {
+        if (Date.now() > item.expire) {
+          // 键已过期，删除并返回-2
+          delete this.data[key];
+          const index = this.list.indexOf(key);
+          if (index !== -1) {
+            this.list.splice(index, 1);
           }
-
-          const start = val.substring(0, index);
-          const end = val.substring(index, val.length);
-          obj.value = start + value + end;
-
-          // 触发后置事件
-          this.emit('setrange_after', { 
-            key, 
-            value: { index, value }, 
-            result: obj.value.length 
-          });
-          resolve(obj.value.length);
+          return -2;
         } else {
-          resolve('ERR');
+          // 计算剩余时间
+          const ttl = Math.floor((item.expire - Date.now()) / 1000);
+          return ttl;
         }
-      } catch (error) {
-        // 触发错误事件
-        this.emit('setrange_error', { 
-          key, 
-          value: { index, value }, 
-          error 
-        });
-        $.log.error('[cachebase] setrange操作失败:', error);
-        resolve('ERR');
+      } else {
+        // 永不过期
+        return -1;
       }
-    });
+    } catch (error) {
+      this.log.error('[cachebase] ttl操作失败:', error);
+      throw error;
+    }
   }
 
-  // 新增：列表获取方法，包含事件触发
-  async list_get(key, start = 0, end = -1) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value: { start, end }, 
-          cancel: false 
-        };
-        this.emit('list_get_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve([]);
-          return;
-        }
-
-        // 执行实际操作
-        const obj = this.data[key];
-        let result = [];
-        if (obj && Array.isArray(obj.value)) {
-          if (end === -1) {
-            result = obj.value.slice(start);
-          } else {
-            result = obj.value.slice(start, end + 1);
-          }
-        }
-
-        // 触发后置事件
-        this.emit('list_get_after', { 
-          key, 
-          value: { start, end }, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('list_get_error', { 
-          key, 
-          value: { start, end }, 
-          error 
-        });
-        $.log.error('[cachebase] list_get操作失败:', error);
-        resolve([]);
+  /**
+   * 设置键的过期时间
+   * @param {string} key - 键名
+   * @param {number} seconds - 过期时间（秒）
+   * @returns {Promise<number>} - 返回1表示设置成功，0表示键不存在
+   */
+  async expire(key, seconds) {
+    try {
+      this.emit('expire_before', { key, seconds });
+      
+      // 检查键是否存在
+      if (!this.data.hasOwnProperty(key)) {
+        this.emit('expire_after', { key, seconds, result: 0 });
+        return 0;
       }
-    });
-  }
-
-  // 新增：字符串范围获取方法，包含事件触发
-  async getrange(key, start, end) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value: { start, end }, 
-          cancel: false 
-        };
-        this.emit('getrange_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve('');
-          return;
-        }
-
-        // 执行实际操作
-        const obj = this.data[key];
-        let result = '';
-        if (obj && typeof obj.value === 'string') {
-          // 处理负数索引
-          if (start < 0) start = Math.max(0, obj.value.length + start);
-          if (end < 0) end = Math.max(0, obj.value.length + end);
-          
-          // 确保索引在有效范围内
-          start = Math.max(0, start);
-          end = Math.min(obj.value.length - 1, end);
-          
-          if (start <= end) {
-            result = obj.value.substring(start, end + 1);
-          }
-        }
-
-        // 触发后置事件
-        this.emit('getrange_after', { 
-          key, 
-          value: { start, end }, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('getrange_error', { 
-          key, 
-          value: { start, end }, 
-          error 
-        });
-        $.log.error('[cachebase] getrange操作失败:', error);
-        resolve('');
+      
+      // 检查是否已过期
+      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('expire_after', { key, seconds, result: 0 });
+        return 0;
       }
-    });
+      
+      // 设置过期时间
+      this.data[key].expire = Date.now() + seconds * 1000;
+      
+      this.emit('expire_after', { key, seconds, result: 1 });
+      return 1;
+    } catch (error) {
+      this.emit('expire_error', { key, seconds, error });
+      this.log.error('[cachebase] expire操作失败:', error);
+      throw error;
+    }
   }
 
-  // 新增：列表包含检查方法，包含事件触发
-  async list_has(key, value) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value, 
-          cancel: false 
-        };
-        this.emit('list_has_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 执行实际操作
-        const obj = this.data[key];
-        let result = 0;
-        if (obj && Array.isArray(obj.value)) {
-          result = obj.value.includes(value) ? 1 : 0;
-        }
-
-        // 触发后置事件
-        this.emit('list_has_after', { 
-          key, 
-          value, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('list_has_error', { 
-          key, 
-          value, 
-          error 
-        });
-        $.log.error('[cachebase] list_has操作失败:', error);
-        resolve(0);
+  /**
+   * 移除键的过期时间
+   * @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;
       }
-    });
-  }
-
-  // 检查键是否存在方法，包含事件触发
-  async exists(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          cancel: false 
-        };
-        this.emit('exists_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 执行实际操作
-        const result = key in this.data ? 1 : 0;
-
-        // 触发后置事件
-        this.emit('exists_after', { 
-          key, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('exists_error', { 
-          key, 
-          error 
-        });
-        $.log.error('[cachebase] exists操作失败:', error);
-        resolve(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;
       }
-    });
+      
+      // 检查是否有过期时间
+      if (item.expire === 0) {
+        // 没有过期时间，返回0
+        this.emit('persist_after', { key, result: 0 });
+        return 0;
+      }
+      
+      // 移除过期时间
+      this.data[key].expire = 0;
+      
+      this.emit('persist_after', { key, result: 1 });
+      return 1;
+    } catch (error) {
+      this.emit('persist_error', { key, error });
+      this.log.error('[cachebase] persist操作失败:', error);
+      throw error;
+    }
   }
 
-  // 检查键是否存在的别名方法，包含事件触发
-  async has(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          cancel: false 
-        };
-        this.emit('has_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 执行实际操作
-        const result = key in this.data ? 1 : 0;
-
-        // 触发后置事件
-        this.emit('has_after', { 
-          key, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('has_error', { 
-          key, 
-          error 
-        });
-        $.log.error('[cachebase] has操作失败:', error);
-        resolve(0);
+  /**
+   * 获取所有键名
+   * @param {string} pattern - 模式匹配
+   * @returns {Promise<Array>} - 返回键名数组
+   */
+  async keys(pattern = '*') {
+    try {
+      // 支持通配符匹配
+      let filteredKeys = [];
+      if (pattern === '*') {
+        // 通配符匹配所有
+        filteredKeys = [...this.list];
+      } else {
+        // 简单的通配符匹配
+        const regex = new RegExp(pattern.replace(/\*/g, '.*'));
+        filteredKeys = this.list.filter(key => regex.test(key));
       }
-    });
+      
+      return filteredKeys;
+    } catch (error) {
+      this.log.error('[cachebase] keys操作失败:', error);
+      throw error;
+    }
   }
 
-  // 查询/设置过期时间方法，包含事件触发
-  async ttl(key, maxAge) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value: maxAge !== undefined ? { ttl: maxAge } : undefined,
-          cancel: false 
-        };
-        this.emit('ttl_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(maxAge !== undefined ? 0 : -2);
-          return;
-        }
-
-        // 执行实际操作
-        const obj = this.data[key];
-        let result;
-        
-        if (!obj) {
-          result = -2; // 键不存在
-        } else if (maxAge !== undefined) {
-          // 设置过期时间
-          if (maxAge === -1) {
-            obj.expire = 0; // 永不过期
-          } else {
-            obj.expire = Date.now() + (parseInt(maxAge, 10) * 1000);
-          }
-          result = 1;
-        } else {
-          // 查询过期时间
-          if (obj.expire === 0) {
-            result = -1; // 永不过期
-          } else {
-            const remaining = Math.floor((obj.expire - Date.now()) / 1000);
-            result = remaining > 0 ? remaining : -2; // -2表示已过期
+  /**
+   * 获取键数量
+   * @returns {Promise<number>} - 返回键数量
+   */
+  async dbsize() {
+    try {
+      // 过滤掉已过期的键
+      let count = 0;
+      for (const key of this.list) {
+        if (this.data.hasOwnProperty(key)) {
+          const item = this.data[key];
+          if (item.expire === 0 || Date.now() <= item.expire) {
+            count++;
           }
         }
-
-        // 触发后置事件
-        this.emit('ttl_after', { 
-          key, 
-          value: maxAge !== undefined ? { ttl: maxAge } : undefined,
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('ttl_error', { 
-          key, 
-          value: maxAge !== undefined ? { ttl: maxAge } : undefined,
-          error 
-        });
-        $.log.error('[cachebase] ttl操作失败:', error);
-        resolve(-2);
       }
-    });
+      
+      return count;
+    } catch (error) {
+      this.log.error('[cachebase] dbsize操作失败:', error);
+      throw error;
+    }
   }
 
-  // 获取所有匹配键方法，包含事件触发
-  async keys(pattern) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          value: { pattern }, 
-          cancel: false 
-        };
-        this.emit('keys_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve([]);
-          return;
-        }
-
-        // 执行实际操作
-        let result;
-        if (!pattern || pattern === '*') {
-          result = [...this.list];
-        } else {
-          // 转换模式为正则表达式
-          const regexPattern = pattern
-            .replace(/\./g, '\\.')
-            .replace(/\*/g, '.*')
-            .replace(/\?/g, '.');
-          const regex = new RegExp(`^${regexPattern}$`);
-
-          // 过滤匹配的键
-          result = this.list.filter(key => regex.test(key));
+  /**
+   * 设置键值并返回旧值
+   * @param {string} key - 键名
+   * @param {*} value - 键值
+   * @returns {Promise<*>} - 返回旧值
+   */
+  async getset(key, value) {
+    try {
+      this.emit('getset_before', { key, value });
+      
+      // 获取旧值
+      let oldValue = undefined;
+      if (this.data.hasOwnProperty(key)) {
+        const item = this.data[key];
+        if (!(item.expire > 0 && Date.now() > item.expire)) {
+          oldValue = item.value;
         }
-
-        // 触发后置事件
-        this.emit('keys_after', { 
-          value: { pattern }, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('keys_error', { 
-          value: { pattern }, 
-          error 
-        });
-        $.log.error('[cachebase] keys操作失败:', error);
-        resolve([]);
       }
-    });
-  }
-
-  // 清空缓存方法，包含事件触发
-  async clear(pattern) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          value: { pattern }, 
-          cancel: false 
-        };
-        this.emit('clear_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 执行实际操作
-        let keysToDelete;
-        
-        if (!pattern || pattern === '*') {
-          keysToDelete = [...this.list];
-        } else {
-          // 转换模式为正则表达式
-          const regexPattern = pattern
-            .replace(/\./g, '\\.')
-            .replace(/\*/g, '.*')
-            .replace(/\?/g, '.');
-          const regex = new RegExp(`^${regexPattern}$`);
-          
-          keysToDelete = this.list.filter(key => regex.test(key));
-        }
-
-        // 删除匹配的键
-        keysToDelete.forEach(key => {
-          delete this.data[key];
-          const index = this.list.indexOf(key);
-          if (index > -1) {
-            this.list.splice(index, 1);
-          }
-        });
-
-        // 触发后置事件
-        this.emit('clear_after', { 
-          value: { pattern }, 
-          result: keysToDelete.length 
-        });
-        resolve(keysToDelete.length);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('clear_error', { 
-          value: { pattern }, 
-          error 
-        });
-        $.log.error('[cachebase] clear操作失败:', error);
-        resolve(0);
+      
+      // 设置新值
+      this.data[key] = { value, expire: 0 };
+      
+      // 添加到键列表
+      if (!this.list.includes(key)) {
+        this.list.push(key);
       }
-    });
+      
+      this.emit('getset_after', { key, value, result: oldValue });
+      return oldValue;
+    } catch (error) {
+      this.emit('getset_error', { key, value, error });
+      this.log.error('[cachebase] getset操作失败:', error);
+      throw error;
+    }
   }
 
-  // 哈希表获取字段值方法，包含事件触发
-  async hget(key, field) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value: { field }, 
-          cancel: false 
-        };
-        this.emit('hget_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(null);
-          return;
-        }
-
-        // 执行实际操作
-        const obj = this.data[key];
-        let result = null;
-        if (obj && typeof obj.value === 'object' && field in obj.value) {
-          result = obj.value[field];
-        }
-
-        // 触发后置事件
-        this.emit('hget_after', { 
-          key, 
-          value: { field }, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('hget_error', { 
-          key, 
-          value: { field }, 
-          error 
-        });
-        $.log.error('[cachebase] hget操作失败:', error);
-        resolve(null);
+  /**
+   * 数值递增
+   * @param {string} key - 键名
+   * @returns {Promise<number>} - 返回递增后的值
+   */
+  async incr(key) {
+    try {
+      this.emit('incr_before', { key });
+      
+      // 获取当前值或默认为0
+      let currentValue = 0;
+      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
+        currentValue = parseFloat(this.data[key].value) || 0;
       }
-    });
-  }
-
-  // 哈希表获取所有字段和值方法，包含事件触发
-  async hgetall(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          cancel: false 
-        };
-        this.emit('hgetall_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve({});
-          return;
-        }
-
-        // 执行实际操作
-        const obj = this.data[key];
-        let result = {};
-        if (obj && typeof obj.value === 'object') {
-          result = {...obj.value};
-        }
-
-        // 触发后置事件
-        this.emit('hgetall_after', { 
-          key, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('hgetall_error', { 
-          key, 
-          error 
-        });
-        $.log.error('[cachebase] hgetall操作失败:', error);
-        resolve({});
+      
+      // 递增
+      const result = currentValue + 1;
+      
+      // 保存结果
+      this.data[key] = { value: result, expire: 0 };
+      
+      // 如果键不存在于列表中，添加到列表
+      if (!this.list.includes(key)) {
+        this.list.push(key);
       }
-    });
+      
+      this.emit('incr_after', { key, result });
+      return result;
+    } catch (error) {
+      this.emit('incr_error', { key, error });
+      this.log.error('[cachebase] incr操作失败:', error);
+      throw error;
+    }
   }
 
-  // 哈希表删除字段方法，包含事件触发
-  async hdel(key, field) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value: { field }, 
-          cancel: false 
-        };
-        this.emit('hdel_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 执行实际操作
-        let result = 0;
-        const obj = this.data[key];
-        if (obj && typeof obj.value === 'object' && field in obj.value) {
-          delete obj.value[field];
-          // 如果哈希表变空了，删除整个键
-          if (Object.keys(obj.value).length === 0) {
-            delete this.data[key];
-            const index = this.list.indexOf(key);
-            if (index > -1) {
-              this.list.splice(index, 1);
-            }
-          }
-          result = 1;
-        }
-
-        // 触发后置事件
-        this.emit('hdel_after', { 
-          key, 
-          value: { field }, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('hdel_error', { 
-          key, 
-          value: { field }, 
-          error 
-        });
-        $.log.error('[cachebase] hdel操作失败:', error);
-        resolve(0);
+  /**
+   * 数值递减
+   * @param {string} key - 键名
+   * @returns {Promise<number>} - 返回递减后的值
+   */
+  async decr(key) {
+    try {
+      this.emit('decr_before', { key });
+      
+      // 获取当前值或默认为0
+      let currentValue = 0;
+      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
+        currentValue = parseFloat(this.data[key].value) || 0;
       }
-    });
-  }
-
-  // 哈希表获取所有字段名方法，包含事件触发
-  async hkeys(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          cancel: false 
-        };
-        this.emit('hkeys_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve([]);
-          return;
-        }
-
-        // 执行实际操作
-        let result = [];
-        const obj = this.data[key];
-        if (obj && typeof obj.value === 'object') {
-          result = Object.keys(obj.value);
-        }
-
-        // 触发后置事件
-        this.emit('hkeys_after', { 
-          key, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('hkeys_error', { 
-          key, 
-          error 
-        });
-        $.log.error('[cachebase] hkeys操作失败:', error);
-        resolve([]);
+      
+      // 递减
+      const result = currentValue - 1;
+      
+      // 保存结果
+      this.data[key] = { value: result, expire: 0 };
+      
+      // 如果键不存在于列表中，添加到列表
+      if (!this.list.includes(key)) {
+        this.list.push(key);
       }
-    });
+      
+      this.emit('decr_after', { key, result });
+      return result;
+    } catch (error) {
+      this.emit('decr_error', { key, error });
+      this.log.error('[cachebase] decr操作失败:', error);
+      throw error;
+    }
   }
 
-  // 哈希表获取所有字段值方法，包含事件触发
-  async hvals(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          cancel: false 
-        };
-        this.emit('hvals_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve([]);
-          return;
-        }
-
-        // 执行实际操作
-        let result = [];
-        const obj = this.data[key];
-        if (obj && typeof obj.value === 'object') {
-          result = Object.values(obj.value);
-        }
-
-        // 触发后置事件
-        this.emit('hvals_after', { 
-          key, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('hvals_error', { 
-          key, 
-          error 
-        });
-        $.log.error('[cachebase] hvals操作失败:', error);
-        resolve([]);
+  /**
+   * 数值增加指定值
+   * @param {string} key - 键名
+   * @param {number} increment - 增加的值
+   * @returns {Promise<number>} - 返回增加后的值
+   */
+  async incrby(key, increment) {
+    try {
+      this.emit('incrby_before', { key, increment });
+      
+      // 获取当前值或默认为0
+      let currentValue = 0;
+      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
+        currentValue = parseFloat(this.data[key].value) || 0;
       }
-    });
-  }
-
-  // 列表左侧弹出方法，包含事件触发
-  async lpop(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          cancel: false 
-        };
-        this.emit('lpop_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(null);
-          return;
-        }
-
-        // 执行实际操作
-        const obj = this.data[key];
-        let result = null;
-        if (obj && Array.isArray(obj.value) && obj.value.length > 0) {
-          result = obj.value.shift();
-          // 如果列表变空了，删除整个键
-          if (obj.value.length === 0) {
-            delete this.data[key];
-            const index = this.list.indexOf(key);
-            if (index > -1) {
-              this.list.splice(index, 1);
-            }
-          }
-        }
-
-        // 触发后置事件
-        this.emit('lpop_after', { 
-          key, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('lpop_error', { 
-          key, 
-          error 
-        });
-        $.log.error('[cachebase] lpop操作失败:', error);
-        resolve(null);
+      
+      // 增加指定值
+      const result = currentValue + parseFloat(increment);
+      
+      // 保存结果
+      this.data[key] = { value: result, expire: 0 };
+      
+      // 如果键不存在于列表中，添加到列表
+      if (!this.list.includes(key)) {
+        this.list.push(key);
       }
-    });
+      
+      this.emit('incrby_after', { key, increment, result });
+      return result;
+    } catch (error) {
+      this.emit('incrby_error', { key, increment, error });
+      this.log.error('[cachebase] incrby操作失败:', error);
+      throw error;
+    }
   }
 
-  // 列表右侧推入元素方法
-  async rpush(key, ...values) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value: { values }, 
-          cancel: false 
-        };
-        this.emit('rpush_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 确保列表存在
-        if (!this.data[key]) {
-          this.data[key] = { value: [], expire: 0 };
-          // 添加到列表
-          if (!this.list.includes(key)) {
-            this.list.push(key);
-          }
-        } else if (!Array.isArray(this.data[key].value)) {
-          this.data[key].value = [];
-        }
-
-        // 将值添加到列表尾部
-        this.data[key].value.push(...values);
-
-        // 触发后置事件
-        this.emit('rpush_after', { 
-          key, 
-          value: { values }, 
-          result: this.data[key].value.length 
-        });
-        resolve(this.data[key].value.length);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('rpush_error', { 
-          key, 
-          value: { values }, 
-          error 
-        });
-        $.log.error('[cachebase] rpush操作失败:', error);
-        resolve(0);
+  /**
+   * 数值减少指定值
+   * @param {string} key - 键名
+   * @param {number} decrement - 减少的值
+   * @returns {Promise<number>} - 返回减少后的值
+   */
+  async decrby(key, decrement) {
+    try {
+      this.emit('decrby_before', { key, decrement });
+      
+      // 获取当前值或默认为0
+      let currentValue = 0;
+      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
+        currentValue = parseFloat(this.data[key].value) || 0;
       }
-    });
-  }
-
-  // 列表右侧弹出元素方法，包含事件触发
-  async rpop(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          cancel: false 
-        };
-        this.emit('rpop_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(null);
-          return;
-        }
-
-        // 执行实际操作
-        const obj = this.data[key];
-        let result = null;
-        if (obj && Array.isArray(obj.value) && obj.value.length > 0) {
-          result = obj.value.pop();
-          // 如果列表变空了，删除整个键
-          if (obj.value.length === 0) {
-            delete this.data[key];
-            const index = this.list.indexOf(key);
-            if (index > -1) {
-              this.list.splice(index, 1);
-            }
-          }
-        }
-
-        // 触发后置事件
-        this.emit('rpop_after', { 
-          key, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('rpop_error', { 
-          key, 
-          error 
-        });
-        $.log.error('[cachebase] rpop操作失败:', error);
-        resolve(null);
+      
+      // 减少指定值
+      const result = currentValue - parseFloat(decrement);
+      
+      // 保存结果
+      this.data[key] = { value: result, expire: 0 };
+      
+      // 如果键不存在于列表中，添加到列表
+      if (!this.list.includes(key)) {
+        this.list.push(key);
       }
-    });
+      
+      this.emit('decrby_after', { key, decrement, result });
+      return result;
+    } catch (error) {
+      this.emit('decrby_error', { key, decrement, error });
+      this.log.error('[cachebase] decrby操作失败:', error);
+      throw error;
+    }
   }
 
-  // 获取列表长度方法，包含事件触发
-  async llen(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          cancel: false 
-        };
-        this.emit('llen_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 执行实际操作
-        let result = 0;
-        const obj = this.data[key];
-        if (obj && Array.isArray(obj.value)) {
-          result = obj.value.length;
-        }
-
-        // 触发后置事件
-        this.emit('llen_after', { 
-          key, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('llen_error', { 
-          key, 
-          error 
-        });
-        $.log.error('[cachebase] llen操作失败:', error);
-        resolve(0);
+  /**
+   * 浮点数增加指定值
+   * @param {string} key - 键名
+   * @param {number} increment - 增加的值
+   * @returns {Promise<number>} - 返回增加后的值
+   */
+  async incrbyfloat(key, increment) {
+    try {
+      this.emit('incrbyfloat_before', { key, increment });
+      
+      // 获取当前值或默认为0
+      let currentValue = 0;
+      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
+        currentValue = parseFloat(this.data[key].value) || 0;
       }
-    });
-  }
-
-  // 集合移除元素方法，包含事件触发
-  async srem(key, value) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value, 
-          cancel: false 
-        };
-        this.emit('srem_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 执行实际操作
-        let result = 0;
-        const obj = this.data[key];
-        if (obj && obj.value && obj.value.members) {
-          if (obj.value.members.hasOwnProperty(value)) {
-            delete obj.value.members[value];
-            // 更新有序数组
-            obj.value.sorted = Object.keys(obj.value.members);
-            result = 1;
-            // 如果集合变空了，删除整个键
-            if (Object.keys(obj.value.members).length === 0) {
-              delete this.data[key];
-              const index = this.list.indexOf(key);
-              if (index > -1) {
-                this.list.splice(index, 1);
-              }
-            }
-          }
-        }
-
-        // 触发后置事件
-        this.emit('srem_after', { 
-          key, 
-          value, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('srem_error', { 
-          key, 
-          value, 
-          error 
-        });
-        $.log.error('[cachebase] srem操作失败:', error);
-        resolve(0);
+      
+      // 增加指定值
+      const result = currentValue + parseFloat(increment);
+      
+      // 保存结果
+      this.data[key] = { value: result, expire: 0 };
+      
+      // 如果键不存在于列表中，添加到列表
+      if (!this.list.includes(key)) {
+        this.list.push(key);
       }
-    });
+      
+      this.emit('incrbyfloat_after', { key, increment, result });
+      return result;
+    } catch (error) {
+      this.emit('incrbyfloat_error', { key, increment, error });
+      this.log.error('[cachebase] incrbyfloat操作失败:', error);
+      throw error;
+    }
   }
 
-  // 获取集合所有成员方法，包含事件触发
-  async smembers(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          cancel: false 
-        };
-        this.emit('smembers_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve([]);
-          return;
-        }
-
-        // 执行实际操作
-        let result = [];
-        const obj = this.data[key];
-        if (obj && obj.value && obj.value.sorted) {
-          result = [...obj.value.sorted];
-        }
-
-        // 触发后置事件
-        this.emit('smembers_after', { 
-          key, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('smembers_error', { 
-          key, 
-          error 
-        });
-        $.log.error('[cachebase] smembers操作失败:', error);
-        resolve([]);
+  /**
+   * 字符串追加
+   * @param {string} key - 键名
+   * @param {string} value - 追加的字符串
+   * @returns {Promise<number>} - 返回追加后的字符串长度
+   */
+  async append(key, value) {
+    try {
+      this.emit('append_before', { key, value });
+      
+      // 获取当前值或默认为空字符串
+      let currentValue = '';
+      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
+        currentValue = String(this.data[key].value);
       }
-    });
-  }
-
-  // 检查元素是否在集合中方法，包含事件触发
-  async sismember(key, value) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value, 
-          cancel: false 
-        };
-        this.emit('sismember_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 执行实际操作
-        let result = 0;
-        const obj = this.data[key];
-        if (obj && obj.value && obj.value.members && obj.value.members.hasOwnProperty(value)) {
-          result = 1;
-        }
-
-        // 触发后置事件
-        this.emit('sismember_after', { 
-          key, 
-          value, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('sismember_error', { 
-          key, 
-          value, 
-          error 
-        });
-        $.log.error('[cachebase] sismember操作失败:', error);
-        resolve(0);
+      
+      // 执行字符串拼接
+      const newValue = currentValue + String(value);
+      const result = newValue.length;
+      
+      // 保存结果
+      this.data[key] = { value: newValue, expire: 0 };
+      
+      // 如果键不存在于列表中，添加到列表
+      if (!this.list.includes(key)) {
+        this.list.push(key);
       }
-    });
+      
+      this.emit('append_after', { key, value, result });
+      return result;
+    } catch (error) {
+      this.emit('append_error', { key, value, error });
+      this.log.error('[cachebase] append操作失败:', error);
+      throw error;
+    }
   }
-
-  // 获取集合大小方法，包含事件触发
-  async scard(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          cancel: false 
-        };
-        this.emit('scard_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 执行实际操作
-        let result = 0;
-        const obj = this.data[key];
-        if (obj && obj.value && obj.value.sorted) {
-          result = obj.value.sorted.length;
-        }
-
-        // 触发后置事件
-        this.emit('scard_after', { 
-          key, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('scard_error', { 
-          key, 
-          error 
-        });
-        $.log.error('[cachebase] scard操作失败:', error);
-        resolve(0);
+  
+  /**
+   * 获取字符串长度
+   * @param {string} key - 键名
+   * @returns {Promise<number>} - 返回字符串长度
+   */
+  async strlen(key) {
+    try {
+      this.emit('strlen_before', { key });
+      
+      // 检查键是否存在且未过期
+      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
+        const result = String(this.data[key].value).length;
+        this.emit('strlen_after', { key, result });
+        return result;
       }
-    });
+      
+      this.emit('strlen_after', { key, result: 0 });
+      return 0;
+    } catch (error) {
+      this.emit('strlen_error', { key, error });
+      this.log.error('[cachebase] strlen操作失败:', error);
+      throw error;
+    }
   }
 
-  // 获取有序集合范围内的成员方法，包含事件触发
-  async zrange(key, start, stop, withScores = false) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value: { start, stop, withScores }, 
-          cancel: false 
-        };
-        this.emit('zrange_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve([]);
-          return;
-        }
-
-        // 执行实际操作
-        let result = [];
-        const obj = this.data[key];
-        if (obj && obj.value && obj.value.sorted) {
-          const sorted = obj.value.sorted.slice(start, stop + 1);
-          if (withScores) {
-            result = [];
-            for (const member of sorted) {
-              result.push(member);
-              result.push(obj.value.members[member]);
-            }
-          } else {
-            result = sorted;
-          }
-        }
-
-        // 触发后置事件
-        this.emit('zrange_after', { 
-          key, 
-          value: { start, stop, withScores }, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('zrange_error', { 
-          key, 
-          value: { start, stop, withScores }, 
-          error 
-        });
-        $.log.error('[cachebase] zrange操作失败:', error);
-        resolve([]);
-      }
-    });
+  /**
+   * 清空数据库
+   * @returns {Promise<string>} - 返回'OK'
+   */
+  async flushdb() {
+    try {
+      this.emit('flushdb_before');
+      
+      // 清空数据
+      this.data = {};
+      this.list = [];
+      
+      this.emit('flushdb_after', { result: 'OK' });
+      return 'OK';
+    } catch (error) {
+      this.emit('flushdb_error', { error });
+      this.log.error('[cachebase] flushdb操作失败:', error);
+      throw error;
+    }
   }
 
-  // 从有序集合中移除成员方法，包含事件触发
-  async zrem(key, member) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value: { member }, 
-          cancel: false 
-        };
-        this.emit('zrem_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 执行实际操作
-        let result = 0;
-        const obj = this.data[key];
-        if (obj && obj.value && obj.value.members && obj.value.members.hasOwnProperty(member)) {
-          delete obj.value.members[member];
-          // 重新排序
-          obj.value.sorted = Object.entries(obj.value.members)
-            .sort((a, b) => a[1] - b[1])
-            .map(entry => entry[0]);
-          result = 1;
-          // 如果集合变空了，删除整个键
-          if (Object.keys(obj.value.members).length === 0) {
-            delete this.data[key];
-            const index = this.list.indexOf(key);
-            if (index > -1) {
-              this.list.splice(index, 1);
-            }
-          }
-        }
-
-        // 触发后置事件
-        this.emit('zrem_after', { 
-          key, 
-          value: { member }, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('zrem_error', { 
-          key, 
-          value: { member }, 
-          error 
-        });
-        $.log.error('[cachebase] zrem操作失败:', error);
-        resolve(0);
-      }
-    });
+  // 保持兼容性的方法
+  async has(key) {
+    try {
+      const exists = await this.exists(key);
+      return exists > 0;
+    } catch (error) {
+      this.log.error('[cachebase] has操作失败:', error);
+      throw error;
+    }
   }
 
-  // 获取有序集合中成员的分数方法，包含事件触发
-  async zscore(key, member) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value: { member }, 
-          cancel: false 
-        };
-        this.emit('zscore_before', beforeEventData);
+  async clear(pattern) {
+    return this.flushdb();
+  }
 
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(null);
-          return;
-        }
+  async add(key, value) {
+    return this.incrby(key, value);
+  }
 
-        // 执行实际操作
-        let result = null;
-        const obj = this.data[key];
-        if (obj && obj.value && obj.value.members && obj.value.members.hasOwnProperty(member)) {
-          result = obj.value.members[member];
-        }
+  async addFloat(key, value) {
+    return this.incrbyfloat(key, value);
+  }
 
-        // 触发后置事件
-        this.emit('zscore_after', { 
-          key, 
-          value: { member }, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('zscore_error', { 
-          key, 
-          value: { member }, 
-          error 
-        });
-        $.log.error('[cachebase] zscore操作失败:', error);
-        resolve(null);
-      }
-    });
+  async addStr(key, value) {
+    return this.append(key, value);
   }
 
-  // 资源销毁方法，包含事件触发
+  /**
+   * 资源销毁方法
+   */
   dispose() {
     try {
-      // 触发前置事件
-      const beforeEventData = { cancel: false };
-      this.emit('dispose_before', beforeEventData);
-
-      // 如果事件处理器设置了cancel为true，则取消操作
-      if (beforeEventData.cancel) {
-        return;
-      }
-
-      // 执行实际操作
+      this.emit('dispose_before');
+      
+      // 清空数据
       this.data = {};
       this.list = [];
-      this.dict = this.data; // 同步dict引用
       
-      // 触发后置事件
-      this.emit('dispose_after', {});
+      this.emit('dispose_after');
       
-      // 最后移除所有监听器（在触发后置事件后）
+      // 移除所有监听器
       this.removeAllListeners();
     } catch (error) {
-      // 触发错误事件
       this.emit('dispose_error', { error });
-      $.log.error('[cachebase] dispose操作失败:', error);
+      this.log.error('[cachebase] dispose操作失败:', error);
     }
   }
 }
 
 // 导出CacheBase类
-module.exports = CacheBase;
+exports.CacheBase = CacheBase;
+
+
+/**
+ * 确保连接池对象存在
+ */
+if (!$.pool) {
+	$.pool = {};
+}
+if (!$.pool.cachebase) {
+	$.pool.cachebase = {};
+}
+
+/**
+ * @description cachebase管理器，用于创建缓存
+ * @param {String} scope 作用域
+ * @param {String} dir 当前路径
+ * @return {Object} 返回一个cachebase类实例
+ */
+function cachebase_admin(scope, dir) {
+	if (!scope) {
+		scope = 'sys';
+	}
+	var obj = $.pool.cachebase[scope];
+	if (!obj) {
+		$.pool.cachebase[scope] = new CacheBase(scope, dir);
+		obj = $.pool.cachebase[scope];
+	}
+	return obj;
+}
 
+/**
+ * @module 导出cachebase管理器
+ */
+exports.cachebase_admin = cachebase_admin;