Regexp is (no) fun?

"?" is a kind of "or", or "else".

This regex
reg(ular expressions?|ex(p|es)?)
searches for the "regular expressions", "regex" and "regexp".

Found this example on
http://www.regular-expressions.info/tutorial.html

jrp
p.s.: couldn't make it on thursday, down with the flu, progging in bed.

On 29 Nov 2008, at 12:40, jayrope wrote:

> "?" is a kind of "or", or "else".

"|" is an "or" (or "|" depending which dialect of regexp you speak,
just to make it more fun).

"?" is a "maybe."

    -- N.

Nick Rothwell / Cassiel.com Limited
www.cassiel.com
www.myspace.com/cassieldotcom
www.last.fm/music/cassiel
www.reverbnation.com/cassiel
www.linkedin.com/in/cassiel
www.loadbang.net

Stefan Tiedje wrote:
> Another one I don't get: I found out how to change a "." into white
> space: [regexp (\.) @substitute " "] (should be in the examples...)
> But how to do the opposite? to change a space into dots or underscores
> etc..?
>

Hi.
I can only help you with that one:

regexp [\s] @substitute _

Ciao

I agree, regexes can be quite confusing but once you understand what all the characters mean and how the engine progresses through a string you might find it becoming a little clearer.

Here's how to remove every instance of a single space.

[regexp " " @substitute %0]

%2 refers to the second pair of capturing parenthesis () in the regex. (%1 for the first, %3 for the third occurence, etc.) The %0 above works a similar way, instead of removing the space it substitutes it for an empty string.

lh

On 29 nov. 08, at 12:05, Stefan Tiedje wrote:

> One which does, is one I don't understand. its a regex which is in
> the "Regexp is fun!" subpatcher to find if a string ends
> with .aif, .aiff, .wav, .wave. What does the "?i:" do exactly before
> "aiff?|wave?" It seems to deal with Upper/Lower case matching, but I
> have no idea how or why...

to summarize:
( ) create a backreference (it will memorize that portion of
text, it's also a way of grouping element so you can apply quantifiers
(?, *, +, {}). The problem with those is that it consume memory
because it have to memorize the all thing

(?: ) is only for grouping, it doesn't create any backreference
(the second outlet of the regexp object won't output anything between
those parenthesis)

(?i: ) defines a portion of things grouped, where the research is
not case sensitive.

so in the case of the one which is in the help file: .+\.(?i:aiff?|
wave?)
.    any character

+    quantifier which apply to the "thing" (can be a character, will card
as it is here, or any group of other things) before and which means
that the thing before should appear at least once

\.    as the dot is a special key we need to escape it to represent the
litteral character dot (and not the one which have the meaning of any
character), and for the escaping we need to backslashes (one for the
regexp, one for the max object)

(?i: ) the famous non capturing parenthesis which are case insensitive

aiff?        means the letters aif followed optionally by another f (a
quantifier only apply on the last character, unless you explicitly
group multiple characters with parenthesis)

|     means or (it's either aiff? or wave?)

wave?    means the letters wav followed optionally by a e

> regexperts also have their own nomenclature. I was searching the http://www.regular-expressions.info/
> site to find out about "?i:" but its almost impossible to find it,
> as the syntax usually consists of single characters, and that is
> hard to match, even with regexp... But then they have their words
> for it as well, but if you don't know them there is no chance to
> find them...

The thing with regexp is that there's not only one way to express the
same thing, and depending on what specific task you want to achieve
you may come with different solution.

> Another one I don't get: I found out how to change a "." into white
> space: [regexp (\.) @substitute " "] (should be in the examples...)
> But how to do the opposite? to change a space into dots or
> underscores etc..?
> I couldn't get it. In general we need examples which deal with the
> special characters of Max...

for instance those two works fine:
regexp @re " " @substitute .
regexp @re \s @substitute .

the first one look for spaces " " (the quotes are required because the
space is used in the Max object to delimit arguments/attributes). the
second solution use the predefined class of character which are the
spaces (note that you have the opposite \S which represent anything
which is not a space).

> In file names I usually need to find a match from the end, but
> regexpressions usually stop searching once a match occurs. What is a
> common way to let it find the last match?

I added one in the strippath help file too:

regexp .+/(.+)

this means:
.    any character
+    quantifiers (the thing before appears at least once, but because of
the DFA engine behind the quantifiers are greedy by default which
means that it will match for the entire thing and then go back to find
the next character, in this example the /)
/    litteral character, we are definitely looking for a /
()    backreference: we memorize everything between those parenthesis
.+    again anything which appears at least once

so because of the way the regexp engine works, we will only memorize
everything which is after the last /.

> And how to substitute a match with nothing? cut it out??? (needs an
> example I guess...)

%0 does that.

> In the lcd example I miss an explanation of the %2 notation, I
> couldn't find any in online regex tutorials. What does it do? It
> seems to replace but what is the syntax. If there are online
> resources, Id like to see links in the help file as well...
> The one I mentioned above is a good tutorial, but is neither
> searchable nor complete, leaves too many questions unanswered...

this example in the help file:
regexp (paint|frame)(rect|oval) @substitute paint%2

could also be written (if that makes more sense):
regexp .+(rect|oval) @substitute paint%1

Basically %n is a way to use what you memorized (the backreference
between parenthesis), in the substitution string. %0 is a special case
which means no characters, %1 is the first backreference, %2 the
second...

I promise at some point I'll make some tuto for the website, in the
meantime, and in any case the bible about that, and I can't recommend
reading it enough is called Mastering Regular Expression from Jeffrey
Friedl it's definitely the thing that you wanna have for christmas ;-)

Cheers,
ej

Personally, I think it's an extremely powerful and valuable tool but it is definitely hard to wrap your head around. I haven't found anywhere online that teaches me clearly and concisely how to use regexes as a beginner, although the site you mentioned in your original post can be helpful if you know what you are looking for (which in my case is rare!)

First of all, the % sign specifies a back-reference in a substitution string. The number after the % specifies which back-reference to use in the substitution, the first one is number 1.

?: makes the parentheses () non-capturing. For example usually parentheses would create a back reference to whatever was contained within them (and also be sent as part of a list from [regexp]s second outlet). But sometimes you want to enclose something in brackets to seperate it from the rest of the regex but without creating a back-reference to it. Here's an example:

Technically the non capturing parentheses are an empty modifier span. (?i: ) is a modifier span that says everything within the brackets should be case insensitive. The opposite would be (?-i: ) which would force things to be case sensitive. You can use these without the colon to refer to everthing to the right of the modifier instead of everything inside the parentheses: (?i) and (?-i). It's probably easier to explain with another example:

The patch you posted will work if you change your regex to [regexp (#) @substitute %0] The "\b" at the end doesn't exist in the string containing the "#" so the regex will return false. If you want to match the character at the end and only at the end of the string use [regexp (#) @substitute %0]. The $ is an anchor and means "match the preceeding characters at the end of the string", The opposite is ^ which looks for the following characters at the beginning of the string.

If any of my explanation isn't clear then let me know which specific bits are troubling you and I will try to come up with some examples where I can explain what the regex is doing character by character.

lh