How do I use RegEx to pick longest match?

regex match longest sequence
regular expression shortest match
regex turn off greedy matching
pcre greedy match
regex greedy priority
regex force lazy
ruby greedy regex
greedy quantifier regex

I tried looking for an answer to this question but just couldn't finding anything and I hope that there's an easy solution for this. I have and using the following code in C#,

String pattern = ("(hello|hello world)");
Regex regex = new Regex(pattern, RegexOptions.IgnoreCase);
var matches = regex.Matches("hello world");

Question is, is there a way for the matches method to return the longest pattern first? In this case, I want to get "hello world" as my match as opposed to just "hello". This is just an example but my pattern list consist of decent amount of words in it.

If you already know the lengths of the words beforehand, then put the longest first. For example:

String pattern = ("(hello world|hello)");

The longest will be matched first. If you don't know the lengths beforehand, this isn't possible.

An alternative approach would be to store all the matches in an array/hash/list and pick the longest one manually, using the language's built-in functions.

How to order regular expression alternatives to get longest match , Python's NFA regexp engine trys only the first option, and happily rests on that. return out # empty is no matches, else longest match p = ['dodad' You can collect all successful parser results beginning from each index This is like taking Aspirin against a headache caused by an operable brain tumor. If the regex is outside of your control and does the wrong thing, either do not use it at all but your own regex or talk to the guy maintaining the regex generator in order to make him fix it for you upstream. – kriegaex Mar 5 '17 at 13:30

Regular expressions (will try) to match patterns from left to right. If you want to make sure you get the longest possible match first, you'll need to change the order of your patterns. The leftmost pattern is tried first. If a match is found against that pattern, the regular expression engine will attempt to match the rest of the pattern against the rest of the string; the next pattern will be tried only if no match can be found.

String pattern = ("(hello world|hello wor|hello)");

How to get the "longest possible" match with Python's RE module , In a regular expression, the vertical bar or pipe symbol tells the regex engine to match You can use alternation to match a single regular expression out of several it up to the implementation to choose a text-directed or regex-directed engine. But the POSIX standard does mandate that the longest match be returned,  How to Match with Regex “shortest match” in .NET. Would any issues arise from letting Sorcerers select different Metamagic options after a long rest?

Make two different regex matches. The first will match your longer option, and if that does not work, the second will match your shorter option.

string input = "hello world";

string patternFull = "hello world";
Regex regexFull = new Regex(patternFull, RegexOptions.IgnoreCase);

var matches = regexFull.Matches(input);

if (matches.Count == 0)
{
    string patternShort = "hello";
    Regex regexShort = new Regex(patternShort, RegexOptions.IgnoreCase);
    matches = regexShort.Matches(input);
}

At the end, matches will be be the output of "full" or "short", but "full" will be checked first and will short-circuit if it is true.

You can wrap the logic in a function if you plan on calling it many times. This is something I came up with (but there are plenty of other ways you can do this).

public bool HasRegexMatchInOrder(string input, params string[] patterns)
{
    foreach (var pattern in patterns)
    {
        Regex regex = new Regex(pattern, RegexOptions.IgnoreCase);

        if (regex.IsMatch(input))
        {
            return true;
        }
    }

    return false;
}

string input = "hello world";
bool hasAMatch = HasRegexMatchInOrder(input, "hello world", "hello", ...);

Regex Tutorial, Let's use the match method, which gives us information about the first Notice that our regular expression matched even though there are no  Tutorials Java Java visual regex tester. Guide to Regular Expressions in Java (Part 1) Guide to Regular Expressions in Java (Part 2) Spring to Java EE – A Migration Experience. Git Use “git reflog” and “git cherry-pick” to restore lost commits. Reset and sync local repository with remote branch.

Regular Expression behavior, Before you use regular expressions in your code, you can test them using apply quantifiers to sub-expressions; extract sub-strings matching a group When you know that you always want the longest conceivable match. The tables below are a reference to basic regex. While reading the rest of the site, when in doubt, you can always come back and look here. (It you want a bookmark, here's a direct link to the regex reference tables ). I encourage you to print the tables so you have a cheat sheet on your desk for quick reference.

Back to Basics: Regular Expressions, longest match be returned, regardless if the regex engine is implemented using an With some databases you can also use regular expressions to extract the. and it won't match: "apple" OR "apple from the" even though these also start with "a" and end with an "e". my problem is that instead of looking for the longest match, i want the shortest match. i've looked at the tutorials, but am still at a loss on how to do this. any help will be much appreciated.

Everything you need to know about Regular Expressions, extract first match + individual character groups *see, e.g. http://www.regular-​expressions.info/lookaround.html expressions using PERL = TRUE for base or by wrapping patterns with perl() matches the longest possible string. It can be. We do not need to create a Regex instance to use Match: we can invoke the static Regex.Match. This example builds up some complexity—we access Groups after testing Success. Part 1: This is the string we are testing. Notice how it has a file name part inside a directory name and extension. Part 2: We use the Regex.Match static method. The

Comments
  • If there are many words which could match, why do you propose a Regex rather than, say, a Dictionary?
  • that works! ordering the pattern by the length of the words did the trick. thanks!
  • I'm actually trying to avoid going that route because the pattern string actually contains a lot of words/keywords.
  • You can always wrap each regex call in a function, and call it multiple time. That will reduce a lot of copy-paste code.
  • @user3749947 If you're searching for many possible words, then a Dictionary might be more appropriate.
  • @ClickRick, A List might actually be better. For a dictionary, I can understand putting the pattern in the key field, but there would be no need for the value field. But again, what I wrote is just one way to do it.