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);

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

javascript中必须有另一种简单的方法。替换子串并不是真的发生在这里。

＆＃34; one_test_line＆＃34;实际上是一个带有事务描述的HTML表col。但这个例子很好：
"The quick brown fox jumps over the lazy dog"并替换“狗”，“拥有”＆＃39;和＃跳过＆＃39;，给予：

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

没有狗，在这个例子中没有任何东西会被替换/标记。

更新：在再次查看问题的同时，我在替换器中提出了一个正则表达式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个字符串可以在行中具有任何顺序

1 个答案: