mm_cachebase 1.9.8 → 2.0.0

package/index.js

@@ -1,5 +1,6 @@
 /**
  * CacheBase 是一个通用缓存基类，支持内存缓存和持久化缓存
+ * 接口与 mm_redis 完全对齐：全异步、冒号风格事件、统一签名与返回值
  * @class CacheBase
  * @extends Base
  */
@@ -51,8 +52,14 @@ class CacheBase extends Base {
 		this.is_inited = false;
 		this.is_destroyed = false;
 
+		// 连接状态（与 mm_redis 保持一致）
+		this.connected = false;
+
+		// 发布订阅频道回调
+		this._channels = {};
+
 		this.setConfig(config);
-		// 初始化服务
+		// 初始化服务（内存缓存特性：构造即初始化）
 		this.init();
 	}
 }
@@ -66,7 +73,7 @@ CacheBase.prototype.setConfig = function (config) {
 	const external_config = this._loadExternalConfig();
 	// 更新配置
 	Object.assign(this.config, external_config, config);
-}
+};
 
 /**
  * 初始化服务
@@ -80,16 +87,17 @@ CacheBase.prototype.init = async function () {
 	try {
 		await this._initService();
 		this.is_inited = true;
+		this.connected = true;
 	} catch (error) {
 		this.log('error', 'Failed to initialize CacheBase service:', error);
 	}
 };
 
 /**
-	 * 加载外部配置文件
-	 * @private
-	 * @returns {Object} 外部配置对象
-	 */
+ * 加载外部配置文件
+ * @private
+ * @returns {Object} 外部配置对象
+ */
 CacheBase.prototype._loadExternalConfig = function () {
 	try {
 		const config_path = './config/cachebase.config.json'.fullname(__dirname);
@@ -199,9 +207,9 @@ CacheBase.prototype.save = function () {
 	}
 
 	try {
-		this.emit('save_before');
+		this.emit('save:before');
 		this._saveData();
-		this.emit('save_after');
+		this.emit('save:after');
 	} catch (error) {
 		this.log('error', 'Failed to save data:', error);
 	}
@@ -260,34 +268,114 @@ CacheBase.prototype.destroy = async function () {
 		this._data = {};
 		this._expires = {};
 		this._types = {};
+		this._channels = {};
 
 		// 设置销毁状态
 		this.is_inited = false;
 		this.is_destroyed = true;
+		this.connected = false;
 
-		// 触发自定义销毁事件
-		this.emit('destroy_after');
+		// 触发销毁事件（注意：不可使用 'destroy:after' 冒号格式，
+		// mm_expand 的 Base.emit 会将冒号格式解释为 do 流程的阶段，触发 _destroyCore）
+		this.emit('destroy', { success: true });
 	} catch (error) {
 		this.log('error', 'Failed to destroy service:', error);
 	}
 };
 
 /**
- * 关闭缓存服务（兼容方法）
- * @returns {Promise<void>}
+ * 打开缓存服务（与 mm_redis 接口对齐）
+ * @returns {Promise<Boolean>} 连接结果
+ */
+CacheBase.prototype.open = async function () {
+	try {
+		if (!this.is_inited) {
+			await this.init();
+		}
+		return this.connected;
+	} catch (error) {
+		this.log('error', 'Failed to open CacheBase:', error);
+		return false;
+	}
+};
+
+/**
+ * 关闭缓存服务（与 mm_redis 接口对齐）
+ * @returns {Promise<Boolean>} 关闭结果
+ */
+CacheBase.prototype.close = async function () {
+	try {
+		await this.destroy();
+		return true;
+	} catch (error) {
+		this.log('error', 'Failed to close CacheBase:', error);
+		return false;
+	}
+};
+
+/**
+ * 检查连接状态（与 mm_redis 接口对齐）
+ * @returns {Boolean} 是否已连接
+ */
+CacheBase.prototype.isConnected = function () {
+	return this.connected;
+};
+
+/**
+ * 清理资源并销毁实例
+ * @returns {Boolean} 操作结果
  */
-CacheBase.prototype.close = function () {
-	return this.destroy();
+CacheBase.prototype.dispose = function () {
+	try {
+		// 防止重复销毁
+		if (this.is_destroyed) {
+			return true;
+		}
+
+		// 清除定时任务
+		if (this._save_timer) {
+			clearInterval(this._save_timer);
+			this._save_timer = null;
+		}
+
+		if (this._check_timer) {
+			clearInterval(this._check_timer);
+			this._check_timer = null;
+		}
+
+		// 清除所有数据
+		this._data = {};
+		this._expires = {};
+		this._types = {};
+		this._channels = {};
+
+		// 设置销毁状态
+		this.is_inited = false;
+		this.is_destroyed = true;
+		this.connected = false;
+
+		// 触发销毁事件
+		this.emit('destroy', {
+			success: true
+		});
+
+		return true;
+	} catch (error) {
+		this.log('error', 'Failed to dispose:', error);
+		return false;
+	}
 };
 
+// ==================== 键值操作 ====================
+
 /**
  * 设置键值对
- * @param {string} key - 键名
- * @param {*} value - 值
- * @param {number} [ttl] - 过期时间（秒）
- * @returns {boolean} 操作结果
+ * @param {String} key 键
+ * @param {*} value 值
+ * @param {Number} [seconds=0] 过期时间（秒），0表示永不过期
+ * @returns {Promise<Boolean>} 成功返回true，失败返回false
  */
-CacheBase.prototype.set = function (key, value, ttl) {
+CacheBase.prototype.set = async function (key, value, seconds = 0) {
 	// 检查服务状态
 	if (!this.is_inited || this.is_destroyed) {
 		this.log('error', 'Service is not initialized or has been destroyed');
@@ -300,55 +388,62 @@ CacheBase.prototype.set = function (key, value, ttl) {
 	}
 
 	try {
-
-		// 触发操作前事件
-		const event_data = {
+		// 触发前置事件
+		const ctx = {
 			key,
 			value,
-			ttl,
+			seconds,
 			cancel: false
 		};
-		this.emit('set_before', event_data);
+		this.emit('set:before', ctx);
 
-		if (event_data.cancel) {
+		if (ctx.cancel) {
+			this.log('debug', `set操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
+		// 使用可能被修改的值
+		const {
+			key: finalKey,
+			value: finalValue,
+			seconds: finalSeconds
+		} = ctx;
+
 		// 保存数据
-		this._data[key] = value;
+		this._data[finalKey] = finalValue;
 
 		// 设置类型
-		this._types[key] = this._getDataTypes(value);
+		this._types[finalKey] = this._getDataTypes(finalValue);
 
 		// 设置过期时间
-		if (ttl && typeof ttl === 'number' && ttl > 0) {
-			this._expires[key] = Date.now() + ttl * 1000;
+		if (finalSeconds && typeof finalSeconds === 'number' && finalSeconds > 0) {
+			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
 		} else {
-			// 清除过期时间
-			delete this._expires[key];
+			delete this._expires[finalKey];
 		}
 
-		// 触发操作后事件
-		this.emit('set_after', {
+		// 触发后置事件
+		this.emit('set:after', {
 			key,
 			value,
-			ttl,
-			result: 'OK'
+			seconds,
+			success: true
 		});
 
 		return true;
 	} catch (error) {
 		this.log('error', `Failed to set key ${key}:`, error);
+		this.emit('set:error', { key, value, seconds, error });
 		return false;
 	}
 };
 
 /**
  * 获取键值
- * @param {string} key - 键
- * @returns {*} 值
+ * @param {String} key 键
+ * @returns {Promise<Object|null>} 值，不存在或错误返回null
  */
-CacheBase.prototype.get = function (key) {
+CacheBase.prototype.get = async function (key) {
 	// 检查服务状态
 	if (!this.is_inited || this.is_destroyed) {
 		this.log('error', 'Service is not initialized or has been destroyed');
@@ -356,38 +451,41 @@ CacheBase.prototype.get = function (key) {
 	}
 
 	try {
+		this.emit('get:before', { key });
+
 		// 检查是否过期
 		if (this._isExpired(key)) {
-			this.del(key);
+			await this.del(key);
+			this.emit('get:after', { key, value: null });
 			return null;
 		}
 
-		return this._data[key];
+		const value = this._data[key];
+		this.emit('get:after', { key, value });
+		return value !== undefined ? value : null;
 	} catch (error) {
 		this.log('error', `Failed to get key ${key}:`, error);
+		this.emit('get:error', { key, error });
 		return null;
 	}
 };
 
 /**
  * 删除键
- * @param {string|Array<string>} key - 键名或键名数组
- * @returns {boolean} 是否成功删除
+ * @param {String|Array<String>} key 键名或键名数组
+ * @returns {Promise<Number>} 删除的键数量
  */
-CacheBase.prototype.del = function (key) {
+CacheBase.prototype.del = async function (key) {
 	// 参数验证
 	if (!key) {
 		throw new TypeError('key必须是非空字符串或非空字符串数组');
 	}
 
-	// 如果是单个键，验证是否为非空字符串
 	if (typeof key === 'string') {
 		if (!key) {
 			throw new TypeError('key必须是非空字符串');
 		}
-	}
-	// 如果是数组，验证每个元素是否为非空字符串
-	else if (Array.isArray(key)) {
+	} else if (Array.isArray(key)) {
 		for (const k of key) {
 			if (!k || typeof k !== 'string') {
 				throw new TypeError('key必须是非空字符串或非空字符串数组');
@@ -397,85 +495,73 @@ CacheBase.prototype.del = function (key) {
 		throw new TypeError('key必须是非空字符串或非空字符串数组');
 	}
 
+	// 检查服务状态
+	if (!this.is_inited || this.is_destroyed) {
+		this.log('error', 'Service is not initialized or has been destroyed');
+		return 0;
+	}
+
 	try {
-		// 触发操作前事件
-		const event_data = {
+		// 触发前置事件
+		const ctx = {
 			key,
 			cancel: false
 		};
-		this.emit('del_before', event_data);
+		this.emit('del:before', ctx);
 
-		if (event_data.cancel) {
-			return false;
+		if (ctx.cancel) {
+			return 0;
 		}
 
-		// 使用可能被修改的值
-		const finalKey = event_data.key;
-
-		let success = true;
-		let deleted = [];
+		const finalKey = ctx.key;
+		let deletedCount = 0;
 
 		if (Array.isArray(finalKey)) {
 			// 批量删除
 			for (const k of finalKey) {
-				// 检查键是否存在
 				if (k in this._data) {
-					// 删除键
 					delete this._data[k];
 					delete this._types[k];
 					delete this._expires[k];
-					deleted.push(k);
-				} else {
-					success = false;
+					deletedCount++;
 				}
 			}
 		} else {
 			// 单个删除
-			// 检查键是否存在
-			if (!(finalKey in this._data)) {
-				return false;
+			if (finalKey in this._data) {
+				delete this._data[finalKey];
+				delete this._types[finalKey];
+				delete this._expires[finalKey];
+				deletedCount++;
 			}
-
-			// 删除键
-			delete this._data[finalKey];
-			delete this._types[finalKey];
-			delete this._expires[finalKey];
-			deleted.push(finalKey);
 		}
 
-		// 触发操作后事件
-		this.emit('del_after', {
+		// 触发后置事件
+		this.emit('del:after', {
 			key: finalKey,
-			success,
-			deleted
+			success: deletedCount > 0,
+			deleted: deletedCount
 		});
 
-		return success;
+		return deletedCount;
 	} catch (error) {
 		this.log('error', 'Failed to del:', error);
-		return false;
+		this.emit('del:error', { key, error });
+		return 0;
 	}
 };
 
 /**
- * 批量删除键（兼容方法，推荐使用del方法）
- * @param {Array} keys - 键名数组
- * @returns {number} 删除的键数量
+ * 批量删除键
+ * @param {Array} keys 键名数组
+ * @returns {Promise<Number>} 删除的键数量
  */
-CacheBase.prototype.delBatch = function (keys) {
+CacheBase.prototype.delBatch = async function (keys) {
 	try {
 		if (!Array.isArray(keys)) {
 			return 0;
 		}
-
-		let deletedCount = 0;
-		for (const key of keys) {
-			if (this.del(key)) {
-				deletedCount++;
-			}
-		}
-
-		return deletedCount;
+		return await this.del(keys);
 	} catch (error) {
 		this.log('error', 'Failed to delBatch:', error);
 		return 0;
@@ -484,43 +570,54 @@ CacheBase.prototype.delBatch = function (keys) {
 
 /**
  * 检查键是否存在
- * @param {string} key - 键
- * @returns {boolean} 存在状态
+ * @param {String} key 键
+ * @returns {Promise<Number>} 存在返回1，不存在返回0
  */
-CacheBase.prototype.exists = function (key) {
+CacheBase.prototype.exists = async function (key) {
 	try {
+		this.emit('exists:before', { key });
+
 		if (this._isExpired(key)) {
-			this.del(key);
-			return false;
+			await this.del(key);
+			this.emit('exists:after', { key, result: 0 });
+			return 0;
 		}
 
-		return key in this._data;
+		const result = key in this._data ? 1 : 0;
+		this.emit('exists:after', { key, result });
+		return result;
 	} catch (error) {
 		this.log('error', `Failed to check key ${key}:`, error);
-		return false;
+		return 0;
 	}
 };
 
 /**
  * 检查键是否存在
- * @param {string} key - 键名
- * @returns {boolean} 是否存在
+ * @param {String} key 键名
+ * @returns {Promise<Boolean>} 是否存在
  */
-CacheBase.prototype.has = function (key) {
-	return this.exists(key);
+CacheBase.prototype.has = async function (key) {
+	const result = await this.exists(key);
+	return result > 0;
 };
 
 /**
  * 清空过期数据
+ * @returns {Promise<void>}
  */
-CacheBase.prototype.clearExpire = function () {
+CacheBase.prototype.clearExpire = async function () {
 	try {
 		const now = Date.now();
+		const expiredKeys = [];
 		for (const key in this._expires) {
 			if (this._expires[key] < now) {
-				this.del(key);
+				expiredKeys.push(key);
 			}
 		}
+		if (expiredKeys.length > 0) {
+			await this.del(expiredKeys);
+		}
 	} catch (error) {
 		this.log('error', 'Failed to clear expired data:', error);
 	}
@@ -529,8 +626,8 @@ CacheBase.prototype.clearExpire = function () {
 /**
  * 检查键是否过期
  * @private
- * @param {string} key - 键名
- * @returns {boolean} 是否过期
+ * @param {String} key 键名
+ * @returns {Boolean} 是否过期
  */
 CacheBase.prototype._isExpired = function (key) {
 	// 先检查键是否存在
@@ -546,37 +643,35 @@ CacheBase.prototype._isExpired = function (key) {
 	const now = Date.now();
 	const is_expired = now > this._expires[key];
 
-	// 惰性删除：如果过期了，删除键
-	if (is_expired) {
-		delete this._data[key];
-		delete this._types[key];
-		delete this._expires[key];
-	}
-
+	// 仅返回过期状态，不在此处做惰性删除。
+	// 删除统一由 del 方法完成，避免事件不成对。
 	return is_expired;
 };
 
 /**
  * 获取数据类型
  * @private
- * @param {*} value - 值
- * @returns {string} 数据类型
+ * @param {*} value 值
+ * @returns {String} 数据类型
  */
 CacheBase.prototype._getDataTypes = function (value) {
 	if (value === null) return 'null';
+	if (value instanceof Set) return 'set';
+	if (value instanceof Map) return 'zset';
 	if (Array.isArray(value)) return 'array';
 	return typeof value;
 };
 
+// ==================== 过期时间管理 ====================
+
 /**
  * 设置键的过期时间
- * @param {string} key - 键名
- * @param {number} seconds - 过期时间（秒）
- * @returns {boolean} 是否成功
+ * @param {String} key 键名
+ * @param {Number} seconds 过期时间（秒）
+ * @returns {Promise<Boolean>} 是否成功
  */
-CacheBase.prototype.expire = function (key, seconds) {
+CacheBase.prototype.expire = async function (key, seconds) {
 	try {
-		// 参数验证
 		if (!key || typeof key !== 'string') {
 			return false;
 		}
@@ -585,219 +680,391 @@ CacheBase.prototype.expire = function (key, seconds) {
 			return false;
 		}
 
-		// 触发设置过期前事件
-		const event_data = {
+		// 触发前置事件
+		const ctx = {
 			key,
-			seconds,
+			ttl: seconds,
 			cancel: false
 		};
-		this.emit('expire_before', event_data);
+		this.emit('expire:before', ctx);
 
-		if (event_data.cancel) {
+		if (ctx.cancel) {
 			return false;
 		}
 
+		const {
+			key: finalKey,
+			ttl: finalSeconds
+		} = ctx;
+
 		// 检查键是否存在
-		if (!(key in this._data)) {
+		if (!(finalKey in this._data)) {
 			return false;
 		}
 
 		// 设置过期时间
-		this._expires[key] = Date.now() + seconds * 1000;
+		this._expires[finalKey] = Date.now() + finalSeconds * 1000;
 
-		// 触发设置过期后事件
-		this.emit('expire_after', {
-			key,
-			seconds,
+		// 触发后置事件
+		this.emit('expire:after', {
+			key: finalKey,
+			ttl: finalSeconds,
 			success: true
 		});
 
 		return true;
 	} catch (error) {
 		this.log('error', `Failed to set expire for key ${key}:`, error);
+		this.emit('expire:error', { key, ttl: seconds, error });
 		return false;
 	}
 };
 
 /**
- * 设置哈希表字段
- * @param {string} key - 哈希表键名
- * @param {string} field - 字段名
- * @param {*} value - 值
- * @returns {number} 1表示新增，0表示更新或失败
+ * 设置键的过期时间（毫秒）
+ * @param {String} key 键名
+ * @param {Number} milliseconds 过期时间（毫秒）
+ * @returns {Promise<Boolean>} 是否成功
  */
-CacheBase.prototype.hset = function (key, field, value) {
+CacheBase.prototype.pexpire = async function (key, milliseconds) {
 	try {
-		// 参数验证
-		if (!key || typeof key !== 'string' || !field || typeof field !== 'string') {
-			return 0;
+		if (!key || typeof key !== 'string') {
+			throw new TypeError('key必须是非空字符串');
+		}
+		if (typeof milliseconds !== 'number' || milliseconds <= 0) {
+			throw new TypeError('milliseconds必须是正数');
 		}
 
-		// 触发设置前事件
-		const event_data = {
+		// 触发前置事件
+		const ctx = {
 			key,
-			field,
-			value,
+			ttl: milliseconds,
 			cancel: false
 		};
-		this.emit('hset_before', event_data);
+		this.emit('pexpire:before', ctx);
 
-		if (event_data.cancel) {
-			return 0;
+		if (ctx.cancel) {
+			return false;
 		}
 
-		// 初始化哈希表
-		if (!(key in this._data)) {
-			this._data[key] = {};
-			this._types[key] = 'hash';
-		} else if (this._types[key] !== 'hash') {
-			this._data[key] = {};
-			this._types[key] = 'hash';
-		}
+		const {
+			key: finalKey,
+			ttl: finalMilliseconds
+		} = ctx;
 
-		// 检查是否是新增字段
-		const is_new_field = !(field in this._data[key]);
+		// 检查键是否存在
+		if (!(finalKey in this._data)) {
+			return false;
+		}
 
-		// 设置字段值
-		this._data[key][field] = value;
+		// 设置过期时间（毫秒）
+		this._expires[finalKey] = Date.now() + finalMilliseconds;
 
-		// 触发设置后事件
-		this.emit('hset_after', {
-			key,
-			field,
-			value,
+		// 触发后置事件
+		this.emit('pexpire:after', {
+			key: finalKey,
+			ttl: finalMilliseconds,
 			success: true
 		});
 
-		return is_new_field ? 1 : 0; // 返回1表示新增，0表示更新
+		return true;
 	} catch (error) {
-		this.log('error', `Failed to hset for key ${key}:`, error);
-		return 0;
+		this.log('error', `Failed to set pexpire for key ${key}:`, error);
+		this.emit('pexpire:error', { key, ttl: milliseconds, error });
+		return false;
 	}
 };
 
 /**
- * 获取哈希表字段值
- * @param {string} key - 哈希表键名
- * @param {string} field - 字段名
- * @returns {*} 字段值
+ * 移除键的过期时间
+ * @param {String} key 键名
+ * @returns {Promise<Boolean>} 是否成功移除
  */
-CacheBase.prototype.hget = function (key, field) {
+CacheBase.prototype.persist = async function (key) {
 	try {
-		// 参数验证
-		if (!key || typeof key !== 'string' || !field || typeof field !== 'string') {
-			return;
+		if (!key || typeof key !== 'string') {
+			return false;
 		}
 
-		// 检查是否过期
-		if (this._isExpired(key)) {
-			this.del(key);
-			return;
-		}
+		// 触发前置事件
+		const ctx = {
+			key,
+			cancel: false
+		};
+		this.emit('persist:before', ctx);
 
-		// 检查键是否存在且类型正确
-		if (!(key in this._data) || this._types[key] !== 'hash') {
-			return;
+		if (ctx.cancel) {
+			return false;
 		}
 
-		return this._data[key][field];
-	} catch (error) {
-		this.log('error', `Failed to hget for key ${key}:`, error);
-	}
-};
-
-/**
- * 清空所有数据
- * @returns {boolean} 操作结果
- */
-CacheBase.prototype.clear = function () {
-	return this.flushdb();
-};
+		const {
+			key: finalKey
+		} = ctx;
 
-/**
- * 获取哈希表所有字段和值
- * @param {string} key - 哈希表键名
- * @returns {Object} 哈希表内容
- */
-CacheBase.prototype.hgetall = function (key) {
-	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			return {};
+		// 检查键是否存在
+		if (!(finalKey in this._data)) {
+			return false;
 		}
 
 		// 检查是否过期
-		if (this._isExpired(key)) {
-			this.del(key);
-			return {};
+		if (this._isExpired(finalKey)) {
+			await this.del(finalKey);
+			return false;
 		}
 
-		// 检查键是否存在且类型正确
-		if (!(key in this._data) || this._types[key] !== 'hash') {
-			return {};
+		// 移除过期时间
+		if (finalKey in this._expires) {
+			delete this._expires[finalKey];
+
+			this.emit('persist:after', {
+				key: finalKey,
+				success: true
+			});
+			return true;
 		}
 
-		// 返回副本，避免直接修改
-		return {
-			...this._data[key]
-		};
+		return false;
 	} catch (error) {
-		this.log('error', `Failed to hgetall for key ${key}:`, error);
-		return {};
+		this.log('error', `Failed to persist key ${key}:`, error);
+		this.emit('persist:error', { key, error });
+		return false;
 	}
 };
 
 /**
- * 删除哈希表字段
- * @param {string} key - 哈希表键名
- * @param {string|Array<string>} field - 字段名或字段名数组
- * @returns {boolean} 删除成功返回true，失败返回false
+ * 获取或设置键的过期时间
+ * @param {String} key 键名
+ * @param {Number} [seconds] 过期时间（秒），不传则获取剩余过期时间
+ * @returns {Promise<Number|Boolean>} 不传seconds返回剩余秒数（-1无过期，-2已过期），传seconds返回是否设置成功
  */
-CacheBase.prototype.hdel = function (key, field) {
+CacheBase.prototype.ttl = async function (key, seconds) {
+	const isSetMode = arguments.length > 1 && seconds !== undefined;
 	try {
-		// 参数验证
+		this.emit('ttl:before', { key, seconds });
+
 		if (!key || typeof key !== 'string') {
-			return false;
+			return isSetMode ? false : -2;
 		}
 
-		// 触发操作前事件
-		const event_data = {
-			key,
-			field,
-			cancel: false
-		};
-		this.emit('hdel_before', event_data);
+		if (isSetMode) {
+			// 设置过期时间模式
+			if (typeof seconds !== 'number' || seconds < 0) {
+				return false;
+			}
 
-		if (event_data.cancel) {
-			return false;
-		}
+			if (!(key in this._data)) {
+				return false;
+			}
 
-		// 检查是否过期
-		if (this._isExpired(key)) {
-			this.del(key);
-			this.emit('hdel_after', {
-				key,
-				field,
-				success: false
-			});
-			return false;
-		}
+			if (this._isExpired(key)) {
+				await this.del(key);
+				return false;
+			}
 
-		// 检查键是否存在且类型正确
-		if (!(key in this._data) || this._types[key] !== 'hash') {
-			this.emit('hdel_after', {
-				key,
-				field,
-				success: false
-			});
-			return false;
-		}
+			if (seconds > 0) {
+				this._expires[key] = Date.now() + seconds * 1000;
+			} else if (seconds === 0) {
+				delete this._expires[key];
+			}
+
+			this.emit('ttl:after', { key, seconds, success: true });
+			return true;
+		} else {
+			// 获取剩余过期时间模式
+			if (!(key in this._data)) {
+				return -2;
+			}
+
+			if (this._isExpired(key)) {
+				await this.del(key);
+				return -2;
+			}
+
+			if (!(key in this._expires)) {
+				return -1;
+			}
+
+			const now = Date.now();
+			const remaining = this._expires[key] - now;
+			return Math.max(0, Math.ceil(remaining / 1000));
+		}
+	} catch (error) {
+		this.log('error', `Failed to ttl for key ${key}:`, error);
+		return isSetMode ? false : -2;
+	}
+};
+
+// ==================== 哈希表操作 ====================
+
+/**
+ * 设置哈希表字段
+ * @param {String} key 哈希表键名
+ * @param {String} field 字段名
+ * @param {*} value 值
+ * @returns {Promise<Boolean>} 操作结果
+ */
+CacheBase.prototype.hset = async function (key, field, value) {
+	try {
+		if (!key || typeof key !== 'string' || !field || typeof field !== 'string') {
+			return false;
+		}
+
+		// 触发前置事件
+		const ctx = {
+			key,
+			field,
+			value,
+			cancel: false
+		};
+		this.emit('hset:before', ctx);
+
+		if (ctx.cancel) {
+			return false;
+		}
+
+		const {
+			key: finalKey,
+			field: finalField,
+			value: finalValue
+		} = ctx;
+
+		// 检查是否过期
+		if (this._isExpired(finalKey)) {
+			await this.del(finalKey);
+		}
+
+		// 初始化哈希表
+		if (!(finalKey in this._data) || this._types[finalKey] !== 'hash') {
+			this._data[finalKey] = {};
+			this._types[finalKey] = 'hash';
+		}
+
+		// 设置字段值
+		this._data[finalKey][finalField] = finalValue;
+
+		this.emit('hset:after', {
+			key: finalKey,
+			field: finalField,
+			value: finalValue,
+			success: true
+		});
+
+		return true;
+	} catch (error) {
+		this.log('error', `Failed to hset for key ${key}:`, error);
+		this.emit('hset:error', { key, field, value, error });
+		return false;
+	}
+};
+
+/**
+ * 获取哈希表字段值
+ * @param {String} key 哈希表键名
+ * @param {String} field 字段名
+ * @returns {Promise<Object|null>} 字段值，不存在或错误返回null
+ */
+CacheBase.prototype.hget = async function (key, field) {
+	try {
+		this.emit('hget:before', { key, field });
+
+		if (!key || typeof key !== 'string' || !field || typeof field !== 'string') {
+			return null;
+		}
+
+		// 检查是否过期
+		if (this._isExpired(key)) {
+			await this.del(key);
+			return null;
+		}
+
+		// 检查键是否存在且类型正确
+		if (!(key in this._data) || this._types[key] !== 'hash') {
+			return null;
+		}
+
+		const value = this._data[key][field];
+		this.emit('hget:after', { key, field, value });
+		return value !== undefined ? value : null;
+	} catch (error) {
+		this.log('error', `Failed to hget for key ${key}:`, error);
+		return null;
+	}
+};
+
+/**
+ * 获取哈希表所有字段和值
+ * @param {String} key 哈希表键名
+ * @returns {Promise<Object>} 哈希表内容
+ */
+CacheBase.prototype.hgetall = async function (key) {
+	try {
+		this.emit('hgetall:before', { key });
+
+		if (!key || typeof key !== 'string') {
+			return {};
+		}
 
-		// 处理字段参数，支持单个字段或字段数组
+		// 检查是否过期
+		if (this._isExpired(key)) {
+			await this.del(key);
+			return {};
+		}
+
+		// 检查键是否存在且类型正确
+		if (!(key in this._data) || this._types[key] !== 'hash') {
+			return {};
+		}
+
+		const result = { ...this._data[key] };
+		this.emit('hgetall:after', { key, result });
+		return result;
+	} catch (error) {
+		this.log('error', `Failed to hgetall for key ${key}:`, error);
+		return {};
+	}
+};
+
+/**
+ * 删除哈希表字段
+ * @param {String} key 哈希表键名
+ * @param {String|Array<String>} field 字段名或字段名数组
+ * @returns {Promise<Number>} 删除的字段数量
+ */
+CacheBase.prototype.hdel = async function (key, field) {
+	try {
+		if (!key || typeof key !== 'string') {
+			return 0;
+		}
+
+		// 触发前置事件
+		const ctx = {
+			key,
+			field,
+			cancel: false
+		};
+		this.emit('hdel:before', ctx);
+
+		if (ctx.cancel) {
+			return 0;
+		}
+
+		// 检查是否过期
+		if (this._isExpired(key)) {
+			await this.del(key);
+			this.emit('hdel:after', { key, field, success: false, deleted: 0 });
+			return 0;
+		}
+
+		// 检查键是否存在且类型正确
+		if (!(key in this._data) || this._types[key] !== 'hash') {
+			this.emit('hdel:after', { key, field, success: false, deleted: 0 });
+			return 0;
+		}
+
+		// 处理字段参数
 		const fields = Array.isArray(field) ? field : [field];
 		let deletedCount = 0;
 
-		// 遍历所有字段进行删除
 		for (const f of fields) {
 			if (typeof f === 'string' && f && f in this._data[key]) {
 				delete this._data[key][f];
@@ -812,321 +1079,708 @@ CacheBase.prototype.hdel = function (key, field) {
 			delete this._expires[key];
 		}
 
-		// 触发操作后事件
-		this.emit('hdel_after', {
+		this.emit('hdel:after', {
 			key,
 			field,
-			success: deletedCount > 0
+			success: deletedCount > 0,
+			deleted: deletedCount
 		});
 
-		return deletedCount > 0;
+		return deletedCount;
 	} catch (error) {
-		this.emit('hdel_error', {
+		this.emit('hdel:error', { key, field, error });
+		this.log('error', 'Failed to hdel:', error);
+		return 0;
+	}
+};
+
+/**
+ * 批量设置哈希表字段
+ * @param {String} key 哈希表键名
+ * @param {Object} obj 包含多个字段的对象
+ * @returns {Promise<Boolean>} 操作结果
+ */
+CacheBase.prototype.hmset = async function (key, obj) {
+	try {
+		if (!key || typeof key !== 'string' || !obj || typeof obj !== 'object' || Array.isArray(obj)) {
+			return false;
+		}
+
+		// 触发前置事件
+		const ctx = {
 			key,
-			field,
-			error
+			value: obj,
+			cancel: false
+		};
+		this.emit('hmset:before', ctx);
+
+		if (ctx.cancel) {
+			return false;
+		}
+
+		const {
+			key: finalKey,
+			value: finalObj
+		} = ctx;
+
+		// 检查是否过期
+		if (this._isExpired(finalKey)) {
+			await this.del(finalKey);
+		}
+
+		// 初始化哈希表
+		if (!(finalKey in this._data) || this._types[finalKey] !== 'hash') {
+			this._data[finalKey] = {};
+			this._types[finalKey] = 'hash';
+		}
+
+		// 批量设置字段
+		for (const field in finalObj) {
+			if (Object.prototype.hasOwnProperty.call(finalObj, field)) {
+				this._data[finalKey][field] = finalObj[field];
+			}
+		}
+
+		this.emit('hmset:after', {
+			key: finalKey,
+			value: finalObj,
+			success: true
 		});
-		this.log('error', 'Failed to hdel:', error);
+
+		return true;
+	} catch (error) {
+		this.emit('hmset:error', { key, value: obj, error });
+		this.log('error', 'Failed to hmset:', error);
 		return false;
 	}
 };
 
 /**
- * 增加键的数值
- * @param {string} key - 键名
- * @param {number} value - 增加的值（默认为1）
- * @returns {number} 增加后的值
+ * 批量获取哈希表字段
+ * @param {String} key 哈希表键名
+ * @param {Array} fields 字段名数组
+ * @returns {Promise<Array>} 字段值数组，不存在的字段返回null
  */
-CacheBase.prototype.incrby = function (key, value) {
-	// 参数验证
-	if (!key || typeof key !== 'string' || typeof value !== 'number') {
+CacheBase.prototype.hmget = async function (key, fields) {
+	try {
+		this.emit('hmget:before', { key, fields });
+
+		if (!key || typeof key !== 'string' || !Array.isArray(fields)) {
+			return [];
+		}
+
+		// 检查是否过期
+		if (this._isExpired(key)) {
+			await this.del(key);
+			return fields.map(() => null);
+		}
+
+		// 检查键是否存在且类型正确
+		if (!(key in this._data) || this._types[key] !== 'hash') {
+			return fields.map(() => null);
+		}
+
+		// 批量获取字段值
+		const results = [];
+		for (const field of fields) {
+			const val = this._data[key][field];
+			results.push(val !== undefined ? val : null);
+		}
+
+		this.emit('hmget:after', { key, fields, results });
+		return results;
+	} catch (error) {
+		this.emit('hmget:error', { key, fields, error });
+		this.log('error', 'Failed to hmget:', error);
+		return [];
+	}
+};
+
+/**
+ * 获取哈希表字段数量
+ * @param {String} key 哈希表键名
+ * @returns {Promise<Number>} 字段数量
+ */
+CacheBase.prototype.hlen = async function (key) {
+	try {
+		this.emit('hlen:before', { key });
+
+		if (!key || typeof key !== 'string') {
+			return 0;
+		}
+
+		// 检查是否过期
+		if (this._isExpired(key)) {
+			await this.del(key);
+			return 0;
+		}
+
+		// 检查键是否存在且类型正确
+		if (!(key in this._data) || this._types[key] !== 'hash') {
+			return 0;
+		}
+
+		const result = Object.keys(this._data[key]).length;
+		this.emit('hlen:after', { key, result });
+		return result;
+	} catch (error) {
+		this.emit('hlen:error', { key, error });
+		this.log('error', 'Failed to hlen:', error);
 		return 0;
 	}
+};
 
-	// 确保_data对象存在
-	if (!this._data) {
-		this._data = {};
+// ==================== 数值操作 ====================
+
+/**
+ * 将键的值增加1
+ * @param {String} key 键
+ * @param {Number} [seconds=0] 过期时间（秒）
+ * @returns {Promise<Number>} 增加后的值，失败返回null
+ */
+CacheBase.prototype.incr = async function (key, seconds = 0) {
+	try {
+		if (!key || typeof key !== 'string') {
+			throw new TypeError('键必须是非空字符串');
+		}
+
+		const ctx = {
+			key,
+			ttl: seconds,
+			cancel: false
+		};
+		this.emit('incr:before', ctx);
+
+		if (ctx.cancel) {
+			return null;
+		}
+
+		const {
+			key: finalKey,
+			ttl: finalSeconds
+		} = ctx;
+
+		// 确保_data对象存在
+		if (!this._data) {
+			this._data = {};
+		}
+
+		let current = 0;
+		if (finalKey in this._data && !this._isExpired(finalKey)) {
+			current = Number(this._data[finalKey]) || 0;
+		}
+
+		const newValue = current + 1;
+		this._data[finalKey] = newValue;
+		this._types[finalKey] = 'number';
+
+		if (finalSeconds > 0) {
+			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
+		} else {
+			delete this._expires[finalKey];
+		}
+
+		this.emit('incr:after', {
+			key: finalKey,
+			ttl: finalSeconds,
+			success: true,
+			result: newValue
+		});
+		return newValue;
+	} catch (error) {
+		this.emit('incr:error', { key, ttl: seconds, error });
+		this.log('error', 'incr操作失败:', error);
+		return null;
+	}
+};
+
+/**
+ * 将键的值减少1
+ * @param {String} key 键
+ * @param {Number} [seconds=0] 过期时间（秒）
+ * @returns {Promise<Number>} 减少后的值，失败返回null
+ */
+CacheBase.prototype.decr = async function (key, seconds = 0) {
+	try {
+		if (!key || typeof key !== 'string') {
+			throw new TypeError('键必须是非空字符串');
+		}
+
+		const ctx = {
+			key,
+			ttl: seconds,
+			cancel: false
+		};
+		this.emit('decr:before', ctx);
+
+		if (ctx.cancel) {
+			return null;
+		}
+
+		const {
+			key: finalKey,
+			ttl: finalSeconds
+		} = ctx;
+
+		if (!this._data) {
+			this._data = {};
+		}
+
+		let current = 0;
+		if (finalKey in this._data && !this._isExpired(finalKey)) {
+			current = Number(this._data[finalKey]) || 0;
+		}
+
+		const newValue = current - 1;
+		this._data[finalKey] = newValue;
+		this._types[finalKey] = 'number';
+
+		if (finalSeconds > 0) {
+			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
+		} else {
+			delete this._expires[finalKey];
+		}
+
+		this.emit('decr:after', {
+			key: finalKey,
+			ttl: finalSeconds,
+			success: true,
+			result: newValue
+		});
+		return newValue;
+	} catch (error) {
+		this.emit('decr:error', { key, ttl: seconds, error });
+		this.log('error', 'decr操作失败:', error);
+		return null;
 	}
+};
 
-	// 获取当前值，如果存在则使用，不存在则为0
-	let current = 0;
-	if (key in this._data) {
-		// 尝试将现有值转换为数字
-		current = Number(this._data[key]) || 0;
+/**
+ * 将键的值增加指定整数
+ * @param {String} key 键
+ * @param {Number} increment 增量
+ * @param {Number} [seconds=0] 过期时间（秒）
+ * @returns {Promise<Number>} 增加后的值，失败返回null
+ */
+CacheBase.prototype.incrby = async function (key, increment, seconds = 0) {
+	// 检查服务状态
+	if (!this.is_inited || this.is_destroyed) {
+		this.log('error', 'Service is not initialized or has been destroyed');
+		return null;
 	}
 
-	// 增加指定值
-	const newValue = current + value;
+	if (!key || typeof key !== 'string' || typeof increment !== 'number') {
+		this.log('error', 'incrby参数错误: key必须是非空字符串，increment必须是数字');
+		return null;
+	}
 
-	// 保存新值
-	this._data[key] = newValue;
+	try {
+		const ctx = {
+			key,
+			increment,
+			seconds,
+			cancel: false
+		};
+		this.emit('incrby:before', ctx);
 
-	// 确保_types对象存在并设置类型
-	if (!this._types) {
-		this._types = {};
+		if (ctx.cancel) {
+			return null;
+		}
+
+		const {
+			key: finalKey,
+			increment: finalIncrement,
+			seconds: finalSeconds
+		} = ctx;
+
+		if (!this._data) {
+			this._data = {};
+		}
+
+		let current = 0;
+		if (finalKey in this._data && !this._isExpired(finalKey)) {
+			current = Number(this._data[finalKey]) || 0;
+		} else if (finalKey in this._data && this._isExpired(finalKey)) {
+			await this.del(finalKey);
+		}
+
+		const newValue = current + finalIncrement;
+		this._data[finalKey] = newValue;
+		this._types[finalKey] = 'number';
+
+		// 设置过期时间（保留 TTL 语义与 Redis 一致）
+		if (finalSeconds > 0) {
+			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
+		}
+
+		this.emit('incrby:after', {
+			key: finalKey,
+			increment: finalIncrement,
+			seconds: finalSeconds,
+			success: true,
+			result: newValue
+		});
+
+		return newValue;
+	} catch (error) {
+		this.emit('incrby:error', { key, increment, seconds, error });
+		this.log('error', 'incrby操作失败:', error);
+		return null;
+	}
+};
+
+/**
+ * 将键的值减少指定整数
+ * @param {String} key 键
+ * @param {Number} decrement 减量
+ * @param {Number} [seconds=0] 过期时间（秒）
+ * @returns {Promise<Number>} 减少后的值，失败返回null
+ */
+CacheBase.prototype.decrby = async function (key, decrement, seconds = 0) {
+	// 检查服务状态
+	if (!this.is_inited || this.is_destroyed) {
+		this.log('error', 'Service is not initialized or has been destroyed');
+		return null;
 	}
-	this._types[key] = 'number';
 
-	// 清理过期时间
-	if (this._expires && this._expires[key]) {
-		delete this._expires[key];
+	if (!key || typeof key !== 'string' || typeof decrement !== 'number') {
+		this.log('error', 'decrby参数错误: key必须是非空字符串，decrement必须是数字');
+		return null;
 	}
 
-	return newValue;
+	try {
+		const ctx = {
+			key,
+			decrement,
+			seconds,
+			cancel: false
+		};
+		this.emit('decrby:before', ctx);
+
+		if (ctx.cancel) {
+			return null;
+		}
+
+		const {
+			key: finalKey,
+			decrement: finalDecrement,
+			seconds: finalSeconds
+		} = ctx;
+
+		if (!this._data) {
+			this._data = {};
+		}
+
+		let current = 0;
+		if (finalKey in this._data && !this._isExpired(finalKey)) {
+			current = Number(this._data[finalKey]) || 0;
+		} else if (finalKey in this._data && this._isExpired(finalKey)) {
+			await this.del(finalKey);
+		}
+
+		const newValue = current - finalDecrement;
+		this._data[finalKey] = newValue;
+		this._types[finalKey] = 'number';
+
+		if (finalSeconds > 0) {
+			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
+		}
+
+		this.emit('decrby:after', {
+			key: finalKey,
+			decrement: finalDecrement,
+			seconds: finalSeconds,
+			success: true,
+			result: newValue
+		});
+
+		return newValue;
+	} catch (error) {
+		this.emit('decrby:error', { key, decrement, seconds, error });
+		this.log('error', 'decrby操作失败:', error);
+		return null;
+	}
 };
 
 /**
- * 增加键的数值（增加1）
- * @param {string} key - 键名
- * @param {number} seconds - 过期时间（秒），0表示永不过期
- * @returns {number|null} 增加后的值，失败返回null
+ * 将键的值增加指定浮点数
+ * @param {String} key 键
+ * @param {Number} [increment=1.0] 增量
+ * @param {Number} [seconds=0] 过期时间（秒）
+ * @returns {Promise<Number>} 增加后的值，失败返回null
  */
-CacheBase.prototype.incr = function (key, seconds = 0) {
+CacheBase.prototype.incrbyfloat = async function (key, increment = 1.0, seconds = 0) {
 	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			this.log('error', 'incr参数错误: key必须是非空字符串');
-			return 0;
+		if (!key || typeof key !== 'string' || typeof increment !== 'number') {
+			this.log('error', 'incrbyfloat参数错误: key必须是非空字符串，increment必须是数字');
+			return null;
 		}
 
-		this.emit('incr_before', {
+		const ctx = {
 			key,
+			increment,
 			ttl: seconds,
 			cancel: false
-		});
+		};
+		this.emit('incrbyfloat:before', ctx);
+
+		if (ctx.cancel) {
+			return null;
+		}
+
+		const {
+			key: finalKey,
+			increment: finalIncrement,
+			ttl: finalSeconds
+		} = ctx;
 
-		// 确保_data对象存在
 		if (!this._data) {
 			this._data = {};
 		}
 
-		// 获取当前值，如果存在则使用，不存在则为0
 		let current = 0;
-		if (key in this._data && !this._isExpired(key)) {
-			current = Number(this._data[key]) || 0;
+		if (finalKey in this._data && !this._isExpired(finalKey)) {
+			current = Number(this._data[finalKey]) || 0;
 		}
 
-		// 增加1
-		const newValue = current + 1;
-
-		// 保存新值
-		this._data[key] = newValue;
-		this._types[key] = 'number';
+		const newValue = current + finalIncrement;
+		this._data[finalKey] = newValue;
+		this._types[finalKey] = 'number';
 
-		if (seconds > 0) {
-			this._expires[key] = Date.now() + seconds * 1000;
+		if (finalSeconds > 0) {
+			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
 		} else {
-			delete this._expires[key];
+			delete this._expires[finalKey];
 		}
 
-		this.emit('incr_after', {
-			key,
-			ttl: seconds,
+		this.emit('incrbyfloat:after', {
+			key: finalKey,
+			increment: finalIncrement,
+			ttl: finalSeconds,
 			success: true,
 			result: newValue
 		});
 		return newValue;
 	} catch (error) {
-		this.emit('incr_error', {
-			key,
-			ttl: seconds,
-			error
-		});
-		this.log('error', 'incr操作失败:', error);
-		return 0;
+		this.emit('incrbyfloat:error', { key, increment, ttl: seconds, error });
+		this.log('error', 'incrbyfloat操作失败:', error);
+		return null;
 	}
 };
 
-CacheBase.prototype.decrby = function (key, value) {
-	// 参数验证
-	if (!key || typeof key !== 'string' || typeof value !== 'number') {
-		return 0;
-	}
+/**
+ * 增加整数值（兼容方法）
+ * @param {String} key 键名
+ * @param {Number} value 要增加的整数值
+ * @param {Number} [seconds=0] 过期时间（秒）
+ * @returns {Promise<Number>} 增加后的值，失败返回null
+ */
+CacheBase.prototype.addInt = async function (key, value, seconds = 0) {
+	try {
+		if (!key || typeof key !== 'string') {
+			throw new TypeError('key必须是非空字符串');
+		}
+		if (typeof value !== 'number') {
+			throw new TypeError('value必须是数字');
+		}
 
-	// 确保_data对象存在
-	if (!this._data) {
-		this._data = {};
-	}
+		const ctx = {
+			key,
+			value,
+			ttl: seconds,
+			cancel: false
+		};
+		this.emit('addInt:before', ctx);
 
-	// 获取当前值，如果存在则使用，不存在则为0
-	let current = 0;
-	if (key in this._data) {
-		// 尝试将现有值转换为数字
-		current = Number(this._data[key]) || 0;
-	}
+		if (ctx.cancel) {
+			return null;
+		}
 
-	// 减少指定值
-	const newValue = current - value;
+		const {
+			key: finalKey,
+			value: finalValue,
+			ttl: finalSeconds
+		} = ctx;
 
-	// 保存新值
-	this._data[key] = newValue;
+		let currentValue = 0;
+		if (finalKey in this._data && !this._isExpired(finalKey)) {
+			currentValue = parseInt(this._data[finalKey], 10) || 0;
+		}
+		const result = Math.floor(currentValue + parseInt(finalValue, 10));
 
-	// 确保_types对象存在并设置类型
-	if (!this._types) {
-		this._types = {};
-	}
-	this._types[key] = 'number';
+		this._data[finalKey] = result;
+		this._types[finalKey] = 'number';
 
-	// 清理过期时间
-	if (this._expires && this._expires[key]) {
-		delete this._expires[key];
-	}
+		if (finalSeconds > 0) {
+			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
+		} else {
+			delete this._expires[finalKey];
+		}
 
-	return newValue;
+		this.emit('addInt:after', {
+			key: finalKey,
+			value: finalValue,
+			ttl: finalSeconds,
+			success: true,
+			result
+		});
+		return result;
+	} catch (error) {
+		this.emit('addInt:error', { key, value, ttl: seconds, error });
+		this.log('error', 'addInt操作失败:', error);
+		return null;
+	}
 };
 
 /**
- * 减少键的数值（减少1）
- * @param {string} key - 键名
- * @param {number} seconds - 过期时间（秒），0表示永不过期
- * @returns {number} 减少后的值
+ * 增加浮点数（兼容方法）
+ * @param {String} key 键名
+ * @param {Number} num 要增加的浮点数值
+ * @param {Number} [seconds=0] 过期时间（秒）
+ * @returns {Promise<Number>} 增加后的值，失败返回null
  */
-CacheBase.prototype.decr = function (key, seconds = 0) {
+CacheBase.prototype.addFloat = async function (key, num, seconds = 0) {
 	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			this.log('error', 'decr参数错误: key必须是非空字符串');
-			return 0;
+		if (!key || typeof key !== 'string' || typeof num !== 'number') {
+			throw new TypeError('addFloat参数错误: key必须是非空字符串，num必须是数字');
 		}
 
-		this.emit('decr_before', {
+		const ctx = {
 			key,
+			num,
 			ttl: seconds,
 			cancel: false
-		});
+		};
+		this.emit('addFloat:before', ctx);
 
-		// 确保_data对象存在
-		if (!this._data) {
-			this._data = {};
+		if (ctx.cancel) {
+			return null;
 		}
 
-		// 获取当前值，如果存在则使用，不存在则为0
-		let current = 0;
-		if (key in this._data && !this._isExpired(key)) {
-			current = Number(this._data[key]) || 0;
-		}
+		const {
+			key: finalKey,
+			num: finalNum,
+			ttl: finalSeconds
+		} = ctx;
 
-		// 减少1
-		const newValue = current - 1;
+		let currentValue = 0;
+		if (finalKey in this._data && !this._isExpired(finalKey)) {
+			currentValue = Number(this._data[finalKey]) || 0;
+		}
+		const result = currentValue + Number(finalNum);
 
-		// 保存新值
-		this._data[key] = newValue;
-		this._types[key] = 'number';
+		this._data[finalKey] = result;
+		this._types[finalKey] = 'number';
 
-		if (seconds > 0) {
-			this._expires[key] = Date.now() + seconds * 1000;
+		if (finalSeconds > 0) {
+			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
 		} else {
-			delete this._expires[key];
+			delete this._expires[finalKey];
 		}
 
-		this.emit('decr_after', {
-			key,
-			ttl: seconds,
+		this.emit('addFloat:after', {
+			key: finalKey,
+			num: finalNum,
+			ttl: finalSeconds,
 			success: true,
-			result: newValue
+			result
 		});
-		return newValue;
+		return result;
 	} catch (error) {
-		this.emit('decr_error', {
-			key,
-			ttl: seconds,
-			error
-		});
-		this.log('error', 'decr操作失败:', error);
-		return 0;
+		this.emit('addFloat:error', { key, num, ttl: seconds, error });
+		this.log('error', 'addFloat操作失败:', error);
+		return null;
 	}
 };
 
+// ==================== 字符串操作 ====================
+
 /**
- * 增加整数值（兼容方法）
- * @param {string} key - 键名
- * @param {number} value - 要增加的整数值
- * @param {number} seconds - 过期时间（秒），0表示永不过期
- * @returns {Promise<number>} - 返回增加后的值
+ * 追加字符串（兼容方法，对齐 mm_redis 的 setrange）
+ * @param {String} key 键名
+ * @param {String} value 要追加的字符串
+ * @param {Number} [seconds=0] 过期时间（秒）
+ * @returns {Promise<Number>} 追加后字符串的长度，失败返回null
  */
-CacheBase.prototype.addInt = function (key, value, seconds = 0) {
-	// 参数验证
-	if (!key || typeof key !== 'string') {
-		throw new TypeError('key必须是非空字符串');
-	}
-	if (typeof value !== 'number') {
-		throw new TypeError('value必须是数字');
-	}
-
+CacheBase.prototype.setrange = async function (key, value, seconds = 0) {
 	try {
+		if (!key || typeof key !== 'string' || typeof value !== 'string') {
+			throw new TypeError('setrange参数错误: key和value必须是非空字符串');
+		}
 
-		this.emit('addInt_before', {
+		const ctx = {
 			key,
 			value,
 			ttl: seconds,
 			cancel: false
-		});
+		};
+		this.emit('setrange:before', ctx);
 
-		// 实现整数递增逻辑
-		let currentValue = 0;
-		if (key in this._data && !this._isExpired(key)) {
-			currentValue = parseInt(this._data[key], 10) || 0;
+		if (ctx.cancel) {
+			return null;
 		}
-		const result = Math.floor(currentValue + parseInt(value, 10));
 
-		// 设置值和过期时间
-		this._data[key] = result;
-		this._types[key] = 'number';
+		const {
+			key: finalKey,
+			value: finalValue,
+			ttl: finalSeconds
+		} = ctx;
+
+		let currentValue = '';
+		if (finalKey in this._data && !this._isExpired(finalKey)) {
+			currentValue = String(this._data[finalKey]) || '';
+		}
+		const result = currentValue + finalValue;
+		const length = result.length;
 
-		if (seconds > 0) {
-			this._expires[key] = Date.now() + seconds * 1000;
+		this._data[finalKey] = result;
+		this._types[finalKey] = 'string';
+
+		if (finalSeconds > 0) {
+			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
 		} else {
-			delete this._expires[key];
+			delete this._expires[finalKey];
 		}
 
-		this.emit('addInt_after', {
-			key,
-			value,
-			ttl: seconds,
-			success: true,
-			result
+		this.emit('setrange:after', {
+			key: finalKey,
+			value: finalValue,
+			ttl: finalSeconds,
+			result,
+			length,
+			success: true
 		});
-		return result;
+		return length;
 	} catch (error) {
-		this.emit('addInt_error', {
-			key,
-			value,
-			ttl: seconds,
-			error
-		});
-		this.log('error', 'addInt操作失败:', error);
-		return 0;
+		this.emit('setrange:error', { key, value, ttl: seconds, error });
+		this.log('error', 'setrange操作失败:', error);
+		return null;
 	}
 };
 
 /**
  * 向字符串末尾追加内容
- * @param {string} key - 键名
- * @param {string} append - 要追加的内容
- * @returns {number|null} 追加后的字符串长度，失败返回null
+ * @param {String} key 键名
+ * @param {String} append 要追加的内容
+ * @returns {Promise<Number>} 追加后的字符串长度，失败返回null
  */
-CacheBase.prototype.append = function (key, append) {
+CacheBase.prototype.append = async function (key, append) {
 	try {
-		// 参数验证
 		if (!key || typeof key !== 'string' || typeof append !== 'string') {
 			return null;
 		}
 
 		// 检查是否过期
 		if (this._isExpired(key)) {
-			this.del(key);
+			await this.del(key);
 			return null;
 		}
 
-		// 获取当前值
 		let current = '';
-
-		// 如果键存在且是字符串，使用当前值
 		if (key in this._data && typeof this._data[key] === 'string') {
 			current = this._data[key];
 		}
 
-		// 追加内容
 		current += append;
 		this._data[key] = current;
 		this._types[key] = 'string';
@@ -1140,88 +1794,247 @@ CacheBase.prototype.append = function (key, append) {
 
 /**
  * 获取字符串长度
- * @param {string} key - 键名
- * @returns {number} 字符串长度，不存在返回0
+ * @param {String} key 键名
+ * @returns {Promise<Number>} 字符串长度，不存在返回0
  */
-CacheBase.prototype.strlen = function (key) {
+CacheBase.prototype.strlen = async function (key) {
 	try {
-		// 参数验证
 		if (!key || typeof key !== 'string') {
 			return 0;
 		}
 
-		// 检查是否过期
-		if (this._isExpired(key)) {
-			this.del(key);
-			return 0;
-		}
+		if (this._isExpired(key)) {
+			await this.del(key);
+			return 0;
+		}
+
+		if (!(key in this._data)) {
+			return 0;
+		}
+
+		if (typeof this._data[key] !== 'string') {
+			return 0;
+		}
+
+		return this._data[key].length;
+	} catch (error) {
+		this.log('error', `Failed to strlen for key ${key}:`, error);
+		return 0;
+	}
+};
+
+/**
+ * 获取并设置值
+ * @param {String} key 键名
+ * @param {*} value 新值
+ * @param {Number} [seconds=0] 过期时间（秒）
+ * @returns {Promise<Object|null>} 旧值
+ */
+CacheBase.prototype.getset = async function (key, value, seconds = 0) {
+	try {
+		if (!key || typeof key !== 'string') {
+			return null;
+		}
+
+		// 获取旧值
+		const oldValue = await this.get(key);
+
+		// 设置新值
+		await this.set(key, value, seconds);
+
+		return oldValue;
+	} catch (error) {
+		this.log('error', 'Failed to getset:', error);
+		return null;
+	}
+};
+
+/**
+ * 仅当键不存在时设置值（兼容方法，类似 Redis SETNX 语义）
+ * @param {String} key 键名
+ * @param {*} value 要设置的值
+ * @param {Number} [seconds=0] 过期时间（秒）
+ * @returns {Promise<Boolean>} 键不存在并设置成功返回true，键已存在返回false
+ */
+CacheBase.prototype.add = async function (key, value, seconds = 0) {
+	try {
+		if (!key || typeof key !== 'string') {
+			throw new TypeError('add参数错误: key必须是非空字符串');
+		}
+
+		const ctx = {
+			key,
+			value,
+			ttl: seconds,
+			cancel: false
+		};
+		this.emit('add:before', ctx);
+
+		if (ctx.cancel) {
+			this.log('debug', `add操作被事件处理器取消 [${key}]`);
+			return false;
+		}
+
+		const {
+			key: finalKey,
+			value: finalValue,
+			ttl: finalSeconds
+		} = ctx;
+
+		// 检查键是否存在且未过期
+		if (finalKey in this._data && !this._isExpired(finalKey)) {
+			this.emit('add:after', {
+				key: finalKey,
+				value: finalValue,
+				ttl: finalSeconds,
+				success: false
+			});
+			return false;
+		}
+
+		// 键不存在或已过期，设置新值
+		this._data[finalKey] = finalValue;
+		this._types[finalKey] = this._getDataTypes(finalValue);
+
+		if (finalSeconds > 0) {
+			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
+		} else {
+			delete this._expires[finalKey];
+		}
+
+		this.emit('add:after', {
+			key: finalKey,
+			value: finalValue,
+			ttl: finalSeconds,
+			success: true
+		});
+		return true;
+	} catch (error) {
+		this.log('error', `add操作失败 [${key}]:`, error);
+		this.emit('add:error', { key, value, ttl: seconds, error });
+		return false;
+	}
+};
+
+// ==================== 批量操作 ====================
+
+/**
+ * 一次性设置多个键值对
+ * @param {Object} obj 键值对对象
+ * @param {Number} [seconds=0] 过期时间（秒）
+ * @returns {Promise<Boolean>} 成功返回true，失败返回false
+ */
+CacheBase.prototype.mset = async function (obj, seconds = 0) {
+	try {
+		// 参数验证：必须是对象
+		if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
+			throw new TypeError('参数必须是键值对对象');
+		}
+
+		// 触发前置事件
+		const ctx = {
+			keyValuePairs: obj,
+			seconds,
+			cancel: false
+		};
+		this.emit('mset:before', ctx);
+
+		if (ctx.cancel) {
+			this.log('debug', '[mset] 操作被事件处理器取消');
+			return false;
+		}
+
+		const {
+			keyValuePairs: finalKeyValuePairs,
+			seconds: finalSeconds
+		} = ctx;
+
+		// 批量设置键值对
+		for (const [key, value] of Object.entries(finalKeyValuePairs)) {
+			if (typeof key !== 'string' || !key) {
+				throw new TypeError('键必须是非空字符串');
+			}
+
+			// 检查键是否过期
+			if (this._isExpired(key)) {
+				await this.del(key);
+			}
 
-		// 检查键是否存在
-		if (!(key in this._data)) {
-			return 0;
-		}
+			this._data[key] = value;
+			this._types[key] = this._getDataTypes(value);
 
-		// 检查值类型
-		if (typeof this._data[key] !== 'string') {
-			return 0;
+			if (finalSeconds > 0) {
+				this._expires[key] = Date.now() + finalSeconds * 1000;
+			} else {
+				delete this._expires[key];
+			}
 		}
 
-		return this._data[key].length;
+		this.emit('mset:after', {
+			keyValuePairs: finalKeyValuePairs,
+			seconds: finalSeconds,
+			result: true,
+			success: true
+		});
+		return true;
 	} catch (error) {
-		this.log('error', `Failed to strlen for key ${key}:`, error);
-		return 0;
+		this.emit('mset:error', { keyValuePairs: obj, error });
+		this.log('error', 'Failed to mset:', error);
+		return false;
 	}
 };
 
 /**
- * 清空所有数据库键
- * @returns {boolean} 操作结果
+ * 批量获取多个键的值
+ * @param {Array} keys 键名数组
+ * @returns {Promise<Array>} 值数组，按键的顺序返回
  */
-CacheBase.prototype.flushdb = function () {
+CacheBase.prototype.mget = async function (keys) {
 	try {
-		// 触发操作前事件
-		const event_data = {
-			cancel: false
-		};
-		this.emit('flushdb_before', event_data);
+		this.emit('mget:before', { keys });
 
-		if (event_data.cancel) {
-			return false;
+		if (!Array.isArray(keys)) {
+			return [];
 		}
 
-		// 清空所有数据
-		this._data = {};
-		this._expires = {};
-		this._types = {};
-
-		// 触发操作后事件
-		this.emit('flushdb_after', {
-			success: true
-		});
+		const results = [];
+		for (const key of keys) {
+			if (typeof key === 'string') {
+				results.push(await this.get(key));
+			} else {
+				results.push(null);
+			}
+		}
 
-		return true;
+		this.emit('mget:after', { keys, results });
+		return results;
 	} catch (error) {
-		this.log('error', 'Failed to flushdb:', error);
-		return false;
+		this.log('error', 'Failed to mget:', error);
+		return [];
 	}
 };
+
+// ==================== 键管理 ====================
+
 /**
  * 获取所有键名
- * @param {string} [pattern] - 键名匹配模式，支持*通配符
- * @returns {Array} 所有键名数组
+ * @param {String} [pattern] 键名匹配模式，支持*通配符
+ * @returns {Promise<Array>} 所有键名数组
  */
-CacheBase.prototype.keys = function (pattern) {
+CacheBase.prototype.keys = async function (pattern) {
 	try {
+		this.emit('keys:before', { pattern });
+
 		const result = [];
 		for (const key in this._data) {
-			// 调用_is_expired方法检查过期并自动删除，无需再调用del
 			if (!this._isExpired(key)) {
-				// 添加基于pattern的键过滤条件
 				if (!pattern || this._matchPattern(key, pattern)) {
 					result.push(key);
 				}
 			}
 		}
+
+		this.emit('keys:after', { pattern, result });
 		return result;
 	} catch (error) {
 		this.log('error', 'Failed to get keys:', error);
@@ -1232,31 +2045,29 @@ CacheBase.prototype.keys = function (pattern) {
 /**
  * 检查键是否匹配指定模式
  * @private
- * @param {string} key - 要检查的键名
- * @param {string} pattern - 匹配模式，支持*通配符
- * @returns {boolean} 是否匹配
+ * @param {String} key 要检查的键名
+ * @param {String} pattern 匹配模式，支持*通配符
+ * @returns {Boolean} 是否匹配
  */
 CacheBase.prototype._matchPattern = function (key, pattern) {
-	// 将模式转换为正则表达式
 	try {
+		// 转义正则元字符（包含 ]）
 		var regexPattern = pattern
-			.replace(/[.+?^${}()|[\\]/g, '\\$&')
+			.replace(/[.+?^${}()|[\]\\]/g, '\\$&')
 			.replace(/\*/g, '.*');
 		var regex = new RegExp('^' + regexPattern + '$');
 		return regex.test(key);
 	} catch (error) {
-		// 如果正则表达式无效，返回false
 		return false;
 	}
 };
 
 /**
  * 获取键的数量
- * @returns {number} 键的数量
+ * @returns {Promise<Number>} 键的数量
  */
-CacheBase.prototype.dbsize = function () {
+CacheBase.prototype.dbsize = async function () {
 	try {
-		// 计算未过期的键数量
 		let count = 0;
 		for (const key in this._data) {
 			if (!this._isExpired(key)) {
@@ -1271,1105 +2082,1045 @@ CacheBase.prototype.dbsize = function () {
 };
 
 /**
- * 增加浮点数（兼容方法）
- * @param {string} key - 键名
- * @param {number} value - 增加的浮点数
- * @param {number} seconds - 过期时间（秒），0表示永不过期
- * @returns {number} 增加后的值，失败返回0
+ * 清空所有数据库键
+ * @returns {Promise<Boolean>} 操作结果
+ */
+CacheBase.prototype.flushdb = async function () {
+	try {
+		const ctx = {
+			cancel: false
+		};
+		this.emit('clear:before', ctx);
+
+		if (ctx.cancel) {
+			return false;
+		}
+
+		this._data = {};
+		this._expires = {};
+		this._types = {};
+
+		this.emit('clear:after', { success: true });
+		return true;
+	} catch (error) {
+		this.log('error', 'Failed to flushdb:', error);
+		return false;
+	}
+};
+
+/**
+ * 清空所有数据（flushdb 别名）
+ * @returns {Promise<Boolean>} 操作结果
+ */
+CacheBase.prototype.clear = async function () {
+	return this.flushdb();
+};
+
+// ==================== 列表操作 ====================
+
+/**
+ * 设置列表
+ * @param {String} key 键名
+ * @param {Array} value 列表值
+ * @param {Number} [seconds=0] 过期时间（秒）
+ * @returns {Promise<Number>} 列表长度
  */
-CacheBase.prototype.incrbyfloat = function (key, value = 1.0, seconds = 0) {
+CacheBase.prototype.setForList = async function (key, value, seconds = 0) {
 	try {
-		// 参数验证
-		if (!key || typeof key !== 'string' || typeof value !== 'number') {
-			this.log('error', 'incrbyfloat参数错误: key必须是非空字符串，value必须是数字');
+		if (!key || typeof key !== 'string') {
 			return 0;
 		}
 
-		this.emit('incrbyfloat_before', {
+		// 确保value是数组
+		let stringValues = [];
+		if (Array.isArray(value)) {
+			stringValues = value.map(item => String(item));
+		} else {
+			stringValues = [String(value)];
+		}
+
+		const ctx = {
 			key,
 			value,
-			ttl: seconds,
+			seconds,
 			cancel: false
-		});
+		};
+		this.emit('setForList:before', ctx);
 
-		// 确保_data对象存在
-		if (!this._data) {
-			this._data = {};
+		if (ctx.cancel) {
+			this.log('debug', `setForList操作被事件处理器取消 [${key}]`);
+			return 0;
 		}
 
-		// 获取当前值，如果存在则使用，不存在则为0
-		let current = 0;
-		if (key in this._data && !this._isExpired(key)) {
-			current = Number(this._data[key]) || 0;
+		const {
+			key: finalKey,
+			value: finalValue,
+			seconds: finalSeconds
+		} = ctx;
+
+		// 重新处理 finalValue
+		let finalStringValues = [];
+		if (Array.isArray(finalValue)) {
+			finalStringValues = finalValue.map(item => String(item));
+		} else {
+			finalStringValues = [String(finalValue)];
 		}
 
-		// 增加指定值
-		const newValue = current + value;
+		// 检查键是否存在且未过期
+		if (finalKey in this._data && !this._isExpired(finalKey)) {
+			if (!Array.isArray(this._data[finalKey])) {
+				delete this._data[finalKey];
+				delete this._types[finalKey];
+				delete this._expires[finalKey];
+			}
+		}
 
-		// 保存新值
-		this._data[key] = newValue;
-		this._types[key] = 'number';
+		this._data[finalKey] = finalStringValues;
+		this._types[finalKey] = 'array';
 
-		if (seconds > 0) {
-			this._expires[key] = Date.now() + seconds * 1000;
+		if (finalSeconds > 0) {
+			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
 		} else {
-			delete this._expires[key];
+			delete this._expires[finalKey];
 		}
 
-		this.emit('incrbyfloat_after', {
-			key,
-			value,
-			ttl: seconds,
-			success: true,
-			result: newValue
+		const length = finalStringValues.length;
+		this.emit('setForList:after', {
+			key: finalKey,
+			value: finalStringValues,
+			seconds: finalSeconds,
+			result: length
 		});
-		return newValue;
+		return length;
 	} catch (error) {
-		this.emit('incrbyfloat_error', {
-			key,
-			value,
-			ttl: seconds,
-			error
-		});
-		this.log('error', 'incrbyfloat操作失败:', error);
+		this.emit('setForList:error', { key, value, seconds, error });
+		this.log('error', 'setForList操作失败:', error);
 		return 0;
 	}
 };
 
 /**
- * 获取并设置值
- * @param {string} key - 键名
- * @param {*} value - 新值
- * @param {number} expire - 过期时间（毫秒）
- * @returns {*} 旧值
+ * 向列表添加元素
+ * @param {String} key 键名
+ * @param {*} value 要添加的元素
+ * @param {Number} [seconds=0] 过期时间（秒）
+ * @returns {Promise<Number>} 添加后列表长度
  */
-CacheBase.prototype.getset = function (key, value, expire) {
+CacheBase.prototype.addForList = async function (key, value, seconds = 0) {
 	try {
-		// 参数验证
 		if (!key || typeof key !== 'string') {
-			return null;
+			return 0;
 		}
 
-		// 获取旧值
-		const oldValue = this.get(key);
+		const ctx = {
+			key,
+			value,
+			seconds,
+			cancel: false
+		};
+		this.emit('addForList:before', ctx);
 
-		// 设置新值
-		this.set(key, value, expire);
+		if (ctx.cancel) {
+			this.log('debug', `addForList操作被事件处理器取消 [${key}]`);
+			return 0;
+		}
 
-		return oldValue;
+		const {
+			key: finalKey,
+			value: finalValue,
+			seconds: finalSeconds
+		} = ctx;
+
+		const stringValue = String(finalValue);
+
+		// 检查键是否存在且未过期
+		if (finalKey in this._data && !this._isExpired(finalKey)) {
+			if (!Array.isArray(this._data[finalKey])) {
+				this._data[finalKey] = [stringValue];
+				this._types[finalKey] = 'array';
+			} else {
+				this._data[finalKey].push(stringValue);
+			}
+		} else {
+			this._data[finalKey] = [stringValue];
+			this._types[finalKey] = 'array';
+		}
+
+		if (finalSeconds > 0) {
+			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
+		} else if (finalKey in this._expires) {
+			delete this._expires[finalKey];
+		}
+
+		const length = this._data[finalKey].length;
+		this.emit('addForList:after', {
+			key: finalKey,
+			value: stringValue,
+			seconds: finalSeconds,
+			result: length
+		});
+		return length;
 	} catch (error) {
-		this.log('error', 'Failed to getset:', error);
-		return null;
+		this.emit('addForList:error', { key, value, seconds, error });
+		this.log('error', 'addForList操作失败:', error);
+		return 0;
 	}
 };
 
 /**
- * 增加整数值 - 兼容方法
- * @param {string} key - 键名
- * @param {*} value - 要设置的值
- * @param {number} maxAge - 过期时间（秒），0表示永不过期
- * @returns {Promise<boolean>} - 操作结果，键不存在并设置成功返回true，键已存在返回false
+ * 检查列表中是否包含指定元素
+ * @param {String} key 键名
+ * @param {*} value 要检查的元素
+ * @returns {Promise<Boolean>} 是否包含
  */
-CacheBase.prototype.add = function (key, value, maxAge = 0) {
+CacheBase.prototype.hasForList = async function (key, value) {
 	try {
-		// 参数验证
 		if (!key || typeof key !== 'string') {
-			throw new TypeError('add参数错误: key必须是非空字符串');
+			return false;
 		}
 
-		// 触发前置事件
-		const beforeEventData = {
+		const ctx = {
 			key,
 			value,
-			maxAge,
 			cancel: false
 		};
-		this.emit('add_before', beforeEventData);
+		this.emit('hasForList:before', ctx);
 
-		if (beforeEventData.cancel) {
-			this.log('debug', `add操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.log('debug', `hasForList操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
 		const {
 			key: finalKey,
-			value: finalValue,
-			maxAge: finalMaxAge
-		} = beforeEventData;
+			value: finalValue
+		} = ctx;
+
+		const stringValue = String(finalValue);
 
-		// 检查键是否存在且未过期
 		if (finalKey in this._data && !this._isExpired(finalKey)) {
-			// 键已存在，返回false
-			this.emit('add_after', {
-				key: finalKey,
-				value: finalValue,
-				maxAge: finalMaxAge,
-				success: false
-			});
+			if (Array.isArray(this._data[finalKey])) {
+				const result = this._data[finalKey].includes(stringValue);
+				this.emit('hasForList:after', { key: finalKey, value: finalValue, result });
+				return result;
+			}
+		}
+
+		this.emit('hasForList:after', { key: finalKey, value: finalValue, result: false });
+		return false;
+	} catch (error) {
+		this.emit('hasForList:error', { key, value, error });
+		this.log('error', 'hasForList操作失败:', error);
+		return false;
+	}
+};
+
+/**
+ * 获取列表缓存
+ * @param {String} key 键名
+ * @param {Number} [start=0] 起始索引
+ * @param {Number} [end=-1] 结束索引
+ * @returns {Promise<Array>} 列表数组
+ */
+CacheBase.prototype.getForList = async function (key, start = 0, end = -1) {
+	try {
+		this.emit('getForList:before', { key, start, end });
+
+		if (!key || typeof key !== 'string') {
+			return [];
+		}
+
+		// 检查是否过期
+		if (this._isExpired(key)) {
+			await this.del(key);
+			return [];
+		}
+
+		// 检查键是否存在
+		if (!(key in this._data)) {
+			return [];
+		}
+
+		// 检查是否为数组
+		if (Array.isArray(this._data[key])) {
+			const array = this._data[key];
+
+			// 处理负索引，符合 Redis LRANGE 语义
+			const startIndex = start < 0
+				? Math.max(0, array.length + start)
+				: start;
+			const endIndex = end < 0
+				? Math.max(0, array.length + end + 1)
+				: end + 1;
+
+			const result = array.slice(startIndex, endIndex);
+			this.emit('getForList:after', { key, start, end, result });
+			return result;
+		}
+
+		return [];
+	} catch (error) {
+		this.log('error', 'getForList操作失败:', error);
+		return [];
+	}
+};
+
+/**
+ * 清空列表
+ * @param {String} key 键名
+ * @returns {Promise<Boolean>} 操作结果
+ */
+CacheBase.prototype.clearForList = async function (key) {
+	try {
+		const ctx = {
+			key,
+			cancel: false
+		};
+		this.emit('clearForList:before', ctx);
+
+		if (ctx.cancel) {
 			return false;
 		}
 
-		// 键不存在，设置新值
-		this._data[finalKey] = finalValue;
-		this._types[finalKey] = this._getDataTypes(finalValue);
+		const {
+			key: finalKey
+		} = ctx;
 
-		// 设置过期时间
-		if (finalMaxAge > 0) {
-			this._expires[finalKey] = Date.now() + finalMaxAge * 1000;
-		} else {
-			delete this._expires[finalKey];
+		if (!finalKey || typeof finalKey !== 'string') {
+			return false;
 		}
 
-		// 触发后置事件
-		this.emit('add_after', {
-			key: finalKey,
-			value: finalValue,
-			maxAge: finalMaxAge,
-			success: true
-		});
+		if (finalKey in this._data && !this._isExpired(finalKey)) {
+			if (Array.isArray(this._data[finalKey])) {
+				this._data[finalKey] = [];
+				this.emit('clearForList:after', { key: finalKey, result: true });
+				return true;
+			} else {
+				delete this._data[finalKey];
+				delete this._types[finalKey];
+				delete this._expires[finalKey];
+				this.emit('clearForList:after', { key: finalKey, result: false });
+				return false;
+			}
+		}
+
+		this._data[finalKey] = [];
+		this._types[finalKey] = 'array';
+		this.emit('clearForList:after', { key: finalKey, result: true });
 		return true;
 	} catch (error) {
-		this.log('error', `add操作失败 [${key}]:`, error);
-		this.emit('add_error', {
-			key,
-			value,
-			maxAge,
-			error
-		});
+		this.emit('clearForList:error', { key, error });
+		this.log('error', 'clearForList操作失败:', error);
 		return false;
 	}
 };
 
+// ==================== 集合操作 ====================
+
 /**
- * 增加浮点数（兼容方法）
- * @param {string} key - 键名
- * @param {number} num - 要增加的浮点数值
- * @param {number} seconds - 过期时间（秒），0表示永不过期
- * @returns {Promise<number>} - 返回增加后的值
+ * 将成员添加到集合
+ * @param {String} key 键
+ * @param {String|Array} members 成员或成员数组
+ * @returns {Promise<Number>} 添加的成员数量
  */
-CacheBase.prototype.addFloat = function (key, num, seconds = 0) {
+CacheBase.prototype.sadd = async function (key, members) {
 	try {
-		// 参数验证
-		if (!key || typeof key !== 'string' || typeof num !== 'number') {
-			throw new TypeError('addFloat参数错误: key必须是非空字符串，num必须是数字');
-		}
-
-		this.emit('addFloat_before', {
+		const ctx = {
 			key,
-			num,
-			ttl: seconds,
+			members: Array.isArray(members) ? members : [members],
 			cancel: false
-		});
+		};
+		this.emit('sadd:before', ctx);
 
-		// 实现浮点数递增逻辑
-		let currentValue = 0;
-		if (key in this._data && !this._isExpired(key)) {
-			currentValue = Number(this._data[key]) || 0;
+		if (ctx.cancel) {
+			return 0;
 		}
-		const result = currentValue + Number(num);
 
-		// 设置值和过期时间
-		this._data[key] = result;
-		this._types[key] = 'number';
+		const {
+			key: finalKey,
+			members: finalMembers
+		} = ctx;
 
-		if (seconds > 0) {
-			this._expires[key] = Date.now() + seconds * 1000;
-		} else {
-			delete this._expires[key];
+		// 检查是否过期
+		if (this._isExpired(finalKey)) {
+			await this.del(finalKey);
 		}
 
-		this.emit('addFloat_after', {
-			key,
-			num,
-			ttl: seconds,
-			success: true,
-			result
+		// 初始化集合
+		if (!(finalKey in this._data) || this._types[finalKey] !== 'set') {
+			this._data[finalKey] = new Set();
+			this._types[finalKey] = 'set';
+		}
+
+		const set = this._data[finalKey];
+		let addedCount = 0;
+		for (const member of finalMembers) {
+			const memberStr = String(member);
+			if (!set.has(memberStr)) {
+				set.add(memberStr);
+				addedCount++;
+			}
+		}
+
+		this.emit('sadd:after', {
+			key: finalKey,
+			members: finalMembers,
+			result: addedCount
 		});
-		return result;
+		return addedCount;
 	} catch (error) {
-		this.emit('addFloat_error', {
-			key,
-			num,
-			ttl: seconds,
-			error
-		});
-		this.log('error', 'addFloat操作失败:', error);
+		this.log('error', `添加集合成员失败 [${key}]:`, error);
+		this.emit('sadd:error', { key, members, error });
 		return 0;
 	}
 };
 
 /**
- * 追加字符串（兼容方法）
- * @param {string} key - 键名
- * @param {string} value - 要追加的字符串
- * @param {number} seconds - 过期时间（秒），0表示永不过期
- * @returns {Promise<number>} - 返回追加后字符串的长度
+ * 从集合中移除成员
+ * @param {String} key 键
+ * @param {String|Array} members 成员或成员数组
+ * @returns {Promise<Number>} 移除的成员数量
  */
-CacheBase.prototype.addStr = function (key, value, seconds = 0) {
+CacheBase.prototype.srem = async function (key, members) {
 	try {
-		// 参数验证
-		if (!key || typeof key !== 'string' || typeof value !== 'string') {
-			throw new TypeError('addStr参数错误: key和value必须是非空字符串');
-		}
-
-		this.emit('addStr_before', {
+		const ctx = {
 			key,
-			value,
-			ttl: seconds,
+			members: Array.isArray(members) ? members : [members],
 			cancel: false
-		});
+		};
+		this.emit('srem:before', ctx);
 
-		// 实现字符串追加逻辑
-		let currentValue = '';
-		if (key in this._data && !this._isExpired(key)) {
-			currentValue = String(this._data[key]) || '';
+		if (ctx.cancel) {
+			return 0;
 		}
-		const result = currentValue + value;
-		const length = result.length;
 
-		// 设置值和过期时间
-		this._data[key] = result;
-		this._types[key] = 'string';
+		const {
+			key: finalKey,
+			members: finalMembers
+		} = ctx;
 
-		if (seconds > 0) {
-			this._expires[key] = Date.now() + seconds * 1000;
-		} else {
-			delete this._expires[key];
+		if (!(finalKey in this._data) || this._types[finalKey] !== 'set') {
+			return 0;
 		}
 
-		this.emit('addStr_after', {
-			key,
-			value,
-			ttl: seconds,
-			result,
-			length,
-			success: true
+		const set = this._data[finalKey];
+		let removedCount = 0;
+		for (const member of finalMembers) {
+			const memberStr = String(member);
+			if (set.has(memberStr)) {
+				set.delete(memberStr);
+				removedCount++;
+			}
+		}
+
+		// 如果集合为空，删除整个键
+		if (set.size === 0) {
+			delete this._data[finalKey];
+			delete this._types[finalKey];
+			delete this._expires[finalKey];
+		}
+
+		this.emit('srem:after', {
+			key: finalKey,
+			members: finalMembers,
+			result: removedCount
 		});
-		return length;
+		return removedCount;
 	} catch (error) {
-		this.emit('addStr_error', {
-			key,
-			value,
-			ttl: seconds,
-			error
-		});
-		this.log('error', 'addStr操作失败:', error);
+		this.log('error', `移除集合成员失败 [${key}]:`, error);
+		this.emit('srem:error', { key, members, error });
 		return 0;
 	}
 };
 
 /**
- * 一次性设置多个键值对 - 兼容Redis的MSET命令
- * @param {string} key1, value1, key2, value2... - 键值对参数列表
- * @returns {boolean} - 成功返回true，失败返回false
+ * 检查成员是否在集合中
+ * @param {String} key 键
+ * @param {String} member 成员
+ * @returns {Promise<Boolean>} 是否存在
  */
-CacheBase.prototype.mset = function (...args) {
+CacheBase.prototype.sismember = async function (key, member) {
 	try {
-		// 参数验证 - 特别处理null参数情况
-		if (args.length === 1 && args[0] === null) {
-			throw new TypeError('参数数量必须为偶数');
-		}
+		this.emit('sismember:before', { key, member });
 
-		// 常规参数验证
-		if (args.length === 0 || args.length % 2 !== 0) {
-			throw new TypeError('参数数量必须为偶数');
+		if (!key || typeof key !== 'string') {
+			throw new TypeError('key必须是非空字符串');
 		}
-
-		// 将参数列表转换为键值对对象
-		const keyValuePairs = {};
-		for (let i = 0; i < args.length; i += 2) {
-			const key = args[i];
-			const value = args[i + 1];
-
-			if (typeof key !== 'string' || !key) {
-				throw new TypeError('键必须是非空字符串');
-			}
-
-			keyValuePairs[key] = value;
+		if (member === undefined || member === null) {
+			throw new TypeError('member不能为undefined或null');
 		}
 
-		// 触发前置事件
-		const beforeEventData = {
-			keyValuePairs,
-			cancel: false
-		};
-		this.emit('mset_before', beforeEventData);
-
-		if (beforeEventData.cancel) {
-			this.log('debug', '[mset] 操作被事件处理器取消');
+		if (this._isExpired(key)) {
+			await this.del(key);
 			return false;
 		}
 
-		const {
-			keyValuePairs: finalKeyValuePairs
-		} = beforeEventData;
-
-		// 批量设置键值对
-		for (const [key, value] of Object.entries(finalKeyValuePairs)) {
-			// 检查键是否过期
-			if (this._isExpired(key)) {
-				this.del(key);
-			}
-
-			// 保存数据
-			this._data[key] = value;
-			// 设置数据类型
-			this._types[key] = this._getDataTypes(value);
-			// 清除过期时间（与Redis MSET一致）
-			delete this._expires[key];
+		if (!(key in this._data) || this._types[key] !== 'set') {
+			return false;
 		}
 
-		// 触发后置事件
-		this.emit('mset_after', {
-			keyValuePairs: finalKeyValuePairs,
-			result: true,
-			success: true
-		});
-		return true;
+		const memberStr = String(member);
+		const result = this._data[key].has(memberStr);
+		this.emit('sismember:after', { key, member, result });
+		return result;
 	} catch (error) {
-		// 确保触发错误事件
-		this.emit('mset_error', {
-			args,
-			error
-		});
-		this.log('error', 'Failed to mset:', error);
+		this.emit('sismember:error', { key, member, error });
+		this.log('error', `检查集合成员失败 [${key}:${member}]:`, error);
 		return false;
 	}
 };
 
 /**
- * 获取或设置键的过期时间
- * @param {String} key 键名
- * @param {Number} [seconds] 过期时间（秒），不传此参数则获取剩余过期时间
- * @return {Promise<Number|Boolean>} 不传seconds时返回剩余过期时间（-1表示无过期设置，-2表示已过期），传seconds时返回是否设置成功
+ * 获取集合中的所有成员
+ * @param {String} key 键
+ * @returns {Promise<Array>} 成员数组
  */
-CacheBase.prototype.ttl = function (key, seconds) {
+CacheBase.prototype.smembers = async function (key) {
 	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			return arguments.length === 1 ? -2 : false;
-		}
-
-		// 判断是否为设置过期时间模式
-		if (arguments.length > 1 && seconds !== undefined) {
-			// 设置过期时间模式
-			if (typeof seconds !== 'number' || seconds < 0) {
-				return false;
-			}
-
-			// 检查键是否存在
-			if (!(key in this._data)) {
-				return false;
-			}
-
-			// 检查是否过期
-			if (this._isExpired(key)) {
-				this.del(key);
-				return false;
-			}
-
-			// 设置过期时间
-			if (seconds > 0) {
-				this._expires[key] = Date.now() + (seconds * 1000);
-			} else if (seconds === 0) {
-				// 移除过期时间
-				delete this._expires[key];
-			}
-
-			return true;
-		} else {
-			// 获取剩余过期时间模式
-			// 检查键是否存在
-			if (!(key in this._data)) {
-				return -2;
-			}
-
-			// 检查是否过期
-			if (this._isExpired(key)) {
-				this.del(key);
-				return -2;
-			}
-
-			// 检查是否设置了过期时间
-			if (!(key in this._expires)) {
-				return -1; // 无过期时间
-			}
+		this.emit('smembers:before', { key });
 
-			// 计算剩余时间
-			const now = Date.now();
-			const remaining = this._expires[key] - now;
+		if (this._isExpired(key)) {
+			await this.del(key);
+			return [];
+		}
 
-			return Math.max(0, Math.ceil(remaining / 1000));
+		if (!(key in this._data) || this._types[key] !== 'set') {
+			return [];
 		}
+
+		const result = Array.from(this._data[key]);
+		this.emit('smembers:after', { key, result });
+		return result;
 	} catch (error) {
-		const errorMsg = arguments.length > 1 && seconds !== undefined
-			? `Failed to set ttl for key ${key}: ${error.message}`
-			: `Failed to get ttl for key ${key}: ${error.message}`;
-		this.log('error', errorMsg, error);
-		return arguments.length > 1 && seconds !== undefined ? false : -2;
+		this.log('error', `获取集合所有成员失败 [${key}]:`, error);
+		this.emit('smembers:error', { key, error });
+		return [];
 	}
 };
 
 /**
- * 移除键的过期时间
- * @param {string} key - 键名
- * @returns {boolean} 是否成功移除
+ * 获取集合中的成员数量
+ * @param {String} key 键
+ * @returns {Promise<Number>} 成员数量
  */
-CacheBase.prototype.persist = function (key) {
+CacheBase.prototype.scard = async function (key) {
 	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			return false;
-		}
-
-		// 触发操作前事件
-		const event_data = {
-			key,
-			cancel: false
-		};
-		this.emit('persist_before', event_data);
-
-		if (event_data.cancel) {
-			return false;
-		}
-
-		// 检查键是否存在
-		if (!(key in this._data)) {
-			return false;
-		}
-
-		// 检查是否过期
 		if (this._isExpired(key)) {
-			this.del(key);
-			return false;
+			await this.del(key);
+			return 0;
 		}
 
-		// 移除过期时间
-		if (key in this._expires) {
-			delete this._expires[key];
-
-			// 触发操作后事件
-			this.emit('persist_after', {
-				key
-			});
-			return true;
+		if (!(key in this._data) || this._types[key] !== 'set') {
+			return 0;
 		}
 
-		return false; // 键没有设置过期时间
+		return this._data[key].size;
 	} catch (error) {
-		this.log('error', `Failed to persist key ${key}:`, error);
-		return false;
+		this.log('error', `获取集合成员数量失败 [${key}]:`, error);
+		return 0;
 	}
 };
+
 /**
- * 批量获取多个键的值
- * @param {Array} keys - 键名数组
- * @returns {Array} 值数组，按键的顺序返回
+ * 获取多个集合的交集
+ * @param {...String} keys 键名列表
+ * @returns {Promise<Array>} 交集成员数组
  */
-CacheBase.prototype.mget = function (keys) {
+CacheBase.prototype.sinter = async function (...keys) {
 	try {
-		// 参数验证
-		if (!Array.isArray(keys)) {
+		if (keys.length === 0) {
 			return [];
 		}
 
-		const results = [];
-
-		// 批量获取值
+		const sets = [];
 		for (const key of keys) {
-			if (typeof key === 'string') {
-				results.push(this.get(key));
-			} else {
-				results.push(null);
+			if (this._isExpired(key)) {
+				await this.del(key);
+				return [];
 			}
+			if (!(key in this._data) || this._types[key] !== 'set') {
+				return [];
+			}
+			sets.push(this._data[key]);
 		}
 
-		return results;
+		const result = Array.from(sets[0]).filter(member =>
+			sets.every(set => set.has(member))
+		);
+		return result;
 	} catch (error) {
-		this.log('error', 'Failed to mget:', error);
+		this.log('error', '获取集合交集失败:', error);
 		return [];
 	}
 };
 
 /**
- * 清理资源并销毁实例
- * @returns {boolean} 操作结果
+ * 获取多个集合的并集
+ * @param {...String} keys 键名列表
+ * @returns {Promise<Array>} 并集成员数组
  */
-CacheBase.prototype.dispose = function () {
+CacheBase.prototype.sunion = async function (...keys) {
 	try {
-		// 清除定时任务
-		if (this._auto_save_timer) {
-			clearInterval(this._auto_save_timer);
-			this._auto_save_timer = null;
+		if (keys.length === 0) {
+			return [];
 		}
 
-		// 清除所有数据
-		this._data = {};
-		this._expires = {};
-		this._types = {};
-
-		// 触发销毁事件
-		this.emit('destroy', {
-			success: true
-		});
+		const resultSet = new Set();
+		for (const key of keys) {
+			if (this._isExpired(key)) {
+				await this.del(key);
+				continue;
+			}
+			if (key in this._data && this._types[key] === 'set') {
+				for (const member of this._data[key]) {
+					resultSet.add(member);
+				}
+			}
+		}
 
-		return true;
+		return Array.from(resultSet);
 	} catch (error) {
-		this.log('error', 'Failed to dispose:', error);
-		return false;
+		this.log('error', '获取集合并集失败:', error);
+		return [];
 	}
 };
 
 /**
- * 确保连接池对象存在
+ * 获取多个集合的差集（第一个集合减去其余集合）
+ * @param {...String} keys 键名列表
+ * @returns {Promise<Array>} 差集成员数组
  */
-global.$ = global.$ || {};
-if (!$.pool) {
-	$.pool = {};
-}
-if (!$.pool.cachebase) {
-	$.pool.cachebase = {};
-}
+CacheBase.prototype.sdiff = async function (...keys) {
+	try {
+		if (keys.length === 0) {
+			return [];
+		}
 
-/**
- * @description cachebase管理器，用于创建缓存
- * @param {String} scope 作用域
- * @param {String} dir 当前路径
- * @return {Object} 返回一个cachebase类实例
- */
-function cachebase_admin(scope, dir) {
-	if (!scope) {
-		scope = 'sys';
-	}
-	var obj = $.pool.cachebase[scope];
-	if (!obj) {
-		const config = {
-			file_path: dir ? `./cachebase_${scope}.json`.fullname(dir) : `/cache/cachebase_${scope}.json`
-		};
-		$.pool.cachebase[scope] = new CacheBase(config);
-		obj = $.pool.cachebase[scope];
+		const firstKey = keys[0];
+		if (this._isExpired(firstKey)) {
+			await this.del(firstKey);
+			return [];
+		}
+		if (!(firstKey in this._data) || this._types[firstKey] !== 'set') {
+			return [];
+		}
+
+		const firstSet = this._data[firstKey];
+		const otherSets = [];
+		for (let i = 1; i < keys.length; i++) {
+			const key = keys[i];
+			if (this._isExpired(key)) {
+				await this.del(key);
+				continue;
+			}
+			if (key in this._data && this._types[key] === 'set') {
+				otherSets.push(this._data[key]);
+			}
+		}
+
+		const result = Array.from(firstSet).filter(member =>
+			!otherSets.some(set => set.has(member))
+		);
+		return result;
+	} catch (error) {
+		this.log('error', '获取集合差集失败:', error);
+		return [];
 	}
-	return obj;
-}
+};
+
+// ==================== 有序集合操作 ====================
 
 /**
- * 设置列表
- * @param {string} key - 键名
- * @param {Array} value - 列表值
- * @param {number} [maxAge=0] - 过期时间（秒），0表示永不过期
- * @returns {Promise<number>} - 列表长度
+ * 添加成员到有序集合
+ * @param {String} key 键
+ * @param {Number} score 分数
+ * @param {String} member 成员
+ * @returns {Promise<Boolean>} 是否成功（新成员返回true，更新返回false）
  */
-CacheBase.prototype.setForList = async function (key, value, maxAge = 0) {
+CacheBase.prototype.zadd = async function (key, score, member) {
 	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			return 0;
-		}
-
-		// 确保value是数组
-		let stringValues = [];
-		if (Array.isArray(value)) {
-			stringValues = value.map(item => String(item));
-		} else {
-			stringValues = [String(value)];
-		}
-
-		// 触发前置事件
-		const beforeEventData = {
+		const ctx = {
 			key,
-			value,
-			maxAge,
+			score,
+			member,
 			cancel: false
 		};
-		this.emit('setForList_before', beforeEventData);
+		this.emit('zadd:before', ctx);
 
-		if (beforeEventData.cancel) {
-			this.log('debug', `setForList操作被事件处理器取消 [${key}]`);
-			return 0;
+		if (ctx.cancel) {
+			return false;
 		}
 
-		// 检查键是否存在且未过期
-		if (key in this._data && !this._isExpired(key)) {
-			// 如果已存在但不是数组，删除并重新设置
-			if (!Array.isArray(this._data[key])) {
-				delete this._data[key];
-				delete this._types[key];
-				delete this._expires[key];
-			}
-		}
+		const {
+			key: finalKey,
+			score: finalScore,
+			member: finalMember
+		} = ctx;
 
-		// 设置列表数据
-		this._data[key] = stringValues;
-		this._types[key] = 'array';
+		// 检查是否过期
+		if (this._isExpired(finalKey)) {
+			await this.del(finalKey);
+		}
 
-		// 设置过期时间
-		if (maxAge > 0) {
-			this._expires[key] = Date.now() + maxAge * 1000;
-		} else {
-			delete this._expires[key];
+		// 初始化有序集合
+		if (!(finalKey in this._data) || this._types[finalKey] !== 'zset') {
+			this._data[finalKey] = new Map();
+			this._types[finalKey] = 'zset';
 		}
 
-		const length = stringValues.length;
+		const map = this._data[finalKey];
+		const memberStr = String(finalMember);
+		const isNew = !map.has(memberStr);
+		map.set(memberStr, Number(finalScore));
 
-		// 触发后置事件
-		this.emit('setForList_after', {
-			key,
-			value: stringValues,
-			maxAge,
-			result: length
+		this.emit('zadd:after', {
+			key: finalKey,
+			score: finalScore,
+			member: finalMember,
+			success: isNew
 		});
-		return length;
+		return isNew;
 	} catch (error) {
-		// 触发错误事件
-		this.emit('setForList_error', {
-			key,
-			value,
-			maxAge,
-			error
-		});
-		this.log('error', 'setForList操作失败:', error);
-		return 0;
+		this.log('error', `添加有序集合成员失败 [${key}]:`, error);
+		this.emit('zadd:error', { key, score, member, error });
+		return false;
 	}
 };
 
 /**
- * 向列表添加元素
- * @param {string} key - 键名
- * @param {*} value - 要添加的元素
- * @param {number} [maxAge=0] - 过期时间（秒），0表示永不过期
- * @returns {Promise<number>} - 添加后列表长度
+ * 从有序集合中移除成员
+ * @param {String} key 键
+ * @param {String|Array} members 成员或成员数组
+ * @returns {Promise<Number>} 移除的成员数量
  */
-CacheBase.prototype.addForList = async function (key, value, maxAge = 0) {
+CacheBase.prototype.zrem = async function (key, members) {
 	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			return 0;
-		}
-
-		// 确保value是字符串
-		const stringValue = String(value);
-
-		// 触发前置事件
-		const beforeEventData = {
+		const ctx = {
 			key,
-			value,
-			maxAge,
+			members: Array.isArray(members) ? members : [members],
 			cancel: false
 		};
-		this.emit('addForList_before', beforeEventData);
+		this.emit('zrem:before', ctx);
 
-		if (beforeEventData.cancel) {
-			this.log('debug', `addForList操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
 			return 0;
 		}
 
-		// 检查键是否存在且未过期
-		if (key in this._data && !this._isExpired(key)) {
-			// 如果已存在但不是数组，删除并重新设置为数组
-			if (!Array.isArray(this._data[key])) {
-				this._data[key] = [stringValue];
-				this._types[key] = 'array';
-			} else {
-				// 向现有数组添加元素
-				this._data[key].push(stringValue);
-			}
-		} else {
-			// 键不存在或已过期，创建新数组
-			this._data[key] = [stringValue];
-			this._types[key] = 'array';
+		const {
+			key: finalKey,
+			members: finalMembers
+		} = ctx;
+
+		if (!(finalKey in this._data) || this._types[finalKey] !== 'zset') {
+			return 0;
 		}
 
-		// 设置过期时间
-		if (maxAge > 0) {
-			this._expires[key] = Date.now() + maxAge * 1000;
-		} else if (key in this._expires) {
-			delete this._expires[key];
+		const map = this._data[finalKey];
+		let removedCount = 0;
+		for (const member of finalMembers) {
+			const memberStr = String(member);
+			if (map.has(memberStr)) {
+				map.delete(memberStr);
+				removedCount++;
+			}
 		}
 
-		const length = this._data[key].length;
+		// 如果有序集合为空，删除整个键
+		if (map.size === 0) {
+			delete this._data[finalKey];
+			delete this._types[finalKey];
+			delete this._expires[finalKey];
+		}
 
-		// 触发后置事件
-		this.emit('addForList_after', {
-			key,
-			value: stringValue,
-			maxAge,
-			result: length
+		this.emit('zrem:after', {
+			key: finalKey,
+			members: finalMembers,
+			result: removedCount
 		});
-		return length;
+		return removedCount;
 	} catch (error) {
-		// 触发错误事件
-		this.emit('addForList_error', {
-			key,
-			value,
-			maxAge,
-			error
-		});
-		this.log('error', 'addForList操作失败:', error);
+		this.log('error', `移除有序集合成员失败 [${key}]:`, error);
+		this.emit('zrem:error', { key, members, error });
 		return 0;
 	}
 };
 
 /**
- * 检查列表中是否包含指定元素
- * @param {string} key - 键名
- * @param {*} value - 要检查的元素
- * @returns {Promise<boolean>} - 是否包含
+ * 获取有序集合中成员的分数
+ * @param {String} key 键
+ * @param {String} member 成员
+ * @returns {Promise<Number|null>} 分数，不存在返回null
  */
-CacheBase.prototype.hasForList = async function (key, value) {
+CacheBase.prototype.zscore = async function (key, member) {
 	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			return false;
+		if (this._isExpired(key)) {
+			await this.del(key);
+			return null;
 		}
 
-		// 确保value是字符串
-		const stringValue = String(value);
+		if (!(key in this._data) || this._types[key] !== 'zset') {
+			return null;
+		}
 
-		// 触发前置事件
-		const beforeEventData = {
-			key,
-			value,
-			cancel: false
-		};
-		this.emit('hasForList_before', beforeEventData);
+		const memberStr = String(member);
+		const map = this._data[key];
+		if (!map.has(memberStr)) {
+			return null;
+		}
+		return map.get(memberStr);
+	} catch (error) {
+		this.log('error', `获取有序集合成员分数失败 [${key}:${member}]:`, error);
+		return null;
+	}
+};
 
-		if (beforeEventData.cancel) {
-			this.log('debug', `hasForList操作被事件处理器取消 [${key}]`);
-			return false;
+/**
+ * 获取有序集合中成员的排名（分数从小到大）
+ * @param {String} key 键
+ * @param {String} member 成员
+ * @returns {Promise<Number|null>} 排名，不存在返回null
+ */
+CacheBase.prototype.zrank = async function (key, member) {
+	try {
+		if (this._isExpired(key)) {
+			await this.del(key);
+			return null;
 		}
 
-		// 检查键是否存在且未过期
-		if (key in this._data && !this._isExpired(key)) {
-			// 检查是否为数组
-			if (Array.isArray(this._data[key])) {
-				// 检查数组中是否包含指定元素
-				const result = this._data[key].includes(stringValue);
-				// 触发后置事件
-				this.emit('hasForList_after', {
-					key,
-					value,
-					result
-				});
-				return result;
-			}
+		if (!(key in this._data) || this._types[key] !== 'zset') {
+			return null;
 		}
 
-		// 键不存在、已过期或不是数组
-		this.emit('hasForList_after', {
-			key,
-			value,
-			result: 0
-		});
-		return false;
+		const memberStr = String(member);
+		const map = this._data[key];
+		if (!map.has(memberStr)) {
+			return null;
+		}
+
+		// 按分数从小到大排序
+		const sorted = Array.from(map.entries()).sort((a, b) => a[1] - b[1]);
+		const rank = sorted.findIndex(([m]) => m === memberStr);
+		return rank >= 0 ? rank : null;
 	} catch (error) {
-		// 触发错误事件
-		this.emit('hasForList_error', {
-			key,
-			value,
-			error
-		});
-		this.log('error', 'hasForList操作失败:', error);
-		return false;
+		this.log('error', `获取有序集合成员排名失败 [${key}:${member}]:`, error);
+		return null;
 	}
 };
 
 /**
- * 获取列表
- * @param {string} key - 键名
- * @param {number} [start=0] - 起始索引
- * @param {number} [stop=-1] - 结束索引，-1表示全部
- * @returns {Promise<Array>} - 列表数组
+ * 获取有序集合中指定范围的成员
+ * @param {String} key 键
+ * @param {Number} start 起始索引
+ * @param {Number} stop 结束索引
+ * @param {Boolean} [withScores=false] 是否返回分数
+ * @returns {Promise<Array>} 成员数组
  */
-CacheBase.prototype.getForList = async function (key, start = 0, stop = -1) {
+CacheBase.prototype.zrange = async function (key, start, stop, withScores = false) {
 	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
+		if (this._isExpired(key)) {
+			await this.del(key);
 			return [];
 		}
 
-		// 触发前置事件
-		const beforeEventData = {
-			key,
-			start,
-			stop,
-			cancel: false
-		};
-		this.emit('getForList_before', beforeEventData);
-
-		if (beforeEventData.cancel) {
-			this.log('debug', `getForList操作被事件处理器取消 [${key}]`);
+		if (!(key in this._data) || this._types[key] !== 'zset') {
 			return [];
 		}
 
-		// 检查键是否存在且未过期
-		if (key in this._data && !this._isExpired(key)) {
-			// 检查是否为数组
-			if (Array.isArray(this._data[key])) {
-				const array = this._data[key];
-
-				// 处理负索引
-				const startIndex = start < 0 ? Math.max(0, array.length + start) : start;
-				const endIndex = stop < 0 ? array.length : stop + 1;
-
-				// 截取数组
-				const result = array.slice(startIndex, endIndex);
-
-				// 触发后置事件
-				this.emit('getForList_after', {
-					key,
-					start,
-					stop,
-					result
-				});
-				return result;
-			}
+		const map = this._data[key];
+		// 按分数从小到大排序
+		const sorted = Array.from(map.entries()).sort((a, b) => a[1] - b[1]);
+		const len = sorted.length;
+
+		// 处理负索引
+		let startIndex = start < 0 ? Math.max(0, len + start) : start;
+		let endIndex = stop < 0 ? Math.max(0, len + stop + 1) : stop + 1;
+
+		if (startIndex >= len) {
+			return [];
 		}
 
-		// 键不存在、已过期或不是数组
-		this.emit('getForList_after', {
-			key,
-			start,
-			stop,
-			result: []
-		});
-		return [];
+		const slice = sorted.slice(startIndex, endIndex);
+		if (withScores) {
+			return slice.map(([member, score]) => ({ member, score }));
+		}
+		return slice.map(([member]) => member);
 	} catch (error) {
-		// 触发错误事件
-		this.emit('getForList_error', {
-			key,
-			start,
-			stop,
-			error
-		});
-		this.log('error', 'getForList操作失败:', error);
+		this.log('error', `获取有序集合范围成员失败 [${key}]:`, error);
 		return [];
 	}
 };
 
 /**
- * 清空列表
- * @param {string} key - 键名
- * @returns {Promise<boolean>} - 操作结果
+ * 获取有序集合中的成员数量
+ * @param {String} key 键
+ * @returns {Promise<Number>} 成员数量
  */
-CacheBase.prototype.clearForList = async function (key) {
+CacheBase.prototype.zcard = async function (key) {
 	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			return false;
-		}
-
-		// 触发前置事件
-		const beforeEventData = {
-			key,
-			cancel: false
-		};
-		this.emit('clearForList_before', beforeEventData);
-
-		if (beforeEventData.cancel) {
-			this.log('debug', `clearForList操作被事件处理器取消 [${key}]`);
-			return false;
+		if (this._isExpired(key)) {
+			await this.del(key);
+			return 0;
 		}
 
-		// 检查键是否存在且未过期
-		if (key in this._data && !this._isExpired(key)) {
-			// 检查是否为数组
-			if (Array.isArray(this._data[key])) {
-				// 清空数组
-				this._data[key] = [];
-
-				// 触发后置事件
-				this.emit('clearForList_after', {
-					key,
-					result: true
-				});
-				return true;
-			} else {
-				// 如果不是数组，删除键
-				delete this._data[key];
-				delete this._types[key];
-				delete this._expires[key];
-
-				// 触发后置事件
-				this.emit('clearForList_after', {
-					key,
-					result: false
-				});
-				return false;
-			}
+		if (!(key in this._data) || this._types[key] !== 'zset') {
+			return 0;
 		}
 
-		// 键不存在或已过期，创建空数组
-		this._data[key] = [];
-		this._types[key] = 'array';
-
-		// 触发后置事件
-		this.emit('clearForList_after', {
-			key,
-			result: true
-		});
-		return true;
+		return this._data[key].size;
 	} catch (error) {
-		// 触发错误事件
-		this.emit('clearForList_error', {
-			key,
-			error
-		});
-		this.log('error', 'clearForList操作失败:', error);
-		return false;
+		this.log('error', `获取有序集合成员数量失败 [${key}]:`, error);
+		return 0;
 	}
 };
 
 /**
- * 批量设置哈希表字段
- * @param {string} key - 哈希表键名
- * @param {Object} obj - 包含多个字段的对象
- * @returns {Promise<boolean>} - 操作结果
+ * 增加有序集合成员的分数
+ * @param {String} key 键
+ * @param {Number} increment 增量
+ * @param {String} member 成员
+ * @returns {Promise<Number>} 增加后的分数
  */
-CacheBase.prototype.hmset = function (key, obj) {
-	return new Promise((resolve) => {
-		try {
-			// 参数验证
-			if (!key || typeof key !== 'string' || !obj || typeof obj !== 'object' || Array.isArray(obj)) {
-				resolve(false);
-				return;
-			}
+CacheBase.prototype.zincrby = async function (key, increment, member) {
+	try {
+		// 检查是否过期
+		if (this._isExpired(key)) {
+			await this.del(key);
+		}
 
-			// 触发前置事件
-			const beforeEventData = {
-				key,
-				obj,
-				cancel: false
-			};
-			this.emit('hmset_before', beforeEventData);
+		// 初始化有序集合
+		if (!(key in this._data) || this._types[key] !== 'zset') {
+			this._data[key] = new Map();
+			this._types[key] = 'zset';
+		}
 
-			if (beforeEventData.cancel) {
-				resolve(false);
-				return;
-			}
+		const map = this._data[key];
+		const memberStr = String(member);
+		const currentScore = map.has(memberStr) ? map.get(memberStr) : 0;
+		const newScore = currentScore + Number(increment);
+		map.set(memberStr, newScore);
 
-			// 检查是否过期
-			if (this._isExpired(key)) {
-				this.del(key);
-			}
+		return newScore;
+	} catch (error) {
+		this.log('error', `增加有序集合成员分数失败 [${key}:${member}]:`, error);
+		return null;
+	}
+};
 
-			// 初始化哈希表
-			if (!(key in this._data) || this._types[key] !== 'hash') {
-				this._data[key] = {};
-				this._types[key] = 'hash';
-			}
+// ==================== 发布订阅 ====================
 
-			// 批量设置字段
-			for (const field in obj) {
-				if (Object.prototype.hasOwnProperty.call(obj, field)) {
-					this._data[key][field] = obj[field];
-				}
-			}
+/**
+ * 消息订阅
+ * @param {String} channel 订阅的频道
+ * @param {Function} func 操作回调函数
+ * @returns {Promise<Boolean>} 订阅结果
+ */
+CacheBase.prototype.subscribe = async function (channel, func) {
+	if (!channel || typeof channel !== 'string') {
+		throw new TypeError('channel必须是非空字符串');
+	}
+	if (typeof func !== 'function') {
+		throw new TypeError('func必须是函数');
+	}
 
-			// 触发后置事件
-			this.emit('hmset_after', {
-				key,
-				obj,
-				success: true
-			});
-			resolve(true);
-		} catch (error) {
-			this.emit('hmset_error', {
-				key,
-				obj,
-				error
-			});
-			this.log('error', 'Failed to hmset:', error);
-			resolve(false);
-		}
-	});
+	try {
+		this._channels[channel] = func;
+		return true;
+	} catch (err) {
+		this.log('error', `订阅频道 ${channel} 失败:`, err);
+		return false;
+	}
 };
 
 /**
- * 批量获取哈希表字段
- * @param {string} key - 哈希表键名
- * @param {Array} fields - 字段名数组
- * @returns {Promise<Array>} - 字段值数组，不存在的字段返回null
+ * 取消订阅
+ * @param {String} channel 订阅的频道
+ * @returns {Promise<Boolean>} 取消订阅结果
  */
-CacheBase.prototype.hmget = function (key, fields) {
-	return new Promise((resolve) => {
-		try {
-			// 参数验证
-			if (!key || typeof key !== 'string' || !Array.isArray(fields)) {
-				resolve([]);
-				return;
-			}
+CacheBase.prototype.unsubscribe = async function (channel) {
+	if (!channel || typeof channel !== 'string') {
+		throw new TypeError('channel必须是非空字符串');
+	}
 
-			// 检查是否过期
-			if (this._isExpired(key)) {
-				this.del(key);
-				resolve([]);
-				return;
-			}
+	try {
+		delete this._channels[channel];
+		return true;
+	} catch (err) {
+		this.log('error', `取消订阅频道 ${channel} 失败:`, err);
+		return false;
+	}
+};
 
-			// 检查键是否存在且类型正确
-			if (!(key in this._data) || this._types[key] !== 'hash') {
-				resolve(fields.map(() => null));
-				return;
-			}
+/**
+ * 发布消息
+ * @param {String} channel 频道
+ * @param {String} message 消息
+ * @returns {Promise<Number>} 接收消息的订阅者数量
+ */
+CacheBase.prototype.publish = async function (channel, message) {
+	if (!channel || typeof channel !== 'string') {
+		throw new TypeError('channel必须是非空字符串');
+	}
+	if (message === undefined || message === null) {
+		throw new TypeError('message不能为undefined或null');
+	}
 
-			// 批量获取字段值
-			const results = [];
-			for (const field of fields) {
-				results.push(this._data[key][field] !== undefined ? this._data[key][field] : null);
+	try {
+		const func = this._channels[channel];
+		if (func) {
+			try {
+				func(message);
+			} catch (err) {
+				this.log('error', `处理频道 ${channel} 的消息时出错:`, err);
 			}
-
-			resolve(results);
-		} catch (error) {
-			this.emit('hmget_error', {
-				key,
-				fields,
-				error
-			});
-			this.log('error', 'Failed to hmget:', error);
-			resolve([]);
+			return 1;
 		}
-	});
+		return 0;
+	} catch (err) {
+		this.log('error', `发布消息到频道 ${channel} 失败:`, err);
+		return 0;
+	}
 };
 
 /**
- * 获取哈希表字段数量
- * @param {string} key - 哈希表键名
- * @returns {Promise<number>} - 字段数量，失败返回0
+ * 订阅消息处理, 如果没有订阅函数，则其他的订阅消息会进入该函数
+ * @param {String} channel 频道
+ * @param {String} message 消息
  */
-CacheBase.prototype.hlen = function (key) {
-	return new Promise((resolve) => {
-		try {
-			// 参数验证
-			if (!key || typeof key !== 'string') {
-				resolve(0);
-				return;
-			}
-
-			// 检查是否过期
-			if (this._isExpired(key)) {
-				this.del(key);
-				resolve(0);
-				return;
-			}
-
-			// 检查键是否存在且类型正确
-			if (!(key in this._data) || this._types[key] !== 'hash') {
-				resolve(0);
-				return;
-			}
+CacheBase.prototype.main = async function (channel, message) {
+	// 默认实现，可由子类重写
+	this.log('debug', `收到未处理的消息 [${channel}]:`, message);
+};
 
-			resolve(Object.keys(this._data[key]).length);
-		} catch (error) {
-			this.emit('hlen_error', {
-				key,
-				error
-			});
-			this.log('error', 'Failed to hlen:', error);
-			resolve(0);
+/**
+ * 消息通知
+ * @param {String} channel 频道
+ * @param {String} message 消息
+ */
+CacheBase.prototype.message = function (channel, message) {
+	var func = this._channels[channel];
+	if (func) {
+		try {
+			func(message);
+		} catch (err) {
+			this.log('error', `处理频道 ${channel} 的消息时出错:`, err);
 		}
-	});
+	} else {
+		this.main(channel, message);
+	}
 };
 
+// ==================== 连接池管理 ====================
+
+/**
+ * 确保连接池对象存在
+ */
+global.$ = global.$ || {};
+if (!$.pool) {
+	$.pool = {};
+}
+if (!$.pool.cachebase) {
+	$.pool.cachebase = {};
+}
 
 /**
  * @description CacheBase管理器，用于创建缓存
@@ -2406,4 +3157,4 @@ function cachebaseAdmin(scope, config) {
 module.exports = {
 	CacheBase,
 	cachebaseAdmin
-};
+};