nodejieba-plus 3.5.11 → 3.5.13

package/README.md

@@ -191,7 +191,7 @@ console.log(nodejieba.cut("男默女泪"));
 
 ### 批量加载用户词典（新功能）
 
-支持通过字符串数组、单个字符串或 Buffer 批量加载用户词典：
+支持通过字符串数组、Set、单个字符串或 Buffer 批量加载用户词典：
 
 ```js
 var nodejieba = require("nodejieba");
@@ -200,10 +200,18 @@ nodejieba.load();
 // 方式1：使用字符串数组
 nodejieba.loadUserDict(["云计算", "人工智能 1000 nz", "大数据"]);
 
-// 方式2：使用单个字符串
+// 方式2：使用 Set 集合（自动去重）
+const dictSet = new Set();
+dictSet.add("云计算");
+dictSet.add("人工智能 1000 nz");
+dictSet.add("大数据");
+dictSet.add("云计算"); // 重复添加会被自动去重
+nodejieba.loadUserDict(dictSet);
+
+// 方式3：使用单个字符串
 nodejieba.loadUserDict("区块链");
 
-// 方式3：使用 Buffer
+// 方式4：使用 Buffer
 const dictBuffer = Buffer.from("新词1\n新词2 100 n\n新词3 nz");
 nodejieba.loadUserDict(dictBuffer);
 

package/index.js

@@ -75,4 +75,21 @@ wrapWithDictLoad("textRankExtract");
 wrapWithDictLoad("insertWord");
 wrapWithDictLoad("loadUserDict");
 
+// 保存原始的 loadUserDict 函数
+var _loadUserDict = exports.loadUserDict;
+
+// 重写 loadUserDict 以支持 Set 格式
+exports.loadUserDict = function (dict) {
+  if (!isDictLoaded) {
+    exports.load();
+  }
+  
+  // 如果是 Set 对象，转换为数组
+  if (dict instanceof Set) {
+    dict = Array.from(dict);
+  }
+  
+  return _loadUserDict.call(this, dict);
+};
+
 module.exports = exports;

package/lib/nodejieba.cpp

@@ -229,14 +229,18 @@ Napi::Value NodeJieba::loadUserDict(const Napi::CallbackInfo& info) {
     Napi::Error::New(info.Env(), "Before calling any other function you have to call load() first").ThrowAsJavaScriptException();
   }
 
-  // 支持传入字符串数组或单个字符串（Buffer）
+  // 支持传入字符串数组、单个字符串或 Buffer
   if (info[0].IsArray()) {
     Napi::Array arr = info[0].As<Napi::Array>();
     std::vector<std::string> buf;
     for (size_t i = 0; i < arr.Length(); i++) {
       Napi::Value val = arr[i];
       if (val.IsString()) {
-        buf.push_back(val.As<Napi::String>().Utf8Value());
+        std::string line = val.As<Napi::String>().Utf8Value();
+        // 过滤空字符串，避免断言失败
+        if (!line.empty()) {
+          buf.push_back(line);
+        }
       }
     }
     _jieba_handle->LoadUserDict(buf);
@@ -244,8 +248,11 @@ Napi::Value NodeJieba::loadUserDict(const Napi::CallbackInfo& info) {
     // 支持传入单个词典条目字符串
     std::string line = info[0].As<Napi::String>().Utf8Value();
     std::vector<std::string> buf;
-    buf.push_back(line);
-    _jieba_handle->LoadUserDict(buf);
+    // 过滤空字符串
+    if (!line.empty()) {
+      buf.push_back(line);
+      _jieba_handle->LoadUserDict(buf);
+    }
   } else if (info[0].IsBuffer()) {
     // 支持传入 Buffer，将其转换为字符串并按行分割
     Napi::Buffer<char> buffer = info[0].As<Napi::Buffer<char>>();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nodejieba-plus",
   "description": "chinese word segmentation for node",
-  "version": "3.5.11",
+  "version": "3.5.13",
   "author": "Yanyi Wu <wuyanyi09@foxmail.com>",
   "maintainers": [
     "Yanyi Wu <wuyanyi09@foxmail.com>"

package/submodules/cppjieba/include/cppjieba/DictTrie.hpp

@@ -10,7 +10,6 @@
 #include <stdint.h>
 #include <cmath>
 #include <limits>
-#include <algorithm>
 #include "limonp/StringUtil.hpp"
 #include "limonp/Logging.hpp"
 #include "Unicode.hpp"
@@ -113,97 +112,26 @@ class DictTrie {
     vector<string> buf;
     DictUnit node_info;
     Split(line, buf, " ");
-    
-    string word;
-    string tag = UNKNOWN_TAG;
-    double weight = user_word_default_weight_;
-    bool hasSpace = false;
-    
-    // 处理包含空格的关键词
-    // 格式可能是: "word" 或 "word tag" 或 "word freq tag"
-    // 其中 word 本身可能包含空格
-    if (buf.size() == 1) {
-      // 只有关键词，无词频和标签
-      word = buf[0];
-    } else if (buf.size() == 2) {
-      // 可能是 "word tag" 或 "word1 word2"
-      // 检查第二个字段是否为数字（词频）
-      bool isNumber = true;
-      for (char c : buf[1]) {
-        if (!isdigit(c)) {
-          isNumber = false;
-          break;
+    if(buf.size() == 1){
+          MakeNodeInfo(node_info, 
+                buf[0], 
+                user_word_default_weight_,
+                UNKNOWN_TAG);
+        } else if (buf.size() == 2) {
+          MakeNodeInfo(node_info, 
+                buf[0], 
+                user_word_default_weight_,
+                buf[1]);
+        } else if (buf.size() == 3) {
+          int freq = atoi(buf[1].c_str());
+          assert(freq_sum_ > 0.0);
+          double weight = log(1.0 * freq / freq_sum_);
+          MakeNodeInfo(node_info, buf[0], weight, buf[2]);
         }
-      }
-      if (isNumber) {
-        // "word freq" 格式，无标签
-        int freq = atoi(buf[1].c_str());
-        assert(freq_sum_ > 0.0);
-        weight = log(1.0 * freq / freq_sum_);
-        word = buf[0];
-      } else {
-        // "word tag" 格式
-        word = buf[0];
-        tag = buf[1];
-      }
-    } else {
-      // 检查最后两个字段：可能是 "... word freq tag" 或 "... word1 word2 tag" 等
-      // 倒数第二个如果是数字，则认为是词频，最后一个是标签
-      // 否则认为只有最后一个是标签，前面都是关键词
-      bool isFreq = true;
-      for (char c : buf[buf.size() - 2]) {
-        if (!isdigit(c)) {
-          isFreq = false;
-          break;
-        }
-      }
-      
-      if (isFreq) {
-        // 格式: "word... freq tag"
-        int freq = atoi(buf[buf.size() - 2].c_str());
-        assert(freq_sum_ > 0.0);
-        weight = log(1.0 * freq / freq_sum_);
-        // 前面的所有部分（除了最后两个）组成关键词
-        for (size_t i = 0; i < buf.size() - 2; ++i) {
-          if (i > 0) word += " ";
-          word += buf[i];
-        }
-        tag = buf[buf.size() - 1];
-      } else {
-        // 格式: "word... tag" (无词频)
-        // 前面的所有部分（除了最后一个）组成关键词
-        for (size_t i = 0; i < buf.size() - 1; ++i) {
-          if (i > 0) word += " ";
-          word += buf[i];
-        }
-        tag = buf[buf.size() - 1];
-      }
-    }
-    
-    // 检查词中是否包含空格
-    hasSpace = (word.find(' ') != string::npos);
-    
-    // 添加原始词（包含空格版本）
-    MakeNodeInfo(node_info, word, weight, tag);
-    static_node_infos_.push_back(node_info);
-    if (node_info.word.size() == 1) {
-      user_dict_single_chinese_word_.insert(node_info.word[0]);
-    }
-    
-    // 如果词包含空格，同时添加无空格版本
-    if (hasSpace) {
-      string wordNoSpace = word;
-      // 移除所有空格
-      wordNoSpace.erase(remove(wordNoSpace.begin(), wordNoSpace.end(), ' '), wordNoSpace.end());
-      if (!wordNoSpace.empty() && wordNoSpace != word) {
-        DictUnit node_info_no_space;
-        MakeNodeInfo(node_info_no_space, wordNoSpace, weight, tag);
-        static_node_infos_.push_back(node_info_no_space);
-        if (node_info_no_space.word.size() == 1) {
-          user_dict_single_chinese_word_.insert(node_info_no_space.word[0]);
+        static_node_infos_.push_back(node_info);
+        if (node_info.word.size() == 1) {
+          user_dict_single_chinese_word_.insert(node_info.word[0]);
         }
-      }
-    }
   }
   
   void LoadUserDict(const vector<string>& buf) {
@@ -287,36 +215,12 @@ class DictTrie {
     DictUnit node_info;
     while (getline(ifs, line)) {
       Split(line, buf, " ");
-      // 支持包含空格的关键词
-      // 格式: "word weight tag" 或 "word1 word2 weight tag" 等
-      // 最后两个字段是 weight 和 tag，前面的都是关键词
-      if (buf.size() >= DICT_COLUMN_NUM) {
-        // 组合前面的字段作为关键词
-        string word;
-        for (size_t i = 0; i < buf.size() - 2; ++i) {
-          if (i > 0) word += " ";
-          word += buf[i];
-        }
-        double weight = atof(buf[buf.size() - 2].c_str());
-        string tag = buf[buf.size() - 1];
-        
-        // 添加原始词（包含空格版本）
-        MakeNodeInfo(node_info, word, weight, tag);
-        static_node_infos_.push_back(node_info);
-        
-        // 如果词包含空格，同时添加无空格版本
-        if (word.find(' ') != string::npos) {
-          string wordNoSpace = word;
-          wordNoSpace.erase(remove(wordNoSpace.begin(), wordNoSpace.end(), ' '), wordNoSpace.end());
-          if (!wordNoSpace.empty() && wordNoSpace != word) {
-            DictUnit node_info_no_space;
-            MakeNodeInfo(node_info_no_space, wordNoSpace, weight, tag);
-            static_node_infos_.push_back(node_info_no_space);
-          }
-        }
-      } else {
-        XCHECK(buf.size() == DICT_COLUMN_NUM) << "split result illegal, line:" << line;
-      }
+      XCHECK(buf.size() == DICT_COLUMN_NUM) << "split result illegal, line:" << line;
+      MakeNodeInfo(node_info, 
+            buf[0], 
+            atof(buf[1].c_str()), 
+            buf[2]);
+      static_node_infos_.push_back(node_info);
     }
   }
 

package/submodules/cppjieba/include/cppjieba/SegmentBase.hpp

@@ -8,9 +8,7 @@
 
 namespace cppjieba {
 
-// 修改分隔符，移除空格，只保留其他分隔符
-// 这样英文单词之间的空格不会被当作分隔符
-const char* const SPECIAL_SEPARATORS = "\t\n\xEF\xBC\x8C\xE3\x80\x82";
+const char* const SPECIAL_SEPARATORS = " \t\n\xEF\xBC\x8C\xE3\x80\x82";
 
 using namespace limonp;
 

package/submodules/cppjieba/include/cppjieba/Unicode.hpp

@@ -92,10 +92,6 @@ inline RuneStrLite DecodeUTF8ToRune(const char* str, size_t len) {
   if (!(str[0] & 0x80)) { // 0xxxxxxx
     // 7bit, total 7bit
     rp.rune = (uint8_t)(str[0]) & 0x7f;
-    // 将大写英文字母转换为小写，实现大小写不敏感匹配
-    if (rp.rune >= 'A' && rp.rune <= 'Z') {
-      rp.rune = rp.rune - 'A' + 'a';
-    }
     rp.len = 1;
   } else if ((uint8_t)str[0] <= 0xdf &&  1 < len) { 
     // 110xxxxxx

package/test/load_user_dict_test.js

@@ -55,4 +55,36 @@ describe("nodejieba.loadUserDict", function() {
     result.should.containEql('云计算');
     result.should.containEql('人工智能');
   });
+
+  it("nodejieba.loadUserDict with Set should return true", function() {
+    const dictSet = new Set();
+    dictSet.add("非常独特的测试词123");
+    dictSet.add("另一个独特测试词 100 n");
+    
+    var loadResult = nodejieba.loadUserDict(dictSet);
+    loadResult.should.eql(true);
+  });
+
+  it("nodejieba.loadUserDict with Set should automatically deduplicate", function() {
+    const dictSet = new Set();
+    dictSet.add("去重专用测试词");
+    dictSet.add("去重专用测试词"); // 重复添加
+    dictSet.add("去重专用测试词"); // 再次重复添加
+    
+    var loadResult = nodejieba.loadUserDict(dictSet);
+    loadResult.should.eql(true);
+  });
+
+  it("nodejieba.loadUserDict should filter empty strings", function() {
+    // 测试空字符串被过滤，不会导致断言失败
+    var dictLines = [
+      "有效词1",
+      "",  // 空字符串
+      "有效词2",
+      "",  // 空字符串
+      "   "  // 只有空格的字符串（也会被保留，因为不是完全空）
+    ];
+    var loadResult = nodejieba.loadUserDict(dictLines);
+    loadResult.should.eql(true);
+  });
 });

package/types/index.d.ts

@@ -27,5 +27,5 @@ declare module "nodejieba" {
   export function textRankExtract(sentence: string, threshold: number): ExtractResult[];
   export function insertWord(word: string, tag?: string): boolean;
   export function cutSmall(sentence: string, small: number): string[];
-  export function loadUserDict(dict: string | string[] | Buffer): boolean;
+  export function loadUserDict(dict: string | string[] | Set<string> | Buffer): boolean;
 }

package/test_open_claw.js

@@ -1,65 +0,0 @@
-// 测试 "open claw" 关键词提取问题
-
-var nodejieba = require("./index.js");
-
-// 测试句子
-var sentence = "Node.js在Web开发中的应用与实践Open Claw，这句测试的话，关键词是\"open claw\"";
-
-console.log("=".repeat(60));
-console.log("测试句子:", sentence);
-console.log("=".repeat(60));
-
-// 1. 先进行分词测试
-console.log("\n【1. 分词结果】");
-var cutResult = nodejieba.cut(sentence);
-console.log("cut:", cutResult);
-
-// 2. 关键词提取测试
-console.log("\n【2. 关键词提取 (extract)】");
-var keywords = nodejieba.extract(sentence, 10);
-console.log("提取的关键词:");
-keywords.forEach(function(kw) {
-  console.log("  - " + kw.word + " (权重: " + kw.weight + ")");
-});
-
-// 3. TextRank 关键词提取测试
-console.log("\n【3. TextRank 关键词提取】");
-var textRankKeywords = nodejieba.textRankExtract(sentence, 10);
-console.log("提取的关键词:");
-textRankKeywords.forEach(function(kw) {
-  console.log("  - " + kw.word + " (权重: " + kw.weight + ")");
-});
-
-// 4. 检查是否包含 "open claw"
-console.log("\n【4. 检查结果】");
-var hasOpenClaw = keywords.some(function(kw) {
-  return kw.word.toLowerCase() === "open claw";
-});
-console.log("是否提取到 'open claw':", hasOpenClaw);
-
-// 5. 添加自定义词后再次测试
-console.log("\n【5. 添加自定义词后测试】");
-nodejieba.insertWord("open claw");
-console.log("已添加自定义词: open claw");
-
-var cutResult2 = nodejieba.cut(sentence);
-console.log("\n再次分词结果:");
-console.log("cut:", cutResult2);
-
-var keywords2 = nodejieba.extract(sentence, 10);
-console.log("\n再次提取关键词:");
-keywords2.forEach(function(kw) {
-  console.log("  - " + kw.word + " (权重: " + kw.weight + ")");
-});
-
-var hasOpenClaw2 = keywords2.some(function(kw) {
-  return kw.word.toLowerCase() === "open claw";
-});
-console.log("\n是否提取到 'open claw':", hasOpenClaw2);
-
-console.log("\n" + "=".repeat(60));
-console.log("问题分析:");
-console.log("1. jieba 分词器默认基于中文语料训练，对英文词汇识别有限");
-console.log("2. 'Open Claw' 作为英文词组，默认词典中不存在");
-console.log("3. 解决方案: 使用 insertWord() 方法添加自定义词");
-console.log("=".repeat(60));