How can I invert a regular expression in JavaScript?
I have a string A and want to test if another string B is not part of it. This is a very simple regex whose result can be inverted afterwards.
I could do:
/foobar/.test('[email protected]')
and invert it afterwards, like this:
!(/foobar/).test('[email protected]')
The problem I have is, that I need to do it within the regular expression and not with their result. Something like:
/!foobar/.test('[email protected]')
(which does not work)
In other words: the regular expression should test for a non-existence and return true in that case.
Is this possible with JavaScript?
Try:
/^(?!.*foobar)/.test('[email protected]')
A (short) explanation:
^ # start of the string
(?! # start negative look-ahead
.* # zero or more characters of any kind (except line terminators)
foobar # foobar
) # end negative look-ahead
So, in plain English, that regex will look from the start of the string if the string 'foobar' can be "seen". If it can be "seen" there is no* match.
* no match because it's negative look-ahead!
More about this look-ahead stuff: http://www.regular-expressions.info/lookaround.html But Note that JavaScript only supports look-aheads, no look-behinds!
^(?!.*(word1|word2|word3))
will match a string that does not contain any of word1
, word2
, or word3
(and you can extend the list indefinitely).
But this also matches null strings. To reject nulls use
^(?!$)(?!.*(word1|word2|word3))
Here's an example of an inequality. First I isolate the operator '<', later the operands 'a' and 'b'. Basically, I take the direct expression, include it into right parentheses, invert the latter by '^' and finally embed the resulting expression into square brackets, 'cause the '^' at the beginning would be interpreted differently.
var _str = "a < b" ;
var _op = /</g ;
var _no_op = /[^(<|\ )]/g ;
console.log( _str, _str.match( _op ) ); // get '<'
console.log( _str, _str.match( _no_op ) ); // get 'a', 'b'
P.s.: I just added the blank space in the inverse expression, in order to retrieve exact matching for the operands.