Expresiones regulares Perl Parte I/III| Tiempo de Tux

Este es un sencillo tutorial sobre algo muy avanzado,que tenemos o llegamos a usar al escribir algo medio/avanzado en perl,las expresiones regulares las usamos como comprobadores de cadenas,ya sea para realizar una accion con una estructura selectiva o para cambiar el texto.

Cambiar el texto?

Si para cambiar el texto,la realidad las expresiones regulares existen en muchos lenguajes de programación desde PHP que en sus principios creado desde un CGI de C diseñado en Perl,hasta python,C,C++ y claro nuestro legendario lenguaje Perl.

También sin olvidar los regex de la SHELL de Unix(no confundir con wilcards)

Y esta solo es una parte de el poder de las expresiones regulares de Perl.

s///;

Cambiar texto

Delimitadores:

Primero que nada debemos conocer los delimitadores,suena un tanto avanzado pero no es mas que una diagonal \ esta diagonal debe comenzar por una orden(letra) y debe ir cerrado

En el caso de cambiar texto,es esta la sintaxis

s///;

Como usar?

Como dije es para cambiar texto,si lo queremos ocupar tenemos que definir algo primero,para poder cambiar el valor:

my $variable = "Hola Mundo";

$variable =~ s/Mundo/Perl/;

Expliquemos eso:

El símbolo =~ quiere decir si encuentra,regresa un valor verdadero

s/Mundo/Perl/ sustituye Mundo por Perl

Veamos un script

#!/usr/bin/env perl
use strict;
use warnings;
use utf8;

my $variable = "Hola Mundo";

$variable =~ s/Mundo/Perl/;

print "$variable\n";

El resultado al ejecutar es el siguiente

Debes tener en cuenta que esto s/Mundo/Perl/; es lo que va a sustituir ya que ejecuta esto y veras lo que pasa :

#!/usr/bin/env perl
use strict;
use warnings;
use utf8;

my $variable = "Hola Mundo";

$variable =~ s/M/Perl/;

print "$variable\n";

Lo podemos mejorar:

Ejecuta este script:

#!/usr/bin/env perl

use strict;
use warnings;
use utf8;

my $variable = "Hola Mundo";

print "Tu variable ahora es : $variable\n";

print "Suplantaremos Mundo por: ";

my $suplantar = <STDIN>;

print "Suplantando...";
system("sleep 2;");

chop($suplantar);

$variable =~ s/Mundo/$suplantar/;

print "\nTu variable ahora es : $variable\n";

Y nos mostrara el proceso :D

Ten en cuenta que esto es muy potente

Por ejemplo:

Si usamos esta variable "Hola Hola Hola Mundo" y cambiamos Hola así

my $variable = "Hola Hola Hola Mundo";

$variable =~ s/Hola/Hello/;

Solo cambiaría el primer Hola

Pero si los queremos cambiar todos?

Solo vasta con que quede asi la sintaxis

#!/usr/bin/env perl

my $variable = "Hola Hola Hola Mundo";

$variable =~ s/Hola/Hello/ig;

print "$variable\n";

Esto es lo básico de s///

Ya que también se puede usar algo como esto

s/\bgreen\b/mauve/g; # don't change wintergreen
$path =~ s|/usr/bin|/usr/local/bin|;
s/Login: $foo/Login: $bar/; # run-time pattern
($foo = $bar) =~ s/this/that/; # copy first, then change
($foo = "$bar") =~ s/this/that/; # convert to string, copy, then change
$foo = $bar =~ s/this/that/r; # Same as above using /r
$foo = $bar =~ s/this/that/r
=~ s/that/the other/r; # Chained substitutes using /r
@foo = map { s/this/that/r } @bar # /r is very useful in maps
$count = ($paragraph =~ s/Mister\b/Mr./g); # get change-count
$_ = 'abc123xyz';
s/\d+/$&*2/e; # yields 'abc246xyz'
s/\d+/sprintf("%5d",$&)/e; # yields 'abc 246xyz'
s/\w/$& x 2/eg; # yields 'aabbcc 224466xxyyzz'
s/%(.)/$percent{$1}/g; # change percent escapes; no /e
s/%(.)/$percent{$1} || $&/ge; # expr now, so /e
s/^=(\w+)/pod($1)/ge; # use function call
$_ = 'abc123xyz';
$a = s/abc/def/r; # $a is 'def123xyz' and
# $_ remains 'abc123xyz'.
# expand variables in $_, but dynamics only, using
# symbolic dereferencing
s/\$(\w+)/${$1}/g;
# Add one to the value of any numbers in the string
s/(\d+)/1 + $1/eg;
# Titlecase words in the last 30 characters only
substr($str, -30) =~ s/\b(\p{Alpha}+)\b/\u\L$1/g;
# This will expand any embedded scalar variable
# (including lexicals) in $_ : First $1 is interpolated
# to the variable name, and then evaluated
s/(\$\w+)/$1/eeg;
# Delete (most) C comments.
$program =~ s {
/\* # Match the opening delimiter.
.*? # Match a minimal number of characters.
\*/ # Match the closing delimiter.
} []gsx;
s/^\s*(.*?)\s*$/$1/; # trim whitespace in $_, expensively
for ($variable) { # trim whitespace in $variable, cheap
s/^\s+//;
s/\s+$//;
}
s/([^ ]*) *([^ ]*)/$2 $1/; # reverse 1st two fields

Pero de momento es todo sobre s///

m//;

Verificador de cadena

Este operador se usa para localicar una expresion(palabra,letra,etc) en una variable, y va sobre una estructura selectiva:

Esta es la sintaxis:

$variable =~ m/palabra/;

Esto en un script va así:

#!/usr/bin/env perl

use warnings;
use utf8;

use strict;

my $variable = "Este es un ejemplo de una cadena para un ejemplo de programación perl de Tiempo de Tux itimetux.com";

# Busquemos perl

if ($variable =~ m/perl/) { print "Se encontro perl en variable\n"}

Lo podemos mejorar :D

Ejecuten este script,sin ver la variable(copy & paste):

#!/usr/bin/env perl

use warnings;
use utf8;

use strict;

my $variable = "Un ejemplo de expresiones regulares perl en Tiempo de Tux";

print "Hay una variable definida pero esta oculta,que desea buscar: ";

my $buscar = <STDIN>;

print "Buscando...";

system("sleep 2");

chop($buscar);

# Busquemos perl

if ($variable =~ m/$buscar/) {

print "\nSe encontro $buscar en variable\n";

}else {

print "\nNo se encontro $buscar\n";

}

Deben tener en cuenta que esto reconoce minusculas y mayusculas, así que aunque este tiempo en la variable y buscan Tiempo,no lo va a encontrar(veremos después como no limitarnos así).

El verificador =~ tiene su opuesto,ya que este revise un valor verdadero pero hay un valor falso:

!~

Como se pueden imaginar hace lo contrario(checa que no coincida)

Por ejemplo algo un poco tonto,pero para ver como funciona es esto:

#!/usr/bin/env perl

use warnings;
use utf8;

use strict;