CODEWITHSUNDEEP
regex
publicRavi
publicRavi

Reputation: 2763

Regular expression to stop at first match

My regex pattern looks something like

<xxxx location="file path/level1/level2" xxxx some="xxx">

I am only interested in the part in quotes assigned to location. Shouldn't it be as easy as below without the greedy switch? 

/.*location="(.*)".*/

Does not seem to work.

Upvotes: 845

Views: 1128167

Answers (10)

tripleee
tripleee

Reputation: 189387

The other answers here fail to spell out a full solution for regex versions which don't support non-greedy matching. The non-greedy quantifiers (.*?, .+? etc) are a Perl 5 extension which isn't supported in traditional regular expressions.

If your stopping condition is a single character, the solution is easy; instead of

a(.*?)b

you can match

a[^ab]*b

i.e specify a character class which excludes the starting and ending delimiiters.

In the more general case, you can painstakingly construct an expression like

start(|[^e]|e(|[^n]|n(|[^d])))*end

to capture a match between start and the first occurrence of end. Notice how the subexpression with nested parentheses spells out a number of alternatives which between them allow e only if it isn't followed by nd and so forth, and also take care to cover the empty string as one alternative which doesn't match whatever is disallowed at that particular point.

Of course, the correct approach in most cases is to use a proper parser for the format you are trying to parse, but sometimes, maybe one isn't available, or maybe the specialized tool you are using is insisting on a regular expression and nothing else.

Upvotes: 6

RARE Kpop Manifesto
RARE Kpop Manifesto

Reputation: 2801

perhaps keep it simple ?

printf '%s' '<xxxx location="file path/level1/level2" xxxx some="xxx">' | 

{m,g,n}awk NF++ FS='^(.+ )?location="|".*$' OFS=

file path/level1/level2

Upvotes: 0

Daniel Vandersluis
Daniel Vandersluis

Reputation: 94153

You need to make your regular expression lazy/non-greedy, because by default, "(.*)" will match all of "file path/level1/level2" xxx some="xxx".

Instead you can make your dot-star non-greedy, which will make it match as few characters as possible:

/location="(.*?)"/

Adding a ? on a quantifier (?, * or +) makes it non-greedy.

Note: this is only available in regex engines which implement the Perl 5 extensions (Java, Ruby, Python, etc) but not in "traditional" regex engines (including Awk, sed, grep without -P, etc.).

Upvotes: 1633

sepp2k
sepp2k

Reputation: 370142

location="(.*)" will match from the " after location= until the " after some="xxx unless you make it non-greedy.

So you either need .*? (i.e. make it non-greedy by adding ?) or better replace .* with [^"]*.

  • [^"] Matches any character except for a " <quotation-mark>
  • More generic: [^abc] - Matches any character except for an a, b or c

Upvotes: 95

user13202738
user13202738

Reputation: 49

import regex
text = 'ask her to call Mary back when she comes back'                           
p = r'(?i)(?s)call(.*?)back'
for match in regex.finditer(p, str(text)):
    print (match.group(1))

Output: Mary

Upvotes: 0

Ste
Ste

Reputation: 2293

Here's another way.

Here's the one you want. This is lazy [\s\S]*?

The first item: [\s\S]*?(?:location="[^"]*")[\s\S]* Replace with: $1

Explaination: https://regex101.com/r/ZcqcUm/2

For completeness, this gets the last one. This is greedy [\s\S]*

The last item:[\s\S]*(?:location="([^"]*)")[\s\S]* Replace with: $1

Explaination: https://regex101.com/r/LXSPDp/3

There's only 1 difference between these two regular expressions and that is the ?

Upvotes: 3

Mohammad Kanan
Mohammad Kanan

Reputation: 4582

Because you are using quantified subpattern and as descried in Perl Doc,

By default, a quantified subpattern is "greedy", that is, it will match as many times as possible (given a particular starting location) while still allowing the rest of the pattern to match. If you want it to match the minimum number of times possible, follow the quantifier with a "?" . Note that the meanings don't change, just the "greediness":

*?        //Match 0 or more times, not greedily (minimum matches)
+?        //Match 1 or more times, not greedily

Thus, to allow your quantified pattern to make minimum match, follow it by ? :

/location="(.*?)"/

Upvotes: 2

Uddhav P. Gautam
Uddhav P. Gautam

Reputation: 7626

Use of Lazy quantifiers ? with no global flag is the answer.

Eg,

enter image description here

If you had global flag /g then, it would have matched all the lowest length matches as below. enter image description here

Upvotes: 23

user193690
user193690

Reputation: 1

How about

.*location="([^"]*)".*

This avoids the unlimited search with .* and will match exactly to the first quote.

Upvotes: 48

mrjoltcola
mrjoltcola

Reputation: 20842

Use non-greedy matching, if your engine supports it. Add the ? inside the capture.

/location="(.*?)"/

Upvotes: 39

Related Questions