pl@nereida:~/Lperltesting$ cat -n c2f.pl 1 #!/usr/bin/perl -w 2 use strict; 3 4 print "Enter a temperature (i.e. 32F, 100C):\n"; 5 my $input = <STDIN>; 6 chomp($input); 7 8 if ($input !~ m/^([-+]?[0-9]+(\.[0-9]*)?)\s*([CF])$/i) { 9 warn "Expecting a temperature, so don't understand \"$input\".\n"; 10 } 11 else { 12 my $InputNum = $1; 13 my $type = $3; 14 my ($celsius, $farenheit); 15 if ($type eq "C" or $type eq "c") { 16 $celsius = $InputNum; 17 $farenheit = ($celsius * 9/5)+32; 18 } 19 else { 20 $farenheit = $InputNum; 21 $celsius = ($farenheit -32)*5/9; 22 } 23 printf "%.2f C = %.2f F\n", $celsius, $farenheit; 24 }
Véase también:
perldoc perlrequick
perldoc perlretut
perldoc perlre
perldoc perlreref
Ejecución con el depurador:
pl@nereida:~/Lperltesting$ perl -wd c2f.pl Loading DB routines from perl5db.pl version 1.28 Editor support available. Enter h or `h h' for help, or `man perldebug' for more help. main::(c2f.pl:4): print "Enter a temperature (i.e. 32F, 100C):\n"; DB<1> c 8 Enter a temperature (i.e. 32F, 100C): 32F main::(c2f.pl:8): if ($input !~ m/^([-+]?[0-9]+(\.[0-9]*)?)\s*([CF])$/i) { DB<2> n main::(c2f.pl:12): my $InputNum = $1; DB<2> x ($1, $2, $3) 0 32 1 undef 2 'F' DB<3> use YAPE::Regex::Explain DB<4> p YAPE::Regex::Explain->new('([-+]?[0-9]+(\.[0-9]*)?)\s*([CF])$')->explain The regular expression: (?-imsx:([-+]?[0-9]+(\.[0-9]*)?)\s*([CF])$) matches as follows: NODE EXPLANATION ---------------------------------------------------------------------- (?-imsx: group, but do not capture (case-sensitive) (with ^ and $ matching normally) (with . not matching \n) (matching whitespace and # normally): ---------------------------------------------------------------------- ( group and capture to \1: ---------------------------------------------------------------------- [-+]? any character of: '-', '+' (optional (matching the most amount possible)) ---------------------------------------------------------------------- [0-9]+ any character of: '0' to '9' (1 or more times (matching the most amount possible)) ---------------------------------------------------------------------- ( group and capture to \2 (optional (matching the most amount possible)): ---------------------------------------------------------------------- \. '.' ---------------------------------------------------------------------- [0-9]* any character of: '0' to '9' (0 or more times (matching the most amount possible)) ---------------------------------------------------------------------- )? end of \2 (NOTE: because you're using a quantifier on this capture, only the LAST repetition of the captured pattern will be stored in \2) ---------------------------------------------------------------------- ) end of \1 ---------------------------------------------------------------------- \s* whitespace (\n, \r, \t, \f, and " ") (0 or more times (matching the most amount possible)) ---------------------------------------------------------------------- ( group and capture to \3: ---------------------------------------------------------------------- [CF] any character of: 'C', 'F' ---------------------------------------------------------------------- ) end of \3 ---------------------------------------------------------------------- $ before an optional \n, and the end of the string ---------------------------------------------------------------------- ) end of grouping ----------------------------------------------------------------------
Dentro de una expresión regular es necesario
referirse a los textos que casan con el primer, paréntesis,
segundo, etc. como \1, \2, etc. La notación
$1 se refieré a lo que casó con el primer paréntesis
en el último matching, no en el actual. Veamos un ejemplo:
pl@nereida:~/Lperltesting$ cat -n dollar1slash1.pl 1 #!/usr/bin/perl -w 2 use strict; 3 4 my $a = "hola juanito"; 5 my $b = "adios anita"; 6 7 $a =~ /(ani)/; 8 $b =~ s/(adios) *($1)/\U$1 $2/; 9 print "$b\n";Observe como el
$1 que aparece en la cadena de reemplazo (línea 8)
se refiere a la cadena adios
mientras que el $1 en la primera parte contiene ani:
pl@nereida:~/Lperltesting$ ./dollar1slash1.pl ADIOS ANIta
$b =~ s/(adios) *(\1)/\U$1 $2/;
El número de paréntesis con memoria no está limitado:
pl@nereida:~/Lperltesting$ perl -wde 0
main::(-e:1): 0
123456789ABCDEF
DB<1> $x = "123456789AAAAAA"
1 2 3 4 5 6 7 8 9 10 11 12
DB<2> $r = $x =~ /(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)\11/; print "$r\n$10\n$11\n"
1
A
A
Véase el siguiente párrafo de perlre (sección Capture buffers):
There is no limit to the number of captured substrings that you may use. However Perl also uses\10,\11, etc. as aliases for\010,\011, etc. (Recall that0means octal, so\011is the character at number9in your coded character set; which would be the 10th character, a horizontal tab under ASCII.) Perl resolves this ambiguity by interpreting\10as a backreference only if at least10left parentheses have opened before it. Likewise\11is a backreference only if at least11left parentheses have opened before it. And so on.\1through\9are always interpreted as backreferences.
Si se utiliza en un contexto que requiere una lista,
el ``pattern match'' retorna una lista consistente en
las subexpresiones casadas mediante los paréntesis,
esto es $1, $2, $3, ....
Si no hubiera emparejamiento se retorna la lista vacía.
Si lo hubiera pero no hubieran paréntesis se retorna la lista
($&).
pl@nereida:~/src/perl/perltesting$ cat -n escapes.pl
1 #!/usr/bin/perl -w
2 use strict;
3
4 my $foo = "one two three four five\nsix seven";
5 my ($F1, $F2, $Etc) = ($foo =~ /^\s*(\S+)\s+(\S+)\s*(.*)/);
6 print "List Context: F1 = $F1, F2 = $F2, Etc = $Etc\n";
7
8 # This is 'almost' the same than:
9 ($F1, $F2, $Etc) = split(/\s+/, $foo, 3);
10 print "Split: F1 = $F1, F2 = $F2, Etc = $Etc\n";
Observa el resultado de la ejecución:
pl@nereida:~/src/perl/perltesting$ ./escapes.pl List Context: F1 = one, F2 = two, Etc = three four five Split: F1 = one, F2 = two, Etc = three four five six seven
La opción s usada en una regexp
hace que el punto '.' case con el retorno
de carro:
pl@nereida:~/src/perl/perltesting$ perl -wd ./escapes.pl main::(./escapes.pl:4): my $foo = "one two three four five\nsix seven"; DB<1> c 9 List Context: F1 = one, F2 = two, Etc = three four five main::(./escapes.pl:9): ($F1, $F2, $Etc) = split(' ',$foo, 3); DB<2> ($F1, $F2, $Etc) = ($foo =~ /^\s*(\S+)\s+(\S+)\s*(.*)/s) DB<3> p "List Context: F1 = $F1, F2 = $F2, Etc = $Etc\n" List Context: F1 = one, F2 = two, Etc = three four five six seven
La opción /s hace que . se empareje con
un \n.
Esto es, casa con cualquier carácter.
Veamos otro ejemplo, que imprime los nombres de los ficheros que contienen cadenas que casan con un patrón dado, incluso si este aparece disperso en varias líneas:
1 #!/usr/bin/perl -w 2 #use: 3 #smodifier.pl 'expr' files 4 #prints the names of the files that match with the give expr 5 undef $/; # input record separator 6 my $what = shift @ARGV; 7 while(my $file = shift @ARGV) { 8 open(FILE, "<$file"); 9 $line = <FILE>; 10 if ($line =~ /$what/s) { 11 print "$file\n"; 12 } 13 }
Ejemplo de uso:
> smodifier.pl 'three.*three' double.in split.pl doublee.pl double.in doublee.pl
Vea la sección 3.4.2 para ver los contenidos
del fichero double.in. En dicho fichero,
el patrón three.*three aparece repartido entre
varias líneas.
El modificador s se suele usar conjuntamente con el modificador
m. He aquí lo que dice
la seccion Using character classes de la sección 'Using-character-classes' en perlretut
al respecto:
m modifier (//m): Treat string as a set of multiple lines.
'.' matches any character except \n.
^ and $ are able to match at the start or end of any line within the string.
s and m modifiers (//sm): Treat string as a single long line, but detect multiple lines.
'.' matches any character, even \n .
^ and $ , however, are able to match at the start or end of any line within the string.
Here are examples of //s and //m in action:
1. $x = "There once was a girl\nWho programmed in Perl\n"; 2. 3. $x =~ /^Who/; # doesn't match, "Who" not at start of string 4. $x =~ /^Who/s; # doesn't match, "Who" not at start of string 5. $x =~ /^Who/m; # matches, "Who" at start of second line 6. $x =~ /^Who/sm; # matches, "Who" at start of second line 7. 8. $x =~ /girl.Who/; # doesn't match, "." doesn't match "\n" 9. $x =~ /girl.Who/s; # matches, "." matches "\n" 10. $x =~ /girl.Who/m; # doesn't match, "." doesn't match "\n" 11. $x =~ /girl.Who/sm; # matches, "." matches "\n"
Most of the time, the default behavior is what is wanted, but//sand//mare occasionally very useful. If//mis being used, the start of the string can still be matched with\Aand the end of the string can still be matched with the anchors\Z(matches both the end and the newline before, like$), and\z(matches only the end):
1. $x =~ /^Who/m; # matches, "Who" at start of second line 2. $x =~ /\AWho/m; # doesn't match, "Who" is not at start of string 3. 4. $x =~ /girl$/m; # matches, "girl" at end of first line 5. $x =~ /girl\Z/m; # doesn't match, "girl" is not at end of string 6. 7. $x =~ /Perl\Z/m; # matches, "Perl" is at newline before end 8. $x =~ /Perl\z/m; # doesn't match, "Perl" is not at end of stringNormalmente el carácter
^ casa solamente con el comienzo de la
cadena y el carácter $ con el final. Los \n empotrados
no casan
con ^ ni $. El modificador /m modifica esta
conducta. De este modo ^ y $ casan con cualquier frontera
de línea interna. Las anclas \A y \Z se utilizan entonces
para casar con
el comienzo y final de la cadena.
Véase un ejemplo:
nereida:~/perl/src> perl -de 0 DB<1> $a = "hola\npedro" DB<2> p "$a" hola pedro DB<3> $a =~ s/.*/x/m DB<4> p $a x pedro DB<5> $a =~ s/^pedro$/juan/ DB<6> p "$a" x pedro DB<7> $a =~ s/^pedro$/juan/m DB<8> p "$a" x juan
Reescribamos el ejemplo anterior usando un contexto de lista:
casiano@millo:~/Lperltesting$ cat -n c2f_list.pl 1 #!/usr/bin/perl -w 2 use strict; 3 4 print "Enter a temperature (i.e. 32F, 100C):\n"; 5 my $input = <STDIN>; 6 chomp($input); 7 8 my ($InputNum, $type); 9 10 ($InputNum, $type) = $input =~ m/^ 11 ([-+]?[0-9]+(?:\.[0-9]*)?) # Temperature 12 \s* 13 ([cCfF]) # Celsius or Farenheit 14 $/x; 15 16 die "Expecting a temperature, so don't understand \"$input\".\n" unless defined($InputNum); 17 18 my ($celsius, $fahrenheit); 19 if ($type eq "C" or $type eq "c") { 20 $celsius = $InputNum; 21 $fahrenheit = ($celsius * 9/5)+32; 22 } 23 else { 24 $fahrenheit = $InputNum; 25 $celsius = ($fahrenheit -32)*5/9; 26 } 27 printf "%.2f C = %.2f F\n", $celsius, $fahrenheit;
La opción /x en una regexp permite utilizar comentarios y
espacios dentro de la expresión
regular. Los espacios dentro de la expresión regular dejan de ser significativos.
Si quieres conseguir un espacio que sea significativo, usa \s o
bien escápalo. Véase la sección 'Modifiers' en perlre
y
la sección 'Building-a-regexp' en perlretut.
La notación (?: ... ) se usa para introducir paréntesis de agrupamiento sin memoria.
(?: ...)
Permite agrupar las expresiones tal y como lo hacen los
paréntesis ordinarios. La diferencia es que no ``memorizan''
esto es no guardan nada en $1, $2, etc.
Se logra así una compilación mas eficiente. Veamos un ejemplo:
> cat groupingpar.pl #!/usr/bin/perl my $a = shift; $a =~ m/(?:hola )*(juan)/; print "$1\n"; nereida:~/perl/src> groupingpar.pl 'hola juan' juan
El patrón regular puede contener variables, que serán interpoladas
(en tal caso, el patrón será recompilado).
Si quieres que dicho patrón se compile una sóla vez, usa la opción
/o.
pl@nereida:~/Lperltesting$ cat -n mygrep.pl
1 #!/usr/bin/perl -w
2 my $what = shift @ARGV || die "Usage $0 regexp files ...\n";
3 while (<>) {
4 print "File $ARGV, rel. line $.: $_" if (/$what/o); # compile only once
5 }
6
Sigue un ejemplo de ejecución:
pl@nereida:~/Lperltesting$ ./mygrep.pl Usage ./mygrep.pl regexp files ... pl@nereida:~/Lperltesting$ ./mygrep.pl if labels.c File labels.c, rel. line 7: if (a < 10) goto LABEL;
El siguiente texto es de la sección 'Using-regular-expressions-in-Perl' en perlretut:
If $pattern won't be changing over the lifetime of the script,
we can add the //o modifier, which directs Perl to only perform variable
substitutions once
Otra posibilidad es hacer una compilación previa usando el operador
qr (véase la sección 'Regexp-Quote-Like-Operators' en perlop).
La siguiente variante del programa anterior también compila el patrón
una sóla vez:
pl@nereida:~/Lperltesting$ cat -n mygrep2.pl
1 #!/usr/bin/perl -w
2 my $what = shift @ARGV || die "Usage $0 regexp files ...\n";
3 $what = qr{$what};
4 while (<>) {
5 print "File $ARGV, rel. line $.: $_" if (/$what/);
6 }
Véase
El siguiente extracto de la sección Matching Repetitions en la sección 'Matching-repetitions' en perlretut
ilustra la semántica greedy de los operadores de repetición *+{}? etc.
For all of these quantifiers, Perl will try to match as much of the string as possible, while still allowing the regexp to succeed. Thus with/a?.../, Perl will first try to match the regexp with the a present; if that fails, Perl will try to match the regexp without the a present. For the quantifier*, we get the following:
1. $x = "the cat in the hat"; 2. $x =~ /^(.*)(cat)(.*)$/; # matches, 3. # $1 = 'the ' 4. # $2 = 'cat' 5. # $3 = ' in the hat'
Which is what we might expect, the match finds the only cat in the string and locks onto it. Consider, however, this regexp:
1. $x =~ /^(.*)(at)(.*)$/; # matches, 2. # $1 = 'the cat in the h' 3. # $2 = 'at' 4. # $3 = '' (0 characters match)
One might initially guess that Perl would find theatincatand stop there, but that wouldn't give the longest possible string to the first quantifier.*. Instead, the first quantifier.*grabs as much of the string as possible while still having the regexp match. In this example, that means having theatsequence with the finalatin the string.
The other important principle illustrated here is that when there are two or more elements in a regexp, the leftmost quantifier, if there is one, gets to grab as much the string as possible, leaving the rest of the regexp to fight over scraps. Thus in our example, the first quantifier.*grabs most of the string, while the second quantifier.*gets the empty string. Quantifiers that grab as much of the string as possible are called maximal match or greedy quantifiers.
When a regexp can match a string in several different ways, we can use the principles above to predict which way the regexp will match:
Principle 0: Taken as a whole, any regexp will be matched at the earliest possible position in the string.
Principle 1: In an alternation a|b|c... , the leftmost alternative that allows a match for the whole regexp will be the one used.
Principle 2: The maximal matching quantifiers ?, *, + and {n,m}
will in general match as much of the string as possible while still allowing the whole regexp to match.
El siguiente párrafo está tomado de la sección 'Repeated-Patterns-Matching-a-Zero-length-Substring' en perlre:
Regular expressions provide a terse and powerful programming language. As with most other power tools, power comes together with the ability to wreak havoc.
A common abuse of this power stems from the ability to make infinite loops using regular expressions, with something as innocuous as:
1. 'foo' =~ m{ ( o? )* }x;
Theo?matches at the beginning of'foo', and since the position in the string is not moved by the match,o?would match again and again because of the*quantifier.
Another common way to create a similar cycle is with the looping modifier //g :
1. @matches = ( 'foo' =~ m{ o? }xg );
or
1. print "match: <$&>\n" while 'foo' =~ m{ o? }xg;
or the loop implied by split().
... Perl allows such constructs, by forcefully breaking the infinite loop. The rules for this are different for lower-level loops given by the greedy quantifiers*+{}, and for higher-level ones like the/gmodifier orsplit()operator.
The lower-level loops are interrupted (that is, the loop is broken) when Perl detects that a repeated expression matched a zero-length substring. Thus
1. m{ (?: NON_ZERO_LENGTH | ZERO_LENGTH )* }x;
is made equivalent to
1. m{ (?: NON_ZERO_LENGTH )*
2. |
3. (?: ZERO_LENGTH )?
4. }x;
The higher level-loops preserve an additional state between iterations: whether the last match was zero-length. To break the loop, the following match after a zero-length match is prohibited to have a length of zero. This prohibition interacts with backtracking (see Backtracking), and so the second best match is chosen if the best match is of zero length.
For example:
1. $_ = 'bar'; 2. s/\w??/<$&>/g;
results in<><b><><a><><r><>. At each position of the string the best match given by non-greedy??is the zero-length match, and the second best match is what is matched by\w. Thus zero-length matches alternate with one-character-long matches.
Similarly, for repeated m/()/g the second-best match is the match at
the position one notch further in the string.
The additional state of being matched with zero-length is associated with the matched string, and is reset by each assignment topos(). Zero-length matches at the end of the previous match are ignored duringsplit.
DB<25> $c = 0 DB<26> print(($c++).": <$&>\n") while 'aaaabababab' =~ /a*(ab)*/g; 0: <aaaa> 1: <> 2: <a> 3: <> 4: <a> 5: <> 6: <a> 7: <> 8: <>
Las expresiones lazy o no greedy hacen que el NFA se detenga en la cadena mas corta que
casa con la expresión. Se denotan como sus análogas greedy añadiéndole el
postfijo ?:
{n,m}?
{n,}?
{n}?
*?
+?
??
Repasemos lo que dice la sección Matching Repetitions en la sección 'Matching-repetitions' en perlretut:
Sometimes greed is not good. At times, we would like quantifiers to match a minimal piece of string, rather than a maximal piece. For this purpose, Larry Wall created the minimal match or non-greedy quantifiers??,*?,+?, and{}?. These are the usual quantifiers with a ? appended to them. They have the following meanings:
a?? means: match 'a' 0 or 1 times. Try 0 first, then 1.
a*? means: match 'a' 0 or more times, i.e., any number of times, but as few times as possible
a+? means: match 'a' 1 or more times, i.e., at least once, but as few times as possible
a{n,m}? means: match at least n times, not more than m times, as few times as possible
a{n,}? means: match at least n times, but as few times as possible
a{n}? means: match exactly n times. Because we match exactly n times, an? is equivalent to an and is just there for notational consistency.
Let's look at the example above, but with minimal quantifiers:
1. $x = "The programming republic of Perl"; 2. $x =~ /^(.+?)(e|r)(.*)$/; # matches, 3. # $1 = 'Th' 4. # $2 = 'e' 5. # $3 = ' programming republic of Perl'
The minimal string that will allow both the start of the string^and the alternation to match isTh, with the alternatione|rmatchinge. The second quantifier.*is free to gobble up the rest of the string.
1. $x =~ /(m{1,2}?)(.*?)$/; # matches,
2. # $1 = 'm'
3. # $2 = 'ming republic of Perl'
The first string position that this regexp can match is at the firstmin programming . At this position, the minimalm{1,2}?matches just onem. Although the second quantifier.*?would prefer to match no characters, it is constrained by the end-of-string anchor$to match the rest of the string.
1. $x =~ /(.*?)(m{1,2}?)(.*)$/; # matches,
2. # $1 = 'The progra'
3. # $2 = 'm'
4. # $3 = 'ming republic of Perl'
In this regexp, you might expect the first minimal quantifier.*?to match the empty string, because it is not constrained by a^anchor to match the beginning of the word. Principle 0 applies here, however. Because it is possible for the whole regexp to match at the start of the string, it will match at the start of the string. Thus the first quantifier has to match everything up to the first m. The second minimal quantifier matches just onemand the third quantifier matches the rest of the string.
1. $x =~ /(.??)(m{1,2})(.*)$/; # matches,
2. # $1 = 'a'
3. # $2 = 'mm'
4. # $3 = 'ing republic of Perl'
Just as in the previous regexp, the first quantifier.??can match earliest at positiona, so it does. The second quantifier is greedy, so it matches mm , and the third matches the rest of the string.
We can modify principle 3 above to take into account non-greedy quantifiers:
Principle 3: If there are two or more elements in a regexp, the leftmost greedy (non-greedy) quantifier, if any, will match as much (little) of the string as possible while still allowing the whole regexp to match. The next leftmost greedy (non-greedy) quantifier, if any, will try to match as much (little) of the string remaining available to it as possible, while still allowing the whole regexp to match. And so on, until all the regexp elements are satisfied.
casiano@millo:~/Lperltesting$ perl -wde 0
main::(-e:1): 0
DB<1> x ('1'x34) =~ m{^(11+)\1+$}
0 11111111111111111
DB<2> x ('1'x34) =~ m{^(11+?)\1+$}
????????????????????????????????????
Just like alternation, quantifiers are also susceptible to backtracking. Here is a step-by-step analysis of the example
1. $x = "the cat in the hat"; 2. $x =~ /^(.*)(at)(.*)$/; # matches, 3. # $1 = 'the cat in the h' 4. # $2 = 'at' 5. # $3 = '' (0 matches)
Start with the first letter in the string 't'.
The first quantifier '.*' starts out by matching the whole string 'the cat in the hat'.
'a' in the regexp element 'at' doesn't match the end of the string. Backtrack one character.
'a' in the regexp element 'at' still doesn't match the last letter of the string 't', so backtrack one more character.
Now we can match the 'a' and the 't'.
Move on to the third element '.*'. Since we are at the end of the string and '.*' can match 0 times, assign it the empty string.
We are done!
La forma en la que se escribe una regexp puede dar lugar agrandes variaciones en el rendimiento. Repasemos lo que dice la sección Matching Repetitions en la sección 'Matching-repetitions' en perlretut:
Most of the time, all this moving forward and backtracking happens quickly and searching is fast. There are some pathological regexps, however, whose execution time exponentially grows with the size of the string. A typical structure that blows up in your face is of the form
/(a|b+)*/;
The problem is the nested indeterminate quantifiers. There are many different ways of partitioning a string of length n between the+and*: one repetition withb+of length, two repetitions with the first
b+lengthand the second with length
,
repetitions whose bits add up to length
In fact there are an exponential number of ways to partition a string as a function of its length. A regexp may get lucky and match early in the process, but if there is no match, Perl will try every possibility before giving up. So be careful with nested*'s,{n,m}'s, and+'s.
The book Mastering Regular Expressions by Jeffrey Friedl [3] gives a wonderful discussion of this and other efficiency issues.
El siguiente ejemplo elimina los comentarios de un programa C.
casiano@millo:~/Lperltesting$ cat -n comments.pl 1 #!/usr/bin/perl -w 2 use strict; 3 4 my $progname = shift @ARGV or die "Usage:\n$0 prog.c\n"; 5 open(my $PROGRAM,"<$progname") || die "can't find $progname\n"; 6 my $program = ''; 7 { 8 local $/ = undef; 9 $program = <$PROGRAM>; 10 } 11 $program =~ s{ 12 /\* # Match the opening delimiter 13 .*? # Match a minimal number of characters 14 \*/ # Match the closing delimiter 15 }[]gsx; 16 17 print $program;Veamos un ejemplo de ejecución. Supongamos el fichero de entrada:
> cat hello.c
#include <stdio.h>
/* first
comment
*/
main() {
printf("hello world!\n"); /* second comment */
}
Entonces la ejecución con ese fichero de entrada produce la salida:
> comments.pl hello.c
#include <stdio.h>
main() {
printf("hello world!\n");
}
Veamos la diferencia de comportamiento entre * y *?
en el ejemplo anterior: