mm_cachebase 1.4.4 → 1.4.6

package/index.js

@@ -1,514 +1,2132 @@
-/**
- * @fileOverview 本地缓存类
- * @author <a href="http://qww.elins.cn">邱文武</a>
- * @version 1.0
- */
-require('mm_expand');
-
-/**
- * 创建基本缓存CacheBase帮助类函数
- */
-class CacheBase {
-	/**
-	 * 构造函数
-	 */
-	constructor() {
-		// 缓存的字典
-		this.list = [];
-		// 到期通知函数
-		this.func;
-		/*
-		格式:
-		{
-		    {
-		        // ID，为时间戳
-		        id:
-		        // 键名
-		        name:
-		        // 保存值
-		        value: "hello world",
-		        // 最大时效
-		        maxAge: -1,
-		        // 到期时间
-		        expires: ""
-		    }
-		}
-		*/
-	}
+require('mm_logs');
+const EventEmitter = require('events');
+
+// 简化版的CacheBase类，只包含事件触发核心功能
+class CacheBase extends EventEmitter {
+  constructor() {
+    super();
+    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.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);
+      }
+    });
+  }
+
+  // 基本的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);
+      }
+    });
+  }
+
+  // 基本的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);
+      }
+    });
+  }
+
+  // 哈希表设置方法
+  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);
+      }
+    });
+  }
+
+  // 列表头部推入方法
+  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 = [];
+        }
+
+        // 将值添加到列表头部
+        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);
+      }
+    });
+  }
+
+  // 集合添加方法
+  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();
+        }
+
+        // 记录添加前的大小
+        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);
+      }
+    });
+  }
+
+  // 有序集合添加方法
+  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);
+          }
+        } 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++;
+          }
+          
+          // 设置成员分数
+          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);
+      }
+    });
+  }
+
+  // 修复的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');
+      }
+    });
+  }
+
+  // 浮点数加法方法
+  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);
+      }
+    });
+  }
+
+  // 字符串添加方法
+  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);
+      }
+    });
+  }
+
+  // 整数加法方法
+  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);
+      }
+    });
+  }
+
+  // 列表设置方法 - 修改为兼容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);
+        }
+
+        // 触发后置事件
+        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);
+      }
+    });
+  }
+
+  // 列表添加元素方法
+  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 };
+          // 添加到列表
+          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);
+      }
+    });
+  }
+
+  // 列表清空方法
+  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;
+          } 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);
+            }
+            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);
+          }
+          
+          // 触发后置事件
+          this.emit('setnx_after', { 
+            key, 
+            value, 
+            result: 1 
+          });
+          resolve(1);
+        } else {
+          // 键已存在
+          this.emit('setnx_after', { 
+            key, 
+            value, 
+            result: 0 
+          });
+          resolve(0);
+        }
+      } catch (error) {
+        // 触发错误事件
+        this.emit('setnx_error', { 
+          key, 
+          value, 
+          error 
+        });
+        $.log.error('[cachebase] setnx操作失败:', error);
+        resolve(0);
+      }
+    });
+  }
+
+  // 设置带过期时间的键值对方法
+  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);
+      }
+    });
+  }
+
+  // 修复的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 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);
+        } else {
+          resolve('ERR');
+        }
+      } catch (error) {
+        // 触发错误事件
+        this.emit('setrange_error', { 
+          key, 
+          value: { index, value }, 
+          error 
+        });
+        $.log.error('[cachebase] setrange操作失败:', error);
+        resolve('ERR');
+      }
+    });
+  }
+
+  // 新增：列表获取方法，包含事件触发
+  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([]);
+      }
+    });
+  }
+
+  // 新增：字符串范围获取方法，包含事件触发
+  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('');
+      }
+    });
+  }
+
+  // 新增：列表包含检查方法，包含事件触发
+  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);
+      }
+    });
+  }
+
+  // 检查键是否存在方法，包含事件触发
+  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);
+      }
+    });
+  }
+
+  // 检查键是否存在的别名方法，包含事件触发
+  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);
+      }
+    });
+  }
+
+  // 查询/设置过期时间方法，包含事件触发
+  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表示已过期
+          }
+        }
+
+        // 触发后置事件
+        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);
+      }
+    });
+  }
+
+  // 获取所有匹配键方法，包含事件触发
+  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));
+        }
+
+        // 触发后置事件
+        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);
+      }
+    });
+  }
+
+  // 哈希表获取字段值方法，包含事件触发
+  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);
+      }
+    });
+  }
+
+  // 哈希表获取所有字段和值方法，包含事件触发
+  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({});
+      }
+    });
+  }
+
+  // 哈希表删除字段方法，包含事件触发
+  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);
+      }
+    });
+  }
+
+  // 哈希表获取所有字段名方法，包含事件触发
+  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([]);
+      }
+    });
+  }
+
+  // 哈希表获取所有字段值方法，包含事件触发
+  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([]);
+      }
+    });
+  }
+
+  // 列表左侧弹出方法，包含事件触发
+  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);
+      }
+    });
+  }
+
+  // 列表右侧推入元素方法
+  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);
+      }
+    });
+  }
+
+  // 列表右侧弹出元素方法，包含事件触发
+  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);
+      }
+    });
+  }
+
+  // 获取列表长度方法，包含事件触发
+  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);
+      }
+    });
+  }
+
+  // 集合移除元素方法，包含事件触发
+  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);
+      }
+    });
+  }
+
+  // 获取集合所有成员方法，包含事件触发
+  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([]);
+      }
+    });
+  }
+
+  // 检查元素是否在集合中方法，包含事件触发
+  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);
+      }
+    });
+  }
+
+  // 获取集合大小方法，包含事件触发
+  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);
+      }
+    });
+  }
+
+  // 获取有序集合范围内的成员方法，包含事件触发
+  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([]);
+      }
+    });
+  }
+
+  // 从有序集合中移除成员方法，包含事件触发
+  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 zscore(key, member) {
+    return new Promise((resolve) => {
+      try {
+        // 触发前置事件
+        const beforeEventData = { 
+          key, 
+          value: { member }, 
+          cancel: false 
+        };
+        this.emit('zscore_before', beforeEventData);
+
+        // 如果事件处理器设置了cancel为true，则取消操作
+        if (beforeEventData.cancel) {
+          resolve(null);
+          return;
+        }
+
+        // 执行实际操作
+        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];
+        }
+
+        // 触发后置事件
+        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);
+      }
+    });
+  }
+
+  // 资源销毁方法，包含事件触发
+  dispose() {
+    try {
+      // 触发前置事件
+      const beforeEventData = { cancel: false };
+      this.emit('dispose_before', beforeEventData);
+
+      // 如果事件处理器设置了cancel为true，则取消操作
+      if (beforeEventData.cancel) {
+        return;
+      }
+
+      // 执行实际操作
+      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);
+    }
+  }
 }
 
