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

Question

我尝试查找包含任意顺序的多个字符串的行。
接下来，我用 <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 table 列。但最好是这个例子：
"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>"

没有狗，本例中不会替换/标记任何内容。

Update：在再次查看问题时，我在替换器中想出了一个正则表达式 OR，例如 /string-1|string-2|string-N/g 因为在替换器中我们知道所有 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);
    }

Answer 1

在再次查看问题时，我在替换器中提出了一个正则表达式 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;
    }
}

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

Replacing N strings in lines with a regex, where the N strings can have any order in the line

javascript

regex

callback

regex-lookarounds