nodejieba-plus 3.5.10 → 3.5.12

package/README.md

@@ -27,6 +27,7 @@
 + **支持包含空格的关键词**（如 "Open Claw"）。
 + **支持无空格版本匹配**（如 "OpenClaw" 可匹配 "Open Claw"）。
 + **支持英文大小写不敏感匹配**（如 "open claw"、"OPEN CLAW" 都可匹配 "Open Claw"）。
++ **支持批量加载用户词典**（字符串数组、单个字符串、Buffer 格式）。
 
 对实现细节感兴趣的请看如下博文：
 
@@ -188,6 +189,55 @@ console.log(nodejieba.cut("男默女泪"));
 // ["男默女泪"]
 ```
 
+### 批量加载用户词典（新功能）
+
+支持通过字符串数组、Set、单个字符串或 Buffer 批量加载用户词典：
+
+```js
+var nodejieba = require("nodejieba");
+nodejieba.load();
+
+// 方式1：使用字符串数组
+nodejieba.loadUserDict(["云计算", "人工智能 1000 nz", "大数据"]);
+
+// 方式2：使用 Set 集合（自动去重）
+const dictSet = new Set();
+dictSet.add("云计算");
+dictSet.add("人工智能 1000 nz");
+dictSet.add("大数据");
+dictSet.add("云计算"); // 重复添加会被自动去重
+nodejieba.loadUserDict(dictSet);
+
+// 方式3：使用单个字符串
+nodejieba.loadUserDict("区块链");
+
+// 方式4：使用 Buffer
+const dictBuffer = Buffer.from("新词1\n新词2 100 n\n新词3 nz");
+nodejieba.loadUserDict(dictBuffer);
+
+// 分词时会识别用户词典中的词
+var result = nodejieba.cut("云计算和大数据是人工智能的基础");
+console.log(result); // ['云计算', '和', '大数据', '是', '人工智能', '的', '基础']
+```
+
+#### 词典条目格式
+
+词典条目支持以下格式：
+
+```
+# 仅关键词
+云计算
+
+# 关键词 + 词频
+人工智能 1000
+
+# 关键词 + 词性标签
+区块链 nz
+
+# 关键词 + 词频 + 词性标签
+大数据 500 n
+```
+
 ### 包含空格的关键词（新功能）
 
 支持在自定义词典中使用包含空格的关键词，且支持无空格版本匹配和大小写不敏感匹配。

package/index.js

@@ -73,5 +73,23 @@ wrapWithDictLoad("tag");
 wrapWithDictLoad("extract");
 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

@@ -6,6 +6,8 @@
 #include "cppjieba/KeywordExtractor.hpp"
 #include "cppjieba/TextRankExtractor.hpp"
 
+#include <sstream>
+
 NodeJieba::NodeJieba(Napi::Env env, Napi::Object exports) {
   DefineAddon(exports, {
     InstanceMethod("load", &NodeJieba::load),
@@ -17,7 +19,8 @@ NodeJieba::NodeJieba(Napi::Env env, Napi::Object exports) {
     InstanceMethod("tag", &NodeJieba::tag),
     InstanceMethod("extract", &NodeJieba::extract),
     InstanceMethod("textRankExtract", &NodeJieba::textRankExtract),
-    InstanceMethod("insertWord", &NodeJieba::insertWord)
+    InstanceMethod("insertWord", &NodeJieba::insertWord),
+    InstanceMethod("loadUserDict", &NodeJieba::loadUserDict)
   });
 }
 
@@ -216,3 +219,49 @@ Napi::Value NodeJieba::textRankExtract(const Napi::CallbackInfo& info) {
   WrapPairVector(info.Env(), words, outArray);
   return outArray;
 }
+
+Napi::Value NodeJieba::loadUserDict(const Napi::CallbackInfo& info) {
+  if (info.Length() < 1) {
+    return Napi::Boolean::New(info.Env(), false);
+  }
+
+  if( !_jieba_handle ){
+    Napi::Error::New(info.Env(), "Before calling any other function you have to call load() first").ThrowAsJavaScriptException();
+  }
+
+  // 支持传入字符串数组、单个字符串或 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());
+      }
+    }
+    _jieba_handle->LoadUserDict(buf);
+  } else if (info[0].IsString()) {
+    // 支持传入单个词典条目字符串
+    std::string line = info[0].As<Napi::String>().Utf8Value();
+    std::vector<std::string> buf;
+    buf.push_back(line);
+    _jieba_handle->LoadUserDict(buf);
+  } else if (info[0].IsBuffer()) {
+    // 支持传入 Buffer，将其转换为字符串并按行分割
+    Napi::Buffer<char> buffer = info[0].As<Napi::Buffer<char>>();
+    std::string content(buffer.Data(), buffer.Length());
+    std::vector<std::string> buf;
+    std::istringstream iss(content);
+    std::string line;
+    while (std::getline(iss, line)) {
+      if (!line.empty()) {
+        buf.push_back(line);
+      }
+    }
+    _jieba_handle->LoadUserDict(buf);
+  } else {
+    return Napi::Boolean::New(info.Env(), false);
+  }
+
+  return Napi::Boolean::New(info.Env(), true);
+}

package/lib/nodejieba.h

@@ -20,6 +20,7 @@ private:
   Napi::Value extract(const Napi::CallbackInfo& info);
   Napi::Value textRankExtract(const Napi::CallbackInfo& info);
   Napi::Value insertWord(const Napi::CallbackInfo& info);
+  Napi::Value loadUserDict(const Napi::CallbackInfo& info);
 
   cppjieba::Jieba* _jieba_handle{nullptr};
   cppjieba::TextRankExtractor* _text_rank_extractor_handle{nullptr};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nodejieba-plus",
   "description": "chinese word segmentation for node",
-  "version": "3.5.10",
+  "version": "3.5.12",
   "author": "Yanyi Wu <wuyanyi09@foxmail.com>",
   "maintainers": [
     "Yanyi Wu <wuyanyi09@foxmail.com>"
@@ -33,7 +33,7 @@
     "typescript": "^5.0.4"
   },
   "scripts": {
-    "test": "mocha --timeout 10s -R spec test/test.js && mocha --timeout 10s -R spec test/load_dict_test.js && mocha --timeout 10s -R spec test/missing_binding_test.js",
+    "test": "mocha --timeout 10s -R spec test/test.js && mocha --timeout 10s -R spec test/load_dict_test.js && mocha --timeout 10s -R spec test/load_user_dict_test.js && mocha --timeout 10s -R spec test/missing_binding_test.js",
     "install": "npx @mapbox/node-pre-gyp install --fallback-to-build",
     "rebuild": "npx @mapbox/node-pre-gyp rebuild"
   },

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

@@ -0,0 +1,77 @@
+var should = require("should");
+var nodejieba = require("../index.js");
+
+describe("nodejieba.loadUserDict", function() {
+
+  // 确保在测试前加载词典
+  before(function() {
+    nodejieba.load();
+  });
+
+  it("nodejieba.loadUserDict with string array should return true", function() {
+    // 使用字符串数组加载用户词典
+    var dictLines = [
+      "测试新词",
+      "自定义词汇 10 n"
+    ];
+    var loadResult = nodejieba.loadUserDict(dictLines);
+    loadResult.should.eql(true);
+  });
+
+  it("nodejieba.loadUserDict with single string should return true", function() {
+    // 加载单个词典条目
+    var loadResult = nodejieba.loadUserDict("单个词");
+    loadResult.should.eql(true);
+  });
+
+  it("nodejieba.loadUserDict with Buffer should return true", function() {
+    // 使用 Buffer 加载用户词典
+    var dictContent = Buffer.from("Buffer词 100 nz\n另一个词");
+    var loadResult = nodejieba.loadUserDict(dictContent);
+    loadResult.should.eql(true);
+  });
+
+  it("nodejieba.loadUserDict should return false when no argument", function() {
+    var loadResult = nodejieba.loadUserDict();
+    loadResult.should.eql(false);
+  });
+
+  it("nodejieba.loadUserDict with tag should return true", function() {
+    // 测试带标签的词典条目
+    var dictLines = [
+      "技术术语 500 nz"
+    ];
+    var result = nodejieba.loadUserDict(dictLines);
+    result.should.eql(true);
+  });
+
+  it("nodejieba.loadUserDict should work after loading words", function() {
+    // 先加载一些用户词典 - 使用比较独特的词确保测试准确性
+    nodejieba.loadUserDict(["云计算"]);
+    nodejieba.loadUserDict("人工智能 1000 nz");
+    
+    // 验证这些词被正确识别
+    var result = nodejieba.cut("云计算是人工智能的基础");
+    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);
+  });
+});

package/types/index.d.ts

@@ -27,4 +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[] | Set<string> | Buffer): boolean;
 }