.* is rarely necessary at the beginning of a RE. You probably don't need it as the first token of your RE's unless you are later using $&, or unless you're wrapping it in parens and using a $1 (etc) capturing variable. See Death to Dot Star for additional reading on this subject.

? is not a non-greedy substitute for *. *? is the nongreedy zero-or-more quantifier.

The * quantifier will allow empty strings to match. In other words, "\w*" will match one, two, hundreds, thousands of word characters, but it will also match no characters at all. Is this what you want? Maybe you want the + quantifier instead.

Ok, here we go again with the deciphering. This time I'm not going to do it by hand, but rather will demonstrate effective use of a great module:

use strict;
use warnings;
use YAPE::Regex::Explain;
#my $exp = YAPE::Regex::Explain->new($REx)->explain;

my $rex1 = qr/.*(\[*\w*\@*\-*\w*[$ #\%>~]\]|\\\[\\e\[0m\\\] \[0m)\s?/;

my $rex2 = qr/.*([$ #\%>~]|\[*\w*\@*\-*\w*\%\]*|\[*\w*\@*\-*\w*#\]*|\[
+*\w*\@*\-*\w*\$\]*|\[*\w*\@*\-*\w*>\]*|\\\[\\e\[0m\\\] \[0m)\s?/;

print YAPE::Regex::Explain->new($rex1)->explain;

print YAPE::Regex::Explain->new($rex2)->explain;

__OUTPUT__
[download]

Also, please take an hour or so and read through perlrequick, perlretut and perlre. Until you've devoured those POD's you're going to be grasping at straws with regular expressions. If you really want to learn them inside and out, beg, buy, borrow, or steal (ok, don't steal) the Owls book, by Jeffrey Friedl, Mastering Regular Expressions. It's an O'Reilly book, and probably the best book ever written on regexps.

Updated: Added link, suggested by broquaint.

use strict;
use warnings;

# allowed prompt characters
my $prompt_regex = '[>$%@~# ]';

# allowed characters in the prompt
my $allowed_regex = '[\w@\-\.]*';

# a list of allowed prompt patterns
my @patterns = (
    '\[?' . $allowed_regex . $prompt_regex . '\]?',
    quotemeta '\\[\\e[0m\\] [0m',
);

# build my regex dynamically
my $regex = '(' . join('|',@patterns) .')\s?';

# test the regex
print "regex: /$regex/\n\n";

while (<DATA>) {
    chomp;
    /$regex/ && printf "%-30smatched: %s\n", $_, $1;
}

__DATA__
roger@www.foo.com# blah
roger@www.foo~ crap crap
[roger@www#] blah blah foo
[roger@www.foo~] crap crap
\[\e[0m\] [0m foo bar
[download]

regex: /(\[?[\w@\-\.]*[>$%@~# ]\]?|\\\[\\e\[0m\\\]\ \[0m)\s?/

roger@www.foo.com# blah       matched: roger@www.foo.com#
roger@www.foo~ crap crap      matched: roger@www.foo~
[roger@www#] blah blah foo    matched: [roger@www#]
[roger@www.foo~] crap crap    matched: [roger@www.foo~]
\[\e[0m\] [0m foo bar         matched: \[\e[0m\] [0m
[download]

Replacing all the * with ? is not necessarily what you want to do. For example \d* will match 1234567, 123, 1, etc... \d? will only match 1 in the previous example. It will also match nothing. (since the ? means optional)

If you are talking about clarity and maintenance, I would go for the first one because of conciseness. However, I would encourage you to rewrite it. The second one has way too many options and will require a LOT of backtracking if it doesn't match the first time.

While I don't know your exact setup, I can try and help guide you to rewriting this horrible mess of a regex. First, do you need to match multiple square brackets at the beginning? Odds are, you only need one... is it optional? If it's like my prompt, I only have one and it's always there so I could just put a \ infront of it (without the *) if it is optional, you could append it with "?". Now to \w*... can it be nothing? If not, it's probably better to use \w+ (one or more word characters) \@* can you have @@@@@? if not, I'd use \@? What might be better at the beginning would be something like /[\[\w\@\-]+[$\s#\%>~]\]/ Other things to think about are spaces and other characters that may be in the prompt. Also if you are not capturing the prompt, you can try replacing the ASCII escape sequences with // (nothing) before you parse it to help clean it up a bit.

One final note, * isn't "evil" it's just used improperly *a lot*. If you find yourself using it, think... "is there another way I can do this?" Usually there is.

Just to make things more confusing ;) I'm going to swap the order of these two expressions, so my first one will be the longer of the two and I'll work on the the shorter (my second - your first) as I think that's the one you wanted to focus on.

To determine if your two regular expressions are suffiently equivalent we need to compare them.

• Any 1 space, $, #, %, > or ~ will be matched by both.
• The escape sequence: \[\e[0m\\] [0m is allowed by both.
• Each pattern: [w@-w$], [w@-w#], [w@-w%], [w@-w~] is allowed by both.
• [w@-w ] is (as you shown) is allowed by the second but not the first (this is easy to fix)

Like you, I can only spot this one significant difference between the two regular expressions (once you fix your typo).

/.*                      # Stuff
 (                        # START capturing to $1 
    \                     # exactly 1 space
  |                       # OR
    \[?                   # 0 or 1 [
    \w*                   # 0 or more word characters
    \@?                   # 0 or 1 @
    [-\w.]*               # 0 or more word chars, dots and hyphens eg 
+w-w.w-.w
    [$\#\%>~]             # exactly 1 of $, #, %, > or ~
    \]?                   # 0 or 1 ]
  |                       # OR 
    \\\[\\e\[0m\\\]\ \[0m # the sequence: \[\e[0m\\] [0m
 )                        # END of $1
\s?                      # 0 or 1 spaces
/x
[download]

But I may be wrong - you may not be interested in the dot at all. ;) I'm not 100% certain that you want the .* at the front though. Do you have some sample data for us?

I hope you recognise that both expressions will match any string with a single space in it... which will be most strings....

I hope this helps.

jarich

You want your finished product to be good code, not "a mess like before, except worse".

there are a couple of things you can do as well as using \X, like:

different delimiters

block quoting

<lecture mode = on>

Finally as others have already pointed out, Perl's regex are very powerful and as such difficult to "just pick up", you have to read up on regex to even begin to understand how to use them - as a beginner you should probably read these first:

perlrequick         Perl regular expressions quick start
perlretut           Perl regular expressions tutorial
perlfaq6            Regexes
[download]