Regex: match everything but specific pattern

Regex: match everything but:

• a string starting with a specific pattern (e.g. any - empty, too - string not starting with foo):
  • Lookahead-based solution for NFAs:
    • ^(?!foo).*$
    • ^(?!foo)
• Negated character class based solution for regex engines not supporting lookarounds:
  • ^(([^f].{2}|.[^o].|.{2}[^o]).*|.{0,2})$
  • ^([^f].{2}|.[^o].|.{2}[^o])|^.{0,2}$
• a string ending with a specific pattern (say, no world. at the end):
  • Lookbehind-based solution:
    • (?<!world\.)$
    • ^.*(?<!world\.)$
  • Lookahead solution:
    • ^(?!.*world\.$).*
    • ^(?!.*world\.$)
  • POSIX workaround:
    • ^(.*([^w].{5}|.[^o].{4}|.{2}[^r].{3}|.{3}[^l].{2}|.{4}[^d].|.{5}[^.])|.{0,5})$
    • ([^w].{5}|.[^o].{4}|.{2}[^r].{3}|.{3}[^l].{2}|.{4}[^d].|.{5}[^.]$|^.{0,5})$
• a string containing specific text (say, not match a string having foo) (no POSIX compliant patern, sorry):
  • ^(?!.*foo)
  • ^(?!.*foo).*$
• a string containing specific character (say, avoid matching a string having a | symbol):
  • ^[^|]*$
• a string equal to some string (say, not equal to foo):
  • Lookaround-based:
    • ^(?!foo$)
    • ^(?!foo$).*$
  • POSIX:
    • ^(.{0,2}|.{4,}|[^f]..|.[^o].|..[^o])$
• a sequence of characters:
  • PCRE (match any text but cat): /cat(*SKIP)(*FAIL)|[^c]*(?:c(?!at)[^c]*)*/i or /cat(*SKIP)(*FAIL)|(?:(?!cat).)+/is
  • Other engines allowing lookarounds: (cat)|[^c]*(?:c(?!at)[^c]*)* (or (?s)(cat)|(?:(?!cat).)*, or (cat)|[^c]+(?:c(?!at)[^c]*)*|(?:c(?!at)[^c]*)+[^c]*) and then check with language means: if Group 1 matched, it is not what we need, else, grab the match value if not empty
• a certain single character or a set of characters:
  • Use a negated character class: [^a-z]+ (any char other than a lowercase ASCII letter)
  • Matching any char(s) but |: [^|]+

Demo note: the newline \n is used inside negated character classes in demos to avoid match overflow to the neighboring line(s). They are not necessary when testing individual strings.

Anchor note: In many languages, use \A to define the unambiguous start of string, and \z (in Python, it is \Z, in JavaScript, $ is OK) to define the very end of the string.

Dot note: In many flavors (but not POSIX, TRE, TCL), . matches any char but a newline char. Make sure you use a corresponding DOTALL modifier (/s in PCRE/Boost/.NET/Python/Java and /m in Ruby) for the . to match any char including a newline.

Backslash note: In languages where you have to declare patterns with C strings allowing escape sequences (like \n for a newline), you need to double the backslashes escaping special characters so that the engine could treat them as literal characters (e.g. in Java, world\. will be declared as "world\\.", or use a character class: "world[.]"). Use raw string literals (Python r'\bworld\b'), C# verbatim string literals @"world\.", or slashy strings/regex literal notations like /world\./.

Not a regexp expert, but I think you could use a negative lookahead from the start, e.g. ^(?!foo).*$ shouldn't match anything starting with foo.

You can put a ^ in the beginning of a character set to match anything but those characters.

[^=]*

will match everything but =