0

src/api/yjbdc/enhanceFormsOfWords.js

@@ -1,3 +1,5 @@
+import { stringUtils } from '../../util/stringClass.js';
+
 /**
  * 计算两个字符串之间的Levenshtein距离（编辑距离）
  * @param {string} a - 第一个字符串
@@ -113,184 +115,7 @@ export function enhanceFormsOfWords(jsonObj, userWords) {
      * @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;
+        return stringUtils.checkSpecialWordForms(word, base);
     }
     
     // 处理用户提供的每个单词

src/api/yjbdc/yjbdcController.js

@@ -1234,7 +1234,7 @@ export async function GetWordChinese(ctx) {
         // 如果没有找到结果，尝试查找单词的原形
         if (!result || result.length === 0) {
             // 使用stringUtils.getWordBaseForm获取可能的原形
-            const possibleBaseWords = stringUtils.getWordBaseForm(param.Word);
+            const possibleBaseWords = stringUtils.getWordAllForms(param.Word);
             
             // 尝试每个可能的原形
             for (const baseWord of possibleBaseWords) {

src/test/build.test.js

@@ -58,26 +58,40 @@ async function runScript(){
             //aiProvider="ali-qwen-plus";
             //生成例句
             let result = await aiController.generateArticle(content, aiProvider);
-            const variable = "Hello, World!";
-            // if (typeof variable === 'string') {
-            //     console.log('变量是字符串');
-            // } else {
-            //     result=JSON.stringify(result);
-            //     result=stringUtils.ReplaceAllString(result,"\r","");
-            //     result=stringUtils.ReplaceAllString(result,"\n","");
-            // }
+            
+            console.log("result1:"+result);
+            //console.log(result.indexOf("{")); 
+            if (result.indexOf("```json")>0){
+                console.log("```json");
+                console.log(result.indexOf("```json"));
+                result=result.substring(result.indexOf("```json")+7);
+                result=result.substring(0,result.lastIndexOf("```"));
+            }
+            else if (result.indexOf("```")>0){
+                console.log("```");
+                console.log(result.indexOf("```"));
+                
+                result=result.substring(result.indexOf("```")+3);
+                result=result.substring(0,result.lastIndexOf("```"));
+            }
+            console.log("result2:"+result);
 
-            //console.log(result);
+            result=result.replace("\"\":","\":");
+            result=result.replace("\"\" :","\" :");
+            result=result.replace(":\"\"",":\"");
+            result=result.replace(": \"\"",": \"");
+            result=result.replace(",\"\"",",\"");
+            result=result.replace("\"\",","\",");
 
-            result=result.replace("\"\": ","\": ");
             result=result.replace("\"\":","\":");
+            result=result.replace("\"\" :","\" :");
             result=result.replace(":\"\"",":\"");
             result=result.replace(": \"\"",": \"");
             result=result.replace(",\"\"",",\"");
             result=result.replace("\"\",","\",");
 
-            result=result.substring(result.lastIndexOf("{\"word"),result.lastIndexOf("}]}")+3);
 
+            
             //console.log(result); 
             let sql2="update Words set ExampleSentence=? where ID="+item.ID+";";
             await commonModel.RunSql(result,sql2);

src/test/build.test2.js

@@ -11,7 +11,7 @@ async function runScript(){
         let list = await commonModel.RunSql(null,sql);
         let count=list.length;
 
-        const start=8995;
+        const start=0;
         //count=10;
         // 添加延时函数，确保每分钟只发送9次请求（约每6.67秒一次请求）
         // const delay = (ms ) => new Promise(resolve => setTimeout(resolve, ms));
@@ -25,13 +25,23 @@ async function runScript(){
             word=item.Word;
             let exampleSentence=item.ExampleSentence;
             if (exampleSentence){
-                exampleSentence=JSON.parse(exampleSentence);
-                let sql2="update Words set ExampleSentence=?,Level='"+exampleSentence.CEFR_Level+"' where BookID<>110 and BookID not in (141,142,143,144,145,146,161,162,163,164,165,166,167,168) and ExampleSentence is null and Word='"+word+"';";
-                //console.log(sql2);
-                await commonModel.RunSql(item.ExampleSentence,sql2);
+                try{
+                    exampleSentence=JSON.parse(exampleSentence);
+                    let sql2="update Words set ExampleSentence=?,Level='"+exampleSentence.CEFR_Level+"' where BookID<>110 and BookID not in (141,142,143,144,145,146,161,162,163,164,165,166,167,168) and ExampleSentence is null and Word='"+word+"';";
+                    //console.log(sql2);
+                    await commonModel.RunSql(item.ExampleSentence,sql2);
+                }
+                catch(e){
+                    //let sql2="update Words set ExampleSentence='' where ID="+id+";";
+                    console.log("出错:"+word);
+
+                    process.exit(1);
+                    //await commonModel.RunSql(item.ExampleSentence,sql2);
+                }
             }
             else{
                 console.log( word +" 空");
+                process.exit(1);
             }
             console.log( i +"/"+ list.length);
             
@@ -43,15 +53,15 @@ async function runScript(){
         }
         
         console.log("完成");
+
+                    process.exit(1);
     } catch (error) {
         console.log(id + " " +word);
         console.error('Error executing script:', error);
+        process.exit(1);
     }
 }
 
-
-
-
 async function runScript2(){
     let id,word;
     try {

src/test/build.test3.js

@@ -7,11 +7,11 @@ async function runScript(){
     let id,word;
     try {
         
-        const sql="select * from Words where BookID=110 and ExampleSentence is not null order by ID;;"
+        const sql="select * from Words where BookID=110 and ExampleSentence is not null order by ID;"
         let list = await commonModel.RunSql(null,sql);
         let count=list.length;
 
-        const start=3630;
+        const start=0;
         //const start=0;
         //count=1;
 
@@ -27,52 +27,66 @@ async function runScript(){
             word=item.Word;
             let exampleSentence=item.ExampleSentence;
             if (exampleSentence){
-                exampleSentence=JSON.parse(exampleSentence);
-                //console.log(exampleSentence);
-                let sql2="select * from MiaoguoLiteracy where Word='"+word+"';";
-                let list2= await commonModel.RunSql(null,sql2);
+                try{
+                    exampleSentence=JSON.parse(exampleSentence);
+                    //console.log(exampleSentence);
+                    let sql2="select * from MiaoguoLiteracy where Word='"+word+"';";
+                    let list2= await commonModel.RunSql(null,sql2);
 
-                for(let j=0;j<list2.length;j++){
-                    let json=list2[j].JSONString;
-                    json=JSON.parse(json);
-
-                    //console.log(json);
-                    
-                    if (json.ENG){
-                        let arrSentence=[];
+                    for(let j=0;j<list2.length;j++){
+                        let json=list2[j].JSONString;
                         
-                        for(let k=0;k<exampleSentence.Sentences.length;k++){
-                            let obj=[];
-                            let sentence1=exampleSentence.Sentences[k].Sentence;
-                            
-                            sentence1=stringUtils.ReplaceAllString(sentence1,word,"[线]"+word+"[/线]");
-                            
-                            if (sentence1.substring(0,word.length).toLowerCase()==word.toLowerCase()){
-                                let word1=sentence1.substring(0,word.length);
-                                sentence1=sentence1.replace(word1,"[线]"+word1+"[/线]");
-                            }
-                            
-                            //console.log(sentence1);
-                            
-                            obj.push(sentence1);
-                            obj.push(exampleSentence.Sentences[k].Translate);
-                            arrSentence.push(obj);
+                        json=JSON.parse(json);
+
+                        //console.log(json);
+                        if (json.ENG 
+                            && json.ENG.ExamplesSentences 
+                            && json.ENG.ExamplesSentences.length>0 
+                            && json.ENG.ExamplesSentences[0][0].indexOf("[线]")<0 
+                        ){
+                            console.log(id+" "+word);
+                            // if (json.ENG){
+                            //     let arrSentence=[];
+                                
+                            //     for(let k=0;k<exampleSentence.Sentences.length;k++){
+                            //         let obj=[];
+                            //         let sentence1=exampleSentence.Sentences[k].Sentence;
+                                    
+                            //         sentence1=stringUtils.ReplaceAllString(sentence1,word,"[线]"+word+"[/线]");
+                                    
+                            //         if (sentence1.substring(0,word.length).toLowerCase()==word.toLowerCase()){
+                            //             let word1=sentence1.substring(0,word.length);
+                            //             sentence1=sentence1.replace(word1,"[线]"+word1+"[/线]");
+                            //         }
+                            //         //console.log(sentence1);
+                                    
+                            //         obj.push(sentence1);
+                            //         obj.push(exampleSentence.Sentences[k].Translate);
+                            //         arrSentence.push(obj);
+                            //     }
+                            //     if (!json.ENG.ExamplesSentences)
+                            //         json.ENG.ExamplesSentences=[];
+                                
+                            //     json.ENG.ExamplesSentences=arrSentence;
+                            // }
+                            // json.ENG.CEFR_Level=exampleSentence.CEFR_Level;
+
+                            // json=JSON.stringify(json);
+                            // let sql3="update MiaoguoLiteracy set JSONString=? where ID="+list2[j].ID+";";
+                            // //console.log(sql3);
+                            // //console.log(json);
+                            // await commonModel.RunSql(json,sql3);
                         }
-                        if (!json.ENG.ExamplesSentences)
-                            json.ENG.ExamplesSentences=[];
-                        
-                        json.ENG.ExamplesSentences=arrSentence;
                     }
-                    json.ENG.CEFR_Level=exampleSentence.CEFR_Level;
 
-                    json=JSON.stringify(json);
-                    let sql3="update MiaoguoLiteracy set JSONString=? where ID="+list2[j].ID+";";
-                    //console.log(sql3);
-                    //console.log(json);
-                    await commonModel.RunSql(json,sql3);
+                }
+                catch(e){
+                    let sql2="update Words set ExampleSentence='' where ID="+id+";";
+                    console.log("出错:"+word);
+                    await commonModel.RunSql(item.ExampleSentence,sql2);
                 }
             }
-            console.log(i +"/"+ list.length+" "+word);
+            //console.log(i +"/"+ list.length+" "+word);
             
             // 在每次请求后添加延时，除非是最后一个请求
             // if (i < count - 1) {

src/test/build.test31.js

@@ -0,0 +1,129 @@
+import commonModel from '../model/commonModel.js';
+import fs from 'fs';
+import { stringUtils } from '../util/stringClass.js';
+import aiController from '../api/yjbdc/aiController.js';
+
+async function runScript(){
+    let id,word;
+    try {
+        
+        const sql="select * from Words where BookID=110 order by ID;"
+        let list = await commonModel.RunSql(null,sql);
+        
+        const start=0;
+        //const start=0;
+        let count=list.length;
+        //count=100;
+
+        // 添加延时函数，确保每分钟只发送9次请求（约每6.67秒一次请求）
+        // const delay = (ms ) => new Promise(resolve => setTimeout(resolve, ms));
+        // const requestDelay = 300; // 7秒，确保每分钟最多9次请求
+        
+        for(let i=start;i<count;i++){
+            let item=list[i];
+
+            id=item.ID;
+            //获得单词
+            word=item.Word;
+            let exampleSentence=item.ExampleSentence;
+            if (exampleSentence){
+                try{
+                    if (exampleSentence.indexOf("\"\"")>=0){
+                        exampleSentence=exampleSentence("\"\"Sentences\"\"","\"Sentences\"");
+                        exampleSentence=exampleSentence("\"\",","\",");
+                        exampleSentence=exampleSentence(",\"\"",",\"");
+                        exampleSentence=exampleSentence("\"\":","\":");
+                        exampleSentence=exampleSentence(":\"\"",":\"");
+                        let sql5="update Words set ExampleSentence='"+exampleSentence+"' where ID="+id+";";
+                        //console.log(exampleSentence);
+                        await commonModel.RunSql(null,sql5);
+                    }
+
+                    exampleSentence=JSON.parse(exampleSentence);
+                    //console.log(exampleSentence);
+                    let sql2="select * from MiaoguoLiteracy where Word='"+word+"';";
+                    let list2= await commonModel.RunSql(null,sql2);
+
+                    for(let j=0;j<list2.length;j++){
+                        let json=list2[j].JSONString;
+                        
+                        json=JSON.parse(json);
+
+                        //console.log(json);
+                        let b=false;
+                        if (json.ENG && json.ENG.ExamplesSentences){
+                            
+                            for(let k=0;k<json.ENG.ExamplesSentences.length;k++){
+                                debugger;
+                                let sentence1=json.ENG.ExamplesSentences[k][0];
+
+                                if (sentence1.indexOf("[线]")<0){
+                                    //console.log("word:"+word);
+                                    let words=stringUtils.getWordAllForms(word);
+
+                                    for(let n=0;n<words.length;n++){
+                                        if (sentence1.indexOf(words[n])>=0){
+                                            sentence1=sentence1.replace(words[n],"[线]"+words[n]+"[/线]");
+                                            break;
+                                        }
+                                        else{
+                                            let word1=words[n].charAt(0).toUpperCase() + words[n].slice(1).toLowerCase();
+                                            if (sentence1.indexOf(word1)>=0){
+                                                sentence1=sentence1.replace(word1,"[线]"+word1+"[/线]");
+                                                break;
+                                            }
+                                        }
+                                    }
+                                    //console.log("words:"+words.join(", "));
+                                    //console.log("sentence1:"+sentence1);
+                                    json.ENG.ExamplesSentences[k][0]=sentence1;
+                                    b=true;
+                                }
+                            }
+                        }
+
+                        if (b){
+                            json.ENG.CEFR_Level=exampleSentence.CEFR_Level;
+
+                            json=JSON.stringify(json);
+                            let sql3="update MiaoguoLiteracy set JSONString=? where ID="+list2[j].ID+";";
+                            // //console.log(sql3);
+                            // //console.log(json);
+                            await commonModel.RunSql(json,sql3);
+                        }
+                        
+                    }
+
+                }
+                catch(e){
+                    // let sql2="update Words set ExampleSentence='' where ID="+id+";";
+
+                    // await commonModel.RunSql(item.ExampleSentence,sql2);
+                    console.log("出错:"+word);
+                    console.log("error:"+e);
+                    process.exit(1);
+                }
+            }
+            console.log(i +"/"+ list.length+" "+word);
+            
+            // 在每次请求后添加延时，除非是最后一个请求
+            // if (i < count - 1) {
+            //     console.log(`等待 ${requestDelay/1000} 秒后继续下一个请求...`);
+            //     await delay(requestDelay);
+            // }
+        }
+        
+        console.log("完成");
+        process.exit(1);
+
+    } catch (error) {
+        console.log(id + " " +word);
+        console.error('Error executing script:', error);
+        throw new Error('终止程序');
+        process.exit(1);
+    }
+}
+
+runScript().catch(error => {
+    console.error('Error in runScript:', error);
+});

src/test/build.test32.js

@@ -0,0 +1,22 @@
+import commonModel from '../model/commonModel.js';
+import fs from 'fs';
+import { stringUtils } from '../util/stringClass.js';
+
+function runScript(a,b,fuhao){
+    if (fuhao=="+")
+        return a+b;
+    if (fuhao=="-")
+        return a-b;
+    if (fuhao=="×")
+        return a*b;
+    if (fuhao=="÷")
+        return a/b;
+
+    if (fuhao=="²")
+        return a*a;
+    
+}
+
+let a=123,b=456;
+let result=runScript(a,b,"²");
+console.log(a+"÷"+b+"="+result);

src/test/build.test4.js

@@ -0,0 +1,110 @@
+import commonModel from '../model/commonModel.js';
+import fs from 'fs';
+import { stringUtils } from '../util/stringClass.js';
+import aiController from '../api/yjbdc/aiController.js';
+
+async function runScript(){
+    try {
+        
+        //按照高频单词的使用频率排序，列出所有单词
+        const sql="select * from Words where Word='';";
+        let list = await commonModel.RunSql(null,sql);
+        let count=list.length;
+        console.log(count);
+        const start=0;
+        //count=2;
+
+        // 添加延时函数，确保每分钟只发送9次请求（约每6.67秒一次请求）
+        const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+        const requestDelay = 7000; // 7秒，确保每分钟最多9次请求
+        
+        for(let i=start;i<count;i++){
+            let item=list[i];
+
+            //获得单词
+            const word=item.Word;
+
+            let content={
+                "instruction": "用单词"+word+"生成例句，中国学生学习英文使用",
+                "requirements": [
+                    "判断单词在CEFR的最低级别，比如experience是B1",
+                    "用单词最常用的含义生成最低级别到C1各两句例句，比如experience生成B1、B2、C1各两句",
+                    "单词允许类似过去式、复数等变形",
+                    "提供例句翻译",
+                    "格式要求是JSON格式，完全遵循output_format，另外生成不要有重复“\"”",
+                    "如果有多个方案，直接给最好的"
+                ],
+                "output_format":{
+                    "word":"单词",
+                    "CEFR_Level":"A1",
+                    "Sentences": [
+                        {
+                        "Sentence":"句子1",
+                        "Translate": "翻译1",
+                        "Level": "A1",
+                        },{
+                        "Sentence":"句子2",
+                        "Translate": "翻译2",
+                        "Level": "A2",
+                        },
+                    ]
+                }
+            };
+            content=JSON.stringify(content);
+            //console.log(content);
+
+            let aiProvider="llama-4-maverick-17b-128e-instruct";
+
+            //aiProvider="ali-qwen-plus";
+            //生成例句
+            let result = await aiController.generateArticle(content, aiProvider);
+            
+
+            console.log("result1:"+result);
+            //console.log(result.indexOf("{")); 
+            if (result.indexOf("```json")>0){
+                console.log("```json");
+                console.log(result.indexOf("```json"));
+                result=result.substring(result.indexOf("```json")+7);
+                result=result.substring(0,result.lastIndexOf("```"));
+            }
+            else if (result.indexOf("```")>0){
+                console.log("```");
+                console.log(result.indexOf("```"));
+                
+                result=result.substring(result.indexOf("```")+3);
+                result=result.substring(0,result.lastIndexOf("```"));
+            }
+            console.log("result2:"+result); 
+
+            result=result.replace("\"\": ","\": ");
+            result=result.replace("\"\":","\":");
+            result=result.replace(":\"\"",":\"");
+            result=result.replace(": \"\"",": \"");
+            result=result.replace(",\"\"",",\"");
+            result=result.replace("\"\",","\",");
+
+            let sql2="update Words set ExampleSentence=? where ID="+item.ID+";";
+            await commonModel.RunSql(result,sql2);
+            
+            console.log( i +"/"+ list.length+" "+word);
+            
+            // 在每次请求后添加延时，除非是最后一个请求
+            if (i < count - 1) {
+                console.log(`等待 ${requestDelay/1000} 秒后继续下一个请求...`);
+                await delay(requestDelay);
+            }
+        }
+        
+        console.log("完成");
+        process.exit(1);
+    } catch (error) {
+        console.error('Error executing script:', error);
+        process.exit(1);
+    }
+}
+
+// 处理Promise并添加错误捕获
+runScript().catch(error => {
+    console.error('Error in runScript:', error);
+});

src/util/stringClass.js

@@ -67,162 +67,281 @@ import os from 'os';
  * @property {Function} cleanWord - 清理单词中的非字母字符
  * @property {Function} extractEnglishWords - 从文本中提取英语单词
  */
