通过字典查找和替换，仅使用一次键

Question

这是Find multiple keywords within a dictionary的后续。

我的问题是……

1. 第一个是：我相信这匹配不完整的单词。就像我的字典中的 short 一样，它与该词很快匹配。我将如何阻止这一切？

2. 第二个不那么重要但很好的是：我将如何使它每个内容只匹配一次？所以short不会在同一个内容区域内被定义两次。

谢谢！

Answer 1

我已经实现了以下附加要求：

• 在查找short时不要匹配shortly（因为shortly是一个不同的词）
• 字典中的键只能使用一次。
  示例输入：key=foo，replacement=bar，content=foo foo。
  输出：bar foo（仅替换第一个 foo）。

演示：http://jsfiddle.net/bhGE3/3/

用法：

1. 定义dictionary。每个密钥只能使用一次。
2. 定义content。将基于此字符串创建一个新字符串。
3. 可选地，定义一个replacehandler 函数。这个函数在每场比赛中被调用。返回值将用于替换匹配的短语。
   默认replacehandler 将返回字典的匹配短语。该函数应接受两个参数：key 和 dictionary。
4. 致电replaceOnceUsingDictionary(dictionary, content, replacehandler)
5. 处理输出，例如。向用户显示content。

代码：

var dictionary = {
    "history": "war . ",
    "no": "in a",
    "nothing": "",
    "oops": "",
    "time": "while",
    "there": "We",
    "upon": "in",
    "was": "get involved"
};
var content = "Once upon a time... There was no history. Nothing. Oops";
content = replaceOnceUsingDictionary(dictionary, content, function(key, dictionary){
    return '_' + dictionary[key] + '_';
});
alert(content);
// End of implementation

/*
* @name        replaceOnceUsingDictionary
* @author      Rob W http://stackoverflow.com/users/938089/rob-w
* @description Replaces phrases in a string, based on keys in a given dictionary.
*               Each key is used only once, and the replacements are case-insensitive
* @param       Object dictionary  {key: phrase, ...}
* @param       String content
* @param       Function replacehandler
* @returns     Modified string
*/
function replaceOnceUsingDictionary(dictionary, content, replacehandler) {
    if (typeof replacehandler != "function") {
        // Default replacehandler function.
        replacehandler = function(key, dictionary){
            return dictionary[key];
        }
    }
    
    var patterns = [], // \b is used to mark boundaries "foo" doesn't match food
        patternHash = {},
        oldkey, key, index = 0,
        output = [];
    for (key in dictionary) {
        // Case-insensitivity:
        key = (oldkey = key).toLowerCase();
        dictionary[key] = dictionary[oldkey];
        
        // Sanitize the key, and push it in the list
        patterns.push('\\b(?:' + key.replace(/([[^$.|?*+(){}])/g, '\\$1') + ')\\b');
        
        // Add entry to hash variable, for an optimized backtracking at the next loop
        patternHash[key] = index++;
    }
    var pattern = new RegExp(patterns.join('|'), 'gi'),
        lastIndex = 0;

    // We should actually test using !== null, but for foolproofness,
    //  we also reject empty strings
    while (key = pattern.exec(content)) {
        // Case-insensitivity
        key = key[0].toLowerCase();

        // Add to output buffer
        output.push(content.substring(lastIndex, pattern.lastIndex - key.length));
        // The next line is the actual replacement method
        output.push(replacehandler(key, dictionary));

        // Update lastIndex variable
        lastIndex = pattern.lastIndex;

        // Don't match again by removing the matched word, create new pattern
        patterns[patternHash[key]] = '^';
        pattern = new RegExp(patterns.join('|'), 'gi');

        // IMPORTANT: Update lastIndex property. Otherwise, enjoy an infinite loop
        pattern.lastIndex = lastIndex;
    }
    output.push(content.substring(lastIndex, content.length));
    return output.join('');
}