Look-Around | a Application name LookAround run in Android Platinum

You may use this regex:

tl;dr:

• Inside a look-behind assertion, a greedy subexpression in effect behaves non-greedily (in global matching in addition to acting greedily), due to considering every prefix string of the input string.

My problem was that I hadn't considered that, in a look-behind assertion, each and every character position in the input string must be checked for the preceding text up to that point to match the subexpression in the lookbehind assertion.

This, combined with the always-global replacement that PowerShell's -replace operator performs (that is, all possible matches are performed), resulted in multiple insertions:

That is, the greedy, anchored subexpression ^.+_ legitimately matched twice, when considering the text to the left of the character position currently being considered:

• First, when a_ was the text to the left.
• And again when a_b_ was the text to the left.

Therefore, two insertions of | resulted.

By contrast, without a look-behind assertion, greedy expression ^.+_ by definition only matches once, through to the last _, because it is only applied to the entire input string.

Your LOOKAHEAD_REGEX looks for a character not in the range in any position after the match, but the original regex with lookahead only looks at the single character immediately after the match. This is why your code finds /bridge and regex101 doesn't: your code sees the . somewhere after the match whereas regex101 only looks at the *.

You can fix your code by anchoring LOOKAHEAD_REGEX so that it will only look at the first character: ^[^a-z0-9%*].

Aternatively, as suggested by @Sven Marnach, you can use a single regex matching the full expression: [^a-z0-9%*][a-z0-9%]{3,}[^a-z0-9%*], and strip the last character of the match.

I think your problem is beyond the capability of a regex. I think the simplest sound way to approach it is to write a tokenizer to examine all the tokens in the string in order, one at a time.

If the input file is just a comment followed by a list of URLs, try:

You can use the regex below for your requirement:

The issue at hand is what is meant by "regular expression". Wikipedia has good information on this, but a simple summary is that a regular language is one defined with a few simple operations, including literal matches, alternation, and the Kleene star (match zero or more). Regex libraries have added features that don't extend this language, but make it easier to use (such as being able to say [a-z] instead of (a|b|c|d|e|f...|z)).

Then, along came Perl, which implemented support for regular expressions. However, instead of using the commonly used NFA/DFA implementation for regular expressions, it implemented them using backtracking. There are two consequences of this, one, it allowed things beyond regular languages to be added, such as backtracking, and two, it can be really, really slow.

Many languages used these backtracking implementations of regular expressions, but there has been a somewhat recent resurgence of removing the features from the expressions that make them difficult to implement efficiently, specifically backtracking. Go has done this, the Re2 library is a C/C++ implementation of this. And, as you've discovered the regex crate also works this way. The advantage is that it always matches in linear time.

For your particular example, what you are trying to match is indeed still a regular language, it just has to be expressed differently. Let's start with the easy part, matching the characters, but not allowing consecutive dots. Instead of thinking of it this way, think of it as matching possibly a dot between the characters, but the characters themselves aren't options. In other words, we can match with: [a-z0-9](\.?[a-z0-9])*. We first match a single character. If you want to allow this to start with a dot, you could remove this part. Then we need zero or more occurrences of an optional dot followed by a single non-dot character. You could append a \.? if you want to allow a dot at the end.

The second requirement, of 3-30 characters would make this regex rather complicated, because our repeated sequence is of 1 or 2 characters. I would suggest, instead, just checking the length programmatically in addition to checking the regex. You could also make a second regex that checks the length, and check that both match (Regular languages do not have an and operation).

You may also find, depending on how your are matching, you may have to anchor the match (putting a ^ at the start and a $ at the end).

A solution to the full problem: