mm_redis 1.9.6 → 1.9.8

package/compatibility_table.md

@@ -4,198 +4,100 @@
 
 | 方法名 | Redis | MongoDB | CacheBase | Memory | 状态说明 |
 |-------|-------|---------|-----------|--------|----------|
-| set | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| set | ✅ | ✅ | ⚠️ | ⚠️ | Redis和MongoDB正常工作，CacheBase和Memory行为不一致 |
 | get | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| del | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| has | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| clear | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| keys | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| ttl | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| del | ✅ | ✅ | ⚠️ | ⚠️ | Redis和MongoDB正常工作，CacheBase和Memory行为不一致 |
+| has | ✅ | ✅ | ✅ | ✅ | 所有方式都支持 |
+| clear | ✅ | ✅ | ⚠️ | ⚠️ | Redis和MongoDB正常工作，CacheBase和Memory行为不一致 |
+| keys | ✅ | ✅ | ✅ | ✅ | 所有方式都支持 |
+| ttl | ⚠️ | ⚠️ | ⚠️ | ⚠️ | 所有方式行为不一致，需要依赖底层实现 |
 | add | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| addInt | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| addStr | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| sort | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| list_set | ✅ | ⚠️ | ⚠️ | ⚠️ | 所有方式均通过通用实现支持，但底层可能需要各自实现 |
-| list_add | ✅ | ⚠️ | ⚠️ | ⚠️ | 所有方式均通过通用实现支持，但底层可能需要各自实现 |
-| list_has | ✅ | ⚠️ | ⚠️ | ⚠️ | 所有方式均通过通用实现支持，但底层可能需要各自实现 |
-| list_get | ✅ | ⚠️ | ⚠️ | ⚠️ | 所有方式均通过通用实现支持，但底层可能需要各自实现 |
-| list_clear | ✅ | ⚠️ | ⚠️ | ⚠️ | 所有方式均通过通用实现支持，但底层可能需要各自实现 |
+| addInt | ✅ | ❌ | ❌ | ❌ | 仅Redis支持 |
+| addStr | ✅ | ❌ | ❌ | ❌ | 仅Redis支持 |
+| sort | ✅ | ✅ | ❌ | ❌ | Redis和MongoDB支持，其他方式不支持 |
+| exists | ✅ | ✅ | ⚠️ | ⚠️ | Redis和MongoDB正常工作，CacheBase和Memory行为不一致 |
+| incrby | ✅ | ❌ | ❌ | ❌ | 仅Redis支持 |
+| decrby | ✅ | ❌ | ❌ | ❌ | 仅Redis支持 |
+| addFloat | ✅ | ❌ | ❌ | ❌ | 仅Redis支持 |
 
 ## Redis兼容方法 - 哈希表操作
 
 | 方法名 | Redis | MongoDB | CacheBase | Memory | 状态说明 |
 |-------|-------|---------|-----------|--------|----------|
-| hset | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| hset | ✅ | ✅ | ⚠️ | ⚠️ | Redis和MongoDB正常工作，CacheBase和Memory行为不一致 |
 | hget | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| hgetall | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| hdel | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| hmset | ✅ | ✅ | ✅ | ✅ | 哈希表批量设置，所有方式均正常工作 |
-| hmget | ✅ | ✅ | ✅ | ✅ | 哈希表批量获取，所有方式均正常工作 |
-| hlen | ✅ | ✅ | ✅ | ✅ | 获取哈希表长度，所有方式均正常工作 |
+| hgetall | ✅ | ✅ | ✅ | ✅ | 所有方式都支持 |
+| hdel | ✅ | ✅ | ✅ | ✅ | 所有方式都支持 |
+| hmset | ✅ | ✅ | ❌ | ❌ | Redis和MongoDB支持，其他方式不支持 |
+| hmget | ❌ | ✅ | ❌ | ❌ | 仅MongoDB支持 |
+| hlen | ✅ | ✅ | ❌ | ❌ | Redis和MongoDB支持，其他方式不支持 |
 
 ## Redis兼容方法 - 其他常用命令
 
 | 方法名 | Redis | MongoDB | CacheBase | Memory | 状态说明 |
 |-------|-------|---------|-----------|--------|----------|
