mm_cachebase 1.4.6 → 1.5.0

package/README.md

@@ -1,6 +1,14 @@
 # mm_cachebase
 
-一个轻量级的本地缓存类库，提供了丰富的缓存操作接口，支持过期时间设置、数组操作、哈希表、集合、有序集合等功能，以及完整的事件通知系统。
+一个轻量级的本地缓存类库，提供了与Redis兼容的缓存操作接口，支持过期时间设置、哈希表操作、数值操作、字符串操作等功能，以及完整的事件通知系统。
+
+## 特点
+
+- **Redis兼容API**：实现了与npm redis模块相似的接口，便于无缝切换
+- **轻量级设计**：纯JavaScript实现，无外部依赖
+- **完整的事件系统**：支持前置/后置/错误事件，便于日志记录和访问控制
+- **过期时间管理**：支持设置和查询键的过期时间
+- **丰富的数据类型支持**：支持字符串、哈希表等Redis常见数据类型
 
 ## 安装
 
@@ -38,9 +46,7 @@ async function example() {
 const cache = new CacheBase();
 ```
 
-创建一个新的缓存实例。缓存实例包含以下属性：
-- `list`: 存储缓存数据的数组
-- `func`: 到期通知函数（可选）
+创建一个新的缓存实例。缓存实例基于EventEmitter，支持完整的事件系统。
 
 ### 基本操作
 
@@ -51,14 +57,14 @@ await cache.set(key, value, maxAge)
 - `key`: 缓存键名
 - `value`: 缓存的值
 - `maxAge`: 过期时间（秒），-1表示永不过期
-- 返回: 设置的值
+- 返回: 'OK'
 
 #### 获取缓存
 ```javascript
 await cache.get(key)
 ```
 - `key`: 缓存键名
-- 返回: 缓存值，不存在则返回undefined
+- 返回: 缓存值，不存在则返回null
 
 #### 删除缓存
 ```javascript
@@ -67,239 +73,138 @@ await cache.del(key)
 - `key`: 缓存键名
 - 返回: 成功返回1，失败返回0
 
-#### 添加缓存
+#### 设置并获取旧值
 ```javascript
-await cache.add(key, value, maxAge)
+await cache.getset(key, value, maxAge)
 ```
-- 只在键不存在时添加缓存
-- 返回: 添加成功返回值，已存在返回0
+- 先获取旧值，然后设置新值
+- 返回: 旧值，不存在则返回null
 
-#### 判断键是否存在
+#### 批量设置缓存
 ```javascript
-await cache.has(key)
+await cache.mset(keys, values, maxAge)
 ```
-- 返回: 存在返回1，不存在返回0
-
-### 过期时间操作
-
-#### 设置/查询过期时间
-```javascript
-await cache.ttl(key, maxAge)
-```
-- `maxAge`: 不传则查询剩余时间，传入则设置新的过期时间
-- 返回: 查询时返回剩余秒数，设置时返回1
-
-### 数值操作
-
-#### 增加整数
-```javascript
-await cache.addInt(key, num)
-```
-- `num`: 要增加的数值，可以为负数
-- 返回: 计算后的结果
+- `keys`: 键名数组
+- `values`: 值数组
+- 返回: 'OK'
 
-#### 增加浮点数
+#### 批量获取缓存
 ```javascript
-await cache.addFloat(key, num)
+await cache.mget(...keys)
 ```
-- 用法同addInt，支持浮点数
-
-### 字符串操作
+- `keys`: 一个或多个键名
+- 返回: 值数组
 
-#### 追加字符串
+#### 判断键是否存在
 ```javascript
-await cache.addStr(key, str)
+await cache.exists(...keys)
 ```
-- 在已有字符串后追加新字符串
-- 返回: 追加后的完整字符串
+- `keys`: 一个或多个键名
+- 返回: 存在的键数量
 
-#### 获取子字符串
-```javascript
-await cache.getrange(key, start, end)
-```
-- 获取缓存字符串的指定范围
-- 返回: 截取的字符串
+### 过期时间操作
 
-#### 替换字符串
+#### 设置过期时间
 ```javascript
-await cache.setrange(key, index, value)
+await cache.expire(key, maxAge)
 ```
-- 从指定位置替换字符串
-
-### 哈希表操作
-
-#### 设置哈希表字段
-```javascript
-await cache.hset(key, field, value)
-```
-- `key`: 哈希表的键名
-- `field`: 字段名
-- `value`: 字段值
+- `maxAge`: 过期时间（秒）
 - 返回: 成功返回1，失败返回0
 
-#### 获取哈希表字段
+#### 查询剩余过期时间
 ```javascript
-await cache.hget(key, field)
+await cache.ttl(key)
 ```
-- 返回: 字段值，不存在则返回null
+- 返回: 剩余秒数，不存在或永不过期返回-1
 
-#### 删除哈希表字段
+#### 移除过期时间
 ```javascript
-await cache.hdel(key, field)
+await cache.persist(key)
 ```
 - 返回: 成功返回1，失败返回0
 
-#### 获取哈希表所有键名
-```javascript
-await cache.hkeys(key)
-```
-- 返回: 键名数组
-
-#### 获取哈希表所有值
-```javascript
-await cache.hvals(key)
-```
-- 返回: 值数组
-
-### 列表操作
-
-#### 设置列表
-```javascript
-await cache.list_set(key, value, maxAge)
-```
-- 设置一个数组类型的缓存
-
-#### 添加列表元素
-```javascript
-await cache.list_add(key, value)
-```
-- 向数组末尾添加元素
-- 返回: 成功返回1，失败返回-1
-
-#### 从左侧推入元素
-```javascript
-await cache.lpush(key, ...values)
-```
-- 从列表左侧添加一个或多个元素
-- 返回: 操作后的列表长度
-
-#### 从左侧弹出元素
-```javascript
-await cache.lpop(key)
-```
-- 从列表左侧移除并返回一个元素
-- 返回: 弹出的元素，列表为空返回null
-
-#### 从右侧推入元素
-```javascript
-await cache.rpush(key, ...values)
-```
-- 从列表右侧添加一个或多个元素
-- 返回: 操作后的列表长度
-
-#### 从右侧弹出元素
-```javascript
-await cache.rpop(key)
-```
-- 从列表右侧移除并返回一个元素
-- 返回: 弹出的元素，列表为空返回null
-
-#### 获取列表长度
-```javascript
-await cache.llen(key)
-```
-- 返回: 列表长度，键不存在返回0
+### 数值操作
 
-#### 判断数组元素是否存在
+#### 增加整数
 ```javascript
-await cache.list_has(key, value)
+await cache.incr(key)
 ```
-- 检查数组中是否包含指定元素
+- 将键的值加1
+- 返回: 增加后的值
 
-#### 获取数组片段
+#### 增加指定整数
 ```javascript
-await cache.list_get(key, start, end)
+await cache.incrby(key, increment)
 ```
-- 获取数组的指定范围元素
+- `increment`: 要增加的整数
+- 返回: 增加后的值
 
-#### 清空/重置数组
+#### 减少整数
 ```javascript
-await cache.list_clear(key, value)
+await cache.decr(key)
 ```
-- 清空数组或用新数组替换
-
-### 集合操作
+- 将键的值减1
+- 返回: 减少后的值
 
-#### 添加集合成员
+#### 减少指定整数
 ```javascript
-await cache.sadd(key, member)
+await cache.decrby(key, decrement)
 ```
-- 向集合添加一个成员
-- 返回: 成功返回1，成员已存在返回0
+- `decrement`: 要减少的整数
+- 返回: 减少后的值
 
-#### 删除集合成员
+#### 增加浮点数
 ```javascript
-await cache.srem(key, member)
+await cache.incrbyfloat(key, increment)
 ```
-- 从集合移除一个成员
-- 返回: 成功返回1，成员不存在返回0
+- `increment`: 要增加的浮点数
+- 返回: 增加后的值
 
-#### 获取集合所有成员
-```javascript
-await cache.smembers(key)
-```
-- 返回: 成员数组，键不存在返回空数组
+### 字符串操作
 
-#### 判断成员是否存在
+#### 追加字符串
 ```javascript
-await cache.sismember(key, member)
+await cache.append(key, value)
 ```
-- 返回: 存在返回1，不存在返回0
+- 在已有字符串后追加新字符串
+- 返回: 追加后的字符串长度
 
-#### 获取集合大小
+#### 获取字符串长度
 ```javascript
-await cache.scard(key)
+await cache.strlen(key)
 ```
-- 返回: 集合大小，键不存在返回0
+- 返回: 字符串长度
 
-### 有序集合操作
+### 哈希表操作
 
-#### 添加有序集合成员
+#### 设置哈希表字段
 ```javascript
-await cache.zadd(key, score, member)
+await cache.hset(key, field, value)
 ```
-- 向有序集合添加一个成员
-- 返回: 成功返回1，成员已存在返回0
+- `key`: 哈希表的键名
+- `field`: 字段名
+- `value`: 字段值
+- 返回: 成功返回1，失败返回0
 
-#### 获取有序集合范围
+#### 获取哈希表字段
 ```javascript
-await cache.zrange(key, start, stop, withScores)
+await cache.hget(key, field)
 ```
-- `start`/`stop`: 范围索引
-- `withScores`: 是否返回分数
-- 返回: 成员数组或[成员, 分数]数组
+- 返回: 字段值，不存在则返回null
 
-#### 删除有序集合成员
+#### 获取哈希表所有字段和值
 ```javascript
-await cache.zrem(key, member)
+await cache.hgetall(key)
 ```
-- 从有序集合移除一个成员
-- 返回: 成功返回1，成员不存在返回0
+- 返回: 包含所有字段和值的对象
 
-#### 获取成员分数
+#### 删除哈希表字段
 ```javascript
-await cache.zscore(key, member)
+await cache.hdel(key, field)
 ```
-- 返回: 成员分数，成员不存在返回null
+- 返回: 成功返回1，失败返回0
 
-### 其他操作
-
-#### 排序
-```javascript
-await cache.sort(key, way, obj_key)
-```
-- `way`: 'asc'升序或'desc'降序
-- `obj_key`: 如果数组元素是对象，指定排序的键
+### 键操作
 
 #### 获取所有键名
 ```javascript
@@ -308,12 +213,18 @@ await cache.keys(pattern)
 - `pattern`: 支持*通配符的匹配模式
 - 返回: 匹配的键名数组
 
+#### 获取键数量
+```javascript
+await cache.dbsize()
+```
+- 返回: 缓存中的键数量
+
 #### 清空缓存
 ```javascript
-await cache.clear(pattern)
+await cache.flushdb()
 ```
-- `pattern`: 可选，支持*通配符，清空匹配的键
-- 不传则清空所有缓存
+- 清空所有缓存
+- 返回: 'OK'
 
 #### 销毁缓存实例
 ```javascript
@@ -321,207 +232,38 @@ await cache.dispose()
 ```
 - 清理所有资源，移除所有监听器
 
-## 使用示例
-
-### 基本缓存操作
-```javascript
-const cache = new CacheBase();
-
-async function example() {
-    // 设置缓存
-    await cache.set("user", "张三", 60); // 60秒后过期
-    
-    // 获取缓存
-    const user = await cache.get("user");
-    console.log(user); // 输出: 张三
-    
-    // 检查是否存在
-    const exists = await cache.has("user");
-    console.log(exists); // 输出: 1
-    
-    // 删除缓存
-    await cache.del("user");
-}
-```
-
-### 哈希表操作示例
-```javascript
-async function hashExample() {
-    // 设置哈希表字段
-    await cache.hset("user:123", "name", "张三");
-    await cache.hset("user:123", "age", 30);
-    await cache.hset("user:123", "email", "zhangsan@example.com");
-    
-    // 获取哈希表字段
-    const name = await cache.hget("user:123", "name");
-    console.log(name); // 输出: 张三
-    
-    // 获取所有键名
-    const keys = await cache.hkeys("user:123");
-    console.log(keys); // 输出: ["name", "age", "email"]
-    
-    // 获取所有值
-    const values = await cache.hvals("user:123");
-    console.log(values); // 输出: ["张三", 30, "zhangsan@example.com"]
-    
-    // 删除字段
-    await cache.hdel("user:123", "email");
-}
-```
+### 兼容方法（保持向后兼容）
 
-### 列表操作示例
+#### 添加缓存（仅当键不存在时）
 ```javascript
-async function listExample() {
-    // 设置列表
-    await cache.list_set("tasks", ["任务1", "任务2"], 300);
-    
-    // 添加元素到末尾
-    await cache.list_add("tasks", "任务3");
-    
-    // 从左侧推入元素
-    await cache.lpush("tasks", "任务0");
-    
-    // 从右侧推入元素
-    await cache.rpush("tasks", "任务4");
-    
-    // 从左侧弹出元素
-    const task0 = await cache.lpop("tasks");
-    console.log("弹出任务:", task0); // 输出: 任务0
-    
-    // 从右侧弹出元素
-    const task4 = await cache.rpop("tasks");
-    console.log("弹出任务:", task4); // 输出: 任务4
-    
-    // 获取列表长度
-    const length = await cache.llen("tasks");
-    console.log("任务数量:", length); // 输出: 3
-    
-    // 获取列表
-    const tasks = await cache.list_get("tasks");
-    console.log("任务列表:", tasks); // 输出: ["任务1", "任务2", "任务3"]
-    
-    // 排序
-    await cache.sort("tasks", "asc");
-}
+await cache.add(key, value, maxAge)
 ```
+- 返回: 添加成功返回值，已存在返回0
 
-### 集合操作示例
+#### 检查键是否存在
 ```javascript
-async function setExample() {
-    // 添加集合成员
-    await cache.sadd("users", "张三");
-    await cache.sadd("users", "李四");
-    await cache.sadd("users", "王五");
-    
-    // 尝试添加重复成员
-    const result = await cache.sadd("users", "张三");
-    console.log("添加重复成员结果:", result); // 输出: 0
-    
-    // 判断成员是否存在
-    const exists = await cache.sismember("users", "张三");
-    console.log("张三是否在用户集合中:", exists); // 输出: 1
-    
-    // 获取集合所有成员
-    const members = await cache.smembers("users");
-    console.log("用户集合:", members); // 输出: ["张三", "李四", "王五"]
-    
-    // 获取集合大小
-    const size = await cache.scard("users");
-    console.log("集合大小:", size); // 输出: 3
-    
-    // 删除成员
-    await cache.srem("users", "李四");
-}
+await cache.has(key)
 ```
+- 返回: 存在返回1，不存在返回0
 
-### 有序集合操作示例
+#### 增加浮点数（兼容方法）
 ```javascript
-async function sortedSetExample() {
-    // 添加有序集合成员
-    await cache.zadd("scores", 95, "张三");
-    await cache.zadd("scores", 88, "李四");
-    await cache.zadd("scores", 92, "王五");
-    
-    // 获取有序集合范围（升序）
-    const ascendingScores = await cache.zrange("scores", 0, -1, true);
-    console.log("分数排序(升序):", ascendingScores);
-    // 输出: ["李四", 88, "王五", 92, "张三", 95]
-    
-    // 获取指定成员分数
-    const zhangScore = await cache.zscore("scores", "张三");
-    console.log("张三的分数:", zhangScore); // 输出: 95
-    
-    // 删除成员
-    await cache.zrem("scores", "李四");
-    
-    // 再次获取有序集合
-    const remainingScores = await cache.zrange("scores", 0, -1);
-    console.log("剩余成员:", remainingScores); // 输出: ["王五", "张三"]
-}
+await cache.addFloat(key, num)
 ```
+- `num`: 要增加的浮点数
+- 返回: 计算后的结果
 
-### 过期时间管理
+#### 追加字符串（兼容方法）
 ```javascript
-async function ttlExample() {
-    // 设置缓存
-    await cache.set("token", "abc123", 30);
-    
-    // 查询剩余时间
-    const ttl = await cache.ttl("token");
-    console.log(`剩余${ttl}秒`);
-    
-    // 延长过期时间
-    await cache.ttl("token", 60);
-    
-    // 设置永不过期
-    await cache.ttl("token", -1);
-}
+await cache.addStr(key, str)
 ```
+- 返回: 追加后的完整字符串
 
-### 批量操作
+#### 清空匹配缓存（兼容方法）
 ```javascript
-async function batchExample() {
-    // 获取所有以user开头的键
-    const keys = await cache.keys("user*");
-    
-    // 清空所有以temp开头的缓存
-    await cache.clear("temp*");
-    
-    // 清空所有缓存
-    await cache.clear();
-}
-
-### 事件系统使用示例
-```javascript
-async function eventExample() {
-    // 设置操作的前置事件
-    cache.on('set_before', (data) => {
-        console.log(`即将设置键: ${data.key}`);
-        
-        // 示例：进行数据验证
-        if (typeof data.value === 'string' && data.value.length > 100) {
-            console.log('值长度过长，取消设置');
-            data.cancel = true; // 取消操作
-        }
-    });
-    
-    // 获取操作的后置事件
-    cache.on('get_after', (data) => {
-        console.log(`获取键 ${data.key} 的结果: ${data.result}`);
-    });
-    
-    // 尝试设置缓存
-    await cache.set("test", "这是一个测试值");
-    
-    // 获取缓存
-    const value = await cache.get("test");
-    
-    // 错误事件监听
-    cache.on('get_error', (data) => {
-        console.error(`获取键 ${data.key} 时出错: ${data.error.message}`);
-    });
-}
+await cache.clear(pattern)
 ```
+- `pattern`: 可选，支持*通配符
 
 ## 事件系统
 
@@ -553,385 +295,159 @@ cache.off('event_name', callback);
 
 ### 支持的事件类型
 
-每个缓存操作都有对应的前置事件（`_before`）、后置事件（`_after`）和错误事件（`_error`）。以下是主要支持的事件类型：
+每个缓存操作都有对应的前置事件（`_before`）、后置事件（`_after`）和错误事件（`_error`）。
 
 #### 基本操作事件
 - `set_before`, `set_after`, `set_error`
 - `get_before`, `get_after`, `get_error`
 - `del_before`, `del_after`, `del_error`
 - `exists_before`, `exists_after`, `exists_error`
-- `dispose_before`, `dispose_after`, `dispose_error`
+- `mset_before`, `mset_after`, `mset_error`
+- `mget_before`, `mget_after`, `mget_error`
+
+#### 过期时间操作事件
+- `expire_before`, `expire_after`, `expire_error`
+- `ttl_before`, `ttl_after`, `ttl_error`
+
+#### 数值操作事件
+- `incr_before`, `incr_after`, `incr_error`
+- `decr_before`, `decr_after`, `decr_error`
+- `incrby_before`, `incrby_after`, `incrby_error`
+- `decrby_before`, `decrby_after`, `decrby_error`
+- `incrbyfloat_before`, `incrbyfloat_after`, `incrbyfloat_error`
+
+#### 字符串操作事件
+- `append_before`, `append_after`, `append_error`
+- `strlen_before`, `strlen_after`, `strlen_error`
 
 #### 哈希表操作事件
 - `hset_before`, `hset_after`, `hset_error`
 - `hget_before`, `hget_after`, `hget_error`
+- `hgetall_before`, `hgetall_after`, `hgetall_error`
 - `hdel_before`, `hdel_after`, `hdel_error`
-- `hkeys_before`, `hkeys_after`, `hkeys_error`
-- `hvals_before`, `hvals_after`, `hvals_error`
-
-#### 列表操作事件
-- `lpush_before`, `lpush_after`, `lpush_error`
-- `lpop_before`, `lpop_after`, `lpop_error`
-- `rpush_before`, `rpush_after`, `rpush_error`
-- `rpop_before`, `rpop_after`, `rpop_error`
-- `llen_before`, `llen_after`, `llen_error`
-- `list_set_before`, `list_set_after`, `list_set_error`
-- `list_add_before`, `list_add_after`, `list_add_error`
-- `list_clear_before`, `list_clear_after`, `list_clear_error`
-
-#### 集合操作事件
-- `sadd_before`, `sadd_after`, `sadd_error`
-- `srem_before`, `srem_after`, `srem_error`
-- `smembers_before`, `smembers_after`, `smembers_error`
-- `sismember_before`, `sismember_after`, `sismember_error`
-- `scard_before`, `scard_after`, `scard_error`
-
-#### 有序集合操作事件
-- `zadd_before`, `zadd_after`, `zadd_error`
-- `zrange_before`, `zrange_after`, `zrange_error`
-- `zrem_before`, `zrem_after`, `zrem_error`
-- `zscore_before`, `zscore_after`, `zscore_error`
-
-#### 其他操作事件
-- `mset_before`, `mset_after`, `mset_error`
-- `setex_before`, `setex_after`, `setex_error`
-- `setnx_before`, `setnx_after`, `setnx_error`
-- `add_before`, `add_after`, `add_error`
-- `addFloat_before`, `addFloat_after`, `addFloat_error`
-- `addStr_before`, `addStr_after`, `addStr_error`
-- `setrange_before`, `setrange_after`, `setrange_error`
 
-### 取消操作示例
+#### 键操作事件
+- `keys_before`, `keys_after`, `keys_error`
+- `dbsize_before`, `dbsize_after`, `dbsize_error`
+- `flushdb_before`, `flushdb_after`, `flushdb_error`
+- `dispose_before`, `dispose_after`, `dispose_error`
 
-在前置事件中，你可以通过设置 `cancel` 标志为 `true` 来取消操作：
+### 事件使用示例
 
 ```javascript
+const cache = new CacheBase();
+
 // 监听设置操作的前置事件
 cache.on('set_before', (data) => {
     console.log('即将设置键:', data.key, '值:', data.value);
     
-    // 检查值是否合法
-    if (typeof data.value !== 'string' || data.value.length > 100) {
-        console.log('值不合法，取消设置操作');
+    // 数据验证示例
+    if (typeof data.value === 'string' && data.value.length > 100) {
+        console.log('值长度过长，取消设置');
         data.cancel = true; // 取消操作
     }
 });
 
-// 监听获取操作的前置事件 - 实现访问控制
-cache.on('get_before', (data) => {
-    console.log('尝试获取键:', data.key);
-    
-    // 实现简单的访问控制
-    const restrictedKeys = ['admin_data', 'sensitive_info'];
-    if (restrictedKeys.includes(data.key) && !userHasPermission()) {
-        console.log('无权限访问此键，取消获取操作');
-        data.cancel = true; // 取消操作
-    }
+// 监听获取操作的后置事件
+cache.on('get_after', (data) => {
+    console.log(`获取键 ${data.key} 的结果: ${data.result}`);
 });
 
-// 监听集合删除操作的前置事件
-cache.on('srem_before', (data) => {
-    console.log('尝试从集合', data.key, '中删除成员:', data.value.member);
-    
-    // 防止删除特定成员
-    if (data.value.member === 'protected_member') {
-        console.log('保护成员不能删除，取消操作');
-        data.cancel = true;
-    }
-});
-
-// 监听删除键操作的前置事件
-cache.on('del_before', (data) => {
-    console.log('尝试删除键:', data.key);
-    
-    // 防止删除系统键
-    if (data.key.startsWith('system:')) {
-        console.log('系统键不能删除，取消操作');
-        data.cancel = true;
-    }
+// 错误事件监听
+cache.on('get_error', (data) => {
+    console.error(`获取键 ${data.key} 时出错: ${data.error.message}`);
 });
 ```
 
-### 完整事件系统示例
-
-以下是一个完整的示例，展示如何使用事件系统进行缓存操作的全面监控、日志记录和访问控制：
+## 使用示例
 
+### 基本缓存操作
 ```javascript
-const CacheBase = require('./index.js');
+const cache = new CacheBase();
 
-async function eventSystemExample() {
-    const cache = new CacheBase();
-    
-    // 1. 实现统一的操作日志记录
-    const operations = ['get', 'set', 'del', 'exists', 'hget', 'hset', 
-                       'lpush', 'lpop', 'rpush', 'rpop', 'sadd', 'srem', 
-                       'smembers', 'zadd', 'zrange'];
-    
-    // 为所有操作添加日志记录
-    operations.forEach(op => {
-        // 记录操作开始
-        cache.on(`${op}_before`, (data) => {
-            console.log(`[CACHE] 开始 ${op} 操作`, {
-                key: data.key,
-                value: data.value,
-                timestamp: new Date().toISOString()
-            });
-        });
-        
-        // 记录操作成功完成
-        cache.on(`${op}_after`, (data) => {
-            console.log(`[CACHE] ${op} 操作成功`, {
-                key: data.key,
-                result: data.result,
-                timestamp: new Date().toISOString()
-            });
-        });
-        
-        // 记录操作失败
-        cache.on(`${op}_error`, (data) => {
-            console.error(`[CACHE] ${op} 操作失败`, {
-                key: data.key,
-                error: data.error.message,
-                timestamp: new Date().toISOString()
-            });
-        });
-    });
-    
-    // 2. 实现缓存操作统计
-    const stats = {
-        totalOperations: 0,
-        successfulOperations: 0,
-        failedOperations: 0,
-        canceledOperations: 0,
-        operationTypes: {}
-    };
-    
-    // 更新统计信息
-    operations.forEach(op => {
-        cache.on(`${op}_before`, () => {
-            stats.totalOperations++;
-            stats.operationTypes[op] = (stats.operationTypes[op] || 0) + 1;
-        });
-        
-        cache.on(`${op}_after`, (data) => {
-            if (op === 'get' && data.result === null) {
-                // 可以特殊处理缓存未命中的情况
-                console.log(`[CACHE] 缓存未命中: ${data.key}`);
-            }
-            stats.successfulOperations++;
-        });
-        
-        cache.on(`${op}_error`, () => {
-            stats.failedOperations++;
-        });
-    });
-    
-    // 3. 实现复杂的访问控制
-    const accessControl = {
-        // 定义哪些用户角色可以访问哪些键模式
-        permissions: {
-            'admin': ['*'],
-            'user': ['user:*', 'public:*'],
-            'guest': ['public:*']
-        },
-        
-        // 当前用户角色
-        currentRole: 'user'
-    };
-    
-    // 为敏感操作添加访问控制
-    ['get', 'del', 'hget', 'hdel'].forEach(op => {
-        cache.on(`${op}_before`, (data) => {
-            const hasPermission = accessControl.permissions[accessControl.currentRole].some(pattern => {
-                // 简单的通配符匹配实现
-                if (pattern === '*') return true;
-                const regexPattern = pattern.replace(/\*/g, '.*');
-                const regex = new RegExp(`^${regexPattern}$`);
-                return regex.test(data.key);
-            });
-            
-            if (!hasPermission) {
-                console.warn(`[SECURITY] 拒绝访问: 用户 ${accessControl.currentRole} 尝试访问键 ${data.key}`);
-                data.cancel = true;
-                stats.canceledOperations++;
-            }
-        });
-    });
-    
-    // 4. 执行一些测试操作
-    console.log('执行测试操作...');
-    
-    // 应该成功的操作
-    await cache.set('user:123:name', '张三');
-    await cache.hset('user:123:profile', 'email', 'zhangsan@example.com');
-    await cache.sadd('user:123:tags', 'vip');
-    
-    // 尝试访问无权限的键
-    const restrictedData = await cache.get('admin:settings');
-    console.log('受限访问结果:', restrictedData); // 应该是 null
+async function example() {
+    // 设置缓存
+    await cache.set("user", "张三", 60); // 60秒后过期
     
-    // 正常访问有权限的键
-    const userName = await cache.get('user:123:name');
-    console.log('用户名:', userName);
+    // 获取缓存
+    const user = await cache.get("user");
+    console.log(user); // 输出: 张三
     
-    // 5. 显示操作统计
-    console.log('\n操作统计:');
-    console.log(stats);
+    // 检查是否存在
+    const exists = await cache.exists("user");
+    console.log(exists); // 输出: 1
     
-    // 6. 清理资源
-    await cache.dispose();
+    // 删除缓存
+    await cache.del("user");
 }
-
-// 运行示例
-eventSystemExample().catch(console.error);
 ```
 
-### 事件参数格式示例
-
-#### 基本操作事件数据
+### 哈希表操作示例
 ```javascript
-// set_before 事件数据
-{
-  key: 'test_key',
-  value: 'test_value',
-  cancel: false
-}
-
-// set_after 事件数据
-{
-  key: 'test_key', 
-  value: 'test_value', 
-  result: 1
-}
-
-// get_before 事件数据
-{
-  key: 'test_key',
-  cancel: false
-}
-
-// get_after 事件数据
-{
-  key: 'test_key',
-  result: 'test_value'
-}
-
-// exists_before 事件数据
-{
-  key: 'test_key',
-  cancel: false
-}
-
-// exists_after 事件数据
-{
-  key: 'test_key',
-  result: 1 // 1表示存在，0表示不存在
-}
-
-// dispose_before 事件数据
-{
-  cancel: false
+async function hashExample() {
+    // 设置哈希表字段
+    await cache.hset("user:123", "name", "张三");
+    await cache.hset("user:123", "age", 30);
+    await cache.hset("user:123", "email", "zhangsan@example.com");
+    
+    // 获取哈希表字段
+    const name = await cache.hget("user:123", "name");
+    console.log(name); // 输出: 张三
+    
+    // 获取所有字段和值
+    const user = await cache.hgetall("user:123");
+    console.log(user); // 输出: { name: "张三", age: 30, email: "zhangsan@example.com" }
+    
+    // 删除字段
+    await cache.hdel("user:123", "email");
 }
-
-// dispose_after 事件无参数
 ```
 
-#### 复合操作事件数据
+### 数值操作示例
 ```javascript
-// hset_before 事件数据
-{
-  key: 'hash_key',
-  value: { field: 'field1', value: 'value1' },
-  cancel: false
-}
-
-// hget_before 事件数据
-{
-  key: 'hash_key',
-  value: { field: 'field1' },
-  cancel: false
-}
-
-// lpush_before 事件数据
-{
-  key: 'list_key',
-  value: { values: ['item1', 'item2'] },
-  cancel: false
-}
-
-// lpop_before/lpop_after 事件数据
-{
-  key: 'list_key',
-  cancel: false // lpop_after 中包含 result
-}
-
-// rpop_before/rpop_after 事件数据
-{
-  key: 'list_key',
-  cancel: false // rpop_after 中包含 result
-}
-
-// llen_before/llen_after 事件数据
-{
-  key: 'list_key',
-  cancel: false // llen_after 中包含 result
-}
-
-// srem_before 事件数据
-{
-  key: 'set_key',
-  value: { member: 'member1' },
-  cancel: false
-}
-
-// smembers_before/smembers_after 事件数据
-{
-  key: 'set_key',
-  cancel: false // smembers_after 中包含 result 数组
-}
-
-// sismember_before 事件数据
-{
-  key: 'set_key',
-  value: { member: 'member1' },
-  cancel: false
-}
-
-// scard_before/scard_after 事件数据
-{
-  key: 'set_key',
-  cancel: false // scard_after 中包含 result
-}
-
-// zrange_before 事件数据
-{
-  key: 'zset_key',
-  value: { start: 0, stop: -1, withScores: false },
-  cancel: false
-}
-
-// zrem_before 事件数据
-{
-  key: 'zset_key',
-  value: { member: 'zmember1' },
-  cancel: false
-}
-
-// zscore_before 事件数据
-{
-  key: 'zset_key',
-  value: { member: 'zmember1' },
-  cancel: false
+async function numberExample() {
+    // 设置初始值
+    await cache.set("counter", 10);
+    
+    // 增加1
+    const incr = await cache.incr("counter");
+    console.log("增加后:", incr); // 输出: 11
+    
+    // 增加指定值
+    const incrby = await cache.incrby("counter", 5);
+    console.log("增加5后:", incrby); // 输出: 16
+    
+    // 减少1
+    const decr = await cache.decr("counter");
+    console.log("减少后:", decr); // 输出: 15
+    
+    // 浮点数操作
+    await cache.set("price", 99.99);
+    const incrFloat = await cache.incrbyfloat("price", 0.01);
+    console.log("浮点数增加后:", incrFloat); // 输出: 100
 }
+```
 
-#### 过期时间操作事件数据
+### 批量操作示例
 ```javascript
-// setex_before 事件数据
-{
-  key: 'setex_key',
-  value: 'setex_value',
-  ttl: 60,
-  cancel: false
+async function batchExample() {
+    // 批量设置
+    await cache.mset(["key1", "key2", "key3"], ["value1", "value2", "value3"]);
+    
+    // 批量获取
+    const values = await cache.mget("key1", "key2", "key3");
+    console.log("批量获取:", values); // 输出: ["value1", "value2", "value3"]
+    
+    // 检查多个键是否存在
+    const existsCount = await cache.exists("key1", "key2", "nonexistent");
+    console.log("存在的键数量:", existsCount); // 输出: 2
+    
+    // 获取键数量
+    const count = await cache.dbsize();
+    console.log("键总数:", count);
+    
+    // 清空所有缓存
+    await cache.flushdb();
 }
 ```
 
@@ -939,10 +455,10 @@ eventSystemExample().catch(console.error);
 
 1. 所有操作方法都是异步的，需要使用async/await或Promise处理
 2. 过期时间单位为秒，-1表示永不过期
-3. 数组操作方法只能用于数组类型的缓存值
-4. 键名支持*通配符匹配，可用于批量操作
-5. 缓存数据存储在内存中，重启后数据会丢失
-6. 事件回调函数中的 `cancel` 标志只在前置事件中有效，后置事件中修改不会产生效果
-7. 当List、Set或Sorted Set类型的缓存变为空时，对应的键会被自动删除
-8. 所有事件参数都遵循统一的格式，包含key、value、result、error和cancel等字段
-9. 错误日志都添加了`[cachebase]`前缀，便于日志识别和过滤
+3. 缓存数据存储在内存中，重启后数据会丢失
+4. 事件回调函数中的 `cancel` 标志只在前置事件中有效，后置事件中修改不会产生效果
+5. 所有事件参数都遵循统一的格式，包含key、value、result、error和cancel等字段
+
+## 许可证
+
+MIT