view release on metacpan or  search on metacpan

lib/POD2/ES/perlop.pod  view on Meta::CPAN

Ejemplos:

 open(TTY, "+>/dev/tty");
    || die "no puedo acceder a /dev/tty: $!";

 <TTY> =~ /^s/i && foo();	# hacer foo() si así se desea

 if (/Version: *([0-9.]*)/) { $version = $1; }

 next if m#^/usr/spool/uucp#;

 # un grep para pobres
 $arg = shift;
 while (<>) {
    print if /$arg/o;	# compilar solo una vez (¡ya no es necesario!)
 }

 if (($F1, $F2, $Etc) = ($foo =~ /^(\S+)\s+(\S+)\s*(.*)/))

Este último ejemplo divide C<$foo> en las dos primeras palabras y el resto de
la línea, y asigna los tres campos a C<$F1>, C<$F2>, y C<$Etc>. La condición
es verdadera si cualquiera de las variables fue establecida; es decir, si el
patrón coincidió.

El modificador C</g> especifica concordancia global del patrón, es decir,
coincidencia tantas veces como sea posible dentro de la cadena. El cómo se
comporta depende del contexto. En contexto de lista, devuelve una lista de las
subcadenas coincidentes con los paréntesis de captura de la expresión
regular. Si no hay paréntesis, devuelve una lista de todas las cadenas
coincidentes, como si hubiera paréntesis alrededor de todo el patrón.

En contexto escalar, cada ejecución de C<m//g> encuentra la siguiente
coincidencia, devolviendo verdadero si coincide, y falso si no hay ninguna
coincidencia más. La posición después de la última coincidencia puede ser
leída o establecida mediante la función C<pos()>; vea L<perlfunc/pos>. Una
coincidencia fallida, normalmente, restablece la posición de búsqueda al
principio de la cadena, pero puede evitarlo añadiendo el modificador C</c>
(por ejemplo C<m//gc>). Modificando la cadena objetivo también restablece la
posición de búsqueda.

=item C<I<aserción> \G>

Puede entremezclar coincidencias C<m//g> con C<m/\G.../g>, donde C<\G> es una
aserción de ancho cero que coincide con la posición exacta en que la anterior
C<m//g>, si hubo, se detuvo. Sin el modificador C</g>, la aserción C<\G> aún
se ancla en pos() como si fuera al principio de la operación (vea
L<perlfunc/pos>), pero la coincidencia, por supuesto, sólo se prueba una vez.
Usando C<\G> sin C</g> en una cadena objetivo que no haya tenido anteriormente
aplicada una coincidencia C</g> es lo mismo que usar la aserción C<\A> para
que coincida con el principio de la cadena. Tenga en cuenta también que,
actualmente, C<\G> está sólo adecuadamente soportada cuando se fija al
comienzo del patrón.

Ejemplos:

    # contexto lista
    ($uno,$cinco,$quince) = (`uptime` =~ /(\d+\.\d+)/g);

    # contexto escalar
    local $/ = "";
    while ($parrafo = <>) {
	while ($parrafo =~ /\p{Ll}['")]*[.!?]+['")]*\s/g) {
	    $sentencias++;
	}
    }
    say $sentencias;

Aquí hay otra forma de buscar sentencias en un párrafo:

 my $sentencia_rx = qr{
    (?: (?<= ^ ) | (?<= \s ) )  # después de inicio-de-cadena o
                                # espacio en blanco
    \p{Lu}                      # letra mayúscula
    .*?                         # un montón de nada
    (?<= \S )                   # que termina en un no
                                # espacio en blanco
    (?<! \b [DMS]r  )           # pero no es una abreviatura conocida
    (?<! \b Mrs )
    (?<! \b Sra )
    (?<! \b St  )
    [.?!]                       # seguido por una sentencia
                                # terminada
    (?= $ | \s )                # delante de un final-de-cadena
                                # o espacio en blanco
 }sx;
 local $/ = "";
 while (my $parrafo = <>) {
    say "NUEVO PÁRRAFO";
    my $cuenta = 0;
    while ($parrafo =~ /($sentencia_rx)/g) {
        printf "\tnueva sentencia %d: <%s>\n", ++$cuenta, $1;
    }
 }

Aquí está cómo se usa C<m//gc> con C<\G>:

    $_ = "ppooqppqq";
    while ($i++ < 2) {
        print "1: '";
        print $1 while /(o)/gc; print "', pos=", pos, "\n";
        print "2: '";
        print $1 if /\G(q)/gc;  print "', pos=", pos, "\n";
        print "3: '";
        print $1 while /(p)/gc; print "', pos=", pos, "\n";
    }
    print "Final: '$1', pos=",pos,"\n" if /\G(.)/;

El último ejemplo debería imprimir:

    1: 'oo', pos=4
    2: 'q', pos=5
    3: 'pp', pos=7
    1: '', pos=7
    2: 'q', pos=8
    3: '', pos=8
    Final: 'q', pos=8

Observe que el último emparejamiento es C<q> en vez de C<p>, que una
coincidencia sin el anclaje C<\G> habría hecho. También tenga en cuenta que
la última coincidencia no actualizó C<pos>. C<pos> sólo es actualizado en
una coincidencia C</g>. En cambio, si la última coincidencia fue C<p>, hay
buenas posibilidades de que está ejecutando una versión anterior de Perl
(pre-5.6.0).

Un modismo útil para escáneres tipo C<lex> es C</\G.../gc>. Puede combinar
varias expresiones regulares como ésta para procesar una cadena parte por
parte, haciendo diferentes acciones dependiendo de la expresión regular
coincidente. Cada I<regex> intenta coincidir donde la anterior lo dejó.

 $_ = <<'EOL';
    $url = URI::URL->new( "http://example.com/" );
    die if $url eq "xXx";
 EOL

 BUCLE: {
     print(" dígitos"),      redo LOOP if /\G\d+\b[,.;]?\s*/gc;
     print(" minúscula"),    redo LOOP
                                    if /\G\p{Ll}+\b[,.;]?\s*/gc;
     print(" MAYÚSCULA"),    redo LOOP
                                    if /\G\p{Lu}+\b[,.;]?\s*/gc;
     print(" Capitalizada"),  redo LOOP
                              if /\G\p{Lu}\p{Ll}+\b[,.;]?\s*/gc;
     print(" MeZcLaDoS"),    redo LOOP if /\G\pL+\b[,.;]?\s*/gc;
     print(" alfanumérico"), redo LOOP
                            if /\G[\p{Alpha}\pN]+\b[,.;]?\s*/gc;
     print(" línea-ruido"),  redo LOOP if /\G\W+/gc;