Question

我正在使用这个正则表达式：

var regex = /\<.*?.\>/g

与此字符串匹配：

var str = 'This <is> a string to <use> to test the <regular> expression'

使用简单匹配：

str.match(regex)

并且，正如所料，我得到：

["<is>", "<use>", "<regular>"]

（但没有反斜杠，抱歉任何可能的混淆）

如何获得相反的结果？即我需要哪些正则表达式不会返回<和>之间包含的那些项目？

我尝试了/(^\<.*?\>)/g和各种其他类似的组合，包括方括号和东西。我有很多很酷的结果，没有什么是我想要的。

我要去的地方：基本上我想搜索和替换子串的出现，但我想排除一些搜索空间，可能使用＆lt;和＆gt;。我真的不想要一个破坏性的方法，因为我不想拆分字符串，改变它们，并担心重建它们。

当然我可以通过搜索字符串'手动'来做到这一点，但我认为正则表达式应该能够很好地处理这个问题。唉，我的知识不是它需要的地方!!

Answer 1

这是一种自定义替换标记之外的所有内容，并从标记部分中剥离标记的方法http://jsfiddle.net/tcATT/

var string = 'This <is> a string to <use> to test the <regular> expression';
// The regular expression matches everything, but each val is either a
// tagged value (<is> <regular>), or the text you actually want to replace
// you need to decide that in the replacer function
console.log(str.replace( /[^<>]+|<.*?>/g, function(val){
    if(val.charAt(0) == '<' && val.charAt(val.length - 1) == '>') {
      // Just strip the < and > from the ends
      return val.slice(1,-1);
    } else {
      // Do whatever you want with val here, I'm upcasing for simplicity
      return val.toUpperCase(); 
    }
} ));
// outputs: "THIS is A STRING TO use TO TEST THE regular EXPRESSION"

要概括它，您可以使用

function replaceOutsideTags(str, replacer) {
    return str.replace( /[^<>]+|<.*?>/g, function(val){
        if(val.charAt(0) == '<' && val.charAt(val.length - 1) == '>') {
          // Just strip the < and > from the ends
          return val.slice(1,-1);
        } else {
          // Let the caller decide how to replace the parts that need replacing
          return replacer(val); 
        }
    })
}
// And call it like
console.log(
    replaceOutsideTags( str, function(val){
        return val.toUpperCase();
    })
);

Answer 2

如果我理解正确，您希望对字符串应用一些自定义处理，但 protected 的部分除外（用<和>括起来）？如果是这样的话，你可以这样做：

// The function that processes unprotected parts
function process(s) {
    // an example could be transforming whole part to uppercase:
    return s.toUpperCase();
}

// The function that splits string into chunks and applies processing
// to unprotected parts
function applyProcessing (s) {
    var a = s.split(/<|>/),
        out = '';

    for (var i=0; i<a.length; i++)
        out += i%2
                ? a[i]
                : process(a[i]);

    return out;
}

// now we just call the applyProcessing()
var str1 = 'This <is> a string to <use> to test the <regular> expression';
console.log(applyProcessing(str1));
// This outputs:
// "THIS is A STRING TO use TO TEST THE regular EXPRESSION"

// and another string:
var str2 = '<do not process this part!> The <rest> of the a <string>.';
console.log(applyProcessing(str2));
// This outputs:
// "do not process this part! THE rest OF THE A string."

基本上就是这样。它返回整个字符串，处理未受保护的部分。

请注意，如果尖括号（<和>）不平衡，分割将无法正常工作。

有各种各样的地方可以改进，但我会把它作为读者的优秀。 ; P

Answer 3

这是将正则表达式参数传递给核心String.split()方法的完美应用程序：

var results = str.split(/<[^<>]*>/);

简单！

Answer 4

使用您已创建的变量，尝试使用replace。它也是非破坏性的。

str.replace(regex, '');
--> "This  a string to  to test the  expression"

Answer 5

/\b[^<\W]\w*(?!>)\b/g

这有效，测试出来：

var str = 'This <is> a string to <use> to test the <regular> expression.';
var regex = /\<.*?.>/g;
console.dir(str.match(regex));
var regex2 = /\b[^<\W]\w*(?!>)\b/g;
console.dir(str.match(regex2));

Answer 6

啊，好的，对不起 - 我误解了你的问题。这是javascript中使用纯正则表达式解决的难题，因为javascript不支持lookbehinds，通常我认为我会使用lookaheads和lookbehinds来解决这个问题。一种（某种人为的）做法就是这样：

str.replace(/((?:<[^>]+>)?)([^<]*)/g, function (m, sep, s) { return sep + s.replace('test', 'FOO'); })

// --> "This <is> a string to <use> to FOO the <regular> expression"

这也适用于"This test <is> a string to <use> to test the <regular> expression"之类的字符串，如果您在更换器功能中使用/test/g而不是'test'，它也会转为

"This test <is> a string to <use> to test the test <regular> expression"

到

"This FOO <is> a string to <use> to FOO the FOO <regular> expression"

<强>更新

这样的事情也会剥夺＆lt;＆gt;字符：

str.replace(/((?:<[^>]+>)?)([^<]*)/g, function (m, sep, s) { return sep.replace(/[<>]/g, '') + s.replace(/test/g, 'FOO'); })

"This test <is> a string to <use> to test the test <regular> expression"
--> "This FOO is a string to use to FOO the FOO regular expression"

Answer 7

试试这个正则表达式：

\b\w+\b(?!>)

更新

要支持括号内的空格，请尝试这一个。它不是纯粹的regex.match，但它有效，而且上面的答案要简单得多：

alert('This <is> a string to <use use> to test the <regular> expression'.split(/\s*<.+?>\s*/).join(' '));

Javascript正则表达式 - 如何不匹配＆lt;之间的子字符串和＆gt;

7 个答案: