正则表达式匹配除给定列表之外的所有单词

Question

I am trying to write a replacement regular expression to surround all words in quotes except the words AND, OR and NOT.

I have tried the following for the match part of the expression:

(?i)(?<word>[a-z0-9]+)(?<!and|not|or)

and

(?i)(?<word>[a-z0-9]+)(?!and|not|or)

but neither work. The replacement expression is simple and currently surrounds all words.

"${word}"

So

This and This not That

becomes

"This" and "This" not "That"

Answer 1

This is a little dirty, but it works:

(?<!\b(?:and| or|not))\b(?!(?:and|or|not)\b)

In plain English, this matches any word boundary not preceded by and not followed by "and", "or", or "not". It matches whole words only, eg the position after the word "sand" would not be a match just because it is preceded by "and".

The space in front of the "or" in the zero-width look-behind assertion is necessary to make it a fixed length look-behind. Try if that already solves your problem.

EDIT: Applied to the string "except the words AND, OR and NOT." as a global replace with single quotes, this returns:

'except' 'the' 'words' AND, OR and NOT.

Answer 2

John,

The regex in your question is almost correct. The only problem is that you put the lookahead at the end of the regex instead of at the start. Also, you need to add word boundaries to force the regex to match whole words. Otherwise, it will match "nd" in "and", "r" in "or", etc, because "nd" and "r" are not in your negative lookahead.

(?i)\\b(?!and|not|or)(?[a-z0-9]+)\\b

Answer 3

Call me crazy, but I'm not a fan of fighting regex; I limit my patterns to simple things I can understand, and often cheat for the rest - for example via a MatchEvaluator :

    string[] whitelist = new string[] { "and", "not", "or" };
    string input = "foo and bar or blop";
    string result = Regex.Replace(input, @"([a-z0-9]+)",
        delegate(Match match) {
            string word = match.Groups[1].Value;
            return Array.IndexOf(whitelist, word) >= 0
                ? word : ("\"" + word + "\"");
        });

(edited for more terse layout)

Answer 4

Based on Tomalaks answer:

(?<!and|or|not)\b(?!and|or|not)

This regex has two problems:

1. (?<! ) only works for fixed length look-behind

2. The previous regex only looked at end ending/beginning of the surrounding words, not the whole word.

(?<!\\band)(?<!\\bor)(?<!\\bnot)\\b(?!(?:and|or|not)\\b)

This regex fixes both the above problems. First by splitting the look-behind into three separate ones. Second by adding word-boundaries ( \\b ) inside the look-arounds.

Answer 5

To match any "word" that is a combination of letters, digits or underscores (including any other word chars defined in the \\w shorthand character class ) , you may use word boundaries like in

\b(?!(?:word1|word2|word3)\b)\w+

If the "word" is a chunk of non-whitespace characters with start/end of string or whitespace on both ends use whitespace boundaries like in

(?<!\S)(?!(?:word1|word2|word3)(?!\S))\S+

Here, the two expressions will look like

\b(?!(?:and|not|or)\b)\w+
(?<!\S)(?!(?:and|not|or)(?!\S))\S+

See the regex demo (or, a popular regex101 demo , but please note that PCRE \\w meaning is different from the .NET \\w meaning.)

Pattern explanation

• \\b - word boundary
• (?<!\\S) - a negative lookbehind that matches a location that is not immediately preceded with a character other than whitespace, it requires a start of string position or a whitespace char to be right before the current location
• (?!(?:word1|word2|word3)\\b) - a negative lookahead that fails the match if, immediately to the right of the current location, there is word1 , word2 or word3 char sequences followed with a word boundary (or, if (?!\\S) whitespace right-hand boundary is used, there must be a whitespace or end of string immediately to the right of the current location)
• \\w+ - 1+ word chars
• \\S+ - 1+ chars other than whitespace

In C#, and any other programming language, you may build the pattern dynamically, by joining array/list items with a pipe character, see the demo below:

var exceptions = new[] { "and", "not", "or" };
var result = Regex.Replace("This and This not That", 
        $@"\b(?!(?:{string.Join("|", exceptions)})\b)\w+",
        "\"$&\"");
Console.WriteLine(result); // => "This" and "This" not "That"

If your "words" may contain special characters, the whitespace boundaries approach is more suitable, and make sure to escape the "words" with, say, exceptions.Select(Regex.Escape) :

var pattern = $@"(?<!\S)(?!(?:{string.Join("|", exceptions.Select(Regex.Escape))})(?!\S))\S+";

NOTE : If there are too many words to search for, it might be a better idea to build a regex trie out of them.

Answer 6

(?!\bnot\b|\band\b|\bor\b|\b\"[^"]+\"\b)((?<=\s|\-|\(|^)[^\"\s\()]+(?=\s|\*|\)|$))

我使用这个正则表达式来查找所有不在双引号内的单词，或者是单词“not”、“and”或“or”。