Treat string as single line. That is, change "." to match any character
whatsoever, even a newline, which normally it would not match.
-Used together, as /ms, they let the "." match any character whatsoever,
+Used together, as C</ms>, they let the "." match any character whatsoever,
while still allowing "^" and "$" to match, respectively, just after
and just before newlines within the string.
a C<\Q...\E> stays unaffected by C</x>. And note that C</x> doesn't affect
whether space interpretation within a single multi-character construct. For
example in C<\x{...}>, regardless of the C</x> modifier, there can be no
-spaces. Same for a L<quantifier|Quantifiers> such as C<{3}> or
-C<{5,}>. Similarly, C<(?:...)> can't have a space between the C<?> and C<:>.
-Within any delimiters for such a construct, allowed spaces are not affected by
-C</x>, and depend on the construct. For example, C<\x{...}> can't have spaces
-because hexadecimal numbers don't have spaces in them. But, in C<\p{...}> the
-C<...> can have spaces that follow the Unicode properties rules.
+spaces. Same for a L<quantifier|/Quantifiers> such as C<{3}> or
+C<{5,}>. Similarly, C<(?:...)> can't have a space between the C<?> and C<:>,
+but can between the C<(> and C<?>. Within any delimiters for such a
+construct, allowed spaces are not affected by C</x>, and depend on the
+construct. For example, C<\x{...}> can't have spaces because hexadecimal
+numbers don't have spaces in them. But, Unicode properties can have spaces, so
+in C<\p{...}> there can be spaces that follow the Unicode rules, for which see
+L<perluniprops/Properties accessible through \p{} and \P{}>.
X</x>
=head2 Regular Expressions
X<\> X<^> X<.> X<$> X<|> X<(> X<()> X<[> X<[]>
- \ Quote the next metacharacter
- ^ Match the beginning of the line
- . Match any character (except newline)
- $ Match the end of the line (or before newline at the end)
- | Alternation
- () Grouping
- [] Character class
+ \ Quote the next metacharacter
+ ^ Match the beginning of the line
+ . Match any character (except newline)
+ $ Match the end of the line (or before newline at the end)
+ | Alternation
+ () Grouping
+ [] Bracketed Character class
By default, the "^" character is guaranteed to match only the
beginning of the string, the "$" character only the end (or before the
The following standard quantifiers are recognized:
X<metacharacter> X<quantifier> X<*> X<+> X<?> X<{n}> X<{n,}> X<{n,m}>
- * Match 0 or more times
- + Match 1 or more times
- ? Match 1 or 0 times
- {n} Match exactly n times
- {n,} Match at least n times
- {n,m} Match at least n but not more than m times
+ * Match 0 or more times
+ + Match 1 or more times
+ ? Match 1 or 0 times
+ {n} Match exactly n times
+ {n,} Match at least n times
+ {n,m} Match at least n but not more than m times
(If a curly bracket occurs in any other context, it is treated
as a regular character. In particular, the lower bound
is not optional.) The "*" quantifier is equivalent to C<{0,}>, the "+"
quantifier to C<{1,}>, and the "?" quantifier to C<{0,1}>. n and m are limited
-to integral values less than a preset limit defined when perl is built.
+to non-negative integral values less than a preset limit defined when perl is built.
This is usually 32766 on the most common platforms. The actual limit can
be seen in the error message generated by code such as this:
X<metacharacter> X<greedy> X<greediness>
X<?> X<*?> X<+?> X<??> X<{n}?> X<{n,}?> X<{n,m}?>
- *? Match 0 or more times, not greedily
- +? Match 1 or more times, not greedily
- ?? Match 0 or 1 time, not greedily
- {n}? Match exactly n times, not greedily
- {n,}? Match at least n times, not greedily
- {n,m}? Match at least n but not more than m times, not greedily
+ *? Match 0 or more times, not greedily
+ +? Match 1 or more times, not greedily
+ ?? Match 0 or 1 time, not greedily
+ {n}? Match exactly n times, not greedily
+ {n,}? Match at least n times, not greedily
+ {n,m}? Match at least n but not more than m times, not greedily
By default, when a quantified subpattern does not allow the rest of the
overall pattern to match, Perl will backtrack. However, this behaviour is
sometimes undesirable. Thus Perl provides the "possessive" quantifier form
as well.
- *+ Match 0 or more times and give nothing back
- ++ Match 1 or more times and give nothing back
- ?+ Match 0 or 1 time and give nothing back
- {n}+ Match exactly n times and give nothing back (redundant)
- {n,}+ Match at least n times and give nothing back
- {n,m}+ Match at least n but not more than m times and give nothing back
+ *+ Match 0 or more times and give nothing back
+ ++ Match 1 or more times and give nothing back
+ ?+ Match 0 or 1 time and give nothing back
+ {n}+ Match exactly n times and give nothing back (redundant)
+ {n,}+ Match at least n times and give nothing back
+ {n,m}+ Match at least n but not more than m times and give nothing back
For instance,
Because patterns are processed as double quoted strings, the following
also work:
-X<\t> X<\n> X<\r> X<\f> X<\e> X<\a> X<\l> X<\u> X<\L> X<\U> X<\E> X<\Q>
-X<\0> X<\c> X<\N> X<\x>
-
- \t tab (HT, TAB)
- \n newline (LF, NL)
- \r return (CR)
- \f form feed (FF)
- \a alarm (bell) (BEL)
- \e escape (think troff) (ESC)
- \033 octal char (example: ESC)
- \x1B hex char (example: ESC)
- \x{263a} long hex char (example: Unicode SMILEY)
- \cK control char (example: VT)
- \N{name} named Unicode character
- \N{U+263D} Unicode character (example: FIRST QUARTER MOON)
- \l lowercase next char (think vi)
- \u uppercase next char (think vi)
- \L lowercase till \E (think vi)
- \U uppercase till \E (think vi)
- \E end case modification (think vi)
- \Q quote (disable) pattern metacharacters till \E
-
-If C<use locale> is in effect, the case map used by C<\l>, C<\L>, C<\u>
-and C<\U> is taken from the current locale. See L<perllocale>. For
-documentation of C<\N{name}>, see L<charnames>.
-
-You cannot include a literal C<$> or C<@> within a C<\Q> sequence.
-An unescaped C<$> or C<@> interpolates the corresponding variable,
-while escaping will cause the literal string C<\$> to be matched.
-You'll need to write something like C<m/\Quser\E\@\Qhost/>.
+
+ \t tab (HT, TAB)
+ \n newline (LF, NL)
+ \r return (CR)
+ \f form feed (FF)
+ \a alarm (bell) (BEL)
+ \e escape (think troff) (ESC)
+ \033 octal char (example: ESC)
+ \x1B hex char (example: ESC)
+ \x{263a} long hex char (example: Unicode SMILEY)
+ \cK control char (example: VT)
+ \N{name} named Unicode character
+ \N{U+263D} Unicode character (example: FIRST QUARTER MOON)
+ \l lowercase next char (think vi)
+ \u uppercase next char (think vi)
+ \L lowercase till \E (think vi)
+ \U uppercase till \E (think vi)
+ \Q quote (disable) pattern metacharacters till \E
+ \E end either case modification or quoted section, think vi
+
+Details are in L<perlop/Quote and Quote-like Operators>.
=head3 Character Classes and other Special Escapes
In addition, Perl defines the following:
-X<\w> X<\W> X<\s> X<\S> X<\d> X<\D> X<\X> X<\p> X<\P> X<\C>
-X<\g> X<\k> X<\N> X<\K> X<\v> X<\V> X<\h> X<\H>
-X<word> X<whitespace> X<character class> X<backreference>
-
- \w Match a "word" character (alphanumeric plus "_")
- \W Match a non-"word" character
- \s Match a whitespace character
- \S Match a non-whitespace character
- \d Match a digit character
- \D Match a non-digit character
- \pP Match P, named property. Use \p{Prop} for longer names.
- \PP Match non-P
- \X Match Unicode "eXtended grapheme cluster"
- \C Match a single C char (octet) even under Unicode.
- NOTE: breaks up characters into their UTF-8 bytes,
- so you may end up with malformed pieces of UTF-8.
- Unsupported in lookbehind.
- \1 Backreference to a specific group.
- '1' may actually be any positive integer.
- \g1 Backreference to a specific or previous group,
- \g{-1} number may be negative indicating a previous buffer and may
- optionally be wrapped in curly brackets for safer parsing.
- \g{name} Named backreference
- \k<name> Named backreference
- \K Keep the stuff left of the \K, don't include it in $&
- \N Any character but \n (experimental)
- \v Vertical whitespace
- \V Not vertical whitespace
- \h Horizontal whitespace
- \H Not horizontal whitespace
- \R Linebreak
-
-A C<\w> matches a single alphanumeric character (an alphabetic
-character, or a decimal digit) or C<_>, not a whole word. Use C<\w+>
-to match a string of Perl-identifier characters (which isn't the same
-as matching an English word). If C<use locale> is in effect, the list
-of alphabetic characters generated by C<\w> is taken from the current
-locale. See L<perllocale>. You may use C<\w>, C<\W>, C<\s>, C<\S>,
-C<\d>, and C<\D> within character classes, but they aren't usable
-as either end of a range. If any of them precedes or follows a "-",
-the "-" is understood literally. If Unicode is in effect, C<\s> matches
-also "\x{85}", "\x{2028}", and "\x{2029}". See L<perlunicode> for more
-details about C<\pP>, C<\PP>, C<\X> and the possibility of defining
-your own C<\p> and C<\P> properties, and L<perluniintro> about Unicode
-in general.
-X<\w> X<\W> X<word>
-
-C<\R> will atomically match a linebreak, including the network line-ending
-"\x0D\x0A". Specifically, X<\R> is exactly equivalent to
-
- (?>\x0D\x0A?|[\x0A-\x0C\x85\x{2028}\x{2029}])
-
-B<Note:> C<\R> has no special meaning inside of a character class;
-use C<\v> instead (vertical whitespace).
-X<\R>
-
-Note that C<\N> has two meanings. When of the form C<\N{NAME}>, it matches the
-character whose name is C<NAME>; and similarly when of the form
-C<\N{U+I<wide hex char>}>, it matches the character whose Unicode ordinal is
-I<wide hex char>. Otherwise it matches any character but C<\n>.
+X<\g> X<\k> X<\K> X<backreference>
+
+ Sequence Note Description
+ [...] [1] Match a character according to the rules of the
+ bracketed character class defined by the "...".
+ Example: [a-z] matches "a" or "b" or "c" ... or "z"
+ [[:...:]] [2] Match a character according to the rules of the POSIX
+ character class "..." within the outer bracketed
+ character class. Example: [[:upper:]] matches any
+ uppercase character.
+ \w [3] Match a "word" character (alphanumeric plus "_")
+ \W [3] Match a non-"word" character
+ \s [3] Match a whitespace character
+ \S [3] Match a non-whitespace character
+ \d [3] Match a decimal digit character
+ \D [3] Match a non-digit character
+ \pP [3] Match P, named property. Use \p{Prop} for longer names
+ \PP [3] Match non-P
+ \X [4] Match Unicode "eXtended grapheme cluster"
+ \C Match a single C-language char (octet) even if that is
+ part of a larger UTF-8 character. Thus it breaks up
+ characters into their UTF-8 bytes, so you may end up
+ with malformed pieces of UTF-8. Unsupported in
+ lookbehind.
+ \1 [5] Backreference to a specific capture buffer or group.
+ '1' may actually be any positive integer.
+ \g1 [5] Backreference to a specific or previous group,
+ \g{-1} [5] The number may be negative indicating a relative
+ previous buffer and may optionally be wrapped in
+ curly brackets for safer parsing.
+ \g{name} [5] Named backreference
+ \k<name> [5] Named backreference
+ \K [6] Keep the stuff left of the \K, don't include it in $&
+ \N [7] Any character but \n (experimental). Not affected by
+ /s modifier
+ \v [3] Vertical whitespace
+ \V [3] Not vertical whitespace
+ \h [3] Horizontal whitespace
+ \H [3] Not horizontal whitespace
+ \R [4] Linebreak
-The POSIX character class syntax
-X<character class>
-
- [:class:]
-
-is also available. Note that the C<[> and C<]> brackets are I<literal>;
-they must always be used within a character class expression.
-
- # this is correct:
- $string =~ /[[:alpha:]]/;
-
- # this is not, and will generate a warning:
- $string =~ /[:alpha:]/;
-
-The following table shows the mapping of POSIX character class
-names, common escapes, literal escape sequences and their equivalent
-Unicode style property names.
-X<character class> X<\p> X<\p{}>
-X<alpha> X<alnum> X<ascii> X<blank> X<cntrl> X<digit> X<graph>
-X<lower> X<print> X<punct> X<space> X<upper> X<word> X<xdigit>
-
-B<Note:> up to Perl 5.10 the property names used were shared with
-standard Unicode properties, this was changed in Perl 5.11, see
-L<perl5110delta> for details.
-
- POSIX Esc Class Property Note
- --------------------------------------------------------
- alnum [0-9A-Za-z] IsPosixAlnum
- alpha [A-Za-z] IsPosixAlpha
- ascii [\000-\177] IsASCII
- blank [\011 ] IsPosixBlank [1]
- cntrl [\0-\37\177] IsPosixCntrl
- digit \d [0-9] IsPosixDigit
- graph [!-~] IsPosixGraph
- lower [a-z] IsPosixLower
- print [ -~] IsPosixPrint
- punct [!-/:-@[-`{-~] IsPosixPunct
- space [\11-\15 ] IsPosixSpace [2]
- \s [\11\12\14\15 ] IsPerlSpace [2]
- upper [A-Z] IsPosixUpper
- word \w [0-9A-Z_a-z] IsPerlWord [3]
- xdigit [0-9A-Fa-f] IsXDigit
-
-=over
+=over 4
=item [1]
-A GNU extension equivalent to C<[ \t]>, "all horizontal whitespace".
+See L<perlrecharclass/Bracketed Character Classes> for details.
=item [2]
-Note that C<\s> and C<[[:space:]]> are B<not> equivalent as C<[[:space:]]>
-includes also the (very rare) "vertical tabulator", "\cK" or chr(11) in
-ASCII.
+See L<perlrecharclass/POSIX Character Classes> for details.
=item [3]
-A Perl extension, see above.
-
-=back
-
-For example use C<[:upper:]> to match all the uppercase characters.
-Note that the C<[]> are part of the C<[::]> construct, not part of the
-whole character class. For example:
-
- [01[:alpha:]%]
-
-matches zero, one, any alphabetic character, and the percent sign.
-
-The other named classes are:
-
-=over 4
+See L<perlrecharclass/Backslash sequences> for details.
-=item cntrl
-X<cntrl>
+=item [4]
-Any control character. Usually characters that don't produce output as
-such but instead control the terminal somehow: for example newline and
-backspace are control characters. All characters with ord() less than
-32 are usually classified as control characters (assuming ASCII,
-the ISO Latin character sets, and Unicode), as is the character with
-the ord() value of 127 (C<DEL>).
+See L<perlrebackslash/Misc> for details.
-=item graph
-X<graph>
+=item [5]
-Any alphanumeric or punctuation (special) character.
+See L</Capture buffers> below for details.
-=item print
-X<print>
+=item [6]
-Any alphanumeric or punctuation (special) character or the space character.
+See L</Extended Patterns> below for details.
-=item punct
-X<punct>
+=item [7]
-Any punctuation (special) character.
-
-=item xdigit
-X<xdigit>
-
-Any hexadecimal digit. Though this may feel silly ([0-9A-Fa-f] would
-work just fine) it is included for completeness.
+Note that C<\N> has two meanings. When of the form C<\N{NAME}>, it matches the
+character whose name is C<NAME>; and similarly when of the form
+C<\N{U+I<wide hex char>}>, it matches the character whose Unicode ordinal is
+I<wide hex char>. Otherwise it matches any character but C<\n>.
=back
-You can negate the [::] character classes by prefixing the class name
-with a '^'. This is a Perl extension. For example:
-X<character class, negation>
-
- POSIX traditional Unicode
-
- [[:^digit:]] \D \P{IsPosixDigit}
- [[:^space:]] \S \P{IsPosixSpace}
- [[:^word:]] \W \P{IsPerlWord}
-
-Perl respects the POSIX standard in that POSIX character classes are
-only supported within a character class. The POSIX character classes
-[.cc.] and [=cc=] are recognized but B<not> supported and trying to
-use them will cause an error.
-
=head3 Assertions
Perl defines the following zero-width assertions:
X<regular expression, zero-width assertion>
X<\b> X<\B> X<\A> X<\Z> X<\z> X<\G>
- \b Match a word boundary
- \B Match except at a word boundary
- \A Match only at beginning of string
- \Z Match only at end of string, or before newline at the end
- \z Match only at end of string
- \G Match only at pos() (e.g. at the end-of-match position
+ \b Match a word boundary
+ \B Match except at a word boundary
+ \A Match only at beginning of string
+ \Z Match only at end of string, or before newline at the end
+ \z Match only at end of string
+ \G Match only at pos() (e.g. at the end-of-match position
of prior m//g)
A word boundary (C<\b>) is a spot between two characters
and print "'$1' is the first doubled character\n";
if (/Time: (..):(..):(..)/) { # parse out values
- $hours = $1;
- $minutes = $2;
- $seconds = $3;
+ $hours = $1;
+ $minutes = $2;
+ $seconds = $3;
}
Several special variables also refer back to portions of the previous
$_ = 'a' x 8;
m<
- (?{ $cnt = 0 }) # Initialize $cnt.
+ (?{ $cnt = 0 }) # Initialize $cnt.
(
a
(?{
- local $cnt = $cnt + 1; # Update $cnt, backtracking-safe.
+ local $cnt = $cnt + 1; # Update $cnt, backtracking-safe.
})
)*
aaaa
- (?{ $res = $cnt }) # On success copy to non-localized
- # location.
+ (?{ $res = $cnt }) # On success copy to
+ # non-localized location.
>x;
will set C<$res = 4>. Note that after the match, C<$cnt> returns to the globally
expression involves run-time interpolation of variables, unless the
perilous C<use re 'eval'> pragma has been used (see L<re>), or the
variables contain results of C<qr//> operator (see
-L<perlop/"qr/STRING/imosx">).
+L<perlop/"qr/STRINGE<sol>msixpo">).
This restriction is due to the wide-spread and remarkably convenient
custom of using run-time determined strings as patterns. For example:
The following pattern matches a parenthesized group:
$re = qr{
- \(
- (?:
- (?> [^()]+ ) # Non-parens without backtracking
- |
- (??{ $re }) # Group with matching parens
- )*
- \)
- }x;
+ \(
+ (?:
+ (?> [^()]+ ) # Non-parens without backtracking
+ |
+ (??{ $re }) # Group with matching parens
+ )*
+ \)
+ }x;
See also C<(?PARNO)> for a different, more efficient way to accomplish
the same task.
expression involves run-time interpolation of variables, unless the
perilous C<use re 'eval'> pragma has been used (see L<re>), or the
variables contain results of C<qr//> operator (see
-L<perlop/"qr/STRING/imosx">).
+L<perlop/"qrE<sol>STRINGE<sol>msixpo">).
Because perl's regex engine is not currently re-entrant, delayed
code may not invoke the regex engine either directly with C<m//> or C<s///>),
m{ \(
(
- [^()]+ # x+
+ [^()]+ # x+
|
\( [^()]* \)
)+
m{ \(
(
- (?> [^()]+ ) # change x+ above to (?> x+ )
+ (?> [^()]+ ) # change x+ above to (?> x+ )
|
\( [^()]* \)
)+
$_ = "Food is on the foo table.";
if ( /\b(foo)\s+(\w+)/i ) {
- print "$2 follows $1.\n";
+ print "$2 follows $1.\n";
}
When the match runs, the first part of the regular expression (C<\b(foo)>)
$_ = "The food is under the bar in the barn.";
if ( /foo(.*)bar/ ) {
- print "got <$1>\n";
+ print "got <$1>\n";
}
Which perhaps unexpectedly yields:
So you write this:
$_ = "I have 2 numbers: 53147";
- if ( /(.*)(\d*)/ ) { # Wrong!
- print "Beginning is <$1>, number is <$2>.\n";
+ if ( /(.*)(\d*)/ ) { # Wrong!
+ print "Beginning is <$1>, number is <$2>.\n";
}
That won't work at all, because C<.*> was greedy and gobbled up the
$_ = "I have 2 numbers: 53147";
@pats = qw{
- (.*)(\d*)
- (.*)(\d+)
- (.*?)(\d*)
- (.*?)(\d+)
- (.*)(\d+)$
- (.*?)(\d+)$
- (.*)\b(\d+)$
- (.*\D)(\d+)$
+ (.*)(\d*)
+ (.*)(\d+)
+ (.*?)(\d*)
+ (.*?)(\d+)
+ (.*)(\d+)$
+ (.*?)(\d+)$
+ (.*)\b(\d+)$
+ (.*\D)(\d+)$
};
for $pat (@pats) {
- printf "%-12s ", $pat;
- if ( /$pat/ ) {
- print "<$1> <$2>\n";
- } else {
- print "FAIL\n";
- }
+ printf "%-12s ", $pat;
+ if ( /$pat/ ) {
+ print "<$1> <$2>\n";
+ } else {
+ print "FAIL\n";
+ }
}
That will print out:
followed by "123". You might try to write that as
$_ = "ABC123";
- if ( /^\D*(?!123)/ ) { # Wrong!
- print "Yup, no 123 in $_\n";
+ if ( /^\D*(?!123)/ ) { # Wrong!
+ print "Yup, no 123 in $_\n";
}
But that isn't going to match; at least, not the way you're hoping. It
of doing that, you get yourself into trouble if you then add an C</e>
modifier.
- s/(\d+)/ \1 + 1 /eg; # causes warning under -w
+ s/(\d+)/ \1 + 1 /eg; # causes warning under -w
Or if you try to do
be significantly simplified by using repeated subexpressions that
may match zero-length substrings. Here's a simple example being:
- @chars = split //, $string; # // is not magic in split
+ @chars = split //, $string; # // is not magic in split
($whitewashed = $string) =~ s/()/ /g; # parens avoid magic s// /
Thus Perl allows such constructs, by I<forcefully breaking
# We must also take care of not escaping the legitimate \\Y|
# sequence, hence the presence of '\\' in the conversion rules.
my %rules = ( '\\' => '\\\\',
- 'Y|' => qr/(?=\S)(?<!\S)|(?!\S)(?<=\S)/ );
+ 'Y|' => qr/(?=\S)(?<!\S)|(?!\S)(?<=\S)/ );
sub convert {
my $re = shift;
$re =~ s{
=head1 BUGS
+There are numerous problems with case insensitive matching of characters
+outside the ASCII range, especially with those whose folds are multiple
+characters, such as ligatures like C<LATIN SMALL LIGATURE FF>.
+
+In a bracketed character class with case insensitive matching, ranges only work
+for ASCII characters. For example,
+C<m/[\N{CYRILLIC CAPITAL LETTER A}-\N{CYRILLIC CAPITAL LETTER YA}]/i>
+doesn't match all the Russian upper and lower case letters.
+
+Many regular expression constructs don't work on EBCDIC platforms.
+
This document varies from difficult to understand to completely
and utterly opaque. The wandering prose riddled with jargon is
hard to fathom in several places.
projects / p5sagit/p5-mst-13.2.git / blobdiff