mm_redis 2.0.8 → 2.0.9

package/README.md

@@ -1,22 +1,28 @@
 # mm_redis
 
-mm_redis是一个高效的Redis客户端封装库，提供了全面的Redis功能支持，包括连接池管理、数据类型操作、错误处理和批量操作优化。
-
-[![npm version](https://badge.fury.io/js/mm_redis.svg)](https://badge.fury.io/js/mm_redis)
+[![npm version](https://badge.fury.io/js/mm_redis.svg)](https://www.npmjs.com/package/mm_redis)
 [![npm downloads](https://img.shields.io/npm/dm/mm_redis.svg)](https://www.npmjs.com/package/mm_redis)
+[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](https://opensource.org/licenses/ISC)
+
+> 一个高效的Redis客户端封装库，提供完整的连接池管理、数据类型操作和批量操作优化
 
 ## 版本信息
 
+- **最新版本**: 2.0.0
 - **更新日期**: 2025-10-20
 - **作者**: qww
 - **NPM**: [https://www.npmjs.com/package/mm_redis](https://www.npmjs.com/package/mm_redis)
 - **GitHub**: [https://gitee.com/qiuwenwu91/mm_redis](https://gitee.com/qiuwenwu91/mm_redis)
+- **Node.js**: >= 14.0.0
 
 ## 功能特性
 
+### 🚀 核心功能
 - **完整的连接池管理**：优化并发性能，支持连接复用和自动回收
 - **Pipeline批量操作**：支持Redis Pipeline机制，大幅提升批量操作效率
 - **全面的数据类型支持**：覆盖String、List、Hash、Set、Sorted Set等所有主要Redis数据类型
+
+### 🔧 高级特性
 - **智能连接管理**：自动重连机制，使用指数退避策略，确保连接稳定可靠
 - **健壮的错误处理**：全面的错误处理机制和详细的日志记录，便于问题排查
 - **便捷的数据序列化**：自动JSON序列化/反序列化，无需手动转换数据格式
@@ -26,55 +32,113 @@ mm_redis是一个高效的Redis客户端封装库，提供了全面的Redis功
 
 ## 安装
 
+### npm
+```bash
+npm install mm_redis
+```
+
+### yarn
+```bash
+yarn add mm_redis
+```
+
+### pnpm
 ```bash
-npm install mm_redis --save
+pnpm add mm_redis
 ```
 
-## Node.js版本要求
+## 快速开始
+
+```javascript
+const { Redis } = require('mm_redis');
+
+// 创建Redis实例
+const redis = new Redis({
+    host: 'localhost',
+    port: 6379,
+    password: 'your_password',
+    db: 0
+});
+
+// 连接Redis
+await redis.connect();
+
+// 设置缓存
+await redis.set('user:1', { name: '张三', age: 25 });
+
+// 获取缓存
+const user = await redis.get('user:1');
+console.log(user); // { name: '张三', age: 25 }
 
-- **最低支持版本**：Node.js 14.0.0
-- **推荐版本**：Node.js 16.0.0及以上
+// 错误处理
+try {
+    await redis.set('key', 'value');
+} catch (err) {
+    console.error('Redis操作失败:', err);
+}
+```
 
 ## 配置引入方式
 
-mm_redis支持多种配置引入方式：
+mm_redis支持多种配置引入方式，满足不同场景的需求：
 
-1. **对象配置（推荐）**：直接传入配置对象
+### 1. 对象配置（推荐）
 ```javascript
-const Redis = require('mm_redis');
-const redis = new Redis('default');
-redis.setConfig({
-    // 服务器地址
-    host: "localhost",
-    // 端口号
+const { Redis } = require('mm_redis');
+
+// 直接传入配置对象
+const redis = new Redis({
+    host: 'localhost',
     port: 6379,
-    // 密码
-    password: "",
-    // 数据库
-    database: 0,
-    // 前缀
-    prefix: "app:",
-    // 连接超时时间(ms)
-    connect_timeout: 10000,
-    // 重试次数
-    retry_count: 3,
-    // 重试间隔(ms)
-    retry_delay: 1000,
-    // 连接池配置
-    pool: {
-        max_clients: 10,      // 最大连接数
-        min_idle: 2,          // 最小空闲连接数
-        max_idle: 5,          // 最大空闲连接数
-        idle_timeout: 30000   // 空闲超时时间(ms)
-    }
+    password: 'your_password',
+    db: 0,
+    key_prefix: 'app:',
+    max_clients: 10,
+    connect_timeout: 5000
 });
 ```
 
-2. **文件配置**：传入配置文件路径
+### 2. 文件配置
+```javascript
+// config/redis.json
+{
+    "host": "localhost",
+    "port": 6379,
+    "password": "your_password",
+    "db": 0,
+    "key_prefix": "app:",
+    "max_clients": 10,
+    "connect_timeout": 5000
+}
+
+// 使用配置
+const { Redis } = require('mm_redis');
+const config = require('./config/redis.json');
+const redis = new Redis(config);
+```
+
+### 3. 环境变量配置
 ```javascript
-const Redis = require('mm_redis');
-const redis = new Redis('default');
-redis.setConfig('./config.json');
+// 环境变量
+REDIS_HOST=localhost
+REDIS_PORT=6379
+REDIS_PASSWORD=your_password
+REDIS_DB=0
+REDIS_KEY_PREFIX=app:
+REDIS_MAX_CLIENTS=10
+REDIS_CONNECT_TIMEOUT=5000
+
+// 使用环境变量
+const { Redis } = require('mm_redis');
+const redis = new Redis({
+    host: process.env.REDIS_HOST,
+    port: parseInt(process.env.REDIS_PORT),
+    password: process.env.REDIS_PASSWORD,
+    db: parseInt(process.env.REDIS_DB),
+    key_prefix: process.env.REDIS_KEY_PREFIX,
+    max_clients: parseInt(process.env.REDIS_MAX_CLIENTS),
+    connect_timeout: parseInt(process.env.REDIS_CONNECT_TIMEOUT)
+});
 ```
 ## 变更日志
 

package/README_EN.md

@@ -0,0 +1,433 @@
+# mm_redis
+
+[![npm version](https://badge.fury.io/js/mm_redis.svg)](https://www.npmjs.com/package/mm_redis)
+[![npm downloads](https://img.shields.io/npm/dm/mm_redis.svg)](https://www.npmjs.com/package/mm_redis)
+[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](https://opensource.org/licenses/ISC)
+
+A high-performance Redis client wrapper library that provides comprehensive Redis functionality support, including connection pool management, data type operations, error handling, and batch operation optimization.
+
+## Version Information
+
+- **Latest Version**: 2.0.0
+- **Update Date**: 2025-10-20
+- **Author**: qww
+- **NPM**: [https://www.npmjs.com/package/mm_redis](https://www.npmjs.com/package/mm_redis)
+- **GitHub**: [https://gitee.com/qiuwenwu91/mm_redis](https://gitee.com/qiuwenwu91/mm_redis)
+- **Node.js**: >= 14.0.0
+
+## Features
+
+### 🚀 Core Features
+- **Complete Connection Pool Management**: Optimized concurrent performance with connection reuse and automatic recycling
+- **Pipeline Batch Operations**: Support for Redis Pipeline mechanism, significantly improving batch operation efficiency
+- **Comprehensive Data Type Support**: Covers all major Redis data types including String, List, Hash, Set, Sorted Set
+
+### 🔧 Advanced Features
+- **Smart Connection Management**: Automatic reconnection with exponential backoff strategy for reliable connections
+- **Robust Error Handling**: Comprehensive error handling mechanism with detailed logging
+- **Automatic Data Serialization**: Automatic JSON serialization/deserialization without manual conversion
+- **Key Space Isolation**: Support for key prefix management for multi-business scenario data isolation
+- **Flexible Event System**: Unified event mechanism supporting pre/post operation event listening and interception
+- **Rich Numeric Operations**: Support for atomic increment/decrement operations, suitable for counter scenarios
+
+## Installation
+
+### Using npm
+```bash
+npm install mm_redis --save
+```
+
+### Using yarn
+```bash
+yarn add mm_redis
+```
+
+### Using pnpm
+```bash
+pnpm add mm_redis
+```
+
+## Node.js Version Requirements
+
+- **Minimum Supported Version**: Node.js 14.0.0
+- **Recommended Version**: Node.js 16.0.0 and above
+
+## Quick Start
+
+### Basic Usage
+```javascript
+const Redis = require('mm_redis');
+
+// Create Redis instance
+const redis = new Redis('default');
+
+async function example() {
+    try {
+        // Connect to Redis
+        await redis.open();
+        
+        // Set cache with expiration
+        await redis.set('user:1', { name: 'John', age: 25 }, 3600);
+        
+        // Get cache
+        const user = await redis.get('user:1');
+        console.log('User info:', user);
+        
+        // Close connection
+        await redis.close();
+    } catch (error) {
+        console.error('Operation failed:', error);
+    }
+}
+
+example();
+```
+
+## Configuration
+
+mm_redis supports multiple configuration loading methods:
+
+### Object Configuration (Recommended)
+```javascript
+const Redis = require('mm_redis');
+const redis = new Redis('default');
+
+redis.setConfig({
+    host: "localhost",
+    port: 6379,
+    password: "",
+    database: 0,
+    prefix: "app:",
+    connect_timeout: 10000,
+    retry_count: 3,
+    retry_delay: 1000,
+    pool: {
+        max_clients: 10,
+        min_idle: 2,
+        max_idle: 5,
+        idle_timeout: 30000
+    }
+});
+```
+
+### File Configuration
+```javascript
+const Redis = require('mm_redis');
+const redis = new Redis('default');
+
+redis.setConfig('./config.json');
+```
+
+Configuration file example (`config.json`):
+```json
+{
+    "host": "localhost",
+    "port": 6379,
+    "password": "",
+    "database": 0,
+    "prefix": "app:",
+    "connect_timeout": 10000,
+    "retry_count": 3,
+    "retry_delay": 1000,
+    "pool": {
+        "max_clients": 10,
+        "min_idle": 2,
+        "max_idle": 5,
+        "idle_timeout": 30000
+    }
+}
+```
+
+### Environment Variables
+```javascript
+const Redis = require('mm_redis');
+const redis = new Redis('default');
+
+redis.setConfig({
+    host: process.env.REDIS_HOST || 'localhost',
+    port: parseInt(process.env.REDIS_PORT) || 6379,
+    password: process.env.REDIS_PASSWORD || '',
+    database: parseInt(process.env.REDIS_DB) || 0
+});
+```
+
+## Change Log
+
+### v2.0.0 (2025-10-14)
+- Removed list_push method, unified to use addForList method for list operations
+- Updated documentation, replaced all list_push references with addForList
+- Updated API list and usage examples in documentation
+- Optimized connection pool configuration management, unified configuration to this.config.pool
+- Added connection pool configuration parameters: min_idle, max_idle, idle_timeout
+
+### v1.9.8 (2024-12-22)
+- Updated documentation, improved content required for npm publishing
+- Added GitHub repository link to documentation
+- Optimized feature description, enhanced document readability
+- Added Node.js version requirement description
+
+### v1.9.5 (2024-12-21)
+- Fixed compatibility issues with hmset and hgetall methods to ensure compatibility with Redis client v5
+- Removed deprecated hexists, hkeys and hvals methods, optimized API design
+- Optimized implementation of mget and mset methods to ensure full compatibility with Redis v5 API
+- Updated test scripts, removed calls to deprecated methods
+- Updated compatibility table to ensure documentation matches actual API
+- Fixed errors in native Redis API calls, improved code stability
+- Optimized connection pool management, fixed potential memory leak issues
+
+### v1.9.4 (2024-12-20)
+- Optimized configuration loading methods, supporting both object configuration and file path configuration
+- Improved implementation of setConfig method, using Object.assign instead of original merge method
+- Fixed warning messages related to connection pool
+- Enhanced error handling mechanism
+
+### v1.9.0 (2024-11-20)
+- Initial version release
+- Support for complete connection pool management
+- Implementation of Pipeline batch operations
+- Support for all major Redis data type operations
+
+## Usage Examples
+
+### Basic Operations
+```javascript
+// Connect to Redis
+await redis.open();
+
+// Set cache
+await redis.set('user:1', { name: 'John', age: 25 }, 3600);
+
+// Get cache
+const user = await redis.get('user:1');
+console.log('User info:', user);
+
+// Check if key exists
+const exists = await redis.has('user:1');
+
+// Delete cache
+await redis.del('user:1');
+
+// Close connection
+await redis.close();
+```
+
+### List Operations
+```javascript
+// Set list
+await redis.setForList('users', ['user1', 'user2', 'user3']);
+
+// Add element to list
+await redis.addForList('users', 'user4');
+
+// Get list
+const users = await redis.getForList('users');
+console.log('User list:', users);
+
+// Get partial list elements
+const partialUsers = await redis.getForList('users', 0, 2);
+
+// Clear list
+await redis.clearForList('users');
+```
+
+### Hash Operations
+```javascript
+// Set hash field
+await redis.hset('user:profile:1', 'name', 'John');
+await redis.hset('user:profile:1', 'age', 25);
+
+// Batch set hash fields
+await redis.hmset('user:profile:1', {
+    'email': 'john@example.com',
+    'phone': '1234567890'
+});
+
+// Get hash field
+const name = await redis.hget('user:profile:1', 'name');
+
+// Get all hash fields and values
+const profile = await redis.hgetall('user:profile:1');
+console.log('User profile:', profile);
+
+// Get hash field count
+const fieldCount = await redis.hlen('user:profile:1');
+
+// Delete hash fields
+await redis.hdel('user:profile:1', ['email', 'phone']);
+```
+
+### Batch Operations
+```javascript
+// Batch get
+const data = await redis.mget(['user:1', 'user:2', 'user:3']);
+console.log('Batch get result:', data);
+
+// Batch set
+await redis.mset({
+    'user:4': { name: 'Jane', age: 30 },
+    'user:5': { name: 'Bob', age: 35 }
+}, 3600);
+```
+
+### Pipeline Optimization
+```javascript
+// Create Pipeline
+const pipeline = redis.pipeline();
+
+// Add multiple commands
+pipeline.set('counter:1', 100);
+pipeline.ttl('counter:1', 3600);
+pipeline.hset('stats:today', 'visits', 500);
+pipeline.hset('stats:today', 'users', 100);
+
+// Execute all commands
+const results = await pipeline.exec();
+console.log('Pipeline execution result:', results);
+```
+
+### Publish/Subscribe
+```javascript
+// Subscribe to channel
+await redis.subscribe('notifications', async (message) => {
+    console.log('Received notification:', message);
+    // Process received message
+});
+
+// Publish message
+const receivedCount = await redis.publish('notifications', JSON.stringify({ 
+    type: 'info', 
+    content: 'System update successful' 
+}));
+
+console.log(`Message published, ${receivedCount} clients received`);
+
+// Unsubscribe
+await redis.unsubscribe('notifications');
+```
+
+## API Documentation
+
+### Connection Management
+- `setConfig(config)`: Set Redis configuration
+- `open()`: Connect to Redis
+- `close()`: Close connection
+- `isConnected()`: Check connection status
+
+### String Operations
+- `set(key, value, seconds)`: Set cache
+- `get(key)`: Get cache
+- `has(key)`: Check if key exists
+- `del(key)`: Delete cache
+- `add(key, value, seconds)`: Set cache only if key doesn't exist
+- `ttl(key, seconds)`: Set or get expiration time
+- `addInt(key, num)`: Increment integer value
+- `addFloat(key, num)`: Increment float value
+- `addStr(key, str)`: Append string
+- `getrange(key, start, end)`: Get substring
+- `setrange(key, index, value)`: Set substring
+
+### List Operations
+- `setForList(key, value, seconds)`: Set list
+- `addForList(key, value)`: Add element to list
+- `getForList(key, start, end)`: Get list
+- `hasForList(key, value)`: Check if element exists in list
+- `clearForList(key, value)`: Clear list or reset list
+
+### Hash Operations
+- `hset(key, field, value)`: Set hash field
+- `hmset(key, obj)`: Batch set hash fields
+- `hget(key, field)`: Get hash field value
+- `hgetall(key)`: Get all hash fields and values
+- `hdel(key, fields)`: Delete hash fields
+- `hlen(key)`: Get hash field count
+
+### Batch Operations
+- `mget(keys)`: Batch get cache
+- `mset(obj, seconds)`: Batch set cache
+- `pipeline()`: Create Pipeline object for batch operation optimization
+
+### Set Operations
+- `sadd(key, members)`: Add members to set
+- `srem(key, members)`: Remove members from set
+- `sismember(key, member)`: Check if member is in set
+- `smembers(key)`: Get all members in set
+- `scard(key)`: Get member count in set
+- `sinter(keys)`: Get intersection of multiple sets
+- `sunion(keys)`: Get union of multiple sets
+- `sdiff(keys)`: Get difference of multiple sets
+
+### Sorted Set Operations
+- `zadd(key, score, member)`: Add member to sorted set
+- `zrem(key, members)`: Remove members from sorted set
+- `zscore(key, member)`: Get member score in sorted set
+- `zrank(key, member)`: Get member rank in sorted set
+- `zrange(key, start, stop, withScores)`: Get members in specified range
+- `zcard(key)`: Get member count in sorted set
+- `zincrby(key, increment, member)`: Increment member score in sorted set
+
+### Numeric Operations
+- `incr(key)`: Increment key value by 1
+- `decr(key)`: Decrement key value by 1
+- `incrby(key, increment)`: Increment key value by specified integer
+- `decrby(key, decrement)`: Decrement key value by specified integer
+- `expire(key, seconds)`: Set key expiration time
+
+## Connection Pool Management
+
+This module has built-in efficient connection pool management that automatically handles connection creation, recycling, and reuse. Connection pool configuration can be set during initialization:
+
+```javascript
+{
+    "pool": {
+        "max_clients": 10,      // Maximum connections
+        "min_idle": 2,          // Minimum idle connections
+        "max_idle": 5,          // Maximum idle connections
+        "idle_timeout": 30000   // Idle timeout (ms)
+    }
+}
+```
+
+## Error Handling
+
+All methods include comprehensive error handling mechanisms and provide detailed log output. When errors occur, error information is automatically recorded and fallback solutions are provided when possible.
+
+## Best Practices
+
+1. **Use Connection Pool**: For high-concurrency applications, connection pool configuration is crucial. Reasonably set maximum connections and idle connections.
+2. **Use Pipeline**: For batch operations, using Pipeline can significantly improve performance.
+3. **Set Expiration Time Reasonably**: Avoid unlimited growth of data in Redis.
+4. **Use Key Prefix**: Isolate business through key prefix to avoid key conflicts.
+5. **Close Connections Timely**: Call close() method to close all connections when application ends.
+6. **Leverage Event System**: Use event system for logging, data validation, and operation interception.
+
+## Contributing
+
+We welcome community contributions! If you're interested in contributing to the mm_redis project, please follow these steps:
+
+1. Fork this repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+Please ensure your code follows the project's coding standards and passes all tests.
+
+## License
+
+This project is licensed under the ISC License - see the [LICENSE](LICENSE) file for details.
+
+## Issue Reporting
+
+If you encounter any problems or have any suggestions during use, please provide feedback through the following methods:
+
+- **GitHub Issues**: [https://gitee.com/qiuwenwu91/mm_redis/issues](https://gitee.com/qiuwenwu91/mm_redis/issues)
+- **NPM**: [https://www.npmjs.com/package/mm_redis](https://www.npmjs.com/package/mm_redis)
+
+## Acknowledgments
+
+Thanks to all developers and users who have contributed to this project!
+
+## Related Links
+
+- **Redis Official Documentation**: [https://redis.io/documentation](https://redis.io/documentation)
+- **Node Redis Client**: [https://github.com/redis/node-redis](https://github.com/redis/node-redis)

package/index.js

@@ -34,12 +34,10 @@ class Redis extends Base {
 			// 重试间隔(ms)
 			"retry_delay": 1000,
 			// 连接池配置
-			"pool": {
-				"max_clients": 100, // 最大连接数
-				"min_idle": 5, // 最小空闲连接数
-				"max_idle": 20, // 最大空闲连接数
-				"idle_timeout": 30000 // 空闲超时时间(ms)
-			}
+			"max_clients": 100, // 最大连接数
+			"min_idle": 5, // 最小空闲连接数
+			"max_idle": 20, // 最大空闲连接数
+			"idle_timeout": 30000 // 空闲超时时间(ms)
 		};
 		this.setConfig(config);
 		// 初始化连接池
@@ -87,15 +85,15 @@ Redis.prototype._delPrefix = function (key) {
  * @return {Promise<Boolean>} 订阅结果
  */
 Redis.prototype.subscribe = async function (channel, func) {
-	try {
-		// 参数验证
-		if (!channel || typeof channel !== 'string') {
-			throw new TypeError('channel必须是非空字符串');
-		}
-		if (typeof func !== 'function') {
-			throw new TypeError('func必须是函数');
-		}
+	// 参数验证
+	if (!channel || typeof channel !== 'string') {
+		throw new TypeError('channel必须是非空字符串');
+	}
+	if (typeof func !== 'function') {
+		throw new TypeError('func必须是函数');
+	}
 
+	try {
 		await this.conn.subscribe(this._addPrefix(channel));
 		this.func_list[channel] = func;
 		return true;
@@ -111,12 +109,12 @@ Redis.prototype.subscribe = async function (channel, func) {
  * @return {Promise<Boolean>} 取消订阅结果
  */
 Redis.prototype.unsubscribe = async function (channel) {
-	try {
-		// 参数验证
-		if (!channel || typeof channel !== 'string') {
-			throw new TypeError('channel必须是非空字符串');
-		}
+	// 参数验证
+	if (!channel || typeof channel !== 'string') {
+		throw new TypeError('channel必须是非空字符串');
+	}
 
+	try {
 		await this.conn.unsubscribe(this._addPrefix(channel));
 		delete this.func_list[channel];
 		return true;
@@ -133,15 +131,15 @@ Redis.prototype.unsubscribe = async function (channel) {
  * @return {Promise<Number>} 接收消息的客户端数量
  */
 Redis.prototype.publish = async function (channel, message) {
-	try {
-		// 参数验证
-		if (!channel || typeof channel !== 'string') {
-			throw new TypeError('channel必须是非空字符串');
-		}
-		if (message === undefined || message === null) {
-			throw new TypeError('message不能为undefined或null');
-		}
+	// 参数验证
+	if (!channel || typeof channel !== 'string') {
+		throw new TypeError('channel必须是非空字符串');
+	}
+	if (message === undefined || message === null) {
+		throw new TypeError('message不能为undefined或null');
+	}
 
+	try {
 		return await this.conn.publish(this._addPrefix(channel), message);
 	} catch (err) {
 		this.logger('error', `发布消息到频道 ${channel} 失败:`, err);
@@ -189,49 +187,11 @@ Redis.prototype.setConfig = function (config) {
 		obj = config.loadJson(__dirname);
 	} else if (config) {
 		// 合并配置参数
-		if (config.pool) {
-			// 确保连接池配置的合并不会覆盖所有默认值
-			if (!this.config.pool) {
-				this.config.pool = {};
-			}
-			Object.assign(this.config.pool, config.pool);
-			// 删除config中的pool属性，避免后续Object.assign重复处理
-			const configCopy = {
-				...config
-			};
-			delete configCopy.pool;
-			Object.assign(this.config, configCopy);
-		} else {
-			Object.assign(this.config, config);
-		}
+		Object.assign(this.config, config);
 	} else {
 		return;
 	}
 
-	// 确保连接池配置存在且包含所有必要字段
-	if (!this.config.pool) {
-		this.config.pool = {};
-	}
-
-	// 设置默认连接池配置，只覆盖未定义的字段
-	const defaultPoolConfig = {
-		max_clients: 100,
-		min_idle: 5,
-		max_idle: 20,
-		idle_timeout: 30000
-	};
-
-	for (const key in defaultPoolConfig) {
-		if (this.config.pool[key] === undefined) {
-			this.config.pool[key] = defaultPoolConfig[key];
-		}
-	}
-
-	// 如果连接池已经初始化，更新其配置
-	if (this.connection_pool) {
-		this.connection_pool.config = this.config.pool;
-	}
-
 	// 初始化连接池
 	this._initPool();
 	// this.logger('debug','配置已更新');
@@ -242,24 +202,16 @@ Redis.prototype.setConfig = function (config) {
 // 添加连接池初始化方法
 Redis.prototype._initPool = function () {
 	// 确保连接池配置存在
-	if (!this.config.pool) {
-		this.config.pool = {
-			max_clients: 100,
-			min_idle: 5,
-			max_idle: 20,
-			idle_timeout: 30000
-		};
-	}
 
 	// 初始化连接池相关属性
 	this.connection_pool = {
 		available: [],
 		in_use: new Set(),
-		config: this.config.pool // 直接引用配置对象，确保同步更新
+		config: this.config // 直接引用配置对象，确保同步更新
 	};
 
 	// 记录连接池初始化
-	// this.logger('debug','连接池已初始化，配置:', this.config.pool);
+	// this.logger('debug','连接池已初始化，配置:', this.config);
 };
 
 /**
@@ -552,12 +504,6 @@ Redis.prototype.isConnected = function () {
 	return this.connected && this.conn && this.conn.isReady;
 };
 
-/**
- * @description 查询或是设置缓存过期时间
- * @param {String} key 键
- * @param {Number} seconds 秒, 为空则查询有效时长
- * @return {Promise<Number|Boolean>} 查询时长或设置结果, 时长为-1表示永不过期
- */
 /**
  * 获取或设置键的过期时间
  * @param {String} key 键名
@@ -565,11 +511,12 @@ Redis.prototype.isConnected = function () {
  * @return {Promise<Number|Boolean>} 不传seconds时返回剩余过期时间（-1表示无过期设置，-2表示已过期），传seconds时返回是否设置成功
  */
 Redis.prototype.ttl = async function (key, seconds) {
+	// 参数验证
+	if (!key || typeof key !== 'string') {
+		throw new TypeError('key必须是非空字符串');
+	}
+
 	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('key必须是非空字符串');
-		}
 
 		const connection = await this._getConnection();
 		try {
@@ -620,16 +567,15 @@ Redis.prototype.ttl = async function (key, seconds) {
  * @return {Promise<Number>} 计算后的结果
  */
 Redis.prototype.addInt = async function (key, num, seconds = 0) {
+	// 参数验证
+	if (!key || typeof key !== 'string') {
+		throw new TypeError('key必须是非空字符串');
+	}
+	if (typeof num !== 'number' || isNaN(num) || !Number.isInteger(num)) {
+		throw new TypeError('num必须是有效整数');
+	}
+
 	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			this.logger('error', '参数错误: 键必须是非空字符串');
-			return false;
-		}
-		if (typeof num !== 'number' || isNaN(num) || !Number.isInteger(num)) {
-			this.logger('error', '参数错误: 数值必须是有效整数');
-			return false;
-		}
 
 		// 触发前置事件，允许修改或阻止操作
 		const ctx = {
@@ -738,17 +684,18 @@ Redis.prototype.addInt = async function (key, num, seconds = 0) {
  * @return {Promise<Number>} 计算后的结果
  */
 Redis.prototype.addFloat = async function (key, num, seconds = 0) {
-	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('key必须是非空字符串');
-		}
+	// 参数验证
+	if (!key || typeof key !== 'string') {
+		throw new TypeError('key必须是非空字符串');
+	}
 
-		// 验证num参数
-		num = parseFloat(num);
-		if (isNaN(num)) {
-			throw new TypeError('num必须是有效的数值');
-		}
+	// 验证num参数
+	num = parseFloat(num);
+	if (isNaN(num)) {
+		throw new TypeError('num必须是有效的数值');
+	}
+
+	try {
 
 		// 触发前置事件，允许修改或阻止操作
 		const ctx = {
@@ -2289,7 +2236,7 @@ Redis.prototype._recycleConnection = function (connection) {
  * @description 删除哈希字段
  * @param {String} key 键
  * @param {String|Array<String>} fields 字段名或字段名数组
- * @return {Promise<Boolean>} 操作结果
+ * @return {Promise<Number>} 删除的字段数量
  */
 Redis.prototype.hdel = async function (key, fields) {
 	try {
@@ -2321,23 +2268,24 @@ Redis.prototype.hdel = async function (key, fields) {
 				finalFields = [finalFields];
 			}
 
+			let deletedCount = 0;
 			// 执行删除操作
 			if (typeof connection.hDel === 'function') {
-				await connection.hDel(finalKey, finalFields);
+				deletedCount = await connection.hDel(finalKey, finalFields);
 			} else if (typeof connection.execute === 'function') {
-				await connection.execute('HDEL', [finalKey, ...finalFields]);
+				deletedCount = await connection.execute('HDEL', [finalKey, ...finalFields]);
 			} else {
 				this.logger('error', '连接对象不支持hDel操作');
-				success = false;
+				deletedCount = 0;
 			}
 
 			// 触发后置事件
 			this.emit('hdel:after', {
 				key: finalKey,
 				value: finalFields,
-				success
+				deletedCount
 			});
-			return success;
+			return deletedCount;
 		} finally {
 			this._recycleConnection(connection);
 		}
@@ -2349,7 +2297,7 @@ Redis.prototype.hdel = async function (key, fields) {
 			error: err
 		});
 		this.logger('error', `删除哈希字段失败 [${key}]:`, err);
-		return false;
+		return 0; // 与Redis语义保持一致，返回删除的字段数量
 	}
 };
 
@@ -2543,7 +2491,7 @@ Redis.prototype._getConnection = function () {
 			// 如果连接数未达到上限，创建新连接
 			const totalConnections = this.connection_pool.available.length + this.connection_pool.in_use
 				.size;
-			if (totalConnections < this.connection_pool.config.max_clients) {
+			if (totalConnections < this.config.max_clients) {
 				this._createConnection().then(connection => {
 					this.connection_pool.in_use.add(connection);
 					resolve(connection);
@@ -2571,7 +2519,7 @@ Redis.prototype._releaseConnection = function (connection) {
 			this.connection_pool.in_use.delete(connection);
 
 			// 检查是否超过最大空闲连接数
-			if (this.connection_pool.available.length < this.connection_pool.config.max_idle) {
+			if (this.connection_pool.available.length < this.config.max_idle) {
 				this.connection_pool.available.push(connection);
 			} else {
 				// 否则关闭多余的连接
@@ -2646,7 +2594,7 @@ Redis.prototype.hset = async function (key, field, value) {
 				value: finalValue,
 				success: true
 			});
-			return result > 0; // 如果field是新的，hSet返回1，否则返回0
+			return true; // hSet操作成功返回true
 		} finally {
 			this._recycleConnection(connection);
 		}

package/package.json

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