高效在Node.js中检测字符串是否包含英文单词

// 假设这是我们预处理后的字典哈希映射
const dictionaryMap = {
   'hom': 'e',          // 对应单词 'home'
   'cat': '',           // 对应单词 'cat'
   'bot': 'tle',        // 对应单词 'bottle'
   'gla': ['ss', 'cier'] // 对应单词 'glass' 和 'glacier'
   // ... 更多词条
};

// 概念性的Trie树结构
const trieDictionary = {
  'h': {
    'o': {
      'm': {
        'e': { '$isWord': true } // '$isWord' 标记表示到此构成一个完整单词
      }
    }
  },
  'b': {
    'o': {
      't': {
        't': {
          'l': {
            'e': { '$isWord': true }
          }
        }
      }
    }
  },
  'g': {
    'l': {
      'a': {
        's': {
          's': { '$isWord': true }
        },
        'c': {
          'i': {
            'e': {
              'r': { '$isWord': true }
            }
          }
        }
      }
    }
  }
  // ... 更多词条
};

function containsEnglishWord(sourceString, dictionaryMap) {
    const minWordLength = 4; // 题目要求长度大于3，即至少4个字符

    // 假设我们从前三个字符开始匹配
    const prefixLength = 3; 

    for (let i = 0; i <= sourceString.length - minWordLength; i++) {
        const currentPrefix = sourceString.substring(i, i + prefixLength);

        if (dictionaryMap.hasOwnProperty(currentPrefix)) {
            // 如果找到了前缀，说明这里“很可能”有一个英文单词
            // 此时，需要进一步验证后缀以确认完整的单词
            const possibleSuffixes = dictionaryMap[currentPrefix];

            // 示例：简单处理单个后缀的情况
            if (typeof possibleSuffixes === 'string') {
                const fullWord = currentPrefix + possibleSuffixes;
                if (sourceString.substring(i, i + fullWord.length) === fullWord && fullWord.length >= minWordLength) {
                    console.log(`Found word: ${fullWord}`);
                    return true;
                }
            } 
            // 示例：处理多个后缀的情况 (如 'gla': ['ss', 'cier'])
            else if (Array.isArray(possibleSuffixes)) {
                for (const suffix of possibleSuffixes) {
                    const fullWord = currentPrefix + suffix;
                    if (sourceString.substring(i, i + fullWord.length) === fullWord && fullWord.length >= minWordLength) {
                        console.log(`Found word: ${fullWord}`);
                        return true;
                    }
                }
            }
            // 对于更复杂的场景，例如需要查找任意长度的单词，
            // 或者字典中只存前缀，需要从这里开始向后匹配，
            // 可以结合Trie树或动态规划的思想进行更精确的匹配。
            // 例如，如果 dictionaryMap[currentPrefix] 只是一个标记，
            // 我们可以从 i+prefixLength 位置开始，继续尝试匹配后续字符，
            // 直到在字典中找到一个完整的单词。
        }
    }
    return false;
}

// 示例用法
const myDictionaryMap = {
   'hom': 'e',
   'bot': 'tle',
   'gla': ['ss', 'cier'],
   'appl': 'e'
};

console.log(containsEnglishWord("y89nsdadhomea98qwoi", myDictionaryMap));    // true
console.log(containsEnglishWord(":_5678aSD.boTTleads.", myDictionaryMap));  // true (注意大小写处理可能需要预处理或正则)
console.log(containsEnglishWord("yfugdnuagybdasglassesmidwqihhniwqnhi", myDictionaryMap)); // true
console.log(containsEnglishWord("y89nsdadhasa98qwoi", myDictionaryMap));    // false
console.log(containsEnglishWord(":_5678aSD.b0TTle4ds.", myDictionaryMap));  // false

// 假设 trieDictionary 已经构建完成
function searchTrie(node, charIndex, sourceString, minWordLength) {
    if (!node) return false;

    // 检查当前节点是否标记为一个完整的单词，并且满足长度要求
    if (node['$isWord'] && (charIndex - node['$wordStart']) >= minWordLength) {
        return true;
    }

    if (charIndex >= sourceString.length) {
        return false;
    }

    const char = sourceString[charIndex].toLowerCase(); // 统一小写处理

    if (node[char]) {
        return searchTrie(node[char], charIndex + 1, sourceString, minWordLength);
    }

    return false;
}

function containsEnglishWordWithTrie(sourceString, trieDictionary, minWordLength = 4) {
    for (let i = 0; i < sourceString.length; i++) {
        // 为Trie搜索设置起始节点和起始索引
        // 在Trie中，我们需要知道单词的开始位置来计算长度
        const rootNode = { ...trieDictionary, '$wordStart': i }; // 临时添加一个属性来记录起始位置
        if (searchTrie(rootNode, i, sourceString, minWordLength)) {
            return true;
        }
    }
    return false;
}

// 假设 trieDictionary 已经如上文所示构建
// 注意：实际的Trie构建需要确保每个单词路径上的节点都包含一个'$isWord'标记
// 并且在构建时，如果需要计算长度，可能需要存储单词的完整路径或长度。
// 为了简化，这里假设 $isWord 标记存在且可以判断。
// 实际应用中，searchTrie函数可能需要返回匹配到的单词或其长度，以便进行长度判断。