-| expire | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| incr | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作，返回正确数值 |
-| decr | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作，返回正确数值 |
-| exists | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| mget | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作，返回正确的结果数组 |
-| mset | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| pexpire | ✅ | ✅ | ✅ | ✅ | 毫秒级过期时间设置，所有方式均正常工作 |
-| persist | ✅ | ✅ | ✅ | ✅ | 移除过期时间，所有方式均正常工作 |
-| strlen | ✅ | ✅ | ✅ | ✅ | 字符串长度获取，所有方式均正常工作 |
-| type | ✅ | ✅ | ✅ | ✅ | 数据类型检测，所有方式均正常工作 |
-| rename | ✅ | ✅ | ✅ | ✅ | 键重命名，所有方式均正常工作 |
+| expire | ✅ | ✅ | ✅ | ✅ | 所有方式都支持 |
+| incr | ✅ | ✅ | ✅ | ✅ | 所有方式都支持 |
+| decr | ✅ | ❌ | ❌ | ❌ | 仅Redis支持 |
+| mget | ✅ | ✅ | ❌ | ❌ | Redis和MongoDB支持，其他方式不支持 |
+| mset | ✅ | ✅ | ❌ | ❌ | Redis和MongoDB支持，其他方式不支持 |
+| pexpire | ❌ | ❌ | ❌ | ❌ | 所有方式都不支持 |
+| persist | ✅ | ❌ | ✅ | ✅ | Redis、CacheBase和Memory支持，MongoDB不支持 |
+| strlen | ✅ | ❌ | ✅ | ❌ | Redis和CacheBase支持，其他方式不支持 |
+| type | ❌ | ❌ | ❌ | ❌ | 所有方式都不支持 |
+| rename | ❌ | ❌ | ❌ | ❌ | 所有方式都不支持 |
 
 ## Redis兼容方法 - 集合操作
 
 | 方法名 | Redis | MongoDB | CacheBase | Memory | 状态说明 |
 |-------|-------|---------|-----------|--------|----------|
-| sadd | ✅ | ✅ | ✅ | ✅ | 集合添加元素，所有方式均正常工作 |
-| srem | ✅ | ✅ | ✅ | ✅ | 集合移除元素，所有方式均正常工作 |
-| sismember | ✅ | ✅ | ✅ | ✅ | 检查元素是否在集合中，所有方式均正常工作 |
-| smembers | ✅ | ✅ | ✅ | ✅ | 获取集合所有元素，所有方式均正常工作 |
+| sadd | ✅ | ❌ | ❌ | ❌ | 仅Redis支持 |
+| srem | ✅ | ❌ | ❌ | ❌ | 仅Redis支持 |
+| sismember | ✅ | ✅ | ❌ | ❌ | Redis和MongoDB支持，其他方式不支持 |
+| smembers | ✅ | ✅ | ❌ | ❌ | Redis和MongoDB支持，其他方式不支持 |
 
 ## 数组/列表操作方法
 
 | 方法名 | Redis | MongoDB | CacheBase | Memory | 状态说明 |
 |-------|-------|---------|-----------|--------|----------|
-| list_set | ✅ | ✅ | ✅ | ✅ | 已实现并测试通过 |
-| list_add | ✅ | ✅ | ✅ | ✅ | 已实现并测试通过 |
-| list_has | ✅ | ✅ | ✅ | ✅ | 已实现并测试通过 |
-| list_get | ✅ | ✅ | ✅ | ✅ | 已实现并测试通过 |
-| list_clear | ✅ | ✅ | ✅ | ✅ | 已实现并测试通过 |
+| list_set | ✅ | ❌ | ⚠️ | ⚠️ | Redis正常工作，CacheBase和Memory行为不一致，MongoDB不支持 |
+| list_add | ✅ | ❌ | ⚠️ | ⚠️ | Redis正常工作，CacheBase和Memory行为不一致，MongoDB不支持 |
+| list_has | ✅ | ❌ | ⚠️ | ⚠️ | Redis正常工作，CacheBase和Memory行为不一致，MongoDB不支持 |
+| list_get | ✅ | ❌ | ⚠️ | ⚠️ | Redis正常工作，CacheBase和Memory行为不一致，MongoDB不支持 |
+| list_clear | ✅ | ❌ | ✅ | ✅ | MongoDB不支持，其他方式支持 |
 
 ## 兼容性报告总结
 
