javascript - 用正则表达式替换行中的N个字符串，其中N个字符串可以在行中具有任何顺序

我尝试以任意顺序查找包含许多字符串的行。
接下来，将行内的字符串替换为<mark>string-n</mark>。

我使用一个小型解析器，将"string-1&&string-2&&string-N'转换为
 正则表达式模式：(?=.*(string-1))(?=.*(string-2))(?=.*(string-N)).*

这对于查找至少包含所有N个字符串的行效果很好，但是必须有一种更好的方法来替换/标记每行的字符串。

代码：

function replacer() {
    console.log('args', arguments);
    const arg_len = arguments.length;
    let result =  arguments[arg_len - 1];
    for (let i = 1; i < arg_len - 2; i++) {
        let re = new RegExp(arguments[i], 'gum');
        result = result.replace(re, `<mark>${arguments[i]}</mark>`);
    }
    return result
}
function testAndPattern(one_test_line) {
    const and_pattern = 'string-1&&string-2&&string-n';
    const regex_pattern = buildRexPattern(and_pattern);
    let result = one_test_line.replace(new RegExp(regex_pattern,"gum"), replacer);
    console.log('result', result);

替换参数参数对象显示一次：{0: '..one_test_line..', 1:'string-1', 2:'string-2', 3:'string-n', 4:0, 5: '..One_test_line..'}
结果也很好。但是我需要在替换器中使用很多正则表达式。

javascript中必须有另一种简单的方法。子字符串替换实际上不是在这里发生。

“ one_test_line”实际上是带有事务描述的HTML表列。但最好是这个例子：
"The quick brown fox jumps over the lazy dog"并替换“ dog”，“ own”和“ jumps over”，得到：

"The quick br<mark>own</mark> fox <mark>jumps over</mark> the lazy <mark>dog</mark>"

如果没有狗，则在此示例中不会替换/标记任何内容。

更新：在再次查看问题时，我在诸如/string-1|string-2|string-N/g之类的替换器中提出了一个正则表达式OR，因为在替换器中，我们知道所有N个字符串都存在。

    function marker(arg) {
        return `<mark>${arg}</mark>`;
    }
    function replacer(re_or) {
        return function() {
            return arguments[0].replace(re_or, marker)
        }
    }
    function testAndPattern(one_test_line) {
        const and_pattern = 'string-1&&string-2&&string-n'
        const or_pattern = and_pattern.split('&&').join('|');
        const regex_pattern = buildRexPattern(and_pattern);
        let result = one_test_line.replace(new RegExp(regex_pattern,"gum"), replacer(new RegExp(`(${or_pattern})`,"gum")));
        console.log('result', result);
    }

最佳答案

在再次查看问题时，我在替换程序中提出了一个正则表达式OR，例如/ string-1 | string-2 | string-N / g，因为在替换程序中我们知道所有N个字符串都存在。

function marker(arg) {
    return `<mark>${arg}</mark>`;
}
function replacer(re_or) {
    return function(match) {
        return match.replace(re_or, marker)
    }
}
function testAndPattern(one_test_line) {
    const and_pattern = 'string-1&&string-2&&string-n'
    const or_pattern = and_pattern.split('&&').join('|');
    const regex_pattern = buildRexPattern(and_pattern);
    let result = one_test_line.replace(new RegExp(regex_pattern,"gum"), replacer(new RegExp(`(${or_pattern})`,"gum")));
    console.log('result', result);
}

在解析器下方：

function buildRexPattern(raw_pattern) {
    let pattern = '';
    const p_list = raw_pattern.split('&&');
    // search and-ed list items in any order
    if (p_list.length > 1) {
        for (let i = 0; i < p_list.length; i++) {
            pattern += `(?=.*(${p_list[i]}))`
        }
        pattern += '.*';
        return  pattern;
    } else {
        // search or-ed items in any order, example 'string-1|string-2|string-N'
        return raw_pattern;
    }
}