-/**
- * @description 获取缓存对象
- * @param {String} key 键
- * @return {String} 对象
- */
-CacheBase.prototype.getObj = function(key) {
-	var obj = this.list.getObj({
-		name: key
-	});
-	if (obj && obj.expires) {
-		var cha = Date.parse(obj.expires) - Date.parse(new Date());
-		if (cha < 1) {
-			this.delObj(key);
-			obj = undefined;
-		}
-	}
-	return obj;
-};
-/**
- * @description 删除缓存对象
- * @param {String} key 键
- * @return {Number} 成功返回1，否则返回0
- */
-CacheBase.prototype.delObj = function(key) {
-	this.list.del({
-		name: key
-	}, true);
-	return 1;
-};
-
-/**
- * @description 设置缓存对象
- * @param {Object} obj 值
- * @return {Number} 成功返回1，否则返回0
- */
-CacheBase.prototype.addObj = function(obj) {
-	obj.id = obj.name.md5();
-	var maxAge = obj.maxAge;
-	if (maxAge > 0) {
-		// 如果maxAge大于0则设置缓存时长
-		obj.expires = new Date().addSeconds(maxAge).toUTCString();
-	} else {
-		obj.maxAge = -1;
-		obj.expires = null;
-	}
-	this.list.push(obj);
-	return 1;
-};
-
-/**
- * @description 查询或是设置缓存过期时间
- * @param {String} key 键
- * @param {Number} maxAge 秒, 为空则查询有效时长
- * @return {Promise|Number|Boolean} 查询时长或设置结果, 时长为-1表示永不过期
- */
-CacheBase.prototype.ttl = async function(key, maxAge) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (obj) {
-			if (maxAge === undefined) {
-				// 如果maxAge没有设置则查询时长
-				if (obj.expires) {
-					// 如果有效期
-					var cha = Date.parse(obj.expires) - Date.parse(new Date());
-					maxAge = parseInt(cha / 1000);
-				} else {
-					maxAge = obj.maxAge;
-				}
-				resolve(maxAge);
-				return;
-			} else if (maxAge > 0) {
-				// 如果maxAge大于0则设置缓存时长
-				obj.maxAge = maxAge;
-				obj.expires = new Date().addSeconds(maxAge).toUTCString();
-			} else if (maxAge < 0) {
-				// 如果maxAge小于0则设置缓存时长为永久
-				obj.maxAge = -1;
-				obj.expires = null;
-			} else {
-				// 如果maxAge等于0则设置删除缓存
-				_this.delObj(key);
-			}
-			resolve(1);
-		} else {
-			resolve(0);
-		}
-	});
-};
-/**
- * @description 增加整数值(负数为减)
- * @param {String} key 键
- * @param {Number} num 数值
- * @return {Promise|Number} 计算后的结果
- */
-CacheBase.prototype.addInt = async function(key, num) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (obj) {
-			obj.value += num;
-			resolve(obj.value);
-		} else {
-			resolve(0);
-		}
-	});
-};
-/**
- * @description 增加浮点数值(负数为减)
- * @param {String} key 键
- * @param {Number} num 数值
- * @return {Promise|Number} 计算后的结果
- */
-CacheBase.prototype.addFloat = async function(key, num) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (obj) {
-			obj.value += num;
-			resolve(obj.value);
-		} else {
-			resolve(0);
-		}
-	});
-};
-/**
- * @description 增加字符串值到指定缓存
- * @param {String} key 键
- * @param {String} str 添加的字符串
- * @return {Promise|String} 添加后的字符串
- */
-CacheBase.prototype.addStr = async function(key, str) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (obj) {
-			obj.value += str;
-			resolve(obj.value);
-		} else {
-			resolve(0);
-		}
-	});
-};
-/**
- * @description 删除缓存
- * @param {String} key 键
- * @return {Promise|Boolean} 成功返回true,失败返回false
- */
-CacheBase.prototype.del = async function(key) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var ret = _this.delObj(key);
-		resolve(ret);
-	});
-};
-/**
- * @description 修改缓存
- * @param {String} key 键
- * @param {Object} value 值
- * @param {Number} maxAge 秒
- * @return {Object} 值
- */
-CacheBase.prototype.setVal = function(key, value, maxAge) {
-	var _this = this;
-	var obj = _this.getObj(key);
-	if (obj) {
-		obj.value = value;
-		if (maxAge !== undefined) {
-			_this.ttl(key, maxAge);
-		}
-	} else {
-		if (maxAge === undefined) {
-			maxAge = -1;
-		}
-		obj = {
-			name: key,
-			value: value,
-			maxAge: maxAge
-		};
-		_this.addObj(obj);
-	}
-	return obj.value;
-};
-/**
- * @description 修改缓存
- * @param {String} key 键
- * @param {Object} value 值
- * @param {Number} maxAge 秒
- * @return {Promise|Object} 值
- */
-CacheBase.prototype.set = async function(key, value, maxAge) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var ret = _this.setVal(key, value, maxAge);
-		resolve(ret);
-	});
-};
-/**
- * @description 增加缓存 增加缓存和修改缓存不一样, 如果键存在则不会增加
- * @param {String} key 键
- * @param {Object} value 值
- * @param {Number} maxAge 秒
- * @return {Promise<Object>} 添加成功返回值, 如果已存在则返回null
- */
-CacheBase.prototype.add = async function(key, value, maxAge) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (!obj) {
-			var ret = _this.setVal(key, value, maxAge);
-			resolve(ret);
-		} else {
-			resolve(0);
-		}
-	});
-};
-/**
- * @description 查询缓存
- * @param {String} key 键
- * @return {Promise|Object} 查询值
- */
-CacheBase.prototype.get = async function(key) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (obj) {
-			resolve(obj.value);
-		} else {
-			resolve(undefined);
-		}
-	});
-};
-/**
- * @description 判断键是否存在
- * @param {String} key 键
- * @return {Promise|Boolean} 有返回true, 没有返回false
- */
-CacheBase.prototype.has = async function(key) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		resolve(obj ? 1 : 0);
-	});
-};
-/**
- * @description 查询缓存的字符串中的一段字符串
- * @param {String} key 键
- * @param {Number} start 开始位置
- * @param {Number} end 结束位置
- * @return {Promise|String} 查询值
- */
-CacheBase.prototype.getrange = async function(key, start, end) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (obj) {
-			resolve(obj.value.substring(start, end));
-		} else {
-			resolve('');
-		}
-	});
-};
-/**
- * @description 在值的指定位置开始增加一段字符串
- * @param {String} key 键
- * @param {Number} index 开始位置
- * @param {String} value 变更的值
- * @return {Promise|Number} 字符串长度
- */
-CacheBase.prototype.setrange = async function(key, index, value) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (obj) {
-			var val = obj.value;
-			var start = val.substring(0, index);
-			var end = val.substring(index, val.length);
-			obj.value = start + value + end;
-			resolve(obj.value);
-		} else {
-			resolve('');
-		}
-	});
-};
-/**
- * @description 清空缓存
- * @param {String} key 键, 为空则清空所有
- * @return {Promise|Array} 执行结果
- */
-CacheBase.prototype.clear = async function(key) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		if (key) {
-			for (var i = this.list.length - 1; i >= 0; i--) {
-				if (this.list[i].name.has(key)) {
-					_this.delObj(this.list[i].name);
-				}
-			}
-		} else {
-			for (var i = this.list.length - 1; i >= 0; i--) {
-				_this.delObj(this.list[i].name);
-			}
-		}
-		resolve(1);
-	});
-};
-/**
- * @description 排序
- * @param {String} key 键
- * @param {String} way = [asc|desc]排序方式, 可以为空
- * @param {String} obj_key 排序成员的键
- * @return {Promise|Array} 排序后的数组
- */
-CacheBase.prototype.sort = async function(key, way, obj_key) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (obj) {
-			if (obj.value.constructor == Array) {
-				obj.value.sortBy(way, obj_key);
-				resolve(1);
-			} else {
-				resolve(-1);
-			}
-		} else {
-			resolve(0);
-		}
-	});
-};
-/**
- * @description 获取所有键名
- * @param {String} key 键 支持*号, 前面加*表示后面名称一致, 前后加*表示包含名称, 后面加*表示前面名称一致
- * @return {Promise|Array} 键数组
- */
-CacheBase.prototype.keys = async function(key) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		if (key) {
-			var list = _this.list.search(key, 'name');
-			resolve(list.toArr('name'));
-		} else {
-			resolve(_this.list.toArr('name'));
-		}
-	});
-};
-/**
- * @description 修改数组缓存
- * @param {String} key 键
- * @param {Object} value 值
- * @param {Number} maxAge 秒
- * @return {Promise|Array} 执行结果
- */
-CacheBase.prototype.list_set = async function(key, value, maxAge) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var ret = _this.setVal(key, value, maxAge);
-		resolve(ret);
-	});
-};
-/**
- * @description 数组缓存追加对象
- * @param {String} key 键
- * @param {Object} value 值
- * @return {Promise|String} 追加后的数组
- */
-CacheBase.prototype.list_add = async function(key, value) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (obj) {
-			var arr = obj.value;
-			if (arr.constructor == Array) {
-				arr.push(value);
-				obj.value = arr;
-				resolve(1);
-			} else {
-				_this.error = "当前缓存值非数组";
-				resolve(-1);
-			}
-		} else {
-			resolve(0);
-		}
-	});
-};
-/**
- * @description 判断成员是否存在
- * @param {String} key 键
- * @param {Object} value 值
- * @return {Promise|Boolean} 存在返回true, 否则返回false
- */
-CacheBase.prototype.list_has = async function(key, value) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (obj) {
-			if (obj.value.constructor == Array) {
-				resolve(obj.value.has(value));
-			} else {
-				_this.error = "当前缓存值非数组";
-				resolve(-1);
-			}
-		} else {
-			resolve(0);
-		}
-	});
-};
-/**
- * @description 查询数组缓存
- * @param {String} key 键
- * @param {Number} start 起始位置
- * @param {Number} end 结束位置
- * @return {Promise|Array} 查询到的数组
- */
-CacheBase.prototype.list_get = async function(key, start, end) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (obj) {
-			if (obj.value.constructor == Array) {
-				var lt = obj.value;
-				if (!end) {
-					end = lt.length;
-				}
-				if (!start) {
-					start = 0;
-				}
-				var list = [];
-				for (var i = start; i < end; i++) {
-					list.push(lt[i]);
-				}
-				resolve(list);
-			} else {
-				_this.error = "当前缓存值非数组";
-				resolve([]);
-			}
-		} else {
-			resolve([]);
-		}
-	});
-};
-/**
- * @description 清空数组缓存
- * @param {String} key 键
- * @param {Array} value 新成员, 没有则删除数组
- * @return {Promise|Boolean} 成功返回true，是否返回false
- */
-CacheBase.prototype.list_clear = async function(key, value) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		if (value) {
-			var obj = _this.getObj(key);
-			if (obj) {
-				obj.value = value;
-				resolve(1);
-			} else {
-				resolve(0);
-			}
-		} else {
-			var ret = _this.del(key);
-			resolve(ret);
-		}
-	});
-};
-/**
- * @description 到期通知
- * @param {Object} obj 对象
- */
-CacheBase.prototype.notity = function(obj) {
-	if (this.func) {
-		this.func(obj);
-	}
-};
-
-// 导出CacheBase函数
+// 导出CacheBase类
 module.exports = CacheBase;
+