+
 // 不规则动词映射
 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'],
-    'fly': ['flew', 'flown', 'flying', 'flies'],
-    'break': ['broke', 'broken', 'breaking', 'breaks'],
-    'buy': ['bought', 'buying', 'buys'],
-    'bring': ['brought', 'bringing', 'brings'],
-    'build': ['built', 'building', 'builds'],
-    'choose': ['chose', 'chosen', 'choosing', 'chooses'],
-    'catch': ['caught', 'catching', 'catches'],
-    'draw': ['drew', 'drawn', 'drawing', 'draws'],
-    'drink': ['drank', 'drunk', 'drinking', 'drinks'],
-    'drive': ['drove', 'driven', 'driving', 'drives'],
-    'eat': ['ate', 'eaten', 'eating', 'eats'],
-    'fall': ['fell', 'fallen', 'falling', 'falls'],
-    'forget': ['forgot', 'forgotten', 'forgetting', 'forgets'],
-    'grow': ['grew', 'grown', 'growing', 'grows'],
-    'hear': ['heard', 'hearing', 'hears'],
-    'keep': ['kept', 'keeping', 'keeps'],
-    'lead': ['led', 'leading', 'leads'],
-    'learn': ['learnt', 'learned', 'learning', 'learns'],
-    'lose': ['lost', 'losing', 'loses'],
-    'pay': ['paid', 'paying', 'pays'],
-    'read': ['read', 'reading', 'reads'],
-    'run': ['ran', 'run', 'running', 'runs'],
-    'rise': ['rose', 'risen', 'rising', 'rises'],
-    'ride': ['rode', 'ridden', 'riding', 'rides'],
-    'ring': ['rang', 'rung', 'ringing', 'rings'],
-    'set': ['set', 'setting', 'sets'],
-    'sit': ['sat', 'sitting', 'sits'],
-    'speak': ['spoke', 'spoken', 'speaking', 'speaks'],
-    'spend': ['spent', 'spending', 'spends'],
-    'stand': ['stood', 'standing', 'stands'],
-    'swim': ['swam', 'swum', 'swimming', 'swims'],
-    'teach': ['taught', 'teaching', 'teaches'],
-    'understand': ['understood', 'understanding', 'understands'],
-    'write': ['wrote', 'written', 'writing', 'writes'],
-    'win': ['won', 'winning', 'wins'],
-    'wear': ['wore', 'worn', 'wearing', 'wears'],
-    'throw': ['threw', 'thrown', 'throwing', 'throws'],
-    'sing': ['sang', 'sung', 'singing', 'sings'],
-    'sleep': ['slept', 'sleeping', 'sleeps'],
-    'sell': ['sold', 'selling', 'sells'],
-    'send': ['sent', 'sending', 'sends'],
-    'put': ['put', 'putting', 'puts'],
-    'meet': ['met', 'meeting', 'meets'],
-    'let': ['let', 'letting', 'lets'],
-    'hold': ['held', 'holding', 'holds'],
-    'cut': ['cut', 'cutting', 'cuts'],
-    'cost': ['cost', 'costing', 'costs'],
-    'become': ['became', 'become', 'becoming', 'becomes'],
-    'begin': ['began', 'begun', 'beginning', 'begins'],
-    'bend': ['bent', 'bending', 'bends'],
-    'bet': ['bet', 'betting', 'bets'],
-    'bite': ['bit', 'bitten', 'biting', 'bites'],
-    'blow': ['blew', 'blown', 'blowing', 'blows'],
-    'feed': ['fed', 'feeding', 'feeds'],
-    'fight': ['fought', 'fighting', 'fights'],
-    'freeze': ['froze', 'frozen', 'freezing', 'freezes'],
-    'hang': ['hung', 'hanging', 'hangs'],
-    'hide': ['hid', 'hidden', 'hiding', 'hides'],
-    'hit': ['hit', 'hitting', 'hits'],
-    'hurt': ['hurt', 'hurting', 'hurts'],
-    'lay': ['laid', 'laying', 'lays'],
-    'lie': ['lay', 'lain', 'lying', 'lies'],
-    'light': ['lit', 'lighting', 'lights'],
-    'mean': ['meant', 'meaning', 'means'],
-    'prove': ['proved', 'proven', 'proving', 'proves'],
-    'shake': ['shook', 'shaken', 'shaking', 'shakes'],
-    'shine': ['shone', 'shining', 'shines'],
-    'shoot': ['shot', 'shooting', 'shoots'],
-    'show': ['showed', 'shown', 'showing', 'shows'],
-    'shut': ['shut', 'shutting', 'shuts'],
-    'steal': ['stole', 'stolen', 'stealing', 'steals'],
-    'stick': ['stuck', 'sticking', 'sticks'],
-    'strike': ['struck', 'striking', 'strikes'],
-    'swear': ['swore', 'sworn', 'swearing', 'swears'],
-    'sweep': ['swept', 'sweeping', 'sweeps'],
-    'tear': ['tore', 'torn', 'tearing', 'tears'],
-    'wake': ['woke', 'woken', 'waking', 'wakes'],
-    'bear': ['bore', 'born', 'bearing', 'bears'],
-    'beat': ['beat', 'beaten', 'beating', 'beats'],
-    'burst': ['burst', 'bursting', 'bursts'],
-    'deal': ['dealt', 'dealing', 'deals'],
-    'dig': ['dug', 'digging', 'digs'],
-    'forbid': ['forbade', 'forbidden', 'forbidding', 'forbids'],
-    'forecast': ['forecast', 'forecasting', 'forecasts'],
+    'arise': ['arose', 'arisen', 'arising', 'arises'],
+    'awake': ['awoke', 'awoken', 'awaking', 'awakes'],
+    'backslide': ['backslid', 'backslidden', 'backsliding', 'backslides'],
+    'become': ['became', 'become', 'becoming', 'becomes'], // 已有，但确保完整
+    'behold': ['beheld', 'beholding', 'beholds'],
+    'bend': ['bent', 'bending', 'bends'], 
+    'bet': ['bet', 'betting', 'bets'], 
+    'bid': ['bid', 'bidding', 'bids'],
+    'bind': ['bound', 'binding', 'binds'],
+    'bleed': ['bled', 'bleeding', 'bleeds'],
+    'blow': ['blew', 'blown', 'blowing', 'blows'], 
+    'break': ['broke', 'broken', 'breaking', 'breaks'], 
+    'breed': ['bred', 'breeding', 'breeds'],
+    'bring': ['brought', 'bringing', 'brings'], 
+    'build': ['built', 'building', 'builds'], 
+    'burn': ['burnt', 'burned', 'burning', 'burns'],
+    'burst': ['burst', 'bursting', 'bursts'], 
+    'buy': ['bought', 'buying', 'buys'], 
+    'cast': ['cast', 'casting', 'casts'],
+    'catch': ['caught', 'catching', 'catches'], 
+    'choose': ['chose', 'chosen', 'choosing', 'chooses'], 
+    'cling': ['clung', 'clinging', 'clings'],
+    'come': ['came', 'coming', 'comes'], 
+    'cost': ['cost', 'costing', 'costs'], 
+    'creep': ['crept', 'creeping', 'creeps'],
+    'cut': ['cut', 'cutting', 'cuts'], 
+    'deal': ['dealt', 'dealing', 'deals'], 
+    'dig': ['dug', 'digging', 'digs'], 
+    'dive': ['dove', 'dived', 'diving', 'dives'],
+    'do': ['did', 'done', 'doing', 'does'], 
+    'draw': ['drew', 'drawn', 'drawing', 'draws'], 
+    'dream': ['dreamt', 'dreamed', 'dreaming', 'dreams'],
+    'drink': ['drank', 'drunk', 'drinking', 'drinks'], 
+    'drive': ['drove', 'driven', 'driving', 'drives'], 
+    'eat': ['ate', 'eaten', 'eating', 'eats'], 
+    'fall': ['fell', 'fallen', 'falling', 'falls'], 
+    'feed': ['fed', 'feeding', 'feeds'], 
+    'feel': ['felt', 'feeling', 'feels'], 
+    'fight': ['fought', 'fighting', 'fights'], 
+    'find': ['found', 'finding', 'finds'], 
+    'fit': ['fit', 'fitted', 'fitting', 'fits'],
+    'flee': ['fled', 'fleeing', 'flees'],
+    'fling': ['flung', 'flinging', 'flings'],
+    'fly': ['flew', 'flown', 'flying', 'flies'], 
+    'forbid': ['forbade', 'forbidden', 'forbidding', 'forbids'], 
+    'forget': ['forgot', 'forgotten', 'forgetting', 'forgets'], 
     'forgive': ['forgave', 'forgiven', 'forgiving', 'forgives'],
