Well let’s take your tooth example – here is what the regex-engine does (a lot simplified for better understanding) Start with t then look ahead in the string – and fail the lookahead, as there is another t. tooth ^ ° Next take o, look ahead in the string – and fail, as there is … Read more
You can use a negative lookahead (documented under “Extended Patterns” in perlre): /^\/(?!bob\/)/
You can use negative lookaheads: ^(?!.*\.\.).*$ That causes the expression to not match if it can find a sequence of two periods anywhere in the string.
Try String regex = “/foo/(?!.*bar).+”; or possibly String regex = “/foo/(?!.*\\bbar\\b).+”; to avoid failures on paths like /foo/baz/crowbars which I assume you do want that regex to match. Explanation: (without the double backslashes required by Java strings) /foo/ # Match “/foo/” (?! # Assert that it’s impossible to match the following regex here: .* # … Read more
Negative lookahead isn’t supported for technical reasons, specifically because it conflicts with the O(n)-time guarantees of the library. See the golang-nuts group discussion about this, as well as the Caveats section in Regular Expression Matching in the Wild. You can express the regular expression you’ve described without negative lookahead: BBB([^B]|B[^B]|BB[^B])*EEE Here’s an example to demonstrate: … Read more
Lookaheads do not consume any characters. It just checks if the lookahead can be matched or not: a(?!b)c So here after matching a it just checks if it is followed not by b but does not consume that not character (which is c) and is followed by c. How a(?!b)c matches ac ac | a … Read more
Python re lookbehinds really need to be fixed-width, and when you have alternations in a lookbehind pattern that are of different length, there are several ways to handle this situation: Rewrite the pattern so that you do not have to use alternation (e.g. Tim’s above answer using a word boundary, or you might also use … Read more
Your attempt was pretty close; you need to pull the .* that allows an arbitrary distance between the match and the asserted later non-match into the negative look-ahead: /abc\(.*xyz\)\@! I guess this works because the non-match is attempted for all possible matches of .*, and only when all branches have been exhausted is the \@! … Read more
The problem is pretty simple really. This will do it: /^(?!.*foo\.htm$).*\.htm$/i.test(“/foo.htm”); // returns false
sed -i ‘/^foo/! s/^/bar/’ file.txt -i change the file in place /^foo/! only perform the next action on lines not ! starting with foo ^foo s/^/bar/ change the start of the line to bar