mm_cachebase 1.4.5 → 1.5.0

package/index.js

@@ -1,537 +1,1217 @@
-/**
- * @fileOverview 本地缓存类
- * @author <a href="http://qww.elins.cn">邱文武</a>
- * @version 1.0
- */
-require('mm_expand');
-
-/**
- * 创建基本缓存CacheBase帮助类函数
- */
-class CacheBase {
-	/**
-	 * 构造函数
-	 */
-	constructor() {
-		// 缓存的字典
-		this.dict = {};
-		// 到期通知函数
-		this.func;
-		/*
-		格式:
-		{
-		    {
-		        // ID，为时间戳
-		        id:
-		        // 键名
-		        name:
-		        // 保存值
-		        value: "hello world",
-		        // 最大时效
-		        maxAge: -1,
-		        // 到期时间
-		        expires: ""
-		    }
-		}
-		*/
-	}
-
-	get list() {
-		var list = [];
-		for (var key in this.dict) {
-			list.push(this.dict[key]);
-		}
-		return list;
-	}
-
-	set list(lt) {
-		this.dict = {};
-		for (var i = 0; i < lt.length; i++) {
-			var o = lt;
-			this.dict[o.name] = o;
-		}
-	}
+require('mm_logs');
+const EventEmitter = require('events');
+
+// 符合Redis API的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(0);
+          return;
+        }
+
+        // 执行实际操作
+        this.data[key] = { value, expire: 0 };
+        
+        // 如果键不存在于列表中，添加到列表
+        if (!this.list.includes(key)) {
+          this.list.push(key);
+        }
+
+        // 触发后置事件
+        this.emit('set_after', { 
+          key, 
+          value, 
+          result: 'OK' 
+        });
+        resolve('OK');
+      } 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);
+      }
+    });
+  }
+
+  // Redis兼容的getset方法
+  async getset(key, value) {
+    return new Promise((resolve) => {
+      try {
+        // 触发前置事件
+        const beforeEventData = { 
+          key, 
+          value,
+          cancel: false 
+        };
+        this.emit('getset_before', beforeEventData);
+
+        // 如果事件处理器设置了cancel为true，则取消操作
+        if (beforeEventData.cancel) {
+          resolve(null);
+          return;
+        }
+
+        // 获取旧值
+        const obj = this.data[key];
+        const oldValue = obj ? obj.value : null;
+        
+        // 设置新值
+        this.data[key] = { value, expire: 0 };
+        
+        // 如果键不存在于列表中，添加到列表
+        if (!this.list.includes(key)) {
+          this.list.push(key);
+        }
+
+        // 触发后置事件
+        this.emit('getset_after', { 
+          key, 
+          value,
+          result: oldValue 
+        });
+        resolve(oldValue);
+      } catch (error) {
+        // 触发错误事件
+        this.emit('getset_error', { 
+          key, 
+          value,
+          error 
+        });
+        $.log.error('[cachebase] getset操作失败:', error);
+        resolve(null);
+      }
+    });
+  }
+
+  // Redis兼容的append方法
+  async append(key, value) {
+    return new Promise((resolve) => {
+      try {
+        // 触发前置事件
+        const beforeEventData = { 
+          key, 
+          value,
+          cancel: false 
+        };
+        this.emit('append_before', beforeEventData);
+
+        // 如果事件处理器设置了cancel为true，则取消操作
+        if (beforeEventData.cancel) {
+          resolve(0);
+          return;
+        }
+
+        // 获取当前值或默认为空字符串
+        const obj = this.data[key];
+        let currentValue = '';
+        if (obj) {
+          currentValue = String(obj.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 
+        });
+        resolve(result);
+      } catch (error) {
+        // 触发错误事件
+        this.emit('append_error', { 
+          key, 
+          value,
+          error 
+        });
+        $.log.error('[cachebase] append操作失败:', error);
+        resolve(0);
+      }
+    });
+  }
+
+  // Redis兼容的strlen方法
+  async strlen(key) {
+    return new Promise((resolve) => {
+      try {
+        // 触发前置事件
+        const beforeEventData = { 
+          key,
+          cancel: false 
+        };
+        this.emit('strlen_before', beforeEventData);
+
+        // 如果事件处理器设置了cancel为true，则取消操作
+        if (beforeEventData.cancel) {
+          resolve(0);
+          return;
+        }
+
+        // 执行实际操作
+        const obj = this.data[key];
+        let result = 0;
+        if (obj) {
+          result = String(obj.value).length;
+        }
+
+        // 触发后置事件
+        this.emit('strlen_after', { 
+          key,
+          result 
+        });
+        resolve(result);
+      } catch (error) {
+        // 触发错误事件
+        this.emit('strlen_error', { 
+          key,
+          error 
+        });
+        $.log.error('[cachebase] strlen操作失败:', error);
+        resolve(0);
+      }
+    });
+  }
+
+  // 哈希表设置方法 - 模拟实现
+  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 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);
+      }
+    });
+  }
+
+  // 修复的mset方法 - Redis兼容格式
+  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(null);
+          return;
+        }
+
+        // 参数校验
+        if (args.length % 2 !== 0) {
+          $.log.error('[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');
+      }
+    });
+  }
+
+  // 修复的mget方法 - 返回数组格式，与Redis保持一致
+  async mget(...keys) {
+    return new Promise((resolve) => {
+      try {
+        // 触发前置事件
+        const beforeEventData = { 
+          value: { keys }, 
+          cancel: false 
+        };
+        this.emit('mget_before', beforeEventData);
+
+        // 如果事件处理器设置了cancel为true，则取消操作
+        if (beforeEventData.cancel) {
+          resolve([]);
+          return;
+        }
+
+        // 执行实际操作 - 返回数组格式，与Redis保持一致
+        const result = keys.map(key => {
+          const obj = this.data[key];
+          return obj ? obj.value : null;
+        });
+
+        // 触发后置事件
+        this.emit('mget_after', { 
+          value: { keys }, 
+          result 
+        });
+        resolve(result);
+      } catch (error) {
+        // 触发错误事件
+        this.emit('mget_error', { 
+          value: { keys }, 
+          error 
+        });
+        $.log.error('[cachebase] mget操作失败:', error);
+        resolve([]);
+      }
+    });
+  }
+
+  // Redis兼容的exists方法，支持多个键
+  async exists(...keys) {
+    return new Promise((resolve) => {
+      try {
+        // 触发前置事件
+        const beforeEventData = { 
+          value: { keys }, 
+          cancel: false 
+        };
+        this.emit('exists_before', beforeEventData);
+
+        // 如果事件处理器设置了cancel为true，则取消操作
+        if (beforeEventData.cancel) {
+          resolve(0);
+          return;
+        }
+
+        // 执行实际操作
+        const result = keys.filter(key => key in this.data).length;
+
+        // 触发后置事件
+        this.emit('exists_after', { 
+          value: { keys }, 
+          result 
+        });
+        resolve(result);
+      } catch (error) {
+        // 触发错误事件
+        this.emit('exists_error', { 
+          value: { keys }, 
+          error 
+        });
+        $.log.error('[cachebase] exists操作失败:', error);
+        resolve(0);
+      }
+    });
+  }
+
+  // 查询/设置过期时间方法，包含事件触发
+  async ttl(key) {
+    return new Promise((resolve) => {
+      try {
+        // 触发前置事件
+        const beforeEventData = { 
+          key,
+          cancel: false 
+        };
+        this.emit('ttl_before', beforeEventData);
+
+        // 如果事件处理器设置了cancel为true，则取消操作
+        if (beforeEventData.cancel) {
+          resolve(-2);
+          return;
+        }
+
+        // 执行实际操作
+        const obj = this.data[key];
+        let result;
+        
+        if (!obj) {
+          result = -2; // 键不存在
+        } 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,
+          result 
+        });
+        resolve(result);
+      } catch (error) {
+        // 触发错误事件
+        this.emit('ttl_error', { 
+          key,
+          error 
+        });
+        $.log.error('[cachebase] ttl操作失败:', error);
+        resolve(-2);
+      }
+    });
+  }
+
+  // Redis兼容的expire方法
+  async expire(key, seconds) {
+    return new Promise((resolve) => {
+      try {
+        // 触发前置事件
+        const beforeEventData = { 
+          key,
+          value: { seconds },
+          cancel: false 
+        };
+        this.emit('expire_before', beforeEventData);
+
+        // 如果事件处理器设置了cancel为true，则取消操作
+        if (beforeEventData.cancel) {
+          resolve(0);
+          return;
+        }
+
+        // 执行实际操作
+        const obj = this.data[key];
+        let result = 0;
+        
+        if (obj) {
+          if (seconds === 0) {
+            obj.expire = 0; // 永不过期
+          } else {
+            obj.expire = Date.now() + (parseInt(seconds, 10) * 1000);
+          }
+          result = 1;
+        }
+
+        // 触发后置事件
+        this.emit('expire_after', { 
+          key,
+          value: { seconds },
+          result 
+        });
+        resolve(result);
+      } catch (error) {
+        // 触发错误事件
+        this.emit('expire_error', { 
+          key,
+          value: { seconds },
+          error 
+        });
+        $.log.error('[cachebase] expire操作失败:', error);
+        resolve(0);
+      }
+    });
+  }
+
+  // Redis兼容的persist方法
+  async persist(key) {
+    return new Promise((resolve) => {
+      try {
+        // 触发前置事件
+        const beforeEventData = { 
+          key,
+          cancel: false 
+        };
+        this.emit('persist_before', beforeEventData);
+
+        // 如果事件处理器设置了cancel为true，则取消操作
+        if (beforeEventData.cancel) {
+          resolve(0);
+          return;
+        }
+
+        // 执行实际操作
+        const obj = this.data[key];
+        let result = 0;
+        
+        if (obj && obj.expire !== 0) {
+          obj.expire = 0; // 移除过期时间
+          result = 1;
+        }
+
+        // 触发后置事件
+        this.emit('persist_after', { 
+          key,
+          result 
+        });
+        resolve(result);
+      } catch (error) {
+        // 触发错误事件
+        this.emit('persist_error', { 
+          key,
+          error 
+        });
+        $.log.error('[cachebase] persist操作失败:', error);
+        resolve(0);
+      }
+    });
+  }
+
+  // 获取所有匹配键方法，包含事件触发
+  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([]);
+      }
+    });
+  }
+
+  // Redis兼容的dbsize方法
+  async dbsize() {
+    return new Promise((resolve) => {
+      try {
+        // 触发前置事件
+        const beforeEventData = { 
+          cancel: false 
+        };
+        this.emit('dbsize_before', beforeEventData);
+
+        // 如果事件处理器设置了cancel为true，则取消操作
+        if (beforeEventData.cancel) {
+          resolve(0);
+          return;
+        }
+
+        // 执行实际操作
+        const result = this.list.length;
+
+        // 触发后置事件
+        this.emit('dbsize_after', { 
+          result 
+        });
+        resolve(result);
+      } catch (error) {
+        // 触发错误事件
+        this.emit('dbsize_error', { 
+          error 
+        });
+        $.log.error('[cachebase] dbsize操作失败:', error);
+        resolve(0);
+      }
+    });
+  }
+
+  // Redis兼容的flushdb方法
+  async flushdb() {
+    return new Promise((resolve) => {
+      try {
+        // 触发前置事件
+        const beforeEventData = { 
+          cancel: false 
+        };
+        this.emit('flushdb_before', beforeEventData);
+
+        // 如果事件处理器设置了cancel为true，则取消操作
+        if (beforeEventData.cancel) {
+          resolve(null);
+          return;
+        }
+
+        // 执行实际操作
+        this.data = {};
+        this.list = [];
+        this.dict = this.data; // 同步dict引用
+
+        // 触发后置事件
+        this.emit('flushdb_after', { 
+          result: 'OK' 
+        });
+        resolve('OK');
+      } catch (error) {
+        // 触发错误事件
+        this.emit('flushdb_error', { 
+          error 
+        });
+        $.log.error('[cachebase] flushdb操作失败:', error);
+        resolve(null);
+      }
+    });
+  }
+
+  // Redis兼容的incr方法
+  async incr(key) {
+    return new Promise((resolve) => {
+      try {
+        // 触发前置事件
+        const beforeEventData = { 
+          key,
+          cancel: false 
+        };
+        this.emit('incr_before', beforeEventData);
+
+        // 如果事件处理器设置了cancel为true，则取消操作
+        if (beforeEventData.cancel) {
+          resolve(0);
+          return;
+        }
+
+        // 获取当前值或默认为0
+        let currentValue = 0;
+        if (this.data[key] && !isNaN(this.data[key].value)) {
+          currentValue = parseInt(this.data[key].value, 10);
+        }
+
+        // 执行递增
+        const result = currentValue + 1;
+        
+        // 保存结果
+        this.data[key] = { value: result, expire: 0 };
+        
+        // 如果键不存在于列表中，添加到列表
+        if (!this.list.includes(key)) {
+          this.list.push(key);
+        }
+
+        // 触发后置事件
+        this.emit('incr_after', { 
+          key,
+          result 
+        });
+        resolve(result);
+      } catch (error) {
+        // 触发错误事件
+        this.emit('incr_error', { 
+          key,
+          error 
+        });
+        $.log.error('[cachebase] incr操作失败:', error);
+        resolve(0);
+      }
+    });
+  }
+
+  // Redis兼容的decr方法
+  async decr(key) {
+    return new Promise((resolve) => {
+      try {
+        // 触发前置事件
+        const beforeEventData = { 
+          key,
+          cancel: false 
+        };
+        this.emit('decr_before', beforeEventData);
+
+        // 如果事件处理器设置了cancel为true，则取消操作
+        if (beforeEventData.cancel) {
+          resolve(0);
+          return;
+        }
+
+        // 获取当前值或默认为0
+        let currentValue = 0;
+        if (this.data[key] && !isNaN(this.data[key].value)) {
+          currentValue = parseInt(this.data[key].value, 10);
+        }
+
+        // 执行递减
+        const result = currentValue - 1;
+        
+        // 保存结果
+        this.data[key] = { value: result, expire: 0 };
+        
+        // 如果键不存在于列表中，添加到列表
+        if (!this.list.includes(key)) {
+          this.list.push(key);
+        }
+
+        // 触发后置事件
+        this.emit('decr_after', { 
+          key,
+          result 
+        });
+        resolve(result);
+      } catch (error) {
+        // 触发错误事件
+        this.emit('decr_error', { 
+          key,
+          error 
+        });
+        $.log.error('[cachebase] decr操作失败:', error);
+        resolve(0);
+      }
+    });
+  }
+
+  // Redis兼容的incrby方法
+  async incrby(key, increment) {
+    return new Promise((resolve) => {
+      try {
+        // 触发前置事件
+        const beforeEventData = { 
+          key,
+          value: { increment },
+          cancel: false 
+        };
+        this.emit('incrby_before', beforeEventData);
+
+        // 如果事件处理器设置了cancel为true，则取消操作
+        if (beforeEventData.cancel) {
+          resolve(0);
+          return;
+        }
+
+        // 获取当前值或默认为0
+        let currentValue = 0;
+        if (this.data[key] && !isNaN(this.data[key].value)) {
+          currentValue = parseInt(this.data[key].value, 10);
+        }
+
+        // 执行递增
+        const result = currentValue + parseInt(increment, 10);
+        
+        // 保存结果
+        this.data[key] = { value: result, expire: 0 };
+        
+        // 如果键不存在于列表中，添加到列表
+        if (!this.list.includes(key)) {
+          this.list.push(key);
+        }
+
+        // 触发后置事件
+        this.emit('incrby_after', { 
+          key,
+          value: { increment },
+          result 
+        });
+        resolve(result);
+      } catch (error) {
+        // 触发错误事件
+        this.emit('incrby_error', { 
+          key,
+          value: { increment },
+          error 
+        });
+        $.log.error('[cachebase] incrby操作失败:', error);
+        resolve(0);
+      }
+    });
+  }
+
+  // Redis兼容的decrby方法
+  async decrby(key, decrement) {
+    return new Promise((resolve) => {
+      try {
+        // 触发前置事件
+        const beforeEventData = { 
+          key,
+          value: { decrement },
+          cancel: false 
+        };
+        this.emit('decrby_before', beforeEventData);
+
+        // 如果事件处理器设置了cancel为true，则取消操作
+        if (beforeEventData.cancel) {
+          resolve(0);
+          return;
+        }
+
+        // 获取当前值或默认为0
+        let currentValue = 0;
+        if (this.data[key] && !isNaN(this.data[key].value)) {
+          currentValue = parseInt(this.data[key].value, 10);
+        }
+
+        // 执行递减
+        const result = currentValue - parseInt(decrement, 10);
+        
+        // 保存结果
+        this.data[key] = { value: result, expire: 0 };
+        
+        // 如果键不存在于列表中，添加到列表
+        if (!this.list.includes(key)) {
+          this.list.push(key);
+        }
+
+        // 触发后置事件
+        this.emit('decrby_after', { 
+          key,
+          value: { decrement },
+          result 
+        });
+        resolve(result);
+      } catch (error) {
+        // 触发错误事件
+        this.emit('decrby_error', { 
+          key,
+          value: { decrement },
+          error 
+        });
+        $.log.error('[cachebase] decrby操作失败:', error);
+        resolve(0);
+      }
+    });
+  }
+
+  // Redis兼容的incrbyfloat方法
+  async incrbyfloat(key, increment) {
+    return new Promise((resolve) => {
+      try {
+        // 触发前置事件
+        const beforeEventData = { 
+          key,
+          value: { increment },
+          cancel: false 
+        };
+        this.emit('incrbyfloat_before', beforeEventData);
+
+        // 如果事件处理器设置了cancel为true，则取消操作
+        if (beforeEventData.cancel) {
+          resolve(0);
+          return;
+        }
+
+        // 获取当前值或默认为0
+        let currentValue = 0;
+        if (this.data[key] && !isNaN(this.data[key].value)) {
+          currentValue = parseFloat(this.data[key].value);
+        }
+
+        // 执行浮点递增
+        const result = currentValue + parseFloat(increment);
+        
+        // 保存结果
+        this.data[key] = { value: result, expire: 0 };
+        
+        // 如果键不存在于列表中，添加到列表
+        if (!this.list.includes(key)) {
+          this.list.push(key);
+        }
+
+        // 触发后置事件
+        this.emit('incrbyfloat_after', { 
+          key,
+          value: { increment },
+          result 
+        });
+        resolve(result);
+      } catch (error) {
+        // 触发错误事件
+        this.emit('incrbyfloat_error', { 
+          key,
+          value: { increment },
+          error 
+        });
+        $.log.error('[cachebase] incrbyfloat操作失败:', error);
+        resolve(0);
+      }
+    });
+  }
+
+  // 保持兼容性的方法
+  async has(key) {
+    return this.exists(key);
+  }
+
+  async clear(pattern) {
+    return this.flushdb();
+  }
+
+  async add(key, value) {
+    return this.incrby(key, value);
+  }
+
+  async addFloat(key, value) {
+    return this.incrbyfloat(key, value);
+  }
+
+  async addStr(key, value) {
+    return this.append(key, value);
+  }
+
+  // 资源销毁方法，包含事件触发
+  dispose() {
+    try {
+      // 触发前置事件
+      const beforeEventData = { cancel: false };
+      this.emit('dispose_before', beforeEventData);
+
+      // 如果事件处理器设置了cancel为true，则取消操作
+      if (beforeEventData.cancel) {
+        return;
+      }
+
+      // 执行实际操作
+      this.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.dict[key];
-	if (obj && obj.expires) {
-		var cha = obj.expires - new Date().stamp();
-		if (cha < 1) {
-			this.delObj(key);
-			obj = undefined;
-		}
-	}
-	return obj;
-};
-/**
- * @description 删除缓存对象
- * @param {String} key 键
- * @return {Number} 成功返回1，否则返回0
- */
-CacheBase.prototype.delObj = function(key) {
-	delete this.dict[key];
-	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).stamp();
-	} else {
-		obj.maxAge = -1;
-		obj.expires = null;
-	}
-	this.dict[obj.name] = 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).stamp();
-			} 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) {
-			var keys = Object.keys(this.dict);
-			for (var i = 0; i < keys.length; i++) {
-				var name = keys[i];
-				if (name.has(key)) {
-					_this.delObj(name);
-				}
-			}
-		} else {
-			this.dict = {};
-		}
-		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 keys = Object.keys(this.dict);
-			var list = [];
-			for (var i = 0; i < keys.length; i++) {
-				var name = keys[i];
-				if (name.has(key)) {
-					list.push(name);
-				}
-			}
-			resolve(list.toArr('name'));
-		} else {
-			var keys = Object.keys(this.dict);
-			resolve(keys);
-		}
-	});
-};
-
-/**
- * @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函数
-module.exports = CacheBase;
+// 导出CacheBase类
+module.exports = CacheBase;
+