-基于全面测试，以下是四种缓存方式的兼容性报告：
+基于实际功能测试，以下是四种缓存方式的兼容性报告：
 
 | 方法类别 | CacheBase | Redis | MongoDB | Memory | 状态说明 |
 |---------|-----------|-------|---------|--------|----------|
-| 基础键值操作 | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| 数组操作 | ⚠️ | ✅ | ⚠️ | ⚠️ | 所有方式通过通用实现支持，但底层可能需要各自实现 |
-| 过期时间操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
-| 原子递增操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
-| 批量操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
-| 哈希表基本操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
-| 哈希表批量操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
-| 集合操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
-| 字符串操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
-| 类型检测 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
-| 键重命名 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
-| 清理操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
+| 基础键值操作 | ⚠️ | ✅ | ✅ | ⚠️ | Redis和MongoDB正常工作，CacheBase和Memory部分方法行为不一致 |
+| 数组操作 | ⚠️ | ✅ | ❌ | ⚠️ | Redis完全支持，CacheBase和Memory行为不一致，MongoDB不支持 |
+| 过期时间操作 | ✅ | ✅ | ✅ | ✅ | 基本过期时间操作支持，但MongoDB不支持persist |
+| 原子递增操作 | ✅ | ✅ | ✅ | ✅ | incr支持，但decr、incrby、decrby只有Redis支持 |
+| 批量操作 | ❌ | ✅ | ✅ | ❌ | Redis和MongoDB支持，其他方式不支持 |
+| 哈希表基本操作 | ✅ | ✅ | ✅ | ✅ | 基本操作均支持 |
+| 哈希表批量操作 | ❌ | ✅ | ✅ | ❌ | Redis和MongoDB支持，其他方式不支持 |
+| 集合操作 | ❌ | ✅ | ⚠️ | ❌ | Redis完整支持，MongoDB支持部分方法，其他方式不支持 |
+| 字符串操作 | ⚠️ | ✅ | ❌ | ❌ | Redis完全支持，CacheBase支持部分方法，其他方式不支持 |
+| 类型检测 | ❌ | ❌ | ❌ | ❌ | 所有方式都不支持 |
+| 键重命名 | ❌ | ❌ | ❌ | ❌ | 所有方式都不支持 |
+| 清理操作 | ✅ | ✅ | ✅ | ✅ | clear操作正常工作 |
 
 ### 测试统计
 
-- **总测试用例**：43个
-- **通过数**：43个测试用例
-- **整体成功率**：100%
-
-### 所有缓存方式都支持的功能：
-- **核心键值操作**：set, get, exists, del, has, keys, sort（add除外）
-- **哈希表操作**：hset, hget, hgetall, hdel, hmset, hmget, hlen
-- **过期时间操作**：expire, ttl, persist, pexpire
-- **原子递增操作**：incr, decr
-- **批量操作**：mset, mget
-- **集合操作**：sadd, srem, sismember, smembers
-- **字符串操作**：strlen
-- **类型检测**：type
-- **键重命名**：rename
-- **清理操作**：clear
-- **数组操作**：list_set, list_add, list_has, list_get, list_clear (通过通用实现)
-
-### CacheBase 缓存方式：
-- **测试状态**：✅ 所有12个方法类别测试通过
-- **兼容性**：完全兼容Redis接口
-- **返回值**：所有操作都返回符合预期的结果
-- **优点**：无需外部依赖，性能优秀，返回值一致性高，支持持久化
-
-### MongoDB 缓存方式：
-- **测试状态**：✅ 所有12个方法类别测试通过
-- **兼容性**：完全兼容Redis接口
-- **返回值**：所有操作都返回正确的结果，包括incr/decr返回数值，mget返回正确的结果数组
-- **优点**：支持持久化存储，重启后数据不会丢失
-
-### Redis 缓存方式：
-- **测试状态**：✅ 所有12个方法类别测试通过
-- **通过率**：100%
-- **优点**：支持持久化存储，重启后数据不会丢失，支持分布式缓存
-- **注意事项**：已修复认证配置问题，现在可以正常使用
-
-### Memory 缓存方式：
-- **测试状态**：✅ 所有12个方法类别测试通过
-- **兼容性**：完全兼容Redis接口
-- **优点**：最高性能，纯内存操作，无I/O开销
-- **缺点**：不支持持久化，程序重启后数据会丢失
-
-### 已确认移除的方法：
-- hexists：测试中报错 "TypeError: cache.hexists is not a function"
-- hkeys、hvals：已移除
-
-## 最佳使用建议
-
-1. **Memory 方式**（推荐用于内存临时缓存）：
-   - 所有功能完全兼容，返回值符合预期
-   - 性能最优，纯内存操作无I/O开销
-   - 适合短期缓存、临时数据缓存场景
-   - 不需要额外的外部服务依赖
-   - 程序重启后数据会丢失
-
-2. **CacheBase 方式**（推荐用于单机持久化缓存）：
-   - 所有功能完全兼容，返回值符合预期
-   - 性能稳定，在多次依赖更新中保持一致表现
-   - 适合需要持久化但不需要分布式的场景
-   - 不需要额外的外部服务依赖
-   - 程序重启后数据不会丢失
-
-3. **Redis 方式**（推荐用于分布式持久化缓存）：
-   - 已完全修复所有兼容性问题
-   - 支持分布式缓存，数据可在多实例间共享
-   - 适合需要高性能、分布式缓存或Redis特有功能的场景
-   - 需要外部Redis服务
-   - 程序重启后数据不会丢失
-
-4. **MongoDB 方式**（推荐用于已有MongoDB环境的场景）：
-   - 所有方法均完全兼容Redis接口
-   - 所有操作都返回正确的结果，包括incr/decr和mget
-   - 适合需要持久化缓存且已有MongoDB环境的场景
-   - 提供了数据持久化保障
-   - 需要外部MongoDB服务
-   - 程序重启后数据不会丢失
-
-## 实际使用建议
-
-1. **开发环境**：推荐使用Memory或CacheBase，无需额外配置，使用简单
-
-2. **生产环境**：
-   - 如果需要极致性能且数据不敏感：使用Memory
-   - 如果需要单机持久化：使用CacheBase
-   - 如果需要高性能、分布式缓存：使用Redis
-   - 如果需要缓存持久化且已有MongoDB环境：使用MongoDB
-
-3. **跨环境部署**：
-   - 可以根据环境配置自动切换缓存方式
-   - 所有缓存方式的返回值特性一致，可以放心切换
-
-4. **性能考虑**：
-   - Memory：纯内存操作，最快但不持久化
-   - CacheBase：文件系统操作，性能优秀且支持持久化
-   - Redis：网络操作，但性能优秀，支持持久化和分布式
-   - MongoDB：网络+磁盘操作，性能相对较低但支持持久化
-
-## 兼容性维护建议
-
-1. **文档维护**：
-   - 更新README.md，明确标注支持的方法和各缓存方式的特点
-
-2. **测试维护**：
-   - 保留test.js作为标准全面兼容性测试
-   - 在发布新版本前运行全面测试
-
-3. **错误处理**：
-   - 对已移除的方法添加更友好的错误提示
-   - 考虑在代码中添加方法兼容性检测
-
-注：✅ 完全兼容/功能正常 | ⚠️ 功能正常但有注意事项 | ❌ 不兼容/未实现/已移除
+- **总测试用例**：43个方法
+- **通过数**：不同缓存方式通过数量不同（Redis最多，MongoDB次之）
+- **整体支持情况**：
+  - Redis：支持28个方法，不支持9个，行为不一致6个
+  - MongoDB：支持23个方法，不支持15个，行为不一致0个
+  - CacheBase：支持15个方法，不支持17个，行为不一致7个
+  - Memory：支持15个方法，不支持17个，行为不一致7个
+- **注意事项**：
+  1. CacheBase和Memory的行为完全一致
+  2. Redis完全支持列表操作方法
+  3. MongoDB完全不支持列表操作方法（list_*）
+  4. addInt、addStr、incrby、decrby和addFloat仅Redis支持
+  5. 基础键值操作在Redis和MongoDB中表现最佳
+  6. 集合操作只有Redis完整支持

package/index.js

@@ -512,50 +512,26 @@ Redis.prototype.isConnected = function () {
  * @param {Number} seconds 秒, 为空则查询有效时长
  * @return {Promise<Number|Boolean>} 查询时长或设置结果, 时长为-1表示永不过期
  */
-Redis.prototype.ttl = async function (key, seconds) {
+Redis.prototype.ttl = async function (key) {
 	try {
 		const connection = await this._getConnection();
 		try {
 			key = this.applyPrefix(key);
-			if (seconds !== undefined) {
-				if (seconds > 0) {
-					// 设置过期时间
-					if (typeof connection.expire === 'function') {
-						return await connection.expire(key, seconds);
-					} else if (typeof connection.execute === 'function') {
-						return await connection.execute('EXPIRE', [key, seconds]);
-					} else {
-						$.log.error('[Redis] 连接对象不支持expire操作');
-						return false;
-					}
-				} else {
-					// 移除过期时间
-					if (typeof connection.persist === 'function') {
-						return await connection.persist(key);
-					} else if (typeof connection.execute === 'function') {
-						return await connection.execute('PERSIST', [key]);
-					} else {
-						$.log.error('[Redis] 连接对象不支持persist操作');
-						return false;
-					}
-				}
+			// 只获取过期时间，符合ttl的标准功能
+			if (typeof connection.ttl === 'function') {
+				return await connection.ttl(key);
+			} else if (typeof connection.execute === 'function') {
+				return await connection.execute('TTL', [key]);
 			} else {
-				// 获取过期时间
-				if (typeof connection.ttl === 'function') {
-					return await connection.ttl(key);
-				} else if (typeof connection.execute === 'function') {
-					return await connection.execute('TTL', [key]);
-				} else {
-					$.log.error('[Redis] 连接对象不支持ttl操作');
-					return -2; // 默认返回键不存在
-				}
+				$.log.error('[Redis] 连接对象不支持ttl操作');
+				return -2; // 默认返回键不存在
 			}
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 设置或获取过期时间失败 [${key}]:`, err);
-		return seconds !== undefined ? false : -2; // -2表示出错
+		$.log.error(`[Redis] 获取过期时间失败 [${key}]:`, err);
+		return -2; // -2表示出错
 	}
 };
 
@@ -2572,7 +2548,8 @@ Redis.prototype.sinter = async function (keys) {
 		const connection = await this._getConnection();
 		try {
 			const prefixedKeys = keys.map(key => this.applyPrefix(key));
-			const result = await connection.execute('sinter', ...prefixedKeys);
+			// 使用Redis v4正确的方法
+			const result = await connection.sInter(...prefixedKeys);
 			return result || [];
 		} finally {
 			this._recycleConnection(connection);
@@ -2593,7 +2570,8 @@ Redis.prototype.sunion = async function (keys) {
 		const connection = await this._getConnection();
 		try {
 			const prefixedKeys = keys.map(key => this.applyPrefix(key));
-			const result = await connection.execute('sunion', ...prefixedKeys);
+			// 使用Redis v4正确的方法
+			const result = await connection.sUnion(...prefixedKeys);
 			return result || [];
 		} finally {
 			this._recycleConnection(connection);
@@ -2614,7 +2592,8 @@ Redis.prototype.sdiff = async function (keys) {
 		const connection = await this._getConnection();
 		try {
 			const prefixedKeys = keys.map(key => this.applyPrefix(key));
-			const result = await connection.execute('sdiff', ...prefixedKeys);
+			// 使用Redis v4正确的方法
+			const result = await connection.sDiff(...prefixedKeys);
 			return result || [];
 		} finally {
 			this._recycleConnection(connection);
@@ -2763,21 +2742,38 @@ Redis.prototype.zrange = async function (key, start, stop, withScores = false) {
 		const connection = await this._getConnection();
 		try {
 			const prefixedKey = this.applyPrefix(key);
-			const result = await connection.zRange(prefixedKey, start, stop, { WITHSCORES: withScores });
-
-			// 如果需要返回分数，将结果转换为对象数组
-			if (withScores && result && result.length) {
-				const formattedResult = [];
-				for (let i = 0; i < result.length; i += 2) {
-					formattedResult.push({
-						member: result[i],
-						score: parseFloat(result[i + 1])
-					});
+			
+			if (withScores) {
+				// 对于需要分数的情况，使用更可靠的方法
+				try {
+					// 直接获取所有成员的分数
+					const members = await connection.zRange(prefixedKey, start, stop);
+					const results = [];
+					
+					// 为每个成员单独获取分数，确保准确性
+					for (const member of members) {
+						try {
+							let score = await connection.zScore(prefixedKey, member);
+							score = score ? parseFloat(score) : 0;
+							results.push({ member, score });
+						} catch (scoreErr) {
+							// 如果获取分数失败，设置默认值0
+							results.push({ member, score: 0 });
+							$.log.warn(`[Redis] 获取成员 ${member} 分数失败:`, scoreErr);
+						}
+					}
+					
+					return results;
+				} catch (err) {
+					$.log.error(`[Redis] 使用备用方法获取有序集合范围失败 [${prefixedKey}]:`, err);
+					// 回退到简单列表
+					return [];
 				}
-				return formattedResult;
+			} else {
+				// 不需要分数的情况
+				const result = await connection.zRange(prefixedKey, start, stop);
+				return result || [];
 			}
-
-			return result || [];
 		} finally {
 			this._recycleConnection(connection);
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mm_redis",
-    "version": "1.9.6",
+    "version": "1.9.8",
     "description": "高效的Redis客户端封装库，提供连接池管理、数据类型操作、错误处理和批量操作优化",
     "main": "index.js",
     "scripts": {

package/test.js

@@ -252,11 +252,17 @@ async function test() {
 	}
 }
 
-test().catch(err => {
+test().then(() => {
+	// 测试成功完成
+	$.log.debug('[Redis] 测试脚本正常退出');
+	process.exit(0);
+}).catch(err => {
 	$.log.error('[Redis] 未捕获的错误:', err);
 	process.exit(1);
 });
 
+// 添加超时保护，但让Promise处理正常结束
 setTimeout(() => {
-	process.exit(0);
+	$.log.warn('[Redis] 测试脚本超时');
+	process.exit(1);
 }, 10000); // 延长超时时间以确保所有测试完成

package/verify_compatibility.js

@@ -8,7 +8,7 @@ async function verifyCompatibility() {
 		
 		console.log('开始验证兼容性表格中的所有方法...');
 		
-		// 1. 测试核心缓存方法 - 已标记为完全兼容的方法
+		// 1. 测试核心缓存方法
 		console.log('\n=== 核心缓存方法验证 ===');
 		await testBasicMethods(rs);
 		
@@ -20,9 +20,13 @@ async function verifyCompatibility() {
 		console.log('\n=== 列表操作方法验证 ===');
 		await testListMethods(rs);
 		
-		// 4. 清理并关闭连接
+		// 4. 测试哈希表相关方法
+		console.log('\n=== 哈希表方法验证 ===');
+		await testHashMethods(rs);
+		
+		// 5. 清理并关闭连接
 		console.log('\n清理测试数据...');
-		await rs.del(["list_test_key"]);
+		await rs.del(["list_test_key", "hash_test_key", "test_counter", "test_string"]);
 		
 		await rs.close();
 		console.log('\n所有验证完成!');
@@ -35,7 +39,7 @@ async function verifyCompatibility() {
 
 async function testBasicMethods(rs) {
 	try {
-		// 测试文档中所有标记为✅的核心方法
+		// 测试核心方法
 		const methods = [
 			{ name: 'set', result: await rs.set('temp_key', 'test_value') },
 			{ name: 'get', result: await rs.get('temp_key') },
@@ -44,18 +48,20 @@ async function testBasicMethods(rs) {
 			{ name: 'ttl', result: await rs.ttl('temp_key') },
 			{ name: 'persist', result: await rs.persist('temp_key') },
 			{ name: 'add', result: await rs.add('new_temp_key', 'new_value') },
-			{ name: 'addInt', result: await rs.addInt('counter', 10) },
-			{ name: 'addStr', result: await rs.addStr('string_key', 'text') },
+			{ name: 'addInt', result: await rs.addInt('test_counter', 10) },
+			{ name: 'addStr', result: await rs.addStr('test_string', 'text') },
 			{ name: 'keys', result: await rs.keys('*') },
 			{ name: 'clear', result: await rs.clear('temp_key') },
 			{ name: 'del', result: await rs.del('new_temp_key') },
-			{ name: 'incr', result: await rs.incr('counter') },
-			{ name: 'decr', result: await rs.decr('counter') },
-			{ name: 'mget', result: await rs.mget(['counter', 'string_key']) },
+			{ name: 'incr', result: await rs.incr('test_counter') },
+			{ name: 'decr', result: await rs.decr('test_counter') },
+			{ name: 'mget', result: await rs.mget(['test_counter', 'test_string']) },
 			{ name: 'mset', result: await rs.mset({batch1: 'value1', batch2: 'value2'}) },
-			{ name: 'expire', result: await rs.expire('counter', 60) },
-//			{ name: 'type', result: await rs.type('counter') },
-//			{ name: 'rename', result: await rs.rename('string_key', 'renamed_string') }
+			{ name: 'expire', result: await rs.expire('test_counter', 60) },
+			{ name: 'sort', result: await rs.sort('temp_sort', {order: 'asc'}) },
+			{ name: 'decrby', result: await rs.decrby('test_counter', 5) },
+			{ name: 'incrby', result: await rs.incrby('test_counter', 10) },
+			{ name: 'addFloat', result: await rs.addFloat('test_counter', 0.5) }
 		];
 		
 		console.log('所有核心方法测试结果:');
@@ -125,6 +131,42 @@ async function testListMethods(rs) {
 	}
 }
 
+async function testHashMethods(rs) {
+	try {
+		// 测试哈希表方法
+		const hashKey = 'hash_test_key';
+		
+		console.log('哈希表方法测试结果:');
+		
+		// 测试hset
+		const hsetResult = await rs.hset(hashKey, 'field1', 'value1');
+		console.log(`- hset: ${typeof hsetResult !== 'undefined' ? '✅ 可用' : '❌ 不可用'}`);
+		
+		// 测试hget
+		const hgetResult = await rs.hget(hashKey, 'field1');
+		console.log(`- hget: ${hgetResult === 'value1' ? '✅ 可用' : '❌ 不可用'}`);
+		
+		// 测试hmset
+		const hmsetResult = await rs.hmset(hashKey, {field2: 'value2', field3: 'value3'});
+		console.log(`- hmset: ${typeof hmsetResult !== 'undefined' ? '✅ 可用' : '❌ 不可用'}`);
+		
+		// 测试hgetall
+		const hgetallResult = await rs.hgetall(hashKey);
+		console.log(`- hgetall: ${typeof hgetallResult === 'object' ? '✅ 可用' : '❌ 不可用'}`);
+		
+		// 测试hdel
+		const hdelResult = await rs.hdel(hashKey, 'field1');
+		console.log(`- hdel: ${typeof hdelResult !== 'undefined' ? '✅ 可用' : '❌ 不可用'}`);
+		
+		// 测试hlen
+		const hlenResult = await rs.hlen(hashKey);
+		console.log(`- hlen: ${typeof hlenResult === 'number' ? '✅ 可用' : '❌ 不可用'}`);
+		
+	} catch (error) {
+		console.error('哈希表方法测试失败:', error);
+	}
+}
+
 verifyCompatibility();
 
 setTimeout(() => {