-    'grind': ['ground', 'grinding', 'grinds'],
-    'kneel': ['knelt', 'kneeling', 'kneels'],
-    'knit': ['knit', 'knitting', 'knits'],
-    'lean': ['leant', 'leaning', 'leans'],
-    'leap': ['leapt', 'leaping', 'leaps'],
-    'lend': ['lent', 'lending', 'lends'],
-    'mistake': ['mistook', 'mistaken', 'mistaking', 'mistakes'],
-    'overcome': ['overcame', 'overcome', 'overcoming', 'overcomes'],
-    'overtake': ['overtook', 'overtaken', 'overtaking', 'overtakes'],
-    'rid': ['rid', 'ridding', 'rids'],
-    'seek': ['sought', 'seeking', 'seeks'],
-    'sew': ['sewed', 'sewn', 'sewing', 'sews'],
-    'slay': ['slew', 'slain', 'slaying', 'slays'],
-    'slide': ['slid', 'sliding', 'slides'],
-    'sling': ['slung', 'slinging', 'slings'],
-    'slit': ['slit', 'slitting', 'slits'],
-    'smell': ['smelt', 'smelling', 'smells'],
-    'sow': ['sowed', 'sown', 'sowing', 'sows'],
-    'spell': ['spelt', 'spelling', 'spells'],
-    'spill': ['spilt', 'spilling', 'spills'],
-    'spit': ['spat', 'spitting', 'spits'],
-    'split': ['split', 'splitting', 'splits'],
-    'spread': ['spread', 'spreading', 'spreads'],
-    'spring': ['sprang', 'sprung', 'springing', 'springs'],
-    'stink': ['stank', 'stunk', 'stinking', 'stinks'],
-    'stride': ['strode', 'stridden', 'striding', 'strides'],
-    'string': ['strung', 'stringing', 'strings'],
-    'strive': ['strove', 'striven', 'striving', 'strives'],
-    'sweat': ['sweat', 'sweating', 'sweats'],
-    'swell': ['swelled', 'swollen', 'swelling', 'swells'],
-    'swing': ['swung', 'swinging', 'swings'],
-    'thrust': ['thrust', 'thrusting', 'thrusts'],
-    'tread': ['trod', 'trodden', 'treading', 'treads'],
-    'undergo': ['underwent', 'undergone', 'undergoing', 'undergoes'],
-    'undertake': ['undertook', 'undertaken', 'undertaking', 'undertakes'],
-    'upset': ['upset', 'upsetting', 'upsets'],
-    'weave': ['wove', 'woven', 'weaving', 'weaves'],
-    'weep': ['wept', 'weeping', 'weeps'],
-    'wind': ['wound', 'winding', 'winds'],
-    'withdraw': ['withdrew', 'withdrawn', 'withdrawing', 'withdraws'],
-    'wring': ['wrung', 'wringing', 'wrings']
+    'freeze': ['froze', 'frozen', 'freezing', 'freezes'], 
+    'get': ['got', 'gotten', 'getting', 'gets'], 
+    'give': ['gave', 'given', 'giving', 'gives'], 
+    'go': ['went', 'gone', 'going', 'goes'], 
+    'grind': ['ground', 'grinding', 'grinds'], 
+    'grow': ['grew', 'grown', 'growing', 'grows'], 
+    'hang': ['hung', 'hanging', 'hangs'], 
+    'have': ['has', 'had', 'having'], 
+    'hear': ['heard', 'hearing', 'hears'], 
+    'hide': ['hid', 'hidden', 'hiding', 'hides'], 
+    'hit': ['hit', 'hitting', 'hits'], 
+    'hold': ['held', 'holding', 'holds'], 
+    'hurt': ['hurt', 'hurting', 'hurts'], 
+    'keep': ['kept', 'keeping', 'keeps'], 
+    'kneel': ['knelt', 'kneeling', 'kneels'], 
+    'know': ['knew', 'known', 'knowing', 'knows'], 
+    'lay': ['laid', 'laying', 'lays'], 
+    'lead': ['led', 'leading', 'leads'], 
+    'lean': ['leant', 'leaning', 'leans'], 
+    'leap': ['leapt', 'leaping', 'leaps'], 
+    'learn': ['learnt', 'learned', 'learning', 'learns'], 
+    'leave': ['left', 'leaving', 'leaves'], 
+    'lend': ['lent', 'lending', 'lends'], 
+    'let': ['let', 'letting', 'lets'], 
+    'lie': ['lay', 'lain', 'lying', 'lies'], 
+    'light': ['lit', 'lighting', 'lights'], 
+    'lose': ['lost', 'losing', 'loses'], 
+    'make': ['made', 'making', 'makes'], 
+    'mean': ['meant', 'meaning', 'means'], 
+    'meet': ['met', 'meeting', 'meets'], 
+    'mistake': ['mistook', 'mistaken', 'mistaking', 'mistakes'], 
+    'pay': ['paid', 'paying', 'pays'], 
+    'put': ['put', 'putting', 'puts'], 
+    'quit': ['quit', 'quitting', 'quits'],
+    'read': ['read', 'reading', 'reads'], 
+    'ride': ['rode', 'ridden', 'riding', 'rides'], 
+    'ring': ['rang', 'rung', 'ringing', 'rings'], 
+    'rise': ['rose', 'risen', 'rising', 'rises'], 
+    'run': ['ran', 'run', 'running', 'runs'], 
+    'say': ['said', 'saying', 'says'], 
+    'see': ['saw', 'seen', 'seeing', 'sees'], 
+    'seek': ['sought', 'seeking', 'seeks'], 
+    'sell': ['sold', 'selling', 'sells'], 
+    'send': ['sent', 'sending', 'sends'], 
+    'set': ['set', 'setting', 'sets'], 
+    'shake': ['shook', 'shaken', 'shaking', 'shakes'], 
+    'shed': ['shed', 'shedding', 'sheds'],
+    'shine': ['shone', 'shining', 'shines'], 
+    'shoot': ['shot', 'shooting', 'shoots'], 
+    'show': ['showed', 'shown', 'showing', 'shows'], 
+    'shrink': ['shrank', 'shrunk', 'shrinking', 'shrinks'],
+    'shut': ['shut', 'shutting', 'shuts'], 
+    'sing': ['sang', 'sung', 'singing', 'sings'], 
+    'sink': ['sank', 'sunk', 'sinking', 'sinks'],
+    'sit': ['sat', 'sitting', 'sits'], 
+    'sleep': ['slept', 'sleeping', 'sleeps'], 
+    'slide': ['slid', 'sliding', 'slides'], 
+    'sling': ['slung', 'slinging', 'slings'], 
+    'slink': ['slunk', 'slinking', 'slinks'],
+    'smell': ['smelt', 'smelling', 'smells'], 
+    'speak': ['spoke', 'spoken', 'speaking', 'speaks'], 
+    'speed': ['sped', 'speeding', 'speeds'],
+    'spell': ['spelt', 'spelling', 'spells'], 
+    'spend': ['spent', 'spending', 'spends'], 
+    'spill': ['spilt', 'spilling', 'spills'], 
+    'spin': ['spun', 'spinning', 'spins'],
+    'spit': ['spat', 'spitting', 'spits'], 
+    'split': ['split', 'splitting', 'splits'], 
+    'spread': ['spread', 'spreading', 'spreads'], 
+    'spring': ['sprang', 'sprung', 'springing', 'springs'], 
+    'stand': ['stood', 'standing', 'stands'], 
+    'steal': ['stole', 'stolen', 'stealing', 'steals'], 
+    'stick': ['stuck', 'sticking', 'sticks'], 
+    'sting': ['stung', 'stinging', 'stings'],
+    'stink': ['stank', 'stunk', 'stinking', 'stinks'], 
+    'strike': ['struck', 'striking', 'strikes'], 
+    'strive': ['strove', 'striven', 'striving', 'strives'], 
+    'swear': ['swore', 'sworn', 'swearing', 'swears'], 
+    'sweep': ['swept', 'sweeping', 'sweeps'], 
+    'swim': ['swam', 'swum', 'swimming', 'swims'], 
+    'swing': ['swung', 'swinging', 'swings'], 
+    'take': ['took', 'taken', 'taking', 'takes'], 
+    'teach': ['taught', 'teaching', 'teaches'], 
+    'tear': ['tore', 'torn', 'tearing', 'tears'], 
+    'tell': ['told', 'telling', 'tells'], 
+    'think': ['thought', 'thinking', 'thinks'], 
+    'throw': ['threw', 'thrown', 'throwing', 'throws'], 
+    'thrust': ['thrust', 'thrusting', 'thrusts'], 
+    'tread': ['trod', 'trodden', 'treading', 'treads'], 
+    'undergo': ['underwent', 'undergone', 'undergoing', 'undergoes'], 
+    'understand': ['understood', 'understanding', 'understands'], 
+    'undertake': ['undertook', 'undertaken', 'undertaking', 'undertakes'], 
+    'upset': ['upset', 'upsetting', 'upsets'], 
+    'wake': ['woke', 'woken', 'waking', 'wakes'], 
+    'wear': ['wore', 'worn', 'wearing', 'wears'], 
+    'weave': ['wove', 'woven', 'weaving', 'weaves'], 
+    'weep': ['wept', 'weeping', 'weeps'], 
+    'win': ['won', 'winning', 'wins'], 
+    'wind': ['wound', 'winding', 'winds'], 
+    'withdraw': ['withdrew', 'withdrawn', 'withdrawing', 'withdraws'], 
+    'wring': ['wrung', 'wringing', 'wrings'] 
+};
+
+// 不规则形容词/副词映射表
+const irregularAdjectives = {
+    'good': ['better', 'best'],
+    'bad': ['worse', 'worst'],
+    'many': ['more', 'most'],
+    'much': ['more', 'most'],
+    'little': ['less', 'least'],
+    'far': ['further', 'furthest', 'farther', 'farthest'],
+    'old': ['older', 'oldest', 'elder', 'eldest'],
+    'late': ['later', 'latest', 'latter', 'last'],
+    'well': ['better', 'best'],
+    'ill': ['worse', 'worst'],
+    'easy': ['easier', 'easiest'],
+    'happy': ['happier', 'happiest'],
+    'busy': ['busier', 'busiest'],
+    'pretty': ['prettier', 'prettiest'],
+    'heavy': ['heavier', 'heaviest'],
+    'simple': ['simpler', 'simplest'],
+    'clever': ['cleverer', 'cleverest'],
+    'narrow': ['narrower', 'narrowest'],
+    'quiet': ['quieter', 'quietest'],
+    'large': ['larger', 'largest'],
+    'small': ['smaller', 'smallest'],
+    'big': ['bigger', 'biggest'],
+    'hot': ['hotter', 'hottest'],
+    'tall': ['taller', 'tallest'],
+    'short': ['shorter', 'shortest'],
+    'long': ['longer', 'longest'],
+    'high': ['higher', 'highest'],
+    'low': ['lower', 'lowest'],
+    'deep': ['deeper', 'deepest'],
+    'wide': ['wider', 'widest'],
+    'near': ['nearer', 'nearest'],
+    'clean': ['cleaner', 'cleanest'],
+    'quick': ['quicker', 'quickest'],
+    'slow': ['slower', 'slowest'],
+    'strong': ['stronger', 'strongest'],
+    'weak': ['weaker', 'weakest'],
+    'young': ['younger', 'youngest'],
+    'rich': ['richer', 'richest'],
+    'poor': ['poorer', 'poorest'],
+    'thick': ['thicker', 'thickest'],
+    'thin': ['thinner', 'thinnest'],
+    'fast': ['faster', 'fastest'],
+    'hard': ['harder', 'hardest'],
+    'soft': ['softer', 'softest'],
+    'warm': ['warmer', 'warmest'],
+    'cool': ['cooler', 'coolest'],
+    'cold': ['colder', 'coldest'],
+    'bright': ['brighter', 'brightest'],
+    'dark': ['darker', 'darkest'],
+    'light': ['lighter', 'lightest'],
+    'loud': ['louder', 'loudest'],
+    'sweet': ['sweeter', 'sweetest'],
+    'sour': ['sourer', 'sourest'],
+    'bitter': ['bitterer', 'bitterest'],
+    'nice': ['nicer', 'nicest'],
+    'fine': ['finer', 'finest'],
+    'brave': ['braver', 'bravest'],
+    'calm': ['calmer', 'calmest'],
+    'cute': ['cuter', 'cutest'],
+    'fair': ['fairer', 'fairest'],
+    'fresh': ['fresher', 'freshest'],
+    'full': ['fuller', 'fullest'],
+    'glad': ['gladder', 'gladdest'],
+    'great': ['greater', 'greatest'],
+    'kind': ['kinder', 'kindest'],
+    'new': ['newer', 'newest'],
+    'odd': ['odder', 'oddest'],
+    'rare': ['rarer', 'rarest'],
+    'real': ['realer', 'realest'],
+    'safe': ['safer', 'safest'],
+    'same': ['samer', 'samest'],
+    'sure': ['surer', 'surest'],
+    'true': ['truer', 'truest'],
+    'wise': ['wiser', 'wisest']
+};
+
+// 特殊不规则名词复数形式
+const irregularNouns = {
+    'child': ['children'],
+    'man': ['men'],
+    'woman': ['women'],
+    'foot': ['feet'],
+    'tooth': ['teeth'],
+    'goose': ['geese'],
+    'mouse': ['mice'],
+    'ox': ['oxen'],
+    'person': ['people'],
+    'louse': ['lice'],
+    'leaf': ['leaves'],
+    'life': ['lives'],
+    'knife': ['knives'],
+    'wife': ['wives'],
+    'half': ['halves'],
+    'wolf': ['wolves'],
+    'shelf': ['shelves'],
+    'self': ['selves'],
+    'calf': ['calves'],
+    'thief': ['thieves'],
+    'deer': ['deer'],
+    'sheep': ['sheep'],
+    'fish': ['fish'],
+    'series': ['series'],
+    'species': ['species'],
+    'aircraft': ['aircraft'],
+    'information': ['information'],
+    'money': ['money'],
+    'rice': ['rice'],
+    'equipment': ['equipment'],
+    'furniture': ['furniture'],
+    'datum': ['data'],
+    'phenomenon': ['phenomena'],
+    'criterion': ['criteria']
 };
 
 export const stringUtils = {
+    // 导出不规则字典
+    irregularVerbs,
+    irregularAdjectives,
+    irregularNouns,
+
     //给字符串左侧补零
     AddZero: (str, length) => {
         while (str.length < length) {
@@ -881,25 +1000,165 @@ export const stringUtils = {
         return result;
     },
     
+
+    
     /**
-     * 获取单词的原形（基本形式）
-     * @param {string} word - 要转换的单词
-     * @returns {string[]} - 可能的原形单词数组
+     * 获取单词的所有变形形式
+     * @param {string} word - 要获取变形的单词
+     * @returns {string[]} - 单词的所有变形形式数组
      */
-    getWordBaseForm: (word) => {
+    getWordAllForms: (word) => {
+        if (!word || typeof word !== 'string') {
+            return [];
+        }
+        word = word.trim();
+        if (word === '') {
+            return [];
+        }
+        
+        // 保留原始单词，包括大小写和标点符号
+        const originalWord = word;
+        
+        // 处理缩写词中的撇号
+        const hasApostrophe = word.includes("'");
+        
+        // 转换为小写进行处理
         const lowerWord = word.toLowerCase();
-        const possibleBaseWords = [];
         
-        // 检查是否是不规则动词的变形
-        for (const [base, forms] of Object.entries(irregularVerbs)) {
-            if (forms.includes(lowerWord)) {
-                possibleBaseWords.push(base);
-                return possibleBaseWords; // 不规则动词直接返回原形
+        // 使用Set存储所有可能的变形，避免重复
+        const allForms = new Set([lowerWord]); // 初始包含原单词
+        
+        // 如果原始单词与小写形式不同，也添加原始单词
+        if (originalWord !== lowerWord) {
+            allForms.add(originalWord);
+        }
+        
+        // 可以考虑添加一个标志来避免重复检查
+        let foundIrregular = false;
+        // 检查是否是不规则动词
+        for (const [base, forms] of Object.entries(stringUtils.irregularVerbs)) {
+            if (base === lowerWord || forms.includes(lowerWord)) {
+                // 添加原形和所有变形
+                allForms.add(base);
+                forms.forEach(form => allForms.add(form));
+                foundIrregular = true;
+                break;
+            }
+        }
+        
+        // 不规则形容词/副词检查后应该也考虑是否返回
+        for (const [base, forms] of Object.entries(stringUtils.irregularAdjectives)) {
+            if (base === lowerWord || forms.includes(lowerWord)) {
+                // 添加原形和所有变形
+                allForms.add(base);
+                forms.forEach(form => allForms.add(form));
+                foundIrregular = true;
+                break;
+            }
+        }
+
+        // 不规则名词检查后也应该设置标志
+        if (stringUtils.irregularNouns[lowerWord]) {
+            stringUtils.irregularNouns[lowerWord].forEach(form => allForms.add(form));
+            foundIrregular = true;
+        }
+
+        // 不规则名词复数形式检查后也应该设置标志
+        for (const [singular, plurals] of Object.entries(stringUtils.irregularNouns)) {
+            if (plurals.includes(lowerWord)) {
+                allForms.add(singular);
+                plurals.forEach(form => allForms.add(form));
+                foundIrregular = true;
+                break;
             }
         }
         
         // 处理规则变形
+        // 特殊处理一些常见的副词和特殊单词，避免错误的词干提取和变形
+        const specialWords = {
+            // 情态动词
+            'can': ['can', 'could', 'cannot', "can't"],
+            'may': ['may', 'might'],
+            'shall': ['shall', 'should', "shouldn't"],
+            'will': ['will', 'would', "won't", "wouldn't"],
+            'must': ['must', 'have to', 'has to', 'had to', "mustn't"],
+            
+            // 副词
+            'early': ['early', 'earlier', 'earliest'],
+            'only': ['only'],
+            'likely': ['likely', 'more likely', 'most likely'],
+            'friendly': ['friendly', 'friendlier', 'friendliest'],
+            'lovely': ['lovely', 'lovelier', 'loveliest'],
+            'timely': ['timely', 'timelier', 'timeliest'],
+            'weekly': ['weekly'],
+            'monthly': ['monthly'],
+            'yearly': ['yearly'],
+            'daily': ['daily'],
+            'badly': ['badly', 'worse', 'worst'], // 对应bad的副词形式
+            
+            // 特殊动词
+            'play': ['play', 'plays', 'played', 'playing'],
+            'stay': ['stay', 'stays', 'stayed', 'staying'],
+            'pay': ['pay', 'pays', 'paid', 'paying'],
+            'lay': ['lay', 'lays', 'laid', 'laying'],
+            'say': ['say', 'says', 'said', 'saying'],
+            
+            // 特殊名词
+            'box': ['box', 'boxes'],
+            'fox': ['fox', 'foxes'],
+            'tax': ['tax', 'taxes'],
+            'bush': ['bush', 'bushes'],
+            'dish': ['dish', 'dishes'],
+            'church': ['church', 'churches'],
+            'tomato': ['tomato', 'tomatoes'],
+            'potato': ['potato', 'potatoes'],
+            'hero': ['hero', 'heroes'],
+            'echo': ['echo', 'echoes'],
+
+            'its': ['its'], // 物主代词
+            'it\'s': ['it\'s'], // it is 的缩写
+            'I\'m': ['I\'m'], // I am 的缩写
+            'don\'t': ['don\'t'], // do not 的缩写
+            'doesn\'t': ['doesn\'t'], // does not 的缩写
+            'we\'re': ['we are'],
+            'they\'re': ['they are'],
+            'you\'re': ['you are'],
+            'he\'s': ['he is', 'he has'],
+            'she\'s': ['she is', 'she has'],
+            'it\'d': ['it would', 'it had'],
+            'we\'d': ['we would', 'we had'],
+            'they\'d': ['they would', 'they had'],
+            'couldn\'t': ['could not'],
+            'should\'ve': ['should have'],
+            'would\'ve': ['would have'],
+            'could\'ve': ['could have']
+        };
+        
+        // 如果是特殊单词，直接返回预定义的变形
+        if (specialWords[lowerWord]) {
+            specialWords[lowerWord].forEach(form => allForms.add(form));
+            return [...allForms];
+        }
+        
+        // 检查是否是特殊单词的变形
+        for (const [base, forms] of Object.entries(specialWords)) {
+            if (forms.includes(lowerWord)) {
+                forms.forEach(form => allForms.add(form));
+                return [...allForms];
+            }
+        }
+        
+        // 获取单词的原形（基本形式）
+        const possibleBaseWords = [];
+        
+        // 特殊单词列表，这些单词不应被识别为任何变形
+        const specialBaseWords = ['this', 'is', 'was', 'has', 'his', 'its', 'us', 'yes', 'thus', 'plus'];
+        if (specialBaseWords.includes(lowerWord)) {
+            possibleBaseWords.push(lowerWord);
+            return [...allForms];
+        }
         
+        // 处理规则变形
         // 处理过去式/过去分词 (-ed)
         if (lowerWord.endsWith('ed')) {
             possibleBaseWords.push(lowerWord.slice(0, -2)); // 常规情况 (walked -> walk)
@@ -992,7 +1251,7 @@ export const stringUtils = {
         if (lowerWord.endsWith('ily')) {
             possibleBaseWords.push(lowerWord.slice(0, -3) + 'y'); // 如 happily -> happy
         }
-        
+
         // 处理复数形式
         if (lowerWord.endsWith('s') && !lowerWord.endsWith('ss')) {
             possibleBaseWords.push(lowerWord.slice(0, -1)); // 常规情况 (books -> book)
@@ -1040,6 +1299,195 @@ export const stringUtils = {
         // 去重并过滤掉过短的单词
         const uniqueBaseWords = [...new Set(possibleBaseWords)].filter(w => w.length >= 2);
         
-        return uniqueBaseWords;
+        // 如果没有找到任何可能的原形，或者所有可能的原形都不是有效单词，则返回单词本身
+        if (uniqueBaseWords.length === 0 || !uniqueBaseWords.some(w => w === lowerWord || w.length >= 3)) {
+            // 清空可能不正确的原形
+            uniqueBaseWords.length = 0;
+            uniqueBaseWords.push(lowerWord);
+        }
+        
+        // 添加所有可能的原形到变形集合中
+        uniqueBaseWords.forEach(base => allForms.add(base));
+        
+        // 判断词性的简单启发式规则
+        const adjectiveSuffixes = ['ful', 'ous', 'ive', 'ic', 'al', 'ent', 'ant', 'able', 'ible', 'ary', 'ory', 'ish'];
+        const verbSuffixes = ['ize', 'ise', 'ate', 'ify', 'en'];
+        const nounSuffixes = ['tion', 'sion', 'ment', 'ness', 'ity', 'hood', 'ship', 'dom', 'ism', 'ist'];
+        const adverbSuffixes = ['ly', 'ward', 'wise'];// 副词后缀
+
+        
+        // 一些常见的形容词
+        const commonAdjectives = ['good', 'bad', 'big', 'small', 'high', 'low', 'long', 'short', 'old', 'new', 
+                                 'fast', 'slow', 'hard', 'soft', 'hot', 'cold', 'warm', 'cool', 'rich', 'poor', 
+                                 'thick', 'thin', 'wide', 'narrow', 'deep', 'shallow', 'strong', 'weak', 'young', 
+                                 'old', 'bright', 'dark', 'light', 'heavy', 'easy', 'hard', 'clean', 'dirty', 
+                                 'full', 'empty', 'dry', 'wet', 'sick', 'healthy', 'loud', 'quiet', 'sweet', 
+                                 'sour', 'bitter', 'nice', 'mean', 'kind', 'cruel', 'brave', 'afraid', 'happy', 
+                                 'sad', 'angry', 'calm', 'busy', 'free', 'cheap', 'expensive', 'safe', 'dangerous'];
+        
+        // 一些常见的动词
+        const commonVerbs = ['go', 'come', 'get', 'give', 'make', 'take', 'put', 'set', 'let', 'run', 'move', 
+                            'walk', 'talk', 'look', 'see', 'hear', 'feel', 'think', 'know', 'find', 'want', 
+                            'need', 'use', 'try', 'ask', 'work', 'call', 'help', 'play', 'stop', 'start', 
+                            'turn', 'show', 'tell', 'say', 'write', 'read', 'sing', 'eat', 'drink', 'sleep', 
+                            'sit', 'stand', 'lie', 'fall', 'rise', 'leave', 'reach', 'like', 'love', 'hate', 
+                            'hope', 'live', 'die', 'buy', 'sell', 'pay', 'build', 'break', 'cut', 'open', 'close'];
+        
+        // 检查是否是形容词
+        let isLikelyAdjective = adjectiveSuffixes.some(suffix => lowerWord.endsWith(suffix)) || 
+                            commonAdjectives.includes(lowerWord) ||
+                            (lowerWord.length <= 6 && !nounSuffixes.some(suffix => lowerWord.endsWith(suffix)));
+
+        // 检查是否是动词
+        let isLikelyVerb = verbSuffixes.some(suffix => lowerWord.endsWith(suffix)) || 
+                        commonVerbs.includes(lowerWord) ||
+                        (lowerWord.length <= 5 && !adjectiveSuffixes.some(suffix => lowerWord.endsWith(suffix)) && 
+                        !nounSuffixes.some(suffix => lowerWord.endsWith(suffix)));
+
+        // 检查是否是副词
+        let isLikelyAdverb = adverbSuffixes.some(suffix => lowerWord.endsWith(suffix));
+                
+        // 动词变形 (如果可能是动词)
+        if (isLikelyVerb && lowerWord.length >= 2) {
+            // 第三人称单数
+            if (lowerWord.endsWith('s') || lowerWord.endsWith('x') || lowerWord.endsWith('ch') || lowerWord.endsWith('sh') || lowerWord.endsWith('z')) {
+                allForms.add(lowerWord + 'es');
+            } else if (lowerWord.endsWith('y') && !['a', 'e', 'i', 'o', 'u'].includes(lowerWord.charAt(lowerWord.length - 2))) {
+                allForms.add(lowerWord.slice(0, -1) + 'ies');
+            } else {
+                allForms.add(lowerWord + 's');
+            }
+            
+            // 过去式和过去分词 (-ed)
+            if (lowerWord.endsWith('e')) {
+                allForms.add(lowerWord + 'd');
+            } else if (lowerWord.endsWith('y') && !['a', 'e', 'i', 'o', 'u'].includes(lowerWord.charAt(lowerWord.length - 2))) {
+                allForms.add(lowerWord.slice(0, -1) + 'ied');
+            } else if (lowerWord.length > 2 && 
+                      !['a', 'e', 'i', 'o', 'u'].includes(lowerWord.charAt(lowerWord.length - 1)) && 
+                      ['a', 'e', 'i', 'o', 'u'].includes(lowerWord.charAt(lowerWord.length - 2)) && 
+                      !['a', 'e', 'i', 'o', 'u'].includes(lowerWord.charAt(lowerWord.length - 3))) {
+                // 双写末尾辅音字母的情况，如 stop -> stopped
+                allForms.add(lowerWord + lowerWord.charAt(lowerWord.length - 1) + 'ed');
+            } else {
+                allForms.add(lowerWord + 'ed');
+            }
+            
+            // 现在分词 (-ing)
+            if (lowerWord.endsWith('ie')) {
+                allForms.add(lowerWord.slice(0, -2) + 'ying');
+            } else if (lowerWord.endsWith('e') && lowerWord.length > 2) {
+                allForms.add(lowerWord.slice(0, -1) + 'ing');
+            } else if (lowerWord.length > 2 && 
+                      !['a', 'e', 'i', 'o', 'u'].includes(lowerWord.charAt(lowerWord.length - 1)) && 
+                      ['a', 'e', 'i', 'o', 'u'].includes(lowerWord.charAt(lowerWord.length - 2)) && 
+                      !['a', 'e', 'i', 'o', 'u'].includes(lowerWord.charAt(lowerWord.length - 3))) {
+                // 双写末尾辅音字母的情况，如 run -> running
+                allForms.add(lowerWord + lowerWord.charAt(lowerWord.length - 1) + 'ing');
+            } else {
+                allForms.add(lowerWord + 'ing');
+            }
+        }
+        
+        // 形容词和副词变形 (如果可能是形容词或副词)
+        if ((isLikelyAdjective || isLikelyAdverb) && lowerWord.length >= 3 && 
+            !lowerWord.endsWith('ing') && !lowerWord.endsWith('ed') && 
+            lowerWord.length <= 8) { // 限制长度，避免生成不必要的变形
+            
+            // 检查是否是多音节形容词，这些通常使用 more/most 而不是 -er/-est
+            const isMultisyllabic = lowerWord.length > 7 || 
+                                   lowerWord.endsWith('ful') || 
+                                   lowerWord.endsWith('ous') || 
+                                   lowerWord.endsWith('ive') || 
+                                   lowerWord.endsWith('ic') || 
+                                   lowerWord.endsWith('al') || 
+                                   lowerWord.endsWith('ent') || 
+                                   lowerWord.endsWith('ant') || 
+                                   lowerWord.endsWith('able') || 
+                                   lowerWord.endsWith('ible');
+            
+            // 只为短形容词生成比较级和最高级
+            if (!isMultisyllabic) {
+                // 比较级 (-er)
+                if (lowerWord.endsWith('e')) {
+                    allForms.add(lowerWord + 'r');
+                } else if (lowerWord.endsWith('y') && !['a', 'e', 'i', 'o', 'u'].includes(lowerWord.charAt(lowerWord.length - 2))) {
+                    allForms.add(lowerWord.slice(0, -1) + 'ier');
+                } else if (lowerWord.length > 2 && 
+                          !['a', 'e', 'i', 'o', 'u'].includes(lowerWord.charAt(lowerWord.length - 1)) && 
+                          ['a', 'e', 'i', 'o', 'u'].includes(lowerWord.charAt(lowerWord.length - 2)) && 
+                          !['a', 'e', 'i', 'o', 'u'].includes(lowerWord.charAt(lowerWord.length - 3))) {
+                    // 双写末尾辅音字母的情况，如 big -> bigger
+                    allForms.add(lowerWord + lowerWord.charAt(lowerWord.length - 1) + 'er');
+                } else {
+                    allForms.add(lowerWord + 'er');
+                }
+                
+                // 最高级 (-est)
+                if (lowerWord.endsWith('e')) {
+                    allForms.add(lowerWord + 'st');
+                } else if (lowerWord.endsWith('y') && !['a', 'e', 'i', 'o', 'u'].includes(lowerWord.charAt(lowerWord.length - 2))) {
+                    allForms.add(lowerWord.slice(0, -1) + 'iest');
+                } else if (lowerWord.length > 2 && 
+                          !['a', 'e', 'i', 'o', 'u'].includes(lowerWord.charAt(lowerWord.length - 1)) && 
+                          ['a', 'e', 'i', 'o', 'u'].includes(lowerWord.charAt(lowerWord.length - 2)) && 
+                          !['a', 'e', 'i', 'o', 'u'].includes(lowerWord.charAt(lowerWord.length - 3))) {
+                    // 双写末尾辅音字母的情况，如 big -> biggest
+                    allForms.add(lowerWord + lowerWord.charAt(lowerWord.length - 1) + 'est');
+                } else {
+                    allForms.add(lowerWord + 'est');
+                }
+            }
+            
+            // 副词变形 (-ly)，只为真正的形容词生成副词形式
+            if (!lowerWord.endsWith('ly')) {
+                if (lowerWord.endsWith('y') && !['a', 'e', 'i', 'o', 'u'].includes(lowerWord.charAt(lowerWord.length - 2))) {
+                    allForms.add(lowerWord.slice(0, -1) + 'ily');
+                } else if (lowerWord.endsWith('le')) {
+                    allForms.add(lowerWord.slice(0, -1) + 'y');
+                } else {
+                    allForms.add(lowerWord + 'ly');
+                }
+            }
+        }
+        
+        // 名词复数形式 (对大多数单词都适用)
+        if (lowerWord.length >= 2 && !lowerWord.endsWith('ing') && !lowerWord.endsWith('ed')) {
+            if (lowerWord.endsWith('s') || lowerWord.endsWith('x') || lowerWord.endsWith('ch') || lowerWord.endsWith('sh') || lowerWord.endsWith('z')) {
+                allForms.add(lowerWord + 'es');
+            } else if (lowerWord.endsWith('y') && !['a', 'e', 'i', 'o', 'u'].includes(lowerWord.charAt(lowerWord.length - 2))) {
+                allForms.add(lowerWord.slice(0, -1) + 'ies');
+            } else if (lowerWord.endsWith('f')) {
+                allForms.add(lowerWord.slice(0, -1) + 'ves');
+            } else if (lowerWord.endsWith('fe')) {
+                allForms.add(lowerWord.slice(0, -2) + 'ves');
+            } else {
+                allForms.add(lowerWord + 's');
+            }
+        }
+        
+        return [...allForms];
     },
+    
+    /**
+     * 检查单词是否符合特定的变形规则
+     * @param {string} word - 要检查的单词
+     * @param {string} base - 基本形式
+     * @returns {boolean} - 是否符合变形规则
+     */
+    checkSpecialWordForms(word, base) {
+        // 使用 getWordAllForms 获取基本形式的所有可能变形
+        const baseForms = this.getWordAllForms(base);
+        if (baseForms.includes(word)) {
+            return true;
+        }
+        
+        // 反向检查：如果 word 是基本形式，base 是变形
+        const wordForms = this.getWordAllForms(word);
+        if (wordForms.includes(base)) {
+            return true;
+        }
+        
+        return false;
+    }
 }