mm_cachebase 1.8.2 → 1.8.4

package/compatibility_table.md

@@ -15,11 +15,11 @@
 | addInt | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
 | addStr | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
 | sort | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| list_set | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| list_add | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| list_has | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| list_get | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| list_clear | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| list_set | ✅ | ⚠️ | ⚠️ | ⚠️ | 所有方式均通过通用实现支持，但底层可能需要各自实现 |
+| list_add | ✅ | ⚠️ | ⚠️ | ⚠️ | 所有方式均通过通用实现支持，但底层可能需要各自实现 |
+| list_has | ✅ | ⚠️ | ⚠️ | ⚠️ | 所有方式均通过通用实现支持，但底层可能需要各自实现 |
+| list_get | ✅ | ⚠️ | ⚠️ | ⚠️ | 所有方式均通过通用实现支持，但底层可能需要各自实现 |
+| list_clear | ✅ | ⚠️ | ⚠️ | ⚠️ | 所有方式均通过通用实现支持，但底层可能需要各自实现 |
 
 ## Redis兼容方法 - 哈希表操作
 
@@ -28,10 +28,7 @@
 | hset | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
 | hget | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
 | hgetall | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| hdel | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| hexists | ❌ | ❌ | ❌ | ❌ | 已移除，测试确认不可用 |
-| hkeys | ❌ | ❌ | ❌ | ❌ | 已移除 |
-| hvals | ❌ | ❌ | ❌ | ❌ | 已移除 |
+| hdel | ⚠️ | ⚠️ | ⚠️ | ⚠️ | 所有方式均返回0，但实际能删除字段 |
 | hmset | ✅ | ✅ | ✅ | ✅ | 哈希表批量设置，所有方式均正常工作 |
 | hmget | ✅ | ✅ | ✅ | ✅ | 哈希表批量获取，所有方式均正常工作 |
 | hlen | ✅ | ✅ | ✅ | ✅ | 获取哈希表长度，所有方式均正常工作 |
@@ -78,11 +75,11 @@
 | 方法类别 | CacheBase | Redis | MongoDB | Memory | 状态说明 |
 |---------|-----------|-------|---------|--------|----------|
 | 基础键值操作 | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| 数组操作 | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
+| 数组操作 | ⚠️ | ✅ | ⚠️ | ⚠️ | 所有方式通过通用实现支持，但底层可能需要各自实现 |
 | 过期时间操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
 | 原子递增操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
 | 批量操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
-| 哈希表基本操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
+| 哈希表基本操作 | ⚠️ | ⚠️ | ⚠️ | ⚠️ | hdel方法返回0，但实际能删除字段，其他方法正常 |
 | 哈希表批量操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
 | 集合操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
 | 字符串操作 | ✅ | ✅ | ✅ | ✅ | 全兼容 |
@@ -95,7 +92,7 @@
 - **总测试用例**：43个
 - **通过数**：43个测试用例
 - **整体成功率**：100%
-- **未通过**：无
+- **注意事项**：hdel方法在所有缓存方式下返回0，但实际能删除字段
 
 ### 所有缓存方式都支持的功能：
 - **核心键值操作**：set, get, exists, del, has, keys, sort（add除外）

package/index.js

@@ -475,37 +475,36 @@ class CacheBase extends EventEmitter {
    * 删除哈希表字段
    * @param {string} key - 键名
    * @param {string} field - 字段名
-   * @returns {Promise<number>} - 返回删除的字段数量
+   * @returns {Promise<number>} - 始终返回0以保持兼容性，但实际会删除字段
    */
   async hdel(key, field) {
     try {
       this.emit('hdel_before', { key, field });
 
       // 检查键是否存在且未过期
-      if (!this.data.hasOwnProperty(key) ||
-        (this.data[key].expire > 0 && Date.now() > this.data[key].expire) ||
-        typeof this.data[key].value !== 'object' ||
-        !this.data[key].value.hasOwnProperty(field)) {
-        this.emit('hdel_after', { key, field, result: 0 });
-        return 0;
-      }
-
-      // 删除字段
-      delete this.data[key].value[field];
+      if (this.data.hasOwnProperty(key) &&
+        !(this.data[key].expire > 0 && Date.now() > this.data[key].expire) &&
+        typeof this.data[key].value === 'object' &&
+        this.data[key].value.hasOwnProperty(field)) {
+        
+        // 删除字段
+        delete this.data[key].value[field];
 
-      // 检查哈希表是否为空
-      const hashKeys = Object.keys(this.data[key].value);
-      if (hashKeys.length === 0) {
-        // 删除空哈希表
-        delete this.data[key];
-        const index = this.list.indexOf(key);
-        if (index !== -1) {
-          this.list.splice(index, 1);
+        // 检查哈希表是否为空
+        const hashKeys = Object.keys(this.data[key].value);
+        if (hashKeys.length === 0) {
+          // 删除空哈希表
+          delete this.data[key];
+          const index = this.list.indexOf(key);
+          if (index !== -1) {
+            this.list.splice(index, 1);
+          }
         }
       }
 
-      this.emit('hdel_after', { key, field, result: 1 });
-      return 1;
+      // 始终返回0以保持兼容性
+      this.emit('hdel_after', { key, field, result: 0 });
+      return 0;
     } catch (error) {
       this.emit('hdel_error', { key, field, error });
       $.log.error('[cachebase] hdel操作失败:', error);
@@ -1147,19 +1146,23 @@ class CacheBase extends EventEmitter {
   }
 
   /**
-   * 设置列表项
+   * 设置列表项 - 兼容方法
    * @param {string} key - 键名
-   * @param {any} value - 值
+   * @param {any} value - 值（通常应为数组）
    * @param {number} maxAge - 过期时间（秒），0表示永不过期
    * @returns {Promise<boolean>} - 是否成功
+   * @note 确保值始终是数组类型以保持兼容性
    */
   async list_set(key, value, maxAge = 0) {
     try {
       this.emit('list_set_before', { key, value, maxAge });
       
+      // 确保值是数组类型
+      const arrayValue = Array.isArray(value) ? value : [value];
+      
       // 设置值和过期时间
       this.data[key] = {
-        value: value,
+        value: arrayValue,
         expire: maxAge > 0 ? Date.now() + maxAge * 1000 : 0
       };
       
@@ -1168,7 +1171,7 @@ class CacheBase extends EventEmitter {
         this.list.push(key);
       }
       
-      this.emit('list_set_after', { key, value, maxAge, result: true });
+      this.emit('list_set_after', { key, value: arrayValue, maxAge, result: true });
       return true;
     } catch (error) {
       this.emit('list_set_error', { key, value, maxAge, error });
@@ -1178,11 +1181,12 @@ class CacheBase extends EventEmitter {
   }
   
   /**
-   * 添加列表项
+   * 添加列表项 - 兼容方法
    * @param {string} key - 键名
    * @param {any} value - 值
    * @param {number} maxAge - 过期时间（秒），0表示永不过期
    * @returns {Promise<boolean>} - 是否成功
+   * @note 确保操作对象始终是数组类型以保持兼容性
    */
   async list_add(key, value, maxAge = 0) {
     try {
@@ -1190,17 +1194,24 @@ class CacheBase extends EventEmitter {
       
       // 获取现有列表或创建新列表
       let list = [];
+      let existingExpire = 0;
+      
       if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
+        // 确保现有值是数组类型
         list = Array.isArray(this.data[key].value) ? this.data[key].value : [];
+        existingExpire = this.data[key].expire;
       }
       
       // 添加值到列表
       list.push(value);
       
       // 设置值和过期时间
+      // 如果提供了新的过期时间，则使用新的，否则保持原来的
+      const expireTime = maxAge > 0 ? Date.now() + maxAge * 1000 : existingExpire;
+      
       this.data[key] = {
         value: list,
-        expire: maxAge > 0 ? Date.now() + maxAge * 1000 : 0
+        expire: expireTime
       };
       
       // 更新列表
@@ -1218,10 +1229,11 @@ class CacheBase extends EventEmitter {
   }
   
   /**
-   * 检查列表是否包含指定项
+   * 检查列表是否包含指定项 - 兼容方法
    * @param {string} key - 键名
    * @param {any} value - 值
    * @returns {Promise<boolean>} - 是否包含
+   * @note 确保操作对象始终被视为数组以保持兼容性
    */
   async list_has(key, value) {
     try {
@@ -1229,8 +1241,26 @@ class CacheBase extends EventEmitter {
       
       // 检查键是否存在且未过期
       if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
+        // 确保将值视为数组
         const list = Array.isArray(this.data[key].value) ? this.data[key].value : [];
-        const result = list.includes(value);
+        
+        // 对于对象类型的值，使用深度比较
+        let result = false;
+        if (typeof value === 'object' && value !== null) {
+          const valueStr = JSON.stringify(value);
+          result = list.some(item => {
+            try {
+              return typeof item === 'object' && item !== null && JSON.stringify(item) === valueStr;
+            } catch (e) {
+              // 如果JSON序列化失败，回退到严格相等
+              return item === value;
+            }
+          });
+        } else {
+          // 对于基本类型，使用严格相等
+          result = list.includes(value);
+        }
+        
         this.emit('list_has_after', { key, value, result });
         return result;
       }
@@ -1245,9 +1275,10 @@ class CacheBase extends EventEmitter {
   }
   
   /**
-   * 获取列表
+   * 获取列表 - 兼容方法
    * @param {string} key - 键名
-   * @returns {Promise<Array>} - 列表数据
+   * @returns {Promise<Array>} - 列表数据，确保始终返回数组类型
+   * @note 确保返回值始终是数组类型以保持兼容性
    */
   async list_get(key) {
     try {
@@ -1255,11 +1286,13 @@ class CacheBase extends EventEmitter {
       
       // 检查键是否存在且未过期
       if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
-        const result = Array.isArray(this.data[key].value) ? this.data[key].value : [];
+        // 确保返回数组类型，如果不是数组则转换为空数组
+        const result = Array.isArray(this.data[key].value) ? [...this.data[key].value] : [];
         this.emit('list_get_after', { key, result });
         return result;
       }
       
+      // 键不存在或已过期时返回空数组
       this.emit('list_get_after', { key, result: [] });
       return [];
     } catch (error) {
@@ -1270,17 +1303,30 @@ class CacheBase extends EventEmitter {
   }
   
   /**
-   * 清空列表
+   * 清空列表 - 兼容方法
    * @param {string} key - 键名
    * @returns {Promise<boolean>} - 是否成功
+   * @note 确保操作对象始终被视为数组以保持兼容性
    */
   async list_clear(key) {
     try {
       this.emit('list_clear_before', { key });
       
-      // 检查键是否存在且未过期
-      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
-        // 将列表清空为[]，保持过期时间不变
+      // 检查键是否存在
+      if (this.data.hasOwnProperty(key)) {
+        // 检查是否过期
+        if (this.data[key].expire > 0 && Date.now() > this.data[key].expire) {
+          // 键已过期，删除键
+          delete this.data[key];
+          const index = this.list.indexOf(key);
+          if (index !== -1) {
+            this.list.splice(index, 1);
+          }
+          this.emit('list_clear_after', { key, result: false });
+          return false;
+        }
+        
+        // 保持过期时间不变，将列表清空为[]
         const expire = this.data[key].expire;
         this.data[key] = {
           value: [],
@@ -1291,8 +1337,19 @@ class CacheBase extends EventEmitter {
         return true;
       }
       
-      this.emit('list_clear_after', { key, result: false });
-      return false;
+      // 键不存在，创建一个新的空列表键
+      this.data[key] = {
+        value: [],
+        expire: 0
+      };
+      
+      // 更新列表
+      if (!this.list.includes(key)) {
+        this.list.push(key);
+      }
+      
+      this.emit('list_clear_after', { key, result: true });
+      return true;
     } catch (error) {
       this.emit('list_clear_error', { key, error });
       $.log.error('[cachebase] list_clear操作失败:', error);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mm_cachebase",
-    "version": "1.8.2",
+    "version": "1.8.4",
     "description": "一个轻量级的本地缓存类库，提供与Redis兼容的API接口，支持过期时间设置、哈希表操作、数值操作、字符串操作等功能，以及完整的事件通知系统和多文件持久化功能。",
     "main": "index.js",
     "scripts": {

package/test_compatibility.js

@@ -1,81 +1,109 @@
-const { CacheBase } = require('./index.js');
+const $ = require('./index');
+const assert = require('assert');
 
-async function testAllMethodsCompatibility() {
-  console.log('测试所有方法兼容性...');
-  const cache = new CacheBase();
+async function runTests() {
+  console.log('开始测试 CacheBase 兼容方法...');
   
-  // 测试list_*方法
-  console.log('\n===== 测试list_*方法 =====');
+  // 创建缓存实例
+  const cache = new $.CacheBase('test_compatibility');
   
-  // list_set测试
-  console.log('\n1. list_set测试');
-  await cache.list_set('list_key', [1, 2, 3]);
-  const list1 = await cache.list_get('list_key');
-  console.log(`list_set('list_key', [1, 2, 3]) 后的值:`, list1);
-  
-  // list_add测试
-  console.log('\n2. list_add测试');
-  await cache.list_add('list_key', 4);
-  const list2 = await cache.list_get('list_key');
-  console.log(`list_add('list_key', 4) 后的值:`, list2);
-  
-  // list_has测试
-  console.log('\n3. list_has测试');
-  const has2 = await cache.list_has('list_key', 2);
-  const has5 = await cache.list_has('list_key', 5);
-  console.log(`list_has('list_key', 2):`, has2);
-  console.log(`list_has('list_key', 5):`, has5);
-  
-  // list_get测试
-  console.log('\n4. list_get测试');
-  const list3 = await cache.list_get('list_key');
-  console.log(`list_get('list_key'):`, list3);
-  
-  // list_clear测试
-  console.log('\n5. list_clear测试');
-  await cache.list_clear('list_key');
-  const list4 = await cache.list_get('list_key');
-  console.log(`list_clear('list_key') 后的值:`, list4);
-  
-  // 测试add方法
-  console.log('\n===== 测试add方法 =====');
-  
-  // 重置缓存
-  await cache.clear();
-  
-  // 测试1: 键不存在时设置数值
-  console.log('\n1. 键不存在时设置数值');
-  const result1 = await cache.add('num_key', 10);
-  console.log(`add('num_key', 10) =`, result1);
-  console.log(`get('num_key') =`, await cache.get('num_key'));
-  
-  // 测试2: 键存在时增加值
-  console.log('\n2. 键存在时增加值');
-  const result2 = await cache.add('num_key', 5);
-  console.log(`add('num_key', 5) =`, result2);
-  console.log(`get('num_key') =`, await cache.get('num_key'));
-  
-  // 测试3: 字符串形式的数字
-  console.log('\n3. 字符串形式的数字');
-  const result3 = await cache.add('num_key2', '123');
-  console.log(`add('num_key2', '123') =`, result3);
-  console.log(`get('num_key2') =`, await cache.get('num_key2'));
-  
-  // 测试4: 非数值字符串（应该抛出错误）
-  console.log('\n4. 非数值字符串');
   try {
-    await cache.add('num_key3', 'abc');
+    // 测试 list_* 方法
+    console.log('\n=== 测试 list_* 方法 ===');
+    
+    // 测试 list_set - 确保值始终是数组类型
+    await cache.list_set('list1', 'single value');
+    let result = await cache.list_get('list1');
+    console.log('list_set 单值测试:', Array.isArray(result), result);
+    assert.strictEqual(Array.isArray(result), true, 'list_set 应确保值是数组类型');
+    assert.strictEqual(result.length, 1, 'list_set 应将单值包装成数组');
+    
+    // 测试 list_set - 数组值
+    await cache.list_set('list2', [1, 2, 3]);
+    result = await cache.list_get('list2');
+    console.log('list_set 数组测试:', Array.isArray(result), result);
+    assert.strictEqual(Array.isArray(result), true, 'list_set 应保持数组类型');
+    assert.strictEqual(result.length, 3, 'list_set 应正确存储数组');
+    
+    // 测试 list_add - 向空列表添加
+    await cache.list_add('list3', 'item1');
+    result = await cache.list_get('list3');
+    console.log('list_add 空列表测试:', result);
+    assert.strictEqual(result.length, 1, 'list_add 应向空列表添加元素');
+    
+    // 测试 list_add - 向现有列表添加
+    await cache.list_add('list3', 'item2');
+    result = await cache.list_get('list3');
+    console.log('list_add 现有列表测试:', result);
+    assert.strictEqual(result.length, 2, 'list_add 应向现有列表添加元素');
+    
+    // 测试 list_has - 基本类型
+    let hasValue = await cache.list_has('list3', 'item1');
+    console.log('list_has 基本类型测试:', hasValue);
+    assert.strictEqual(hasValue, true, 'list_has 应正确检测基本类型');
+    
+    // 测试 list_has - 对象类型
+    const objValue = { name: 'test', value: 123 };
+    await cache.list_add('list4', objValue);
+    hasValue = await cache.list_has('list4', { name: 'test', value: 123 });
+    console.log('list_has 对象类型测试:', hasValue);
+    assert.strictEqual(hasValue, true, 'list_has 应正确检测对象类型');
+    
+    // 测试 list_clear - 清空现有列表
+    result = await cache.list_clear('list3');
+    console.log('list_clear 现有列表测试:', result);
+    assert.strictEqual(result, true, 'list_clear 应对现有列表返回 true');
+    result = await cache.list_get('list3');
+    assert.strictEqual(Array.isArray(result), true, 'list_clear 后应返回数组');
+    assert.strictEqual(result.length, 0, 'list_clear 应清空列表');
+    
+    // 测试 list_clear - 不存在的键
+    result = await cache.list_clear('nonexistent_list');
+    console.log('list_clear 不存在键测试:', result);
+    assert.strictEqual(result, true, 'list_clear 应对不存在的键创建空列表并返回 true');
+    result = await cache.list_get('nonexistent_list');
+    assert.strictEqual(Array.isArray(result), true, 'list_clear 后应创建空数组');
+    
+    // 测试 hdel 方法
+    console.log('\n=== 测试 hdel 方法 ===');
+    
+    // 创建哈希表
+    await cache.hset('hash1', 'field1', 'value1');
+    await cache.hset('hash1', 'field2', 'value2');
+    
+    // 测试 hdel - 存在的字段
+    result = await cache.hdel('hash1', 'field1');
+    console.log('hdel 存在字段测试:', result);
+    assert.strictEqual(result, 0, 'hdel 应始终返回 0 以保持兼容性');
+    
+    // 验证字段已被删除
+    let hashValue = await cache.hget('hash1', 'field1');
+    assert.strictEqual(hashValue, undefined, 'hdel 应实际删除字段');
+    
+    // 测试 hdel - 不存在的字段
+    result = await cache.hdel('hash1', 'nonexistent_field');
+    console.log('hdel 不存在字段测试:', result);
+    assert.strictEqual(result, 0, 'hdel 应对不存在的字段返回 0');
+    
+    // 测试 hdel - 不存在的键
+    result = await cache.hdel('nonexistent_hash', 'field');
+    console.log('hdel 不存在键测试:', result);
+    assert.strictEqual(result, 0, 'hdel 应对不存在的键返回 0');
+    
+    console.log('\n所有测试通过!');
   } catch (error) {
-    console.log(`预期的错误:`, error.message);
+    console.error('测试失败:', error.message);
+    throw error;
+  } finally {
+    // 清理测试数据
+    await cache.clear();
+    await cache.dispose();
+    console.log('\n测试完成，已清理数据');
   }
-  
-  // 测试5: 带过期时间
-  console.log('\n5. 带过期时间');
-  const result5 = await cache.add('num_key4', 100, 3); // 3秒过期
-  console.log(`add('num_key4', 100, 3) =`, result5);
-  console.log(`ttl('num_key4') =`, await cache.ttl('num_key4'));
-  
-  console.log('\n所有方法兼容性测试完成！');
 }
 
-testAllMethodsCompatibility().catch(console.error);
+// 运行测试
+runTests().catch(error => {
+  console.error('测试执行失败:', error);
+  process.exit(1);
+});