0

src/api/yjbdc/aiController.js

@@ -123,6 +123,71 @@ class OpenAIProvider extends AIProvider {
     }
 }
 
+/**
+ * 阿里云通义平台实现
+ */
+class AliyunAIProvider extends AIProvider {
+    constructor(model = 'qwen-plus') {
+        super();
+
+        this.accessKey = config.aliyun.accessKey;
+        this.headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json"
+        };
+        this.url = "https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions";
+        this.model = model;
+    }
+
+    /**
+     * 生成文章
+     * @param {string} content - 生成文章的提示内容
+     * @returns {Promise<string>} - 返回生成的文章内容
+     */
+    async generateArticle(content) {
+        // 设置请求头中的API密钥
+        this.headers["Authorization"] = `Bearer ${this.accessKey}`;
+        
+        const postJSON = {
+            "model": this.model,
+            "messages": [
+                {
+                    "role": "user",
+                    "content": content
+                }
+            ],
+            "temperature": 0.7,
+            "top_p": 0.8
+        };
+
+        try {
+            console.log(`阿里云通义 ${this.model}`);
+            const response = await axios.post(this.url, postJSON, { headers: this.headers });
+            
+            // 根据阿里云通义API的返回格式提取内容
+            if (response.data && response.data.choices && response.data.choices[0] && response.data.choices[0].message) {
+                let responseContent = response.data.choices[0].message.content;
+                
+                // 处理可能的Markdown代码块标记
+                if (responseContent.startsWith('```json') || responseContent.startsWith('```')) {
+                    console.log("阿里云返回了Markdown代码块，正在处理...");
+                    // 移除开头的```json或```
+                    responseContent = responseContent.replace(/^```(?:json)?\s*\n/, '');
+                    // 移除结尾的```
+                    responseContent = responseContent.replace(/\n```\s*$/, '');
+                }
+                
+                return responseContent;
+            } else {
+                throw new Error("Unexpected response format from Aliyun API");
+            }
+        } catch (error) {
+            console.error("Aliyun AI API error:", error);
+            throw error;
+        }
+    }
+}
+
 /**
  * 百度文心一言平台实现
  */
@@ -195,6 +260,12 @@ class AIProviderFactory {
             return new VolcesAIProvider(version);
         }
         
+        // 处理阿里云通义通用提供者格式：aliyun:模型名
+        if (providerLower.startsWith('aliyun:')) {
+            const model = providerLower.split(':')[1];
+            return new AliyunAIProvider(model);
+        }
+        
         // 处理传统提供者名称
         switch (providerLower) {
             case 'volces':
@@ -204,8 +275,12 @@ class AIProviderFactory {
                 return new VolcesAIProvider1_6('1-6');
             case 'openai':
                 return new OpenAIProvider();
+            case 'qwen-plus':
+                return new AliyunAIProvider();
             case 'baidu':
                 return new BaiduAIProvider();
+            case 'aliyun':
+                return new AliyunAIProvider(); // 默认使用qwen-turbo模型
             default:
                 return new VolcesAIProvider('1-5'); // 默认使用火山云1.5
         }
@@ -235,15 +310,43 @@ async function generateArticle(content, provider = 'volces1-5') {
  * @returns {string} - 返回修复后的JSON字符串
  */
 function validateAndFixJSON(jsonString) {
+    // 如果输入不是字符串，直接返回
+    if (typeof jsonString !== 'string') {
+        console.error("输入不是字符串类型");
+        return jsonString;
+    }
+    
+    // 预处理：移除Markdown代码块标记
+    let processedJson = jsonString;
+    
+    // 检查并移除Markdown代码块标记
+    if (processedJson.includes('```')) {
+        console.log("检测到Markdown代码块，尝试移除标记");
+        
+        // 处理可能的多行代码块
+        const codeBlockRegex = /```(?:json)?\s*\n([\s\S]*?)\n```/;
+        const match = processedJson.match(codeBlockRegex);
+        
+        if (match && match[1]) {
+            // 提取代码块内容
+            processedJson = match[1];
+            console.log("成功提取代码块内容");
+        } else {
+            // 如果正则匹配失败，尝试简单替换
+            processedJson = processedJson.replace(/^```(?:json)?\s*\n/, '');
+            processedJson = processedJson.replace(/\n```\s*$/, '');
+        }
+    }
+    
     try {
         // 尝试解析JSON
-        const parsed = JSON.parse(jsonString);
-        return jsonString;
+        const parsed = JSON.parse(processedJson);
+        return processedJson;
     } catch (error) {
         console.error("JSON解析错误，尝试修复:", error);
         
         // 尝试修复常见的JSON错误
-        let fixedJson = jsonString;
+        let fixedJson = processedJson;
         
         // 修复缺少引号的键
         fixedJson = fixedJson.replace(/(\s*?)(\w+)(\s*?):/g, '"$2":');
@@ -262,7 +365,23 @@ function validateAndFixJSON(jsonString) {
             return fixedJson;
         } catch (error2) {
             console.error("JSON修复失败:", error2);
-            // 如果修复失败，返回原始字符串
+            
+            // 最后尝试：如果内容看起来像JSON但解析失败，尝试提取{}之间的内容
+            const jsonObjectRegex = /\{[\s\S]*\}/;
+            const objectMatch = jsonString.match(jsonObjectRegex);
+            
+            if (objectMatch) {
+                try {
+                    const extractedJson = objectMatch[0];
+                    JSON.parse(extractedJson);
+                    console.log("通过提取{}内容成功修复JSON");
+                    return extractedJson;
+                } catch (error3) {
+                    console.error("提取{}内容后仍解析失败");
+                }
+            }
+            
+            // 如果所有尝试都失败，返回原始字符串
             return jsonString;
         }
     }

src/api/yjbdc/enhanceFormsOfWords.js

@@ -84,6 +84,193 @@ export function enhanceFormsOfWords(jsonObj, userWords) {
     // 常见的后缀列表
     const commonSuffixes = ['ed', 'ing', 's', 'es', 'er', 'est', 'ly'];
     
+    /**
+     * 检查单词是否符合特定的变形规则
+     * @param {string} word - 要检查的单词
+     * @param {string} base - 基本形式
+     * @returns {boolean} - 是否符合变形规则
+     */
+    function checkSpecialWordForms(word, base) {
+        // 处理以y结尾的单词变为复数时，y变为ies的情况 (如cry -> cries)
+        if (base.endsWith('y') && word === base.slice(0, -1) + 'ies') {
+            return true;
+        }
+        
+        // 处理以fe结尾的单词变为复数时，fe变为ves的情况 (如knife -> knives)
+        if (base.endsWith('fe') && word === base.slice(0, -2) + 'ves') {
+            return true;
+        }
+        
+        // 处理以f结尾的单词变为复数时，f变为ves的情况 (如leaf -> leaves)
+        if (base.endsWith('f') && word === base.slice(0, -1) + 'ves') {
+            return true;
+        }
+        
+        // 处理常规的第三人称单数形式（动词后加s或es）
+        if (word === base + 's' || word === base + 'es') {
+            return true;
+        }
+        
+        // 处理反向情况：如果base是word加s或es
+        if (base === word + 's' || base === word + 'es') {
+            return true;
+        }
+        
+        // 处理动词的过去式和过去分词
+        // 常规动词加-ed
+        if (word === base + 'ed') {
+            return true;
+        }
+        // 以e结尾的动词加-d
+        if (base.endsWith('e') && word === base + 'd') {
+            return true;
+        }
+        // 以辅音+y结尾的动词，y变i再加-ed
+        if (base.length > 1 && 
+            base.endsWith('y') && 
+            !'aeiou'.includes(base.charAt(base.length - 2)) && 
+            word === base.slice(0, -1) + 'ied') {
+            return true;
+        }
+        
+        // 处理动词的现在分词
+        // 以e结尾的动词，去e加-ing
+        if (base.endsWith('e') && word === base.slice(0, -1) + 'ing') {
+            return true;
+        }
+        // 常规动词加-ing
+        if (word === base + 'ing') {
+            return true;
+        }
+        
+        // 处理形容词的比较级和最高级
+        // 常规形容词加-er/-est
+        if (word === base + 'er' || word === base + 'est') {
+            return true;
+        }
+        // 以e结尾的形容词加-r/-st
+        if (base.endsWith('e') && (word === base + 'r' || word === base + 'st')) {
+            return true;
+        }
+        // 以辅音+y结尾的形容词，y变i再加-er/-est
+        if (base.length > 1 && 
+            base.endsWith('y') && 
+            !'aeiou'.includes(base.charAt(base.length - 2)) && 
+            (word === base.slice(0, -1) + 'ier' || word === base.slice(0, -1) + 'iest')) {
+            return true;
+        }
+        
+        // 处理副词的形成
+        // 常规形容词加-ly
+        if (word === base + 'ly') {
+            return true;
+        }
+        // 以y结尾的形容词，y变i加-ly
+        if (base.endsWith('y') && word === base.slice(0, -1) + 'ily') {
+            return true;
+        }
+        
+        // 处理反向情况
+        // 如果word是变形后的单词，base是基本形式
+        
+        // 过去式/过去分词 -> 基本形式
+        if (word.endsWith('ed') && base === word.slice(0, -2)) {
+            return true;
+        }
+        // 以e结尾的动词加d -> 基本形式
+        if (word.endsWith('d') && !word.endsWith('ed') && base === word.slice(0, -1)) {
+            return true;
+        }
+        // 以辅音+y结尾变为ied -> 基本形式
+        if (word.endsWith('ied') && base === word.slice(0, -3) + 'y') {
+            return true;
+        }
+        
+        // 现在分词 -> 基本形式
+        if (word.endsWith('ing')) {
+            // 常规情况
+            if (base === word.slice(0, -3)) {
+                return true;
+            }
+            // 以e结尾的动词去e加ing
+            if (base.endsWith('e') && base === word.slice(0, -3) + 'e') {
+                return true;
+            }
+        }
+        
+        // 比较级/最高级 -> 基本形式
+        if (word.endsWith('er') && base === word.slice(0, -2)) {
+            return true;
+        }
+        if (word.endsWith('est') && base === word.slice(0, -3)) {
+            return true;
+        }
+        // 以e结尾的形容词
+        if (word.endsWith('r') && !word.endsWith('er') && base.endsWith('e') && base === word.slice(0, -1)) {
+            return true;
+        }
+        if (word.endsWith('st') && !word.endsWith('est') && base.endsWith('e') && base === word.slice(0, -2)) {
+            return true;
+        }
+        // 以辅音+y结尾变为ier/iest
+        if (word.endsWith('ier') && base === word.slice(0, -3) + 'y') {
+            return true;
+        }
+        if (word.endsWith('iest') && base === word.slice(0, -4) + 'y') {
+            return true;
+        }
+        
+        // 副词 -> 形容词
+        if (word.endsWith('ly') && base === word.slice(0, -2)) {
+            return true;
+        }
+        // 以y结尾变为ily
+        if (word.endsWith('ily') && base === word.slice(0, -3) + 'y') {
+            return true;
+        }
+        
+        // 处理不规则动词过去式 (如go -> went, is -> was)
+        const irregularVerbs = {
+            'go': ['went', 'gone', 'going', 'goes'],
+            'be': ['am', 'is', 'are', 'was', 'were', 'been', 'being'],
+            'do': ['did', 'done', 'doing', 'does'],
+            'have': ['has', 'had', 'having'],
+            'say': ['said', 'saying', 'says'],
+            'make': ['made', 'making', 'makes'],
+            'get': ['got', 'gotten', 'getting', 'gets'],
+            'know': ['knew', 'known', 'knowing', 'knows'],
+            'take': ['took', 'taken', 'taking', 'takes'],
+            'see': ['saw', 'seen', 'seeing', 'sees'],
+            'come': ['came', 'coming', 'comes'],
+            'think': ['thought', 'thinking', 'thinks'],
+            'look': ['looked', 'looking', 'looks'],
+            'want': ['wanted', 'wanting', 'wants'],
+            'give': ['gave', 'given', 'giving', 'gives'],
+            'use': ['used', 'using', 'uses'],
+            'find': ['found', 'finding', 'finds'],
+            'tell': ['told', 'telling', 'tells'],
+            'ask': ['asked', 'asking', 'asks'],
+            'work': ['worked', 'working', 'works'],
+            'seem': ['seemed', 'seeming', 'seems'],
+            'feel': ['felt', 'feeling', 'feels'],
+            'try': ['tried', 'trying', 'tries'],
+            'leave': ['left', 'leaving', 'leaves'],
+            'call': ['called', 'calling', 'calls']
+        };
+        
+        // 检查是否是不规则动词的变形
+        if (irregularVerbs[base] && irregularVerbs[base].includes(word)) {
+            return true;
+        }
+        
+        if (Object.entries(irregularVerbs).some(([verb, forms]) => 
+            verb === word && forms.includes(base))) {
+            return true;
+        }
+        
+        return false;
+    }
+    
     // 处理用户提供的每个单词
     userWordsList.forEach(originalInput => {
         // 跳过空输入
@@ -103,6 +290,11 @@ export function enhanceFormsOfWords(jsonObj, userWords) {
             if (articleWord === originalInput) {
                 shouldAdd = true;
             } 
+            // 检查特殊变形规则 (提高优先级，放在前面检查)
+            else if (checkSpecialWordForms(articleWord, originalInput) || 
+                     checkSpecialWordForms(originalInput, articleWord)) {
+                shouldAdd = true;
+            }
             // 对于长度小于等于4的单词，只进行完全匹配，不做错误修正
             else if (originalInput.length <= 4) {
                 // 不做任何处理，保持shouldAdd为false

src/api/yjbdc/yjbdcController.js

@@ -230,11 +230,9 @@ export async function GenerateArticle(ctx) {
             "提供5道针对文章阅读理解的单项选择题，各有四个选项，并提供答案;"+
             "单项选择题和选项也要有中文翻译;"+
             "必须确保用户提供的每个单词（除像'fuck'、'shit'等脏话外）至少在文章中出现一次，可以是原形或某种变形（第三人称单数、复数、过去式、过去分词、现在分词、比较级、最高级等等所有可能的变形形式）。比如用户输入'go',文章除了'go'以外，也可以生成像'goes'、'went'、'gone'、'going'等单词;"+
-            "用户提交的每个单词，都放入FormsOfWords中;"+
             "内容格式为JSON，必须严格按照以下格式，不能有任何字段名错误或缺失：{"+
             "  \"ArticleEnglish\":[\"<英文文章句子1>\",\"<英文文章句子2>\"...],"+
             "  \"ArticleChinese\":[\"<中文翻译句子1>\",\"<中文翻译句子2>\"...],"+
-            "  \"FormsOfWords\":[\"<单词1>\",\"<单词2>\",\"<单词3>\",...],"+
             "  \"Question\":[{"+
             "    \"QuestionEnglish\":\"<英语题目1>\","+
             "    \"QuestionChinese\":\"<题目1中文翻译>\","+
@@ -269,6 +267,9 @@ export async function GenerateArticle(ctx) {
             else if (params.AIVersion=="1.5"){
                 aiProvider="volces1-6";
             }
+            else if (params.AIVersion=="1.8"){
+                aiProvider="qwen-plus";
+            }
             
             try {
                 //开始时间
@@ -276,6 +277,9 @@ export async function GenerateArticle(ctx) {
                 // 使用aiController生成文章
                 let result2 = await aiController.generateArticle(content, aiProvider);
                 
+                //console.log(result2);
+                //debugger;
+
                 // 校验和修复JSON结构
                 result2 = aiController.validateAndFixJSON(result2);
                 //console.log("JSON结构已校验和修复");

src/config/index.js

@@ -76,6 +76,9 @@ const commonConfig = {
         apikeyCJ:"d276e65d-4c39-49ad-a2e2-5060c30ca9a0",
         apikeyHLR:"2b7d737e-6773-4d55-ae77-da8d4e819c96",
     },
+    aliyun:{
+        accessKey: "sk-12e38cdfe5b1477880e5c99efbd10b48", // 需要替换为实际的阿里云AccessKey
+    },
     BufferMemoryTimeSuperLower:1,//缓存时间1秒
     BufferMemoryTimeLower:5,//缓存时间5秒
     BufferMemoryTimeLow:10,//缓存时间10秒

src/test/test-enhance-words.js

@@ -0,0 +1,148 @@
+import { enhanceFormsOfWords } from '../api/yjbdc/enhanceFormsOfWords.js';
+
+// 测试文章
+const testArticle = [
+    "She cries when she is sad.",
+    "The leaves fall from the trees in autumn.",
+    "He went to the store yesterday.",
+    "The knives are in the drawer.",
+    "I am trying to understand this concept."
+];
+
+// 创建测试JSON对象
+const testJsonObj = {
+    ArticleEnglish: testArticle
+};
+
+// 打印测试文章
+console.log("[DEBUG] 文章中的句子:");
+testArticle.forEach((sentence, index) => {
+    console.log(`[DEBUG]   ${index + 1}: ${sentence}`);
+});
+
+// 提取文章中的所有单词
+const allWords = testArticle.join(" ")
+    .toLowerCase()
+    .replace(/[.,\/#!$%\^&\*;:{}=\-_`~()]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .split(" ");
+
+console.log("[DEBUG] 文章中的所有单词:");
+console.log(`[DEBUG]   ${allWords.join(" ")}`);
+
+// 测试checkSpecialWordForms函数
+console.log("测试checkSpecialWordForms函数...");
+
+// 从enhanceFormsOfWords.js中提取checkSpecialWordForms函数
+// 由于它是私有函数，我们需要重新实现它进行测试
+function checkSpecialWordForms(word, base) {
+    // 处理以y结尾的单词变为复数时，y变为ies的情况 (如cry -> cries)
+    if (base.endsWith('y') && word === base.slice(0, -1) + 'ies') {
+        return true;
+    }
+    
+    // 处理以fe结尾的单词变为复数时，fe变为ves的情况 (如knife -> knives)
+    if (base.endsWith('fe') && word === base.slice(0, -2) + 'ves') {
+        return true;
+    }
+    
+    // 处理以f结尾的单词变为复数时，f变为ves的情况 (如leaf -> leaves)
+    if (base.endsWith('f') && word === base.slice(0, -1) + 'ves') {
+        return true;
+    }
+    
+    // 处理不规则动词过去式 (如go -> went)
+    const irregularVerbs = {
+        'go': ['went', 'gone', 'going', 'goes'],
+        'try': ['tried', 'trying', 'tries']
+    };
+    
+    // 检查是否是不规则动词的变形
+    if (irregularVerbs[base] && irregularVerbs[base].includes(word)) {
+        return true;
+    }
+    
+    return false;
+}
+
+// 测试用例
+const testCases = [
+    { base: "cry", form: "cries", expected: true },
+    { base: "leaf", form: "leaves", expected: true },
+    { base: "knife", form: "knives", expected: true },
+    { base: "go", form: "went", expected: true },
+    { base: "try", form: "trying", expected: true },
+    { base: "cat", form: "cats", expected: false } // 这个应该返回false，因为我们的简化版本不处理常规的复数形式
+];
+
+// 运行测试
+testCases.forEach(test => {
+    console.log("----------------------------------------");
+    console.log(`测试: ${test.base} -> ${test.form}`);
+    const result = checkSpecialWordForms(test.form, test.base);
+    console.log(`结果: ${result}`);
+    console.log(`预期: ${test.expected}`);
+    if (result === test.expected) {
+        console.log("✅ 通过");
+    } else {
+        console.log("❌ 失败");
+    }
+});
+
+// 测试enhanceFormsOfWords函数
+console.log("----------------------------------------");
+console.log("开始测试enhanceFormsOfWords函数...");
+
+// 测试用例
+const enhanceTestCases = [
+    { input: "cry", expected: ["cry", "cries"] },
+    { input: "leaf", expected: ["leaf", "leaves"] },
+    { input: "go", expected: ["go", "went"] },
+    { input: "knife", expected: ["knife", "knives"] },
+    { input: "try", expected: ["try", "trying"] }
+];
+
+// 运行测试
+enhanceTestCases.forEach(test => {
+    console.log("----------------------------------------");
+    console.log(`[DEBUG] 处理测试输入: "${test.input}"`);
+    
+    const result = enhanceFormsOfWords({ ArticleEnglish: testArticle }, test.input);
+    const formsFound = result.FormsOfWords || [];
+    
+    console.log(`测试输入: "${test.input}"`);
+    console.log(`识别到的单词形式: [${formsFound.map(w => `"${w}"`).join("")}]`);
+    
+    // 检查是否所有预期的单词变形都被识别
+    const allExpectedFound = test.expected.every(word => formsFound.includes(word));
+    
+    if (allExpectedFound) {
+        console.log("✅ 测试通过: 所有预期的单词变形都被识别");
+    } else {
+        console.log("❌ 测试失败: 有预期的单词变形未被识别");
+        const missing = test.expected.filter(word => !formsFound.includes(word));
+        console.log(`  缺少: ${missing.join(", ")}`);
+    }
+});
+
+// 测试多个单词输入
+console.log("----------------------------------------");
+const multiWordInput = "cryleafgo";
+const multiWordResult = enhanceFormsOfWords({ ArticleEnglish: testArticle }, multiWordInput);
+const multiWordForms = multiWordResult.FormsOfWords || [];
+
+console.log(`测试多个单词输入: "${multiWordInput}"`);
+console.log(`识别到的单词形式: [${multiWordForms.map(w => `"${w}"`).join("")}]`);
+
+// 预期的单词变形
+const expectedMultiWordForms = ["cry", "leaf", "go", "cries", "leaves", "went"];
+const allMultiWordExpectedFound = expectedMultiWordForms.every(word => multiWordForms.includes(word));
+
+if (allMultiWordExpectedFound) {
+    console.log("✅ 多单词测试通过: 所有预期的单词变形都被识别");
+} else {
+    console.log("❌ 多单词测试失败: 有预期的单词变形未被识别");
+    const missing = expectedMultiWordForms.filter(word => !multiWordForms.includes(word));
+    console.log(`  缺少: ${missing.join(", ")}`);
+}

src/test/test-enhanced-grammar.js

@@ -0,0 +1,75 @@
+import { enhanceFormsOfWords } from '../api/yjbdc/enhanceFormsOfWords.js';
+
+// 测试文章，包含各种语法变形
+const testArticle = [
+    "I walk to school every day. Yesterday, I walked to school. I am walking right now.",
+    "She likes to read books. She liked that novel. She is liking this new approach.",
+    "They try hard in class. They tried their best yesterday. They are trying to improve.",
+    "He makes delicious food. He is making dinner now. He made breakfast this morning.",
+    "The tall building is on the left. That building is taller than this one. It's the tallest in the city.",
+    "She is a nice person. She is nicer than her brother. She is the nicest in her family.",
+    "He is happy with his results. He is happier than before. He is the happiest person I know. He smiled happily.",
+    "She runs quick. She moves quickly. The quick brown fox jumps over the lazy dog."
+];
+
+// 创建测试JSON对象
+const testJsonObj = {
+    ArticleEnglish: testArticle
+};
+
+// 测试enhanceFormsOfWords函数对新增语法变形规则的识别能力
+console.log("测试enhanceFormsOfWords函数对新增语法变形规则的识别能力...");
+console.log("========================================");
+
+// 测试用例
+const testCases = [
+    // 动词过去式和现在分词
+    { input: "walk", expected: ["walk", "walked", "walking"] },
+    { input: "like", expected: ["like", "liked"] },
+    { input: "try", expected: ["try", "tried"] },
+    
+    // 重复一些测试，确保结果一致
+    { input: "walk", expected: ["walk", "walked", "walking"] },
+    { input: "make", expected: ["make", "making"] },
+    
+    // 形容词比较级和最高级
+    { input: "tall", expected: ["tall", "taller", "tallest"] },
+    { input: "nice", expected: ["nice", "nicer", "nicest"] },
+    { input: "happy", expected: ["happy", "happier", "happiest", "happily"] },
+    
+    // 副词
+    { input: "quick", expected: ["quick", "quickly"] },
+    
+    // 再次测试happy，确保结果一致
+    { input: "happy", expected: ["happy", "happier", "happiest", "happily"] },
+    
+    // 反向测试：从变形形式到基本形式
+    { input: "walked", expected: ["walked", "walk"] },
+    { input: "making", expected: ["making", "make"] },
+    { input: "taller", expected: ["taller", "tall"] },
+    { input: "happily", expected: ["happily", "happy"] }
+];
+
+// 运行测试
+testCases.forEach(test => {
+    console.log("----------------------------------------");
+    const result = enhanceFormsOfWords({ ArticleEnglish: testArticle }, test.input);
+    const formsFound = result.FormsOfWords || [];
+    
+    console.log(`测试输入: "${test.input}"`);
+    console.log(`识别到的单词形式: [${formsFound.map(w => `"${w}"`).join("")}]`);
+    
+    // 检查是否所有预期的单词变形都被识别
+    const allExpectedFound = test.expected.every(word => formsFound.includes(word));
+    
+    if (allExpectedFound) {
+        console.log("✅ 测试通过: 成功识别所有预期的单词变形");
+    } else {
+        console.log("❌ 测试失败: 有预期的单词变形未被识别");
+        const missing = test.expected.filter(word => !formsFound.includes(word));
+        console.log(`  缺少: ${missing.join(", ")}`);
+    }
+});
+
+console.log("========================================");
+console.log("测试完成");

src/test/test-love-case.js

@@ -0,0 +1,43 @@
+import { enhanceFormsOfWords } from '../api/yjbdc/enhanceFormsOfWords.js';
+
+// 测试文章，包含love和loves
+const testArticle = [
+    "I love reading books.",
+    "She loves to dance.",
+    "Love is a powerful emotion.",
+    "They love each other very much."
+];
+
+// 创建测试JSON对象
+const testJsonObj = {
+    ArticleEnglish: testArticle
+};
+
+// 测试enhanceFormsOfWords函数识别'love'到'loves'的能力
+console.log("测试enhanceFormsOfWords函数识别'love'到'loves'的能力...");
+console.log("----------------------------------------");
+
+// 测试用例
+const input = "love";
+const result = enhanceFormsOfWords({ ArticleEnglish: testArticle }, input);
+const formsFound = result.FormsOfWords || [];
+
+console.log(`测试输入: "${input}"`);
+console.log(`识别到的单词形式: [${formsFound.map(w => `"${w}"`).join("")}]`);
+
+// 检查是否识别到'loves'
+const hasLoves = formsFound.includes("loves");
+// 检查是否保留了原始单词'love'
+const hasLove = formsFound.includes("love");
+
+if (hasLoves) {
+    console.log("✅ 测试通过: 成功识别'loves'作为'love'的变形");
+} else {
+    console.log("❌ 测试失败: 未能识别'loves'作为'love'的变形");
+}
+
+if (hasLove) {
+    console.log("✅ 测试通过: 成功保留原始单词'love'");
+} else {
+    console.log("❌ 测试失败: 未能保留原始单词'love'");
+}