mm_cachebase 1.8.8 → 1.9.0

package/index_old.js

@@ -1,2521 +0,0 @@
-const EventEmitter = require('events');
-require('mm_logs');
-
-class CacheBase extends EventEmitter {
-  /**
-   * 构造函数，初始化缓存
-   * @param {Object} config - 配置选项
-   */
-  constructor(scope = 'sys', config = {}) {
-    super();
-
-    // 持久化相关属性
-    this.scope = scope;
-    // 配置选项
-    this.config = {
-      dir: './cache/'.fullname(),
-      expire: 0,
-      max: 0,
-      persist: false,  // 是否启用持久化
-      saveInterval: 60000 // 保存间隔（毫秒）
-    };
-    // 数据存储对象
-    this.data = {};
-    // 键列表，用于存储所有的键名
-    this.list = [];
-    this.saveTimer = null;
-    this.dir = this.config.dir;
-    this.setConfig(config);
-    this.init();
-  }
-
-  /**
-   * 初始化方法
-   * @private
-   */
-  init() {
-    // 如果启用了持久化，尝试加载数据
-    if (this.config.persist) {
-      this._loadData().catch(error => {
-        $.log.error('[cachebase] 数据加载失败:', error);
-      });
-    }
-  }
-
-  /**
-   * 启动定时保存功能
-   * @returns {Promise<boolean>} 是否成功连接
-   */
-  async connect() {
-    try {
-      this.emit('connect_before');
-
-      // 只有在启用持久化时才启动定时保存
-      if (this.config.persist) {
-        // 先立即保存一次
-        await this._saveData();
-
-        // 清除已存在的定时器（如果有）
-        if (this.saveTimer) {
-          clearInterval(this.saveTimer);
-        }
-
-        // 设置新的定时器
-        const interval = this.config.saveInterval || 60000;
-        this.saveTimer = setInterval(() => {
-          this._saveData().catch(error => {
-            $.log.error('[cachebase] 定时保存失败:', error);
-          });
-        }, interval);
-
-        $.log.info(`[cachebase] 定时保存已启动，间隔 ${interval}ms`);
-      }
-
-      this.emit('connect_after');
-      return true;
-    } catch (error) {
-      this.emit('connect_error', { error });
-      $.log.error('[cachebase] 连接失败:', error);
-      return 0;
-    }
-  }
-
-  /**
-   * 手动保存数据到文件
-   * @returns {Promise<boolean>} 是否保存成功
-   */
-  async save() {
-    try {
-      this.emit('save_before');
-      await this._saveData();
-      this.emit('save_after');
-      return true;
-    } catch (error) {
-      this.emit('save_error', { error });
-      $.log.error('[cachebase] 保存失败:', error);
-      return 0;
-    }
-  }
-
-  /**
-   * 保存数据到文件
-   * @private
-   * @returns {Promise<void>}
-   */
-  async _saveData() {
-    if (!this.config.persist) return;
-
-    try {
-      // 确保目录存在
-      this.dir.addDir();
-
-      // 过滤过期数据
-      const now = Date.now();
-      const validData = {};
-      const validList = [];
-
-      for (const key of this.list) {
-        if (this.data.hasOwnProperty(key)) {
-          const item = this.data[key];
-          // 检查是否过期
-          if (!item.expire || item.expire === 0 || item.expire > now) {
-            validData[key] = item;
-            validList.push(key);
-          }
-        }
-      }
-
-      // 准备保存的数据
-      const saveData = {
-        data: validData,
-        list: validList,
-        timestamp: now
-      };
-
-      // 保存到文件
-      const file = `./${this.scope}.cache.json`.fullname(this.dir);
-      file.saveJson(saveData);
-      $.log.debug(`[cachebase] 数据已保存到 ${file}，共 ${validList.length} 个键`);
-    } catch (error) {
-      $.log.error('[cachebase] 数据保存失败:', error);
-      return null;
-    }
-  }
-
-  /**
-   * 从文件加载数据
-   * @private
-   * @returns {Promise<void>}
-   */
-  async _loadData() {
-    if (!this.config.persist) return;
-
-    try {
-      // 确保目录存在
-      this.dir.addDir();
-
-      // 只加载当前scope的缓存文件
-      const file = `./${this.scope}.cache.json`.fullname(this.dir);
-
-      if (!file.hasFile()) {
-        $.log.debug(`[cachebase] 未找到当前scope的缓存文件: ${file}`);
-        return;
-      }
-
-      $.log.debug(`[cachebase] 尝试从 ${file} 加载数据`);
-
-      try {
-        try {
-          const savedData = file.loadJson();
-          $.log.debug(`[cachebase] 解析数据成功，包含data: ${savedData.data ? '是' : '否'}, list: ${savedData.list ? '是' : '否'}`);
-
-          if (savedData.data && savedData.list && Array.isArray(savedData.list)) {
-            $.log.debug(`[cachebase] 数据格式正确，list长度: ${savedData.list.length}`);
-
-            // 验证数据并过滤过期项
-            const now = Date.now();
-            const validData = {};
-            const validList = [];
-
-            for (const key of savedData.list) {
-              if (savedData.data.hasOwnProperty(key)) {
-                const item = savedData.data[key];
-                $.log.debug(`[cachebase] 检查键 ${key}，过期时间: ${item.expire || 0}`);
-                // 检查是否过期
-                if (!item.expire || item.expire === 0 || item.expire > now) {
-                  validData[key] = item;
-                  validList.push(key);
-                } else {
-                  $.log.debug(`[cachebase] 键 ${key} 已过期，跳过`);
-                }
-              }
-            }
-
-            // 直接使用加载的数据替换当前数据
-            this.data = validData;
-            this.list = validList;
-            this.dict = this.data; // 确保dict指向最新的data
-
-            $.log.info(`[cachebase] 从 ${this.scope}.cache.json 加载数据成功，共 ${validList.length} 个键`);
-            if (validList.length > 0) {
-              $.log.debug(`[cachebase] 加载的键: ${validList.join(', ')}`);
-            }
-          } else {
-            $.log.warn(`[cachebase] 缓存文件格式不正确，缺少必要字段`);
-          }
-        } catch (parseError) {
-          $.log.error(`[cachebase] 文件JSON解析失败:`, parseError);
-        }
-      } catch (readError) {
-        $.log.error(`[cachebase] 读取文件失败:`, readError);
-      }
-    } catch (error) {
-      $.log.error('[cachebase] 数据加载失败:', error);
-      return null;
-    }
-  }
-
-  /**
-   * 设置缓存配置
-   * @param {Object} config 
-   */
-  setConfig(config) {
-    if (config) {
-      Object.assign(this.config, config);
-      this.dir = this.config.dir.fullname(__dirname)
-    }
-  }
-
-  /**
-   * 检查键是否过期
-   * @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;
-        }
-      }
-    }
-    return 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;
-      }
-    }
-  }
-
-  /**
-   * 设置键值 - 兼容方法
-   * @param {string} key - 键名
-   * @param {*} value - 键值
-   * @param {number} expire - 过期时间(秒)，0表示永不过期
-   * @returns {Promise<boolean>} - 操作成功返回true，失败返回false
-   * @note 确保行为与Redis兼容，支持所有Redis的参数模式
-   */
-  async set(key, value, seconds) {
-    try {
-      // 键名必须是非空字符串
-      if (!key || typeof key !== 'string') {
-        $.log.error('[cachebase] 参数错误: key必须是非空字符串');
-        return 0;
-      }
-
-      // 触发前置事件，允许修改或阻止操作
-      const beforeEventData = { key, value, ttl: seconds, cancel: false };
-      this.emit('set_before', beforeEventData);
-
-      // 如果事件处理器标记为取消，则返回false
-      if (beforeEventData.cancel) {
-        $.log.debug(`[cachebase] set操作被事件处理器取消 [${key}]`);
-        return 0;
-      }
-
-      // 使用可能被修改的值
-      let { key: finalKey, value: finalValue, ttl: finalSeconds } = beforeEventData;
-
-      // 处理参数模式兼容性（Redis支持多种参数模式）
-      // 检查是否是Redis风格的参数模式：set(key, value, 'EX', seconds) 或 set(key, value, 'PX', milliseconds)
-      if (typeof finalSeconds === 'string') {
-        // 暂时不处理复杂参数模式，保持简单的过期时间设置
-        finalSeconds = 0;
-      }
-
-      // 设置值和过期时间，确保结构与Redis完全兼容
-      this.data[finalKey] = {
-        value: finalValue,
-        expire: finalSeconds > 0 ? Date.now() + finalSeconds * 1000 : 0
-      };
-
-      // 如果键不存在于列表中，添加到列表
-      if (!this.list.includes(finalKey)) {
-        this.list.push(finalKey);
-      }
-
-      // 确保返回值始终为布尔值true，与Redis一致
-      this.emit('set_after', { key: finalKey, value: finalValue, ttl: finalSeconds, success: true });
-      return true;
-    } catch (error) {
-      // 触发错误事件
-      this.emit('set_error', { key, value, ttl: seconds, error });
-      $.log.error('[cachebase] set操作失败:', error);
-      return 0;
-    }
-  }
-
-  /**
-   * 获取键值
-   * @param {string} key - 键名
-   * @returns {Promise<*>} - 返回键值，不存在返回null
-   */
-  async get(key) {
-    try {
-      // 参数验证
-      if (!key || typeof key !== 'string') {
-        return null;
-      }
-
-      // 检查键是否存在
-      if (!this.data.hasOwnProperty(key)) {
-        return null;
-      }
-
-      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);
-        }
-        return null;
-      }
-
-      return item.value;
-    } catch (error) {
-      $.log.error('[cachebase] get操作失败:', error);
-      return null;
-    }
-  }
-
-  /**
- * 删除键 - 兼容方法
- * @param {string} key - 键名
- * @returns {Promise<boolean>} - 操作成功返回true，失败返回false
- * @note 确保与其他模块返回值风格一致
- */
-  async del(key) {
-    try {
-      // 键名必须是非空字符串或非空字符串数组
-      if (!key) {
-        $.log.error('[cachebase] 参数错误: key必须是非空字符串或非空字符串数组');
-        return false;
-      }
-
-      // 如果是单个键，验证是否为非空字符串
-      if (typeof key === 'string') {
-        if (!key) {
-          $.log.error('[cachebase] 参数错误: key必须是非空字符串');
-          return false;
-        }
-      }
-      // 如果是数组，验证每个元素是否为非空字符串
-      else if (Array.isArray(key)) {
-        for (const k of key) {
-          if (!k || typeof k !== 'string') {
-            $.log.error('[cachebase] 参数错误: key必须是非空字符串或非空字符串数组');
-            return false;
-          }
-        }
-      }
-      else {
-        $.log.error('[cachebase] 参数错误: key必须是非空字符串或非空字符串数组');
-        return false;
-      }
-
-      // 触发前置事件，允许修改或阻止操作
-      const beforeEventData = { key, cancel: false };
-      this.emit('del_before', beforeEventData);
-
-      // 如果事件处理器标记为取消，则返回false
-      if (beforeEventData.cancel) {
-        $.log.debug(`[cachebase] del操作被事件处理器取消 [${key}]`);
-        return false;
-      }
-
-      // 使用可能被修改的值
-      let { key: finalKey } = beforeEventData;
-
-      let deletedCount = 0;
-
-      if (Array.isArray(finalKey)) {
-        // 批量删除
-        for (const k of finalKey) {
-          if (this.data.hasOwnProperty(k)) {
-            const item = this.data[k];
-            // 检查是否过期
-            if (!(item.expire > 0 && Date.now() > item.expire)) {
-              // 执行删除操作
-              delete this.data[k];
-              const index = this.list.indexOf(k);
-              if (index !== -1) {
-                this.list.splice(index, 1);
-              }
-              deletedCount++;
-            }
-          }
-        }
-      } else {
-        // 单个删除
-        if (this.data.hasOwnProperty(finalKey)) {
-          const item = this.data[finalKey];
-          // 检查是否过期
-          if (!(item.expire > 0 && Date.now() > item.expire)) {
-            // 执行删除操作
-            delete this.data[finalKey];
-            const index = this.list.indexOf(finalKey);
-            if (index !== -1) {
-              this.list.splice(index, 1);
-            }
-            deletedCount++;
-          }
-        }
-      }
-
-      // 触发后置事件
-      this.emit('del_after', { key: finalKey, deletedCount, result: deletedCount > 0 });
-      return deletedCount > 0;
-    } catch (error) {
-      // 触发错误事件
-      this.emit('del_error', { key, error });
-      $.log.error('[cachebase] del操作失败:', error);
-      return false;
-    }
-  }
-
-  /**
- * 检查键是否存在 - 兼容方法
- * @param {string|Array<string>} key - 键名或键名数组
- * @returns {Promise<boolean>} - 键存在返回true，不存在返回false
- * @note 确保与其他模块返回值风格一致
- */
-  async exists(key) {
-    try {
-      // 验证数组中的每个元素都是非空字符串
-      if (Array.isArray(key)) {
-        for (const k of key) {
-          if (typeof k !== 'string' || !k) {
-            throw new Error('all keys must be non-empty strings');
-          }
-        }
-        // 处理多键检查，只要有一个键存在且未过期就返回true
-        for (const k of key) {
-          if (this.data.hasOwnProperty(k)) {
-            // 检查是否过期，与Redis一致：已过期的键被视为不存在
-            const item = this.data[k];
-            if (!(item.expire > 0 && Date.now() > item.expire)) {
-              return true;
-            }
-          }
-        }
-        return false;
-      } else {
-        // 处理单键检查
-        if (this.data.hasOwnProperty(key)) {
-          // 检查是否过期，与Redis一致：已过期的键被视为不存在
-          const item = this.data[key];
-          if (!(item.expire > 0 && Date.now() > item.expire)) {
-            return true;
-          }
-        }
-        return false;
-      }
-    } catch (error) {
-      $.log.error('[cachebase] exists操作失败:', error);
-      return false;
-    }
-  }
-
-  /**
- * 设置键的过期时间 - 兼容Redis的EXPIRE命令
- * @param {string} key - 键名
- * @param {number} seconds - 过期时间（秒）
- * @returns {Promise<boolean>} - 操作成功返回true，失败返回false
- * @note 确保与其他模块返回值风格一致
- */
-  async expire(key, seconds) {
-    try {
-      // 参数验证
-      if (!key || typeof key !== 'string' || typeof seconds !== 'number' || seconds <= 0) {
-        $.log.error('[cachebase] expire参数错误: key必须是非空字符串，seconds必须是正数');
-        return false;
-      }
-
-      // 触发前置事件
-      const beforeEventData = { key, ttl: seconds, cancel: false };
-      this.emit('expire_before', beforeEventData);
-
-      if (beforeEventData.cancel) {
-        $.log.debug(`[cachebase] expire操作被事件处理器取消 [${key}]`);
-        return false;
-      }
-
-      const { key: finalKey, ttl: finalSeconds } = beforeEventData;
-
-      // 检查键是否存在
-      if (!this.data.hasOwnProperty(finalKey)) {
-        this.emit('expire_after', { key: finalKey, ttl: finalSeconds, result: false });
-        return false; // 键不存在，返回false
-      }
-
-      // 检查是否已过期
-      const item = this.data[finalKey];
-      if (item.expire > 0 && Date.now() > item.expire) {
-        // 键已过期，删除并返回false
-        delete this.data[finalKey];
-        const index = this.list.indexOf(finalKey);
-        if (index !== -1) {
-          this.list.splice(index, 1);
-        }
-        this.emit('expire_after', { key: finalKey, ttl: finalSeconds, result: false });
-        return false; // 键已过期，返回false
-      }
-
-      // 设置过期时间
-      this.data[finalKey].expire = Date.now() + finalSeconds * 1000;
-
-      // 触发后置事件
-      this.emit('expire_after', { key: finalKey, ttl: finalSeconds, result: true });
-      return true; // 成功设置，返回true
-    } catch (error) {
-      $.log.error(`[cachebase] 设置过期时间失败 [${key}]:`, error);
-      this.emit('expire_error', { key, ttl: seconds, error });
-      return false; // 发生错误，返回false
-    }
-  }
-
-  /**
-   * 设置哈希表字段 - 兼容方法
-   * @param {string} key - 键名
-   * @param {string} field - 字段名
-   * @param {*} value - 字段值
-   * @returns {Promise<number>} - 返回1表示新建字段，0表示更新字段
-   * @note 完全兼容Redis HSET命令，确保返回值和行为一致性
-   */
-  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' || this.data[key].value === null) {
-        // 类型错误，与Redis一致：如果键不是哈希表类型，应该返回错误
-        throw new Error(`[cachebase] 键 ${key} 不是哈希表类型`);
-      }
-
-      // 检查字段是否存在，以确定是新建还是更新
-      const isNewField = !this.data[key].value.hasOwnProperty(field);
-      // 设置字段值
-      this.data[key].value[field] = value;
-
-      // 确保返回值符合Redis规范：1表示新建字段，0表示更新字段
-      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 });
-      $.log.error('[cachebase] hset操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 获取哈希表字段
-   * @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) {
-      $.log.error('[cachebase] hget操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 获取哈希表所有字段
-   * @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) {
-      $.log.error('[cachebase] hgetall操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 删除哈希表字段
-   * @param {string} key - 键名
-   * @param {string|Array<string>} field - 字段名或字段名数组
-   * @returns {Promise<boolean>} - 操作成功返回true，失败返回false
-   */
-  async hdel(key, field) {
-    try {
-      // 参数验证
-      if (typeof key !== 'string' || key === '') {
-        $.log.error('[cachebase] hdel操作失败: 键必须是非空字符串');
-        return false;
-      }
-
-      // 触发前置事件，允许修改或阻止操作
-      const beforeEventData = { key, field, cancel: false };
-      this.emit('hdel_before', beforeEventData);
-
-      if (beforeEventData.cancel) {
-        $.log.debug('[cachebase] hdel操作被事件处理器取消');
-        return false;
-      }
-
-      const { key: finalKey, field: finalField } = beforeEventData;
-
-      // 处理字段参数，支持单个字段或字段数组
-      const fields = Array.isArray(finalField) ? finalField : [finalField];
-      let deleted = false;
-
-      // 检查键是否存在且未过期
-      if (this.data.hasOwnProperty(finalKey) &&
-        !(this.data[finalKey].expire > 0 && Date.now() > this.data[finalKey].expire) &&
-        typeof this.data[finalKey].value === 'object') {
-
-        // 遍历所有字段进行删除
-        for (const f of fields) {
-          if (typeof f === 'string' && f !== '' && this.data[finalKey].value.hasOwnProperty(f)) {
-            delete this.data[finalKey].value[f];
-            deleted = true;
-          }
-        }
-
-        // 检查哈希表是否为空
-        const hashKeys = Object.keys(this.data[finalKey].value);
-        if (hashKeys.length === 0) {
-          // 删除空哈希表
-          delete this.data[finalKey];
-          const index = this.list.indexOf(finalKey);
-          if (index !== -1) {
-            this.list.splice(index, 1);
-          }
-        }
-
-        // 触发后置事件
-        this.emit('hdel_after', { key: finalKey, field: finalField, success: deleted });
-        return deleted;
-      }
-
-      // 未删除返回false
-      this.emit('hdel_after', { key: finalKey, field: finalField, success: false });
-      return false;
-    } catch (error) {
-      this.emit('hdel_error', { key, field, error });
-      $.log.error('[cachebase] hdel操作失败:', error);
-      return false;
-    }
-  }
-
-  /**
-   * 批量设置键值 - 兼容方法
-   * @param {Object} keyValues - 键值对对象
-   * @returns {Promise<boolean>} - 操作成功返回true，失败返回false
-   * @note 完全兼容Redis MSET命令，确保参数验证和行为一致性
-   */
-  async mset(keyValues) {
-    try {
-      // 触发前置事件，允许修改或阻止操作
-      const beforeEventData = { keyValues, cancel: false };
-      this.emit('mset_before', beforeEventData);
-
-      if (beforeEventData.cancel) {
-        $.log.debug('[cachebase] mset操作被事件处理器取消');
-        return false;
-      }
-
-      const { keyValues: finalKeyValues } = beforeEventData;
-
-      // 参数验证，确保keyValues是对象且不为null
-      if (typeof keyValues !== 'object' || keyValues === null || Array.isArray(keyValues)) {
-        $.log.error('[cachebase] mset参数错误: keyValues必须是非空对象');
-        return false;
-      }
-
-      // 检查对象是否为空
-      if (Object.keys(keyValues).length === 0) {
-        $.log.error('[cachebase] mset参数错误: keyValues不能是空对象');
-        return false;
-      }
-      for (const key in finalKeyValues) {
-        if (finalKeyValues.hasOwnProperty(key)) {
-          // 为每个键设置值，不设置过期时间（与Redis MSET一致）
-          this.data[key] = { value: finalKeyValues[key], expire: 0 };
-          // 如果键不存在于列表中，添加到列表
-          if (!this.list.includes(key)) {
-            this.list.push(key);
-          }
-        }
-      }
-
-      // 确保返回值为布尔值true
-      this.emit('mset_after', { keyValues: finalKeyValues, result: true });
-      return true;
-    } catch (error) {
-      this.emit('mset_error', { keyValues, error });
-      $.log.error('[cachebase] mset操作失败:', error);
-      return false;
-    }
-  }
-
-  /**
-   * 批量获取键值 - 兼容方法
-   * @param {Array<string>} keys - 键名数组
-   * @returns {Promise<Array>} - 返回值数组，与输入键数组顺序一致，不存在的键返回null
-   * @note 完全兼容Redis MGET命令，确保返回值顺序和行为一致性
-   */
-  async mget(keys) {
-    try {
-      // 参数验证，确保keys是数组
-      if (!Array.isArray(keys)) {
-        throw new Error('[cachebase] mget参数必须是数组');
-      }
-
-      // 批量获取键值，确保返回数组与输入键数组顺序一致（与Redis 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 {
-            // 键已过期，删除并添加null到结果数组
-            delete this.data[key];
-            const index = this.list.indexOf(key);
-            if (index !== -1) {
-              this.list.splice(index, 1);
-            }
-            results.push(null);
-          }
-        } else {
-          // 键不存在，添加null到结果数组
-          results.push(null);
-        }
-      }
-
-      // 确保返回值是数组，与输入键数组的顺序完全一致（与Redis MGET一致）
-      return results;
-    } catch (error) {
-      $.log.error('[cachebase] mget操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 移除键的过期时间，使其永不过期 - 兼容Redis的PERSIST命令
-   * @param {string} key - 键名
-   * @returns {Promise<boolean>} - 操作成功返回true，失败返回false
-   */
-  async persist(key) {
-    try {
-      // 参数验证
-      if (!key || typeof key !== 'string') {
-        $.log.error('[cachebase] persist参数错误: key必须是非空字符串');
-        return 0;
-      }
-
-      // 触发前置事件
-      const beforeEventData = { key, cancel: false };
-      this.emit('persist_before', beforeEventData);
-
-      if (beforeEventData.cancel) {
-        $.log.debug(`[cachebase] persist操作被事件处理器取消 [${key}]`);
-        return 0;
-      }
-
-      const { key: finalKey } = beforeEventData;
-
-      // 检查键是否存在
-      if (!this.data.hasOwnProperty(finalKey)) {
-        this.emit('persist_after', { key: finalKey, result: 0 });
-        return 0; // 键不存在，返回0
-      }
-
-      const item = this.data[finalKey];
-
-      // 检查是否已过期
-      if (item.expire > 0 && Date.now() > item.expire) {
-        // 键已过期，删除并返回0
-        delete this.data[finalKey];
-        const index = this.list.indexOf(finalKey);
-        if (index !== -1) {
-          this.list.splice(index, 1);
-        }
-        this.emit('persist_after', { key: finalKey, result: 0 });
-        return 0; // 键已过期，返回0
-      }
-
-      // 检查是否设置了过期时间
-      if (item.expire === 0) {
-        // 键没有设置过期时间，返回0
-        this.emit('persist_after', { key: finalKey, result: 0 });
-        return 0;
-      }
-
-      // 设置为永不过期
-      item.expire = 0;
-
-      // 触发后置事件
-      this.emit('persist_after', { key: finalKey, result: 1 });
-      return 1; // 成功移除过期时间，返回1
-    } catch (error) {
-      $.log.error(`[cachebase] persist操作失败 [${key}]:`, error);
-      this.emit('persist_error', { key, error });
-      return 0; // 发生错误，返回0
-    }
-  }
-
-  /**
-   * 获取或设置键的过期时间
-   * @param {string} key - 键名
-   * @param {number} [seconds] - 过期时间（秒），不传此参数则获取剩余过期时间
-   * @returns {Promise<number|boolean>} - 不传seconds时返回剩余过期时间（-1表示无过期设置，-2表示已过期），传seconds时返回是否设置成功
-   */
-  async ttl(key, seconds) {
-    try {
-      // 参数验证
-      if (typeof key !== 'string' || key === '') {
-        $.log.error('[cachebase] ttl操作失败: 键必须是非空字符串');
-        return seconds === undefined ? -2 : false;
-      }
-
-      // 如果传入了seconds参数，则设置过期时间
-      if (seconds !== undefined) {
-        // 参数验证
-        if (typeof seconds !== 'number' || isNaN(seconds) || seconds < 0) {
-          $.log.error('[cachebase] ttl设置操作失败: 过期时间必须是非负数字');
-          return false;
-        }
-
-        // 触发前置事件，允许修改或阻止操作
-        const beforeEventData = { key, seconds, cancel: false };
-        this.emit('ttl_before', beforeEventData);
-
-        if (beforeEventData.cancel) {
-          $.log.debug('[cachebase] ttl设置操作被事件处理器取消');
-          return false;
-        }
-
-        const { key: finalKey, seconds: finalSeconds } = beforeEventData;
-
-        // 检查键是否存在
-        if (!this.data.hasOwnProperty(finalKey)) {
-          this.emit('ttl_after', { key: finalKey, seconds: finalSeconds, exists: false });
-          return false;
-        }
-
-        // 设置过期时间
-        this.data[finalKey].expire = finalSeconds > 0 ? Date.now() + (finalSeconds * 1000) : 0;
-        this.emit('ttl_after', { key: finalKey, seconds: finalSeconds, exists: true });
-        return true;
-      }
-
-      // 否则获取剩余过期时间
-      // 触发前置事件，允许修改或阻止操作
-      const beforeEventData = { key, cancel: false };
-      this.emit('ttl_before', beforeEventData);
-
-      if (beforeEventData.cancel) {
-        $.log.debug('[cachebase] ttl获取操作被事件处理器取消');
-        return -2;
-      }
-
-      const { key: finalKey } = beforeEventData;
-
-      // 检查键是否存在
-      if (!this.data.hasOwnProperty(finalKey)) {
-        this.emit('ttl_after', { key: finalKey, exists: false });
-        return -2; // 键不存在返回-2
-      }
-
-      const item = this.data[finalKey];
-
-      // 检查是否过期
-      if (item.expire > 0) {
-        if (Date.now() > item.expire) {
-          // 键已过期，删除键
-          delete this.data[finalKey];
-          const index = this.list.indexOf(finalKey);
-          if (index !== -1) {
-            this.list.splice(index, 1);
-          }
-          this.emit('ttl_after', { key: finalKey, exists: false });
-          return -2; // 已过期返回-2
-        } else {
-          // 计算剩余过期时间（秒）
-          const remaining = Math.ceil((item.expire - Date.now()) / 1000);
-          this.emit('ttl_after', { key: finalKey, exists: true, hasExpire: true });
-          return remaining;
-        }
-      } else {
-        // 键存在且永不过期
-        this.emit('ttl_after', { key: finalKey, exists: true, hasExpire: false });
-        return -1; // 无过期设置返回-1
-      }
-    } catch (error) {
-      this.emit('ttl_error', { key, seconds, error });
-      $.log.error('[cachebase] ttl操作失败:', error);
-      return seconds === undefined ? -2 : false;
-    }
-  }
-
-  /**
-   * 设置键的过期时间
-   * @param {string} key - 键名
-   * @param {number} seconds - 过期时间（秒）
-   * @returns {Promise<boolean>} - 操作成功返回true，失败返回false
-   * @note 完全兼容Redis的EXPIRE命令行为，确保返回值和事件数据一致性
-   */
-  async expire(key, seconds) {
-    try {
-      // 参数验证
-      if (!key || typeof key !== 'string' || typeof seconds !== 'number' || seconds <= 0) {
-        $.log.error('[cachebase] expire参数错误: key必须是非空字符串，seconds必须是正数');
-        return false;
-      }
-
-      // 触发前置事件，允许修改或阻止操作
-      const beforeEventData = { key, ttl: seconds, cancel: false };
-      this.emit('expire_before', beforeEventData);
-
-      if (beforeEventData.cancel) {
-        $.log.debug(`[cachebase] expire操作被事件处理器取消 [${key}]`);
-        return false;
-      }
-
-      const { key: finalKey, ttl: finalSeconds } = beforeEventData;
-      // 检查键是否存在
-      if (!this.data.hasOwnProperty(finalKey)) {
-        this.emit('expire_after', { key: finalKey, ttl: finalSeconds, result: false });
-        return false;
-      }
-
-      // 检查是否已过期
-      const item = this.data[finalKey];
-      if (item.expire > 0 && Date.now() > item.expire) {
-        // 键已过期，删除并返回false
-        delete this.data[finalKey];
-        const index = this.list.indexOf(finalKey);
-        if (index !== -1) {
-          this.list.splice(index, 1);
-        }
-        this.emit('expire_after', { key: finalKey, ttl: finalSeconds, result: false });
-        return false;
-      }
-
-      // 设置过期时间
-      this.data[finalKey].expire = Date.now() + finalSeconds * 1000;
-
-      this.emit('expire_after', { key: finalKey, ttl: finalSeconds, result: true });
-      return true;
-    } catch (error) {
-      this.emit('expire_error', { key, ttl: seconds, error });
-      $.log.error('[cachebase] expire操作失败:', error);
-      return false;
-    }
-  }
-
-  /**
-   * @description 移除键的过期时间
-   * @param {string} key - 键名
-   * @returns {Promise<boolean>} - 操作成功返回true，失败返回false
-   */
-  async persist(key) {
-    try {
-      // 参数验证
-      if (!key || typeof key !== 'string') {
-        $.log.error('[cachebase] persist参数错误: key必须是非空字符串');
-        return false;
-      }
-
-      // 触发前置事件
-      const beforeEventData = { key, cancel: false };
-      this.emit('persist_before', beforeEventData);
-
-      if (beforeEventData.cancel) {
-        $.log.debug(`[cachebase] persist操作被事件处理器取消 [${key}]`);
-        return false;
-      }
-
-      const { key: finalKey } = beforeEventData;
-
-      // 检查键是否存在
-      if (!this.data.hasOwnProperty(finalKey)) {
-        this.emit('persist_after', { key: finalKey, success: false });
-        return false;
-      }
-
-      // 检查是否已过期
-      const item = this.data[finalKey];
-      if (item.expire > 0 && Date.now() > item.expire) {
-        // 键已过期，删除并返回false
-        delete this.data[finalKey];
-        const index = this.list.indexOf(finalKey);
-        if (index !== -1) {
-          this.list.splice(index, 1);
-        }
-        this.emit('persist_after', { key: finalKey, success: false });
-        return false;
-      }
-
-      // 检查是否有过期时间
-      if (item.expire === 0) {
-        // 没有过期时间，返回false
-        this.emit('persist_after', { key: finalKey, success: false });
-        return false;
-      }
-
-      // 移除过期时间
-      this.data[finalKey].expire = 0;
-
-      // 触发后置事件
-      this.emit('persist_after', { key: finalKey, success: true });
-      return true;
-    } catch (error) {
-      $.log.error(`[cachebase] 移除过期时间失败 [${key}]:`, error);
-      this.emit('persist_error', { key, error });
-      return false;
-    }
-  }
-
-  /**
-   * 获取所有键名
-   * @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) {
-      $.log.error('[cachebase] keys操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 获取键数量
-   * @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++;
-          }
-        }
-      }
-
-      return count;
-    } catch (error) {
-      $.log.error('[cachebase] dbsize操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 设置键值并返回旧值
-   * @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.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 });
-      $.log.error('[cachebase] getset操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 数值递增
-   * @param {string} key - 键名
-   * @returns {Promise<number>} - 返回递增后的值
-   */
-  async incr(key) {
-    try {
-      // 参数验证
-      if (typeof key !== 'string' || key === '') {
-        $.log.error('[cachebase] incr操作失败: 键必须是非空字符串');
-        return 0;
-      }
-
-      // 触发前置事件，允许修改或阻止操作
-      const beforeEventData = { key, cancel: false };
-      this.emit('incr_before', beforeEventData);
-
-      if (beforeEventData.cancel) {
-        $.log.debug('[cachebase] incr操作被事件处理器取消');
-        return 0;
-      }
-
-      const { key: finalKey } = beforeEventData;
-      // 获取当前值或默认为0
-      let currentValue = 0;
-      if (this.data.hasOwnProperty(finalKey) && !this._checkExpire(finalKey)) {
-        currentValue = parseFloat(this.data[finalKey].value) || 0;
-      }
-
-      // 递增
-      const result = currentValue + 1;
-
-      // 保存结果
-      this.data[finalKey] = { value: result, expire: 0 };
-
-      // 如果键不存在于列表中，添加到列表
-      if (!this.list.includes(finalKey)) {
-        this.list.push(finalKey);
-      }
-
-      this.emit('incr_after', { key: finalKey, result, success: true });
-      return result;
-    } catch (error) {
-      this.emit('incr_error', { key, error });
-      $.log.error('[cachebase] incr操作失败:', error);
-      return 0;
-    }
-  }
-
-  /**
-   * 数值递减
-   * @param {string} key - 键名
-   * @returns {Promise<boolean>} - 操作成功返回true，失败返回false
-   */
-  async decr(key) {
-    try {
-      // 参数验证
-      if (typeof key !== 'string' || key === '') {
-        $.log.error('[cachebase] decr操作失败: 键必须是非空字符串');
-        return false;
-      }
-
-      // 触发前置事件，允许修改或阻止操作
-      const beforeEventData = { key, cancel: false };
-      this.emit('decr_before', beforeEventData);
-
-      if (beforeEventData.cancel) {
-        $.log.debug('[cachebase] decr操作被事件处理器取消');
-        return false;
-      }
-
-      const { key: finalKey } = beforeEventData;
-      // 获取当前值或默认为0
-      let currentValue = 0;
-      if (this.data.hasOwnProperty(finalKey) && !this._checkExpire(finalKey)) {
-        currentValue = parseFloat(this.data[finalKey].value) || 0;
-      }
-
-      // 递减
-      const result = currentValue - 1;
-
-      // 保存结果
-      this.data[finalKey] = { value: result, expire: 0 };
-
-      // 如果键不存在于列表中，添加到列表
-      if (!this.list.includes(finalKey)) {
-        this.list.push(finalKey);
-      }
-
-      this.emit('decr_after', { key: finalKey, result, success: true });
-      return true;
-    } catch (error) {
-      this.emit('decr_error', { key, error });
-      $.log.error('[cachebase] decr操作失败:', error);
-      return false;
-    }
-  }
-
-  /**
-   * 数值增加指定值
-   * @param {string} key - 键名
-   * @param {number} increment - 增加的值
-   * @returns {Promise<number>} - 返回增加后的值
-   */
-  async incrby(key, increment) {
-    try {
-      // 参数验证
-      if (typeof key !== 'string' || key === '' || typeof increment !== 'number') {
-        $.log.error('[cachebase] incrby操作失败: 键必须是非空字符串，增量必须是数字');
-        return 0;
-      }
-
-      // 触发前置事件，允许修改或阻止操作
-      const beforeEventData = { key, increment, cancel: false };
-      this.emit('incrby_before', beforeEventData);
-
-      if (beforeEventData.cancel) {
-        $.log.debug('[cachebase] incrby操作被事件处理器取消');
-        return 0;
-      }
-
-      const { key: finalKey, increment: finalIncrement } = beforeEventData;
-      // 获取当前值或默认为0
-      let currentValue = 0;
-      if (this.data.hasOwnProperty(finalKey) && !this._checkExpire(finalKey)) {
-        currentValue = parseFloat(this.data[finalKey].value) || 0;
-      }
-
-      // 增加指定值
-      const result = currentValue + parseFloat(finalIncrement);
-
-      // 保存结果
-      this.data[finalKey] = { value: result, expire: 0 };
-
-      // 如果键不存在于列表中，添加到列表
-      if (!this.list.includes(finalKey)) {
-        this.list.push(finalKey);
-      }
-
-      this.emit('incrby_after', { key: finalKey, increment: finalIncrement, result, success: true });
-      return result;
-    } catch (error) {
-      this.emit('incrby_error', { key, increment, error });
-      $.log.error('[cachebase] incrby操作失败:', error);
-      return 0;
-    }
-  }
-
-  /**
-   * 数值减少指定值
-   * @param {string} key - 键名
-   * @param {number} decrement - 减少的值
-   * @returns {Promise<number>} - 返回减少后的值
-   */
-  async decrby(key, decrement) {
-    try {
-      // 参数验证
-      if (typeof key !== 'string' || key === '' || typeof decrement !== 'number') {
-        $.log.error('[cachebase] decrby操作失败: 键必须是非空字符串，减量必须是数字');
-        return 0;
-      }
-
-      // 触发前置事件，允许修改或阻止操作
-      const beforeEventData = { key, decrement, cancel: false };
-      this.emit('decrby_before', beforeEventData);
-
-      if (beforeEventData.cancel) {
-        $.log.debug('[cachebase] decrby操作被事件处理器取消');
-        return 0;
-      }
-
-      const { key: finalKey, decrement: finalDecrement } = beforeEventData;
-      // 获取当前值或默认为0
-      let currentValue = 0;
-      if (this.data.hasOwnProperty(finalKey) && !this._checkExpire(finalKey)) {
-        currentValue = parseFloat(this.data[finalKey].value) || 0;
-      }
-
-      // 减少指定值
-      const result = currentValue - parseFloat(finalDecrement);
-
-      // 保存结果
-      this.data[finalKey] = { value: result, expire: 0 };
-
-      // 如果键不存在于列表中，添加到列表
-      if (!this.list.includes(finalKey)) {
-        this.list.push(finalKey);
-      }
-
-      this.emit('decrby_after', { key: finalKey, decrement: finalDecrement, result, success: true });
-      return result;
-    } catch (error) {
-      this.emit('decrby_error', { key, decrement, error });
-      $.log.error('[cachebase] decrby操作失败:', error);
-      return 0;
-    }
-  }
-
-  /**
-   * 浮点数增加指定值
-   * @param {string} key - 键名
-   * @param {number} increment - 增加的值
-   * @returns {Promise<number>} - 返回增加后的值
-   */
-  async incrbyfloat(key, increment) {
-    try {
-      // 参数验证
-      if (typeof key !== 'string' || key === '' || typeof increment !== 'number') {
-        $.log.error('[cachebase] incrbyfloat操作失败: 键必须是非空字符串，增量必须是数字');
-        return 0;
-      }
-
-      // 触发前置事件，允许修改或阻止操作
-      const beforeEventData = { key, increment, cancel: false };
-      this.emit('incrbyfloat_before', beforeEventData);
-
-      if (beforeEventData.cancel) {
-        $.log.debug('[cachebase] incrbyfloat操作被事件处理器取消');
-        return 0;
-      }
-
-      const { key: finalKey, increment: finalIncrement } = beforeEventData;
-      // 获取当前值或默认为0
-      let currentValue = 0;
-      if (this.data.hasOwnProperty(finalKey) && !this._checkExpire(finalKey)) {
-        currentValue = parseFloat(this.data[finalKey].value) || 0;
-      }
-
-      // 增加指定值
-      const result = currentValue + parseFloat(finalIncrement);
-
-      // 保存结果
-      this.data[finalKey] = { value: result, expire: 0 };
-
-      // 如果键不存在于列表中，添加到列表
-      if (!this.list.includes(finalKey)) {
-        this.list.push(finalKey);
-      }
-
-      this.emit('incrbyfloat_after', { key: finalKey, increment: finalIncrement, result, success: true });
-      return result;
-    } catch (error) {
-      this.emit('incrbyfloat_error', { key, increment, error });
-      $.log.error('[cachebase] incrbyfloat操作失败:', error);
-      return 0;
-    }
-  }
-
-  /**
-   * 字符串追加
-   * @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);
-      }
-
-      // 执行字符串拼接
-      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 });
-      $.log.error('[cachebase] append操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 获取字符串值的长度 - 兼容Redis的STRLEN命令
-   * @param {string} key - 键名
-   * @returns {Promise<number>} - 返回字符串长度，键不存在、不是字符串或发生错误时返回0
-   * @note 完全兼容Redis的STRLEN命令行为，确保返回值和错误处理一致性
-   */
-  async strlen(key) {
-    try {
-      // 参数验证
-      if (!key || typeof key !== 'string') {
-        $.log.error('[cachebase] strlen参数错误: key必须是非空字符串');
-        this.emit('strlen_after', { key, result: 0 });
-        return 0;
-      }
-
-      // 触发前置事件，允许修改或阻止操作
-      const beforeEventData = { key, cancel: false };
-      this.emit('strlen_before', beforeEventData);
-
-      if (beforeEventData.cancel) {
-        $.log.debug(`[cachebase] strlen操作被事件处理器取消 [${key}]`);
-        this.emit('strlen_after', { key, result: 0 });
-        return 0;
-      }
-
-      const { key: finalKey } = beforeEventData;
-
-      // 检查键是否存在且未过期
-      if (this.data.hasOwnProperty(finalKey) && !this._checkExpire(finalKey)) {
-        const result = String(this.data[finalKey].value).length;
-        this.emit('strlen_after', { key: finalKey, result });
-        return result;
-      }
-
-      this.emit('strlen_after', { key: finalKey, result: 0 });
-      return 0;
-    } catch (error) {
-      this.emit('strlen_error', { key, error });
-      $.log.error('[cachebase] strlen操作失败:', error);
-      return 0; // 发生错误时返回0，符合Redis API规范
-    }
-  }
-
-  // 保持兼容性的方法
-  async has(key) {
-    try {
-
-      const exists = await this.exists(key);
-      return exists > 0;
-    } catch (error) {
-      $.log.error('[cachebase] has操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 删除一个或多个键 - 兼容Redis的DEL命令
-   * @param {...string} keys - 要删除的键名列表
-   * @returns {Promise<boolean>} - 操作成功返回true，失败返回false
-   * @note 如果没有提供参数，行为类似FLUSHDB清空所有缓存
-   */
-  async clear(...keys) {
-    try {
-      // 触发前置事件，允许修改或阻止操作
-      const beforeEventData = { keys, cancel: false };
-      this.emit('clear_before', beforeEventData);
-
-      if (beforeEventData.cancel) {
-        $.log.debug('[cachebase] clear操作被事件处理器取消');
-        return false;
-      }
-
-      const { keys: finalKeys } = beforeEventData;
-
-      let deletedCount = 0;
-      let success = false;
-
-      if (finalKeys.length === 0) {
-        // 没有提供键，清空所有数据，类似Redis的FLUSHDB行为
-        deletedCount = this.list.length;
-        this.data = {};
-        this.list = [];
-        success = true;
-      } else {
-        // 删除指定的键，类似Redis的DEL命令行为
-        success = true;
-        for (const key of finalKeys) {
-          // 参数验证，只处理字符串类型的键
-          if (typeof key === 'string') {
-            // 检查键是否存在且未过期
-            if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
-              delete this.data[key];
-              const index = this.list.indexOf(key);
-              if (index !== -1) {
-                this.list.splice(index, 1);
-              }
-              deletedCount++;
-            }
-          } else {
-            success = false;
-          }
-        }
-      }
-
-      // 确保返回值为布尔值
-      this.emit('clear_after', { keys: finalKeys, result: success, deletedCount });
-      return success;
-    } catch (error) {
-      this.emit('clear_error', { keys, error });
-      $.log.error('[cachebase] clear操作失败:', error);
-      return false;
-    }
-  }
-
-  /**
-   * 清空所有过期的数据
-   * @returns {Promise<boolean>} - 返回操作是否成功
-   */
-  async clearExpire() {
-    try {
-      this.emit('clearExpire_before', {});
-
-      let expiredCount = 0;
-      // 检查并删除所有过期的键
-      for (const key of [...this.list]) {
-        if (this._checkExpire(key)) {
-          delete this.data[key];
-          this.list = this.list.filter(k => k !== key);
-          expiredCount++;
-        }
-      }
-
-      this.emit('clearExpire_after', { expiredCount, result: true });
-      return true;
-    } catch (error) {
-      this.emit('clearExpire_error', { error });
-      $.log.error('[cachebase] clearExpire操作失败:', error);
-      return false;
-    }
-  }
-  /**
-   * 增加整数值 - 兼容方法
-   * @param {string} key - 键名
-   * @param {*} value - 要设置的值
-   * @param {number} maxAge - 过期时间（秒），0表示永不过期
-   * @returns {Promise<boolean>} - 操作结果，键不存在并设置成功返回true，键已存在返回false
-   */
-  async add(key, value, maxAge = 0) {
-    try {
-      // 参数验证
-      if (!key || typeof key !== 'string') {
-        $.log.error('[cachebase] add参数错误: key必须是非空字符串');
-        return false;
-      }
-
-      // 触发前置事件
-      const beforeEventData = { key, value, maxAge, cancel: false };
-      this.emit('add_before', beforeEventData);
-
-      if (beforeEventData.cancel) {
-        $.log.debug(`[cachebase] add操作被事件处理器取消 [${key}]`);
-        return false;
-      }
-
-      const { key: finalKey, value: finalValue, maxAge: finalMaxAge } = beforeEventData;
-
-      // 检查键是否存在且未过期
-      if (this.data.hasOwnProperty(finalKey) && !this._checkExpire(finalKey)) {
-        // 键已存在，返回false
-        this.emit('add_after', { key: finalKey, value: finalValue, maxAge: finalMaxAge, success: false });
-        return false;
-      }
-
-      // 键不存在，设置新值
-      const now = Date.now();
-      this.data[finalKey] = {
-        value: finalValue,
-        createTime: now,
-        updateTime: now,
-        expire: finalMaxAge > 0 ? now + finalMaxAge * 1000 : 0
-      };
-
-      // 更新列表
-      if (!this.list.includes(finalKey)) {
-        this.list.push(finalKey);
-      }
-
-      // 如果启用了持久化，同步保存到文件
-      if (this._persistence && this._persistence.enabled) {
-        await this._saveData();
-      }
-
-      // 触发后置事件
-      this.emit('add_after', { key: finalKey, value: finalValue, maxAge: finalMaxAge, success: true });
-      return true;
-    } catch (error) {
-      $.log.error(`[cachebase] add操作失败 [${key}]:`, error);
-      this.emit('add_error', { key, value, maxAge, error });
-      return false;
-    }
-  }
-
-  /**
-   * 设置列表项 - 兼容Redis LPUSH/RPUSH行为
-   * @param {string} key - 键名
-   * @param {any} value - 值（通常应为数组）
-   * @param {number} maxAge - 过期时间（秒），0表示永不过期
-   * @returns {Promise<number>} - 设置后列表的长度
-   * @note 兼容Redis的列表设置行为，返回列表长度
-   */
-  async setForList(key, value, maxAge = 0) {
-    try {
-      this.emit('setForList_before', { key, value, maxAge });
-
-      // 确保值是数组类型
-      const arrayValue = Array.isArray(value) ? value : [value];
-
-      // 将数组中的所有值转换为字符串，与Redis行为一致
-      const stringValues = arrayValue.map(item => String(item));
-
-      // 设置值和过期时间
-      this.data[key] = {
-        value: stringValues,
-        expire: maxAge > 0 ? Date.now() + maxAge * 1000 : 0
-      };
-
-      // 更新列表
-      if (!this.list.includes(key)) {
-        this.list.push(key);
-      }
-
-      const length = stringValues.length;
-      this.emit('setForList_after', { key, value: stringValues, maxAge, result: length });
-      return length;
-    } catch (error) {
-      this.emit('setForList_error', { key, value, maxAge, error });
-      $.log.error('[cachebase] setForList操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 添加列表项 - 兼容Redis LPUSH/RPUSH行为
-   * @param {string} key - 键名
-   * @param {any} value - 值
-   * @param {number} maxAge - 过期时间（秒），0表示永不过期
-   * @returns {Promise<number>} - 添加后列表的长度
-   * @note 兼容Redis的列表追加行为，返回列表长度
-   */
-  async addForList(key, value, maxAge = 0) {
-    try {
-      this.emit('addForList_before', { key, value, maxAge });
-
-      // 获取现有列表或创建新列表
-      let list = [];
-      let existingExpire = 0;
-
-      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
-        // 确保现有值是数组类型
-        list = Array.isArray(this.data[key].value) ? this.data[key].value : [];
-        existingExpire = this.data[key].expire;
-      }
-
-      // 将值转换为字符串，与Redis行为一致
-      const stringValue = String(value);
-
-      // 添加值到列表
-      list.push(stringValue);
-
-      // 设置值和过期时间
-      // 如果提供了新的过期时间，则使用新的，否则保持原来的
-      const expireTime = maxAge > 0 ? Date.now() + maxAge * 1000 : existingExpire;
-
-      this.data[key] = {
-        value: list,
-        expire: expireTime
-      };
-
-      // 更新列表
-      if (!this.list.includes(key)) {
-        this.list.push(key);
-      }
-
-      const length = list.length;
-      this.emit('addForList_after', { key, value: stringValue, maxAge, result: length });
-      return length;
-    } catch (error) {
-      this.emit('addForList_error', { key, value, maxAge, error });
-      $.log.error('[cachebase] addForList操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 检查集合是否包含指定成员 - 兼容Redis SISMEMBER行为
-   * @param {string} key - 键名
-   * @param {*} member - 要检查的成员
-   * @returns {Promise<number>} - 1表示成员存在，0表示成员不存在或键不存在/类型错误
-   * @note 完全兼容Redis的SISMEMBER命令行为，返回数字而非布尔值
-   */
-  async sismember(key, member) {
-    try {
-      // 参数验证
-      if (!key || typeof key !== 'string') {
-        $.log.error('[cachebase] 参数错误: key必须是非空字符串');
-        return 0;
-      }
-
-      if (member === undefined || member === null) {
-        $.log.error('[cachebase] 参数错误: member不能为undefined或null');
-        return 0;
-      }
-
-      // 触发前置事件，允许修改或阻止操作
-      const beforeEventData = { key, member, cancel: false };
-      this.emit('sismember_before', beforeEventData);
-
-      if (beforeEventData.cancel) {
-        $.log.debug(`[cachebase] sismember操作被事件处理器取消 [${key}]`);
-        return 0;
-      }
-
-      const { key: finalKey, member: finalMember } = beforeEventData;
-
-      // 检查键是否存在且未过期
-      if (!this.data.hasOwnProperty(finalKey) || this._checkExpire(finalKey)) {
-        this.emit('sismember_after', { key: finalKey, member: finalMember, result: 0 });
-        return 0; // 键不存在或已过期，返回0
-      }
-
-      // 确保值是数组类型
-      const value = this.data[finalKey].value;
-      if (!Array.isArray(value)) {
-        this.emit('sismember_after', { key: finalKey, member: finalMember, result: 0 });
-        return 0;
-      }
-
-      // 检查成员是否存在
-      const result = value.includes(finalMember) ? 1 : 0;
-
-      // 触发后置事件
-      this.emit('sismember_after', { key: finalKey, member: finalMember, result });
-      return result;
-    } catch (error) {
-      $.log.error(`[cachebase] sismember操作失败 [${key}]:`, error);
-      this.emit('sismember_error', { key, member, error });
-      return 0;
-    }
-  }
-
-  /**
-   * 检查列表是否包含指定项 - 兼容Redis SISMEMBER行为
-   * @param {string} key - 键名
-   * @param {any} value - 值
-   * @returns {Promise<number>} - 包含返回1，不包含返回0
-   * @note 兼容Redis的SISMEMBER命令，返回数字而非布尔值
-   */
-  async hasForList(key, value) {
-    try {
-      this.emit('hasForList_before', { key, value });
-
-      // 检查键是否存在且未过期
-      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
-        // 确保将值视为数组
-        const list = Array.isArray(this.data[key].value) ? this.data[key].value : [];
-
-        // 对于对象类型的值，使用深度比较
-        let result = 0;
-        if (typeof value === 'object' && value !== null) {
-          const valueStr = JSON.stringify(value);
-          result = list.some(item => {
-            try {
-              return typeof item === 'object' && item !== null && JSON.stringify(item) === valueStr;
-            } catch (e) {
-              // 如果JSON序列化失败，回退到严格相等
-              return item === value;
-            }
-          }) ? 1 : 0;
-        } else {
-          // 对于基本类型，使用严格相等
-          result = list.includes(value) ? 1 : 0;
-        }
-
-        this.emit('hasForList_after', { key, value, result });
-        return result;
-      }
-
-      this.emit('hasForList_after', { key, value, result: 0 });
-      return 0;
-    } catch (error) {
-      this.emit('hasForList_error', { key, value, error });
-      $.log.error('[cachebase] hasForList操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 获取列表 - 兼容Redis LRANGE行为
-   * @param {string} key - 键名
-   * @param {number} start - 可选的起始索引，默认为0
-   * @param {number} stop - 可选的结束索引，默认为-1（全部）
-   * @returns {Promise<Array>} - 列表数据，确保始终返回数组类型
-   * @note 兼容Redis的LRANGE命令，支持范围获取
-   */
-  async getForList(key, start = 0, stop = -1) {
-    try {
-      this.emit('getForList_before', { key, start, stop });
-
-      // 检查键是否存在且未过期
-      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
-        // 确保返回数组类型，如果不是数组则转换为空数组
-        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('getForList_after', { key, start, stop, result });
-        return result;
-      }
-
-      // 键不存在或已过期时返回空数组
-      this.emit('getForList_after', { key, start, stop, result: [] });
-      return [];
-    } catch (error) {
-      this.emit('getForList_error', { key, start, stop, error });
-      $.log.error('[cachebase] getForList操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 清空列表 - 兼容方法
-   * @param {string} key - 键名
-   * @returns {Promise<boolean>} - 是否成功
-   * @note 确保操作对象始终被视为数组以保持兼容性
-   */
-  async clearForList(key) {
-    try {
-      this.emit('clearForList_before', { key });
-
-      // 检查键是否存在
-      if (this.data.hasOwnProperty(key)) {
-        // 检查是否过期
-        if (this.data[key].expire > 0 && Date.now() > this.data[key].expire) {
-          // 键已过期，删除键
-          delete this.data[key];
-          const index = this.list.indexOf(key);
-          if (index !== -1) {
-            this.list.splice(index, 1);
-          }
-          this.emit('clearForList_after', { key, result: false });
-          return false;
-        }
-
-        // 保持过期时间不变，将列表清空为[]
-        const expire = this.data[key].expire;
-        this.data[key] = {
-          value: [],
-          expire: expire
-        };
-
-        this.emit('clearForList_after', { key, result: true });
-        return true;
-      }
-
-      // 键不存在，创建一个新的空列表键
-      this.data[key] = {
-        value: [],
-        expire: 0
-      };
-
-      // 更新列表
-      if (!this.list.includes(key)) {
-        this.list.push(key);
-      }
-
-      this.emit('clearForList_after', { key, result: true });
-      return true;
-    } catch (error) {
-      this.emit('clearForList_error', { key, error });
-      $.log.error('[cachebase] clearForList操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 减少整数值（兼容Redis decr命令）
-   * @param {string} key - 键名
-   * @param {number} maxAge - 过期时间（秒），0表示永不过期
-   * @returns {Promise<number>} - 返回减少后的值
-   * @note 完全兼容Redis decr命令，键不存在时初始化为0后减1
-   */
-  async decr(key, maxAge = 0) {
-    try {
-      this.emit('decr_before', { key, maxAge });
-
-      // 获取当前值或初始化为0（与Redis一致：键不存在时视为0）
-      let currentValue = 0;
-      let existingExpire = 0;
-
-      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
-        const existingValue = this.data[key].value;
-        // 确保值被解析为数字，非数字值视为0（与Redis行为一致）
-        currentValue = Number(existingValue) || 0;
-        existingExpire = this.data[key].expire;
-      }
-
-      // 减少1
-      const newValue = currentValue - 1;
-
-      // 设置新值和过期时间（如果提供了新的过期时间，则使用新的，否则保持原来的或使用默认值）
-      const expireTime = maxAge > 0 ? Date.now() + maxAge * 1000 : existingExpire;
-
-      this.data[key] = {
-        value: newValue,
-        expire: expireTime
-      };
-
-      // 更新列表
-      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 - 键名
- * @param {number} num - 要增加的浮点数值
- * @param {number} seconds - 过期时间（秒），0表示永不过期
- * @returns {Promise<number>} - 返回增加后的值
- */
-  async addFloat(key, num, seconds = 0) {
-    try {
-      // 参数验证
-      if (!key || typeof key !== 'string' || typeof num !== 'number') {
-        $.log.error('[cachebase] addFloat参数错误: key必须是非空字符串，num必须是数字');
-        return 0;
-      }
-
-      this.emit('addFloat_before', { key, num, ttl: seconds, cancel: false });
-
-      // 原生实现浮点数递增逻辑
-      let currentValue = 0;
-      if (this.data.hasOwnProperty(key)) {
-        const item = this.data[key];
-        if (item.expire === 0 || Date.now() < item.expire) {
-          currentValue = Number(item.value) || 0;
-        }
-      }
-      const result = currentValue + Number(num);
-
-      // 设置值和过期时间
-      this.data[key] = {
-        value: result,
-        expire: seconds > 0 ? Date.now() + seconds * 1000 : 0
-      };
-
-      // 更新列表
-      if (!this.list.includes(key)) {
-        this.list.push(key);
-      }
-
-      this.emit('addFloat_after', { key, num, ttl: seconds, success: true, result });
-      return result;
-    } catch (error) {
-      this.emit('addFloat_error', { key, num, ttl: seconds, error });
-      $.log.error('[cachebase] addFloat操作失败:', error);
-      return 0;
-    }
-  }
-
-  /**
- * 增加整数（兼容方法）
- * @param {string} key - 键名
- * @param {number} value - 要增加的整数值
- * @param {number} seconds - 过期时间（秒），0表示永不过期
- * @returns {Promise<number>} - 返回增加后的值
- */
-  async addInt(key, value, seconds = 0) {
-    try {
-      // 参数验证
-      if (!key || typeof key !== 'string' || typeof value !== 'number') {
-        $.log.error('[cachebase] addInt参数错误: key必须是非空字符串，value必须是数字');
-        return 0;
-      }
-
-      this.emit('addInt_before', { key, value, ttl: seconds, cancel: false });
-
-      // 原生实现整数递增逻辑
-      let currentValue = 0;
-      if (this.data.hasOwnProperty(key)) {
-        const item = this.data[key];
-        if (item.expire === 0 || Date.now() < item.expire) {
-          currentValue = parseInt(item.value, 10) || 0;
-        }
-      }
-      const result = currentValue + parseInt(value, 10);
-
-      // 设置值和过期时间
-      this.data[key] = {
-        value: result,
-        expire: seconds > 0 ? Date.now() + seconds * 1000 : 0
-      };
-
-      // 更新列表
-      if (!this.list.includes(key)) {
-        this.list.push(key);
-      }
-
-      this.emit('addInt_after', { key, value, ttl: seconds, success: true, result });
-      return result;
-    } catch (error) {
-      this.emit('addInt_error', { key, value, ttl: seconds, error });
-      $.log.error('[cachebase] addInt操作失败:', error);
-      return 0;
-    }
-  }
-  /**
- * 追加字符串（兼容方法）
- * @param {string} key - 键名
- * @param {string} value - 要追加的字符串
- * @param {number} seconds - 过期时间（秒），0表示永不过期
- * @returns {Promise<number>} - 返回追加后字符串的长度
- */
-  async addStr(key, value, seconds = 0) {
-    try {
-      // 参数验证
-      if (!key || typeof key !== 'string' || typeof value !== 'string') {
-        $.log.error('[cachebase] addStr参数错误: key和value必须是非空字符串');
-        return 0;
-      }
-
-      this.emit('addStr_before', { key, value, ttl: seconds, cancel: false });
-
-      // 原生实现字符串追加逻辑
-      let currentValue = '';
-      if (this.data.hasOwnProperty(key)) {
-        const item = this.data[key];
-        if (item.expire === 0 || Date.now() < item.expire) {
-          currentValue = String(item.value) || '';
-        }
-      }
-      const result = currentValue + value;
-      const length = result.length;
-
-      // 设置值和过期时间
-      this.data[key] = {
-        value: result,
-        expire: seconds > 0 ? Date.now() + seconds * 1000 : 0
-      };
-
-      // 更新列表
-      if (!this.list.includes(key)) {
-        this.list.push(key);
-      }
-
-      this.emit('addStr_after', { key, value, ttl: seconds, result, length, success: true });
-      return length;
-    } catch (error) {
-      this.emit('addStr_error', { key, value, ttl: seconds, error });
-      $.log.error('[cachebase] addStr操作失败:', error);
-      return 0;
-    }
-  }
-
-  /**
-   * 销毁缓存实例
-   * @returns {Promise<void>}
-   */
-  async dispose() {
-    try {
-      this.emit('dispose_before');
-
-      // 清除定时器
-      if (this.saveTimer) {
-        clearInterval(this.saveTimer);
-        this.saveTimer = null;
-        $.log.info('[cachebase] 定时保存已停止');
-      }
-
-      // 如果启用了持久化，在销毁前保存一次
-      if (this.config.persist) {
-        await this._saveData().catch(error => {
-          $.log.error('[cachebase] 销毁前保存数据失败:', error);
-        });
-      }
-
-      // 清空数据
-      this.data = {};
-      this.list = [];
-      this.dict = this.data; // 确保dict也被清空
-
-      this.emit('dispose_after');
-
-      // 移除所有监听器
-      this.removeAllListeners();
-    } catch (error) {
-      this.emit('dispose_error', { error });
-      $.log.error('[cachebase] dispose操作失败:', error);
-    }
-  }
-  /**
-   * 关闭缓存实例
-   */
-  async close() {
-    await this.dispose()
-  }
-
-  /**
-   * 设置键的过期时间（毫秒）- 兼容Redis的PEXPIRE命令
-   * @param {string} key - 键名
-   * @param {number} milliseconds - 过期时间（毫秒）
-   * @returns {Promise<boolean>} - 操作成功返回true，失败返回false
-   */
-  async pexpire(key, milliseconds) {
-    try {
-      // 参数验证
-      if (!key || typeof key !== 'string') {
-        $.log.error('[cachebase] pexpire参数错误: key必须是非空字符串');
-        return false;
-      }
-      if (!Number.isInteger(milliseconds) || milliseconds <= 0) {
-        $.log.error('[cachebase] pexpire参数错误: milliseconds必须是正整数');
-        return false;
-      }
-
-      // 触发前置事件
-      const beforeEventData = { key, ttl: milliseconds, cancel: false };
-      this.emit('pexpire_before', beforeEventData);
-
-      if (beforeEventData.cancel) {
-        $.log.debug(`[cachebase] pexpire操作被事件处理器取消 [${key}]`);
-        return false;
-      }
-
-      const { key: finalKey, ttl: finalMilliseconds } = beforeEventData;
-
-      // 检查键是否存在且未过期
-      if (!this.data.hasOwnProperty(finalKey) || this._checkExpire(finalKey)) {
-        this.emit('pexpire_after', { key: finalKey, ttl: finalMilliseconds, success: false });
-        return false;
-      }
-
-      // 设置过期时间（转为Date对象）
-      const now = Date.now();
-      this.data[finalKey].expire = now + finalMilliseconds;
-
-      // 如果启用了持久化，同步保存到文件
-      if (this._persistence && this._persistence.enabled) {
-        await this._saveData();
-      }
-
-      // 触发后置事件
-      this.emit('pexpire_after', { key: finalKey, ttl: finalMilliseconds, success: true });
-      return true;
-    } catch (error) {
-      $.log.error(`[cachebase] pexpire操作失败 [${key}]:`, error);
-      this.emit('pexpire_error', { key, milliseconds, error });
-      return false;
-    }
-  }
-  /**
-   * 清空所有数据 - 兼容Redis的FLUSHDB命令
-   * @returns {Promise<boolean>} - 操作成功返回true，失败返回false
-   */
-  async flushdb() {
-    try {
-      // 触发前置事件，允许修改或阻止操作
-      const beforeEventData = { cancel: false };
-      this.emit('flushdb_before', beforeEventData);
-
-      if (beforeEventData.cancel) {
-        $.log.debug('[cachebase] flushdb操作被事件处理器取消');
-        this.emit('flushdb_after', { result: false });
-        return false;
-      }
-
-      // 清空所有数据
-      this.data = {};
-      this.list = [];
-
-      // 如果启用了持久化，同步保存到文件
-      if (this._persistence && this._persistence.enabled) {
-        await this._saveData();
-      }
-
-      // 触发后置事件
-      this.emit('flushdb_after', { result: true });
-      return true;
-    } catch (error) {
-      this.emit('flushdb_error', { error });
-      $.log.error('[cachebase] flushdb操作失败:', error);
-      return false;
-    }
-  }
-  /**
-   * 重命名键 - 兼容Redis的RENAME命令
-   * @param {string} oldKey - 原键名
-   * @param {string} newKey - 新键名
-   * @returns {Promise<string|boolean>} - 成功返回'OK'，失败返回false
-   */
-  async rename(oldKey, newKey) {
-    try {
-      // 参数验证
-      if (!oldKey || typeof oldKey !== 'string') {
-        $.log.error('[cachebase] rename参数错误: oldKey必须是非空字符串');
-        return false;
-      }
-      if (!newKey || typeof newKey !== 'string') {
-        $.log.error('[cachebase] rename参数错误: newKey必须是非空字符串');
-        return false;
-      }
-
-      // 触发前置事件
-      const beforeEventData = { oldKey, newKey, cancel: false };
-      this.emit('rename_before', beforeEventData);
-
-      if (beforeEventData.cancel) {
-        $.log.debug(`[cachebase] rename操作被事件处理器取消 [${oldKey} -> ${newKey}]`);
-        return false;
-      }
-
-      const { oldKey: finalOldKey, newKey: finalNewKey } = beforeEventData;
-
-      // 检查原键是否存在且未过期
-      if (!this.data.hasOwnProperty(finalOldKey) || this._checkExpire(finalOldKey)) {
-        this.emit('rename_after', { oldKey: finalOldKey, newKey: finalNewKey, success: false });
-        return false;
-      }
-
-      // 获取原键数据
-      const oldValue = this.data[finalOldKey];
-
-      // 如果新键存在，先删除它
-      if (this.data.hasOwnProperty(finalNewKey)) {
-        delete this.data[finalNewKey];
-      }
-
-      // 重命名键
-      this.data[finalNewKey] = oldValue;
-      delete this.data[finalOldKey];
-
-      // 如果启用了持久化，同步保存到文件
-      if (this._persistence && this._persistence.enabled) {
-        await this._saveData();
-      }
-
-      // 触发后置事件
-      this.emit('rename_after', { oldKey: finalOldKey, newKey: finalNewKey, success: true });
-      return 'OK'; // 兼容Redis，成功时返回'OK'
-    } catch (error) {
-      $.log.error(`[cachebase] rename操作失败 [${oldKey} -> ${newKey}]:`, error);
-      this.emit('rename_error', { oldKey, newKey, error });
-      return false;
-    }
-  }
-
-  /**
-   * 一次性设置多个键值对 - 兼容Redis的MSET命令
-   * @param {string} key1, value1, key2, value2... - 键值对参数列表
-   * @returns {Promise<boolean>} - 成功返回true，失败返回false
-   */
-  async mset(...args) {
-    try {
-      // 参数验证
-      if (args.length === 0 || args.length % 2 !== 0) {
-        $.log.error('[cachebase] mset参数错误: 参数数量必须为偶数');
-        return false;
-      }
-
-      // 将参数列表转换为键值对对象
-      const keyValuePairs = {};
-      for (let i = 0; i < args.length; i += 2) {
-        const key = args[i];
-        const value = args[i + 1];
-
-        if (typeof key !== 'string' || !key) {
-          $.log.error(`[cachebase] mset参数错误: 键 ${key} 必须是非空字符串`);
-          return false;
-        }
-
-        keyValuePairs[key] = value;
-      }
-
-      // 触发前置事件
-      const beforeEventData = { keyValuePairs, cancel: false };
-      this.emit('mset_before', beforeEventData);
-
-      if (beforeEventData.cancel) {
-        $.log.debug('[cachebase] mset操作被事件处理器取消');
-        return false;
-      }
-
-      const { keyValuePairs: finalKeyValuePairs } = beforeEventData;
-
-      // 批量设置键值对
-      for (const [key, value] of Object.entries(finalKeyValuePairs)) {
-        // 创建新的数据项
-        const now = Date.now();
-        this.data[key] = {
-          value: value,
-          createTime: now,
-          updateTime: now,
-          expire: 0
-        };
-      }
-
-      // 如果启用了持久化，同步保存到文件
-      if (this._persistence && this._persistence.enabled) {
-        await this._saveData();
-      }
-
-      // 触发后置事件
-      this.emit('mset_after', { keyValuePairs: finalKeyValuePairs, success: true });
-      return true;
-    } catch (error) {
-      $.log.error('[cachebase] mset操作失败:', error);
-      this.emit('mset_error', { args, error });
-      return false;
-    }
-  }
-
-  async strlen(key) {
-    try {
-      // 触发前置事件
-      const beforeEventData = { key, cancel: false };
-      this.emit('strlen_before', beforeEventData);
-
-      if (beforeEventData.cancel) {
-        $.log.debug(`[cachebase] strlen操作被事件处理器取消 [${key}]`);
-        return 0;
-      }
-
-      const { key: finalKey } = beforeEventData;
-
-      // 检查键是否存在且未过期
-      if (!this.data.hasOwnProperty(finalKey) || this._checkExpire(finalKey)) {
-        this.emit('strlen_after', { key: finalKey, length: 0 });
-        return 0;
-      }
-
-      // 获取值
-      const value = this.data[finalKey].value;
-      let length = 0;
-
-      // 兼容Redis行为：只有字符串类型计算长度，其他类型返回0
-      if (typeof value === 'string') {
-        length = value.length;
-      }
-      // 注意：与Redis保持一致，非字符串类型不计算长度，返回0
-
-      // 触发后置事件
-      this.emit('strlen_after', { key: finalKey, length });
-      return length;
-    } catch (error) {
-      $.log.error(`[cachebase] strlen操作失败 [${key}]:`, error);
-      this.emit('strlen_error', { key, error });
-      return 0;
-    }
-  }
-
-  /**
-   * 获取键的类型 - 兼容Redis的TYPE命令
-   * @param {string} key - 键名
-   * @returns {Promise<string>} - 返回类型字符串，不存在返回'none'
-   */
-  async type(key) {
-    try {
-      // 参数验证
-      if (!key || typeof key !== 'string') {
-        $.log.error('[cachebase] type参数错误: key必须是非空字符串');
-        return 'none';
-      }
-
-      // 触发前置事件
-      const beforeEventData = { key, cancel: false };
-      this.emit('type_before', beforeEventData);
-
-      if (beforeEventData.cancel) {
-        $.log.debug(`[cachebase] type操作被事件处理器取消 [${key}]`);
-        return 'none';
-      }
-
-      const { key: finalKey } = beforeEventData;
-
-      // 检查键是否存在且未过期
-      if (!this.data.hasOwnProperty(finalKey) || this._checkExpire(finalKey)) {
-        this.emit('type_after', { key: finalKey, type: 'none' });
-        return 'none';
-      }
-
-      // 获取值
-      const value = this.data[finalKey].value;
-      let type = 'none';
-
-      // 确定类型，与Redis保持完全一致
-      if (value === null) {
-        type = 'none';
-      } else if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-        type = 'string'; // Redis将数字和布尔值也视为字符串类型
-      } else if (Array.isArray(value)) {
-        // 检查是否为集合类型（不包含重复元素）
-        if (new Set(value).size === value.length) {
-          type = 'set';
-        } else {
-          type = 'list';
-        }
-      } else if (typeof value === 'object') {
-        type = 'hash'; // 对象类型对应Redis的hash
-      }
-
-      // 触发后置事件
-      this.emit('type_after', { key: finalKey, type });
-      return type;
-    } catch (error) {
-      $.log.error(`[cachebase] type操作失败 [${key}]:`, error);
-      this.emit('type_error', { key, error });
-      return 'none';
-    }
-  }
-}
-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;