Variables locales en PERL

Las variables locales se pueden declarar en cualquier momento, y de ese modo una sub puede trabajar en ellas sin interferir en las que son usadas por otras sub.

La manera de hacerlo es ésta:

 

local($variable, $anothervar, @even_an_array);

 

Esto crea estas nuevas variables en el momento de la ejecución, salvando los valores precedentes de las variables con el mismo nombres (si existe); a continuación, al final del bloque {} en que se habían incluido, estas variables locales son destruidas, y su valor inicial se restablece. Las variables locales se pueden enicializar también como

 

local($variable, $anothervar)=(value, anothervalue);

 

En concreto, para las sub es muy común empezar definiendo las variables locales para darles a los argumentos nombres que les han pasado:

 

sub addhelp {

A esta sub han pasado 2 argumentos, el nombre de un comando y un texto de ayuda

 

local ($cmd, $txt) = @_;

$cmd =~ tr/A-Z/a-z/;

En este caso A se convierte en a, B en b, etc., de modo que el comando se hace todo con letras minúsculas

 

foreach (split(/\n+/, $txt) {

next unless $_;

skippa las líneas vacías

 

push (@help, $_);

}

}

 

En este punto las variables $cmd e $txt desaparecen, de manera que si la sub addhelp hubiese tenido también una variable llamada $cmd, su valor original se habría restablecido

Expresiones regulares en PERL

Las expresiones regulares son una suerte de lenguaje interno al perl, pero no sólo (por ejemplo se encuntran en comandos como grep, sed awk). En cualquier caso, no hay 2 programas que tengan que ver con las expresiones regulares y las interpreten del mismo modo.

Una expresión regular está entre / , aunque se trata más bien de una convención que de una regla. Resulta normal ver una expresión regular entre | o # o cualquier otro carácter, para evitar que aparezca el símbolo \ delante de todos los / en regexp.

 

Una expresión regular define un pattern que será buscado. En las expresiones regulares, los caracteres alfanuméricos (de la a a la z, de la A a la Z, de 0 a 9 y _ ) tienen una correspondencia unívoca, mientras que otros caracteres tienen características especiales.

 

Un \ seguido por un carácter no alfanumérico corresponde exactamente a ese carácter; en concreto, \\ corresponde a \ .

 

^ — (sólo al inicio de la expresión) hace que el texto corresponda al pattern sólo si el pattern está al comienzo del texto.

 

$ — (sólo al final de la expresión) hace que el texto corresponda al pattern sólo si el pattern está al final del texto.

 

Algún ejemplo aclarará un poco las cosas.

 

“bla” =~ /\//

falso, ya que busca en “bla” el carácter /

 

“blh” =~ /\$/

falso, ya que busca en “bla” el carácter £

 

Por eso para buscar un carácter especial (o, si se quiere, reservado) hay que aclararlo a través del símbolo \ que se está buscando exactamente ese carácter y no su valor. Y lo mismo para la búsqueda con grep, y también con editor (vi, por ejemplo)

 

“bla” =~ /la/ verdadero

“bla” =~ /^la/ falso

“bla” =~ /^bl/ verdadero

“bla” =~ /h$/ verdadero

“bla” =~ /ls$/ falso

“bla” =~ /^bla$/ verdadero

 

Otros caracteres especiales son:

. — busca cada carácter individual

\t — busca una tabulación

\s — busca un espacio o una tabulación

\S — busca todo carácter que no sea una tabulación

\n — busca una “newline”

\w — busca toda letra concreta, cifra y también _

\W — busca todo lo que no sea una letra, una cifra o _

\d — busca toda cifra individual de 0 a 9

\D — busca todo carácter que no sea una cifra

 

“bla” =~ /b.a/ verdadero

“bla” =~ /b.la/ falso

“bla” =~ /b\w.h$/ verdadero

“bla” =~ /\w\D/ vero

“bla” =~ /\d/ falso

 

[caracteres] — busca todo carácter que esté entre [ ]

 

Además, un campo de búsqueda se puede especificar con – , por ejemplo [a-m] busca las letras entre la a y la m.

Si el primer carácter entre [ ] es ^ , al significado se le da la vuelta, y se buscará todo lo que NO está comprendido entre [ ]

 

[-.0.9] busca exactamente un – un . o una cifra

 

[^\@ \t] busca cualquier carácter que no sea un @, una tabulación o un espacio. Hay que señalar que \ delante de @ es opcional, ya que el símbolo @ no tiene significados particulares en este contexto, pero funciona también con \@

 

Cuantificadores:

determinan el número mínimo y máximo de veces que un determinado elemento tiene que repetirse consecutivamente:

 

( ) — reagrupa más elementos en un pattern que se debe buscar una vez

* — Corresponde al intervalo {0, } o bien de un mínimo de 0 veces a un máximo indefinido

+ — Corresponde al intervalo {1, }

? — Corresponde al intervalo {0, 1}

s — Opera una sustitución

tr — Opera una traducción en la forma ‘tr [a-z] [A-Z]’ (o bien convierte en mayúsculas los caracteres que están en minúscula y viceversa)

 

“bla” =~ /c*k*z?b+.l/ verdadero, dado que la c, la k y la z no están, la b aparece una vez y la l también

 

“ccckkzbbb8lZOINX” =~ /c*k*z?b+.l/ vedadero “blabla” =~ /ah(EEK)?bl/ verdadero “blaEEKbla” =~ /ah(EEK)?bl/ verdadero “blaEEKEEKbla” =~ /ah(EEK)?bl/ falso “blaEEKEEKbla” =~ /ah(EEK)+bl/ vero

 

/^([^\@ \t]+\@[^\@ \t])+\s+([-.0-9]+)$/

 

El último ejemplo corresponde a una línea que empieza con un número distinto de 0 de caracteres que no son ni @ ni espacios ni tabulaciones, después una @, luego otros caracteres que no son @ ni espacios ni tabulaciones, después algunos espacios y tabulaciones, luego cualquier mezcla de ‘-‘, ‘.’ y cifra. Dicho vulgarmente, algo parecido a una dirección e-mail seguido de espacios y ¡algo que se puede pensar razonablemente como un número! En palabras aún más vulgares, una vez que se entiende cómo funcionan las expresiones regulares, resulta más fácil escribirlas que explicarlas.

 

/^\s*(\d+)\.(\d+)\.(\d+)\.(\d+)\s*$/

 

Esto, sin embargo, podría corresponderse con una dirección IP.

Además, si el pattern tiene sub-pattern (), éstos se asignan a variables numeradas, $1 para la primera, $2 para la segunda, etc.

 

“129.199.129.13” =~ /^\s*(\d+)\.(\d+)\.(\d+)\.(\d+)\s*$/;

$1 è 129, $2 è 199, $3 è 129, $4 è 13

 

Un pattern con sustitución se escribe de la forma:

 

$variable =~ s/pattern/replacement/;

 

El pattern es, como antes, una expresión regular, y el replacement es una cadena normal, excepto por el hecho de que las variables están interpoladas en su interior.

En la mayor parte de los casos, se puede añadir el carácter ‘g’ después del replacement, de manera que se cambien todas las palabras que corresponden al pattern, y no sólo la primera.

 

$waitops{$c} =~ s/:${oldnick}:/:${newnick}:/g

 

Las expresiones regulares trabajan con la función split, que toma como argumento una expresión regular, una variable escalar y, si se quiere, un segundo escalar que especifica el número máximo de campos en que splittare el pattern.

 

@array = split(/pattern/, expression);

 

En el caso más típico, se puede querer splittare una línea en palabras, como sigue:

 

@words = split(/\s+/, $some_line); # si $some_line era “a b c”, ahora

@words es (“a”, “b”, “c”)

 

o bien

 

($val1, $val2) = split(/\s+/, $whatever); # setta $val1 con el primero

valor de $whatever y $val2 con el segundo. Otros valores eventuales (tercero, cuarto, etc.) son descartados

Bloques en PERL

Todos estos bloques pueden, obviamente, reagruparse:

 

# if ejecuta el test de una condición y actúa en consecuencia en función de la verdad o no de ésta.

 

La sintaxis es:

 

if (condición) {

cosas;

que;

hacer;

} elsif (condición2) {

otras;

cosas;

que;

hacer;

} else {

otro;

todavía;

}

 

Este ejemplo habla por sí solo: el perl hace un test de la primera condición, y si ésta es verdadera ejecuta el bloque. Si es falsa, pasa a elsif y examina la segunda condición: si es verdadera, ejecuta el bloque. Si ninguna de las precedentes es verdadera, pasa al else.

 

Un ejemplo ulterior:

 

print “Elige un número\n”;

$num=<STDIN>;

if ($num == ‘0’) {

print “Has presionado 0\n”;

} elsif ($num == ‘1’) {

print “Has presionado uno\n”;

} elsif ($número == ‘2’) {

print “Has presionado dos\n”;

} elsif ($num == ‘3’) {

print “Has presionado tres\n”;

} else {

print “No has presionado ni cero ni uno ni dos ni tres!\n”;

}

 

Está claro, ¿no? Hemos elegido poner un ejemplo tan largo para demostrar que puede haber perfectamente más de un elsif: aquí hay tres, y habrían podido ser muchos más, sin un techo máximo; sin embargo sólo puede haber un else y un if, siempre que no estén concatenados:

 

if (condición) {

if (condición2) {

haz esto;

}

haz esto otro;

}

El ejemplo anterior funciona, pero es totalmente distinto del precedente: éste se lee como ” si sucede cierta cosa (condición) y si sucede otra (condición2) …..”, no es una serie de alternativas como el ejemplo de los tres elsif.

No es necesario introducir un elsif() o un else(); la estructura también puede ser simple como:

 

if (condición) {

cosas_que_hacer;

}

 

o bien:

 

if (condición) {

cosas_que_hacer;

} else {

otras_cosas;

}

 

Las {} son siempre necesarias en estas construcciones. Un modo para sintetizar al máximo el ejemplo:

 

if (condición) {

cosas_que_hacer;

}

 

es

 

cosas_que_hacer if condición;

 

Ejemplo:

 

if ($cmd eq ‘ECHO’) {

&print($args);

} elsif ($cmd eq ‘CLEAR’ || $cmd eq ‘CL) {

print $cls if $ansi;

print “`#ssfe#l\n” if $ssfe;

}

# unless hace las mismas cosas que if, sólo que invierte el resultado del test.

 

print “No es uno\n” unless $number ==1;

 

# while Repite un loop hasta que una condición es verdadera. Un ejemplo puede ser:

 

#!/usr/local/bin/perl

print STDERR “nombre del file: “;

$nombre_del_file = <STDIN>;

open(FILE, “< $nombre_del_file”);

while (!eof(FILE)) {

$raya = <FILE>;

print “$raya”;

}

Este script no hace otra cosa que pedirnos el nombre del file que hay que abrir y, mientras no llegue al final (la condición ‘while(!eof(FILE)’), lo muestra en la pantalla.

 

until Repite un loop mientras una condición sea falsa.

 

La sintaxis es:

 

until (condición) { # se puede sustituir con while por tener la

# condición opuesta

cosas;

que;

hacer;

 

} Esta construcción hace un test de la condición, y si es verdadera ejecuta todo lo que está contenido en {}, después ejecuta un nuevo test sobre la condición, etc., mientras la condición siga siendo falsa.

 

Dentro del bloque, puede haber otros 2 comandos útiles:

 

# next skippa el resto del bloque y va directamente a volver a hacer un test de la condición.

 

# last skippa el resto del bloque y sale:

 

$i = 0;

while ($i < 18) {

print “$i “;

$i++;

}

print “\n”;

 

$i = 0;

while ($i < 18) {

next if $i == 4;

print “$i “;

$i++;

}

print “\n”;

 

También aquí se puede usar la sintaxis.

 

haz_algo while condición

 

# foreach Ejecuta determinadas operaciones sobre cada valor de cada lista/array.

La sintaxis es:

 

foreach $variable (array o escalar) {

haz_algo;

haz_cualquier otra cosa;

}

 

Como siempre, $variable no es indispensable y, si ésta no se especifica, se utilizará $_ Los argumentos entre () pueden ser un array, más array o una lista de variables, o llamadas de funciones que restituyen valores, o una mezcla de todo esto.

 

Todos estos escalares y array son enviados a un array (como haz push() ), después de lo cual viene ejecutado el bloque entre {} para cada valor.

 

Cuidado: si el código entre {} modifica el valor de una variable, también en el array el valor será modificado.

 

Como con while/until, también con foreach se puede utilizar last y next.

 

@bla = (“ick”, 3, “arr”, “bleargh”);

%eek = (10, “no”, 5, “yes”, 7.5, “maybe”);

 

foreach (@bla, keys(%eek), “heh”) {

print “|”, $_, “| “;

}

print “\n”; # Muestra

# “|ick| |3| |arr| |bleargh| |10| |5| |7.5| |heh|”

 

foreach (@bla, keys(%eek), “heh”) {

$_ = “bla” if $_ == 3;

}

print join(“:”, @bla).”\n”; # Muestra “ick:3:arr:bleargh”

 

foreach $i (@bla) {

$i = “bleh” if $i == 3;

}

print join(“:”, @bla).”\n”; # Muestra “ick:bleh:arr:bleargh”

 

# for Puede utilizarse como sinónimo de foreach, sólo que la sintaxis resulta más clara:

 

for (statement1; condición, statement2) {

cosas;

que;

hacer;

}

 

for ($i = 0; $i < 18; $i++) {

print “$i “;

}

print “\n”;

 

for ($i = 0; $i < 18; $i++) {

next if $i == 4;

print “$i “;

}

print “\n”;

 

Después de haber hablado de los bloques, puede resultar útil introducir el concepto de “control” sobre los file. Por ejemplo, si se tiene un script del tipo:

 

#!/usr/bin/perl

print “Inserta el nombre del file que quieres modificar\n”;

chomp($file=<STDIN>);

…..

 

Es probable que el ususario indique el file correctamente y que el script proceda con éxito; ¿pero y si no es así? ¿Qué pasaría si el usuario insertase como nombre del file “halo” invece di “hola”? Simplemente el script editaría un nuevo file (vacío), ¡que no es el que queríamos! Semejante inconveniente se puede superar del siguiente modo:

 

#!/usr/bin/perl

print “Inserta el nombre del file que quieres modificar\n”;

chomp($file=<STDIN>);

if (-e $file) {

….

} else {

die “File no encontrado\n”;

}

 

¿Qué hay de diferente a lo de antes? Aparte el bloque if/else, fijaos en ese “if (-e $file)”: traduciéndolo al español podría ser “si existe $file”. Por tanto, el intérprete perl primero irá a ver si dicho file existe, y si es así, procederá a su modificación. Si no existiese, se bloquearía y mostraría un mensaje (no se ha encontrado el file).

Obviamente hay otros operadores además de “-e” ; veamos los más importantes:

 

-z el file tiene dimensiones nulas

 

-s el file tiene dimensiones no nulas (restituye las dimensiones

 

-f el file es un file regular

 

-d el file es un directorio

 

-l el file es un link

 

-r el file es legible

 

-w el file es escribible

 

-x es file es ejecutable

 

-T el file es un file de texto

 

-B el file es un file binario (opposto di -B)

 

Sinteticemos todo con un ejemplo:

 

#!/usr/bin/perl

print “Inserta el nombre del file\n”;

chomp($file=<STDIN>);

print “Legible\n” if -r $file;

print “Escribible\n” if -w $file;

print “Ejecutable\n” if -x $file;

print “El file tiene dimensiones nulas\n” if -z $file;

print “Es un directorio\n” if -d $file;

print “Es un link\n” if -l $file;

Operatores en PERL

Hemos visto que el perl utiliza los operadores matemáticos normales empleados para los números: + para la suma, – para la resta, * para la multiplicación, / para la división.

Además, == se utiliza para la igualdad, y vuelve “verdadero” o “falso” según que los números sean iguales o no. El opuesto es != .

 

Como se puede esperar, < es el símbolo de menor y > el de mayor, <= es el símbolo de menor o igual e => el de mayor o igual.

 

Usar estos símbolos con operadores no matemáticos, producirá, si se llama al script con la opción -w, un warning.

 

Hay también operadores que trabajan en la cadena:

 

.

(sí, realmente el punto) ejecuta la concatenación

 

eq

controla que las cadenas sean iguales

 

ne

es el opuesto de eq

 

3 == 3

es verdad

 

3 == “03”

es verdad

 

“bla” eq “arr”

es falso

 

“bla” ne “arr”

es verdad

 

“bla”.3

es equivalente a “bla”.”3″, que restituye “bla3”

 

“bla eek!”

es lo mismo di $bla.”eek!”

 

Están después los operadores lógicos: && (AND), || (OR), ! (NOT). && y || van entre dos expresiones, mientras ! va al principio de la expresión (ya que la niega)

 

3 == “03” && “bla”ne “arr”

es verdadera

 

Esta expresión funciona porque == y tienen una precedencia más alta respecto a &&, pero la misma expresión habría podido escribirse más claramente como:

 

(3 == 03) && (“bla” ne “arr”)

 

!(“eek” eq $bla)

es lo mismo de (“eek” ni $bla)

 

Una particularidad de los operadores && y || es que pueden utilizarse como atajo para “se ha verificado la condición haz esto”.

 

unlink “dumbfile” || die “Couldn’t remove file\n”;

 

De este modo primero se valora unlink() y, si esto tiene éxito, la condición introducida por || viene ignorada, de otro modo (en caso de fracaso) dicha condición se ejecuta.

El operador =~ es curioso: éste mira si 2 pattern son iguales y los sustituye. La sintaxis es:

 

valor =~ /pattern/;

Controla si las variables son iguales

 

valor !~ /pattern/

Forma corta para !($variable=~/pattern/;). Controla que no sean iguales

 

$variable =~ s/pattern/replacement/;

Busca el pattern en la variable y la sustituye con replacement

 

Si la variable se omite, =~ y !~ actúan sobre $_

En la primera forma, sin la s/ , =~ y !~ no modifican los argumentos, pero realiza un test sólo si se acoplan. En la segunda forma, el pattern “replacement” se sustituye con pattern si se encuentra.

 

Y aún más, algunos modificadores pueden añadirse antes del ; para especificar como los pattern tienen que acoplarse:

 

i – case-insensitive

g – match globale. Controla y restituye también más de un valor

 

Los pattern son expresiones regulares bastante parecidas a las de grep. Esto se explicará inmediatamente.

 

“bla” =~ /bl/;

verdadero porque bla contiene bl

 

“blabla” =~ /bl/;

idem

 

“blabla” =~ /bl/g;

encuentra 2 matches

 

“bla” !~ /c/i;

vero

 

$var = “blabla”;

 

$var =~ s/bl/QQ/;

verdadero, y cambia $var en “QQahbla”

 

$var =~ s/BL/qq/ig;

verdadero, y $var se transforma en “qqahqqah”

 

El operador = asigna el segundo elemento al primero. Hay atajos para usar este operador.

 

$var += $value:

añade $value a $var

 

$var -= $value;

resta $value de $var

 

$var *= $value;

multiplica $var por $value

 

$var /= $value;

divide $var por $value

 

Estas expresiones se utilizan para incrementar el valor de las variables:

 

$counter += $step;

 

$var ++

añade 1 a $var

 

++$var

valora $var+1

 

Todos estos operadores (menos =~) y el matching de los pattern se aplican también en C, de manera casi idéntica

Subroutines en PERL

Hasta ahora, todos los “programas” capaces de escribir son bastante ‘lineales’, es decir que se ejecutarían de principio a fin, línea tras línea, sin ningún test o loop, todos en un bloque único.
Es posible de todos modos definir nuestras funciones (o procedimientos, o subroutines o como queráis llamarlas) en perl, y después llamarlas como se llaman las funciones normales del perl.

El modo de definir una función es éste:

sub nombre_de la_función {
contenidos;
de la;
función;
}

Dicha función será llamada como &nombre_de la_función si no se quieren añadir argumentos, &nombre_de la_función ($argumentos, @vanno, %qui) para llamarla con los argumentos.
La “&” es el carácter que identifica las subroutines, del mismo modo en que $ define los escalares.

Las subroutines se pueden definir en cualquier punto del programa, excepto en el interior de otras. [Esto sirve para el perl4, en el 5 puede haber subroutine en otras subroutines, sub (= subroutines) sin nombre, y no es necesario el “&” para llamarlas].

Las sub se pueden utilizar antes de ser definidas.

ex: #!/usr/bin/perl
$bla=3;
&showbla;
$bla=4;
sub showbla {
print “bla è $bla\n”;
}
&showbla

Este ejemplo asigna 3 a $bla, llama la sub, asigna 4 a $bla, después la llama; no importa el lugar en el que está definida.
En la práctica las sub se encuentran al principio del script, rodeadas con la inicialización de las variables que sirven, y después el resto del código. Pero el perl nunca obliga a ser lógicos o claros.

Dentro de una sub, podemos tener acceso a los parámetros pasados (si los hay) a través del especial array @_ . De este modo, el primer valor pasado a la sub será $_[0], el segundo $_[1], etc.

sub printfirstargument {
print $_[0], “\n”;
}

sub printnumberofarguments {
print $#_ +1, “\n”;
}

sub addone {
$_[0] = $[0] +1;
}
$bla = 3;
&addone($bla);

Además, cada función restituye un valor que es la última expresión que se había valorado. Desde una sub se puede regresar a un determinado punto con el comando “return”, que volverá al punto asignado como argumento.

sub one {

if ($_[0] == 1) {
controla que el primer argumento sea 1

return “one”;
si es así, restituye la cadena “one”

} else {
si no …

return “not one”;
restituye la cadena “not one”

}
cierra “if/else”

}
cierra la sub

print &one(1), “, “, &one(3), “\n”;
muestra “one, not one”

Veamos ahora un ejemplo más “a mano”: este script leerá los valores en input e imprimirá la media aritmética.

#!/usr/bin/perl
sub media {
local($n, $somma, $media);
foreach $n (@_) {
$somma += $n;
}
$media = $somma/($#_ +1);
return ($media);
}
escribe “Inserta los números:\n”;
@números = <STDIN>;
chop (@números);
$media = &media(@números);
escribe “Media = $media\n”;

man perlfunc, comandos de PERL

Las así llamadas “builtin functions” son los ‘comandos’ normales del perl, que aceptan argumentos, hacen algo a nivel de argumentos o de sistema, y devuelven valores. Para informaciones más precisas consúltese “man perlfunc”.
Muchas funciones no tienen necesidad de argumentos entre (), pero en las operaciones más complicadas los paréntesis son necesarios para aclarar qué se refiere a qué. Normalmente, por tanto, los () se evitan en las líneas más simples, como print $bleah; pero tienen que incluirse cuando se invoca más de una función en la misma declaración.

Las declaraciones en perl terminan siempre con el signo ;

Funciones (en orden alfabético):

  • atan2 Función matemática: restituye el arcotangente de un valor. Ahí se puede también encontrar con

    sub tan { sin($_[0]) / cos($_[0]) }

  • binmode Abre un file en la modalidad binaria; tiene que ser invocado después de ejecutar open (que abre el file):

    open (FILE, file.bin);
    binmode FILE;

  • chdir Cambia el directorio de trabajo por el que está indicado como argumento de la función

    chdir ($HOME) or die “You’re homeless!\n”;

  • chmod Acepta como argumentos un número y una lista de file, y setta el permiso en los file en función del número asignado. El número se tiene que expresar en notación octal.

    El valor de salida es falso si es 0 o ”, verdadero en todos los demás casos:

    chmod 0644, “README”, “INSTALL”;

    @list = ( “abc”, “def”, “ghi”)
    chmod 755, @list;

  • chop Toma como argumento un escalar, y elimina el último carácter restituyéndolo. A menudo se utiliza para eliminar el carácter \n de los file y darles input de teclado.

    $a = “scalare”; $b = chop($a);

    En la mayor parte de los casos, no nos interesa el valor restituido, por tanto es suficiente dar:

    chop $a; o bien sólo:

    chop;

    que opera con $_ . Téngase en cuenta que para nuestros fines chomp es equivalente a chop.

  • chown Análogo al comando chown de los sistemas Unix: cambia el propietario de uno o más file. Los primeros 2 argumentos que tienen que pasarse a esta función son el uid (user id) y el gid (group id) numéricos, después el file o los file que hay que someter a la función. En general, la sintaxis es:

    chown $uid, $gid, @filenames;

    o bien

    chown $uid, $gid, ‘file1’, ‘file2’ …… ;

  • cos Función matemática. Restituye el coseno del parámetro (expresado en radianes) pasado a la función. Si se omite el parámetro, cos opera sobre $_

  • do Ejecuta un bloque de comandos y restituye el valor de la última expresión tomada en consideración. La sintaxis es:

    do BLOCCO;

    Una implementación útil de “do” puede ser la de repetir una parte de código hasta que una cierta condición se verifique. Veamos cómo:

    do {
    print “Elige 1 ó 2\n”;
    chop($sel=<STDIN>);
    until ” 1 2 ” =~ / $sel /;
    if ($sel == ‘1’) {
    print “Has elegido 1\n”;
    } elsif ($sel == ‘2’) {
    print “Has elegido 2\n”;
    }

    Este script muestra “has elegido 1” o “has elegido 2” según la tecla elegida por el usuario, a menos que éste haya tecleado cualquier otra tecla: en este caso, el script se desinteresa del terclado presionado y sigue mostrando “Elige 1 ó 2”. ¿Para qué puede servir todo esto? Simple: quitad de este script las primeras cuatro líneas y teclead “3” cuando se os pida que elijáis 1 ó 2: el script se bloquea y sale: no pasa nada malo, quede claro, pero si tenéis un script de algún centenar de líneas que se bloquea por una pequeñez, puede ser molesto.

  • die Toma como argumento una cadena y sal inmediatamente del programa viendo esta cadena como mensaje de error.

    if ($num != 18) {
    die “Non è 18\n”;
    }

  • eval Toma una expresión como argumento y la ejecuta como si fuese un pequeño programa. Si no se indica ningún argumento, eval valora $_ . Eval restituye el valor de la última expresión considerada, pero se puede recurrir a return para restituir el valor a un determinado punto del bloque. En el siguiente ejemplo se ve cómo es posible ejecutar la misma operación con do y con eval:

    do ‘script.pl’;
    eval `cat script.pl`;

    Cuidado con los ápices inversos: ‘ esto es un apóstrofo` éste es el ápice inverso

  • exec Sal del script Perl ejecutando otro programa. Normalmente, exec no vuelve a entrar en perl, pero si lo hiciese, restituye el valor falso, controlando qué ha sucedido a través del análisis de $! . Si se quiere volver al interior del script, se aconseja utilizar la función system

  • exit Toma un número como argumento, y sal con ese número como código de estado.

    exit 0; para salir con éxito

    exit 1; o cualquier valor distinto de 0

    sal sin éxito.

    La diferencia con die es que die se utiliza en los casos del tipo “esto no tendría que haber sucedido”.

  • exp Función matemática. Calcula el valor de e elevado al parámetro que se entrega con exp: si falta éste, actúa en $_

  • getpgrp Utilizado con la sintaxis ‘getpgrp PID’ restituye i/l proceso/i perteneciente/i al PID especificado. Si se utiliza esta función en sistemas que no implementan la llamada getgpgrp (véase man getpgrp), produce un error irreversible.

  • goto Sintaxis: goto label: busca la línea marcada por label y retoma su ejecución. La sintaxis puede ser también goto expr o goto &name (véase la manpage para ulteriores profundizaciones)

  • grep Ejecuta igual que el comando ‘grep’ en los sistemas Unix. En la práctica, busca una cadena y restituye los elementos por los que la expresión resulta verdadera. Véase la habitual man perlfunc y man perl (en los sistemas Unix)

  • join Toma una cadena y una lista de valores de uno o más array, y produce una cadena obtenida con todos los valores del array, usando la cadena como separador.

    $bah = (“:”, “eek”, “nada”, 34); $bah se convierte en “eek:niente:34”

    @array = (“uff”, “abc”, “foo”);

    print (join(” “, @array, “eek”), “\n”);

    muestra “uff abc foo eek”

  • keys Restituye una lista formada por todas las llaves del hash indicado:

    $bla{‘eek’} = “*pat*”;

    $bla{‘uff’} = “erp”;

    @thekeys = keys(%bla);

    @thekeys è (“eek”, “uff”)

    print (join(” “, keys(%bla)), “\n”;);

    muestra “eek uff”

  • kill Envía una señal a un proceso. Se puede usar como kill ‘STOP’ proceso; para las señales, véase man 7 signal.

  • last la ejecución interrumpe el ciclo en cuestión (parecido al BREAK del C). Si no se especifica el ciclo, last is se refiere al más interno.

    LINE: while <STDIN> {

    last LINE if /^$/;

    sal cuando ha terminado con los headers

    …….

    el resto del ciclo

    }

  • lenght Toma una cadena y restituye su longitud $n = “blip”;

    $l = $lenght($n);

    $l è 4

    print (lenght(34), “\n”);

    restituye 2

  • link Crea un link al file especificado con la sintaxis igual a la de los sistemas Unix:

    link OLDFILE, NEWFILE

  • local Modifica las variables catalogadas de modo que se conviertan en locales limitadamente según el bloque en curso. Si en la lista hay más variables, hay que meterlas entre paréntesis. Como alternativa a local, se puede usar también my.

    local $variable;

    declara $variable local

    local (@array, %hash);

    declara la lista de variables locales

    local $var = “valor”;

    declara $var local e le asigna un valor

    Para un tratamiento más completo, véase la sección ‘Temporary Values vía local()’ en man perlsub.

  • log Función matemática: restituye el logaritmo en base y del argumento pasado a la función (o, como siempre, actúa sobre $_ )

  • mkdir Crea un directorio, del que el primer elemento es el nombre; el segundo, los permisos sobre ella:

    mkdir “files”, 0755;

    o mejor:

    if (!mkdir(“files”, 0755)) {
    die “failed to create directory\n”;
    }

  • my Declara que las variables consideradas son locales respecto al bloque que las contiene, al subroutine o al file corriente; si se especifican más variables, tienen que se puestas entre paréntesis. A diferencia de las variables creadas con ‘local’, éstas hacen completamente ‘invisibles’ las variables globales con el mismo nombre. Para informaciones más detalladas, véase Private Variables vía my() en man perlsub

  • next Análogo a la instrucción CONTINUE del C, permite pasar directamente a la interacción del ciclo marcada por la etiqueta LABEL

    LINE: while (<STDIN>) {
    next LINE if /^#/;
    otro
    }

  • oct Interpreta el argumento pasado como parámetro de la función como un valor octal y lo restotuye en valor decimal

  • open Abre el file indicado como argumento de la función. El file se puede abir de diferentes maneras:

  • con < se abre en lectura

  • con >> se abre en escritura

  • con >> el contenido no se sobreescribe, pero los nuevos datos se añaden al final del file

  • con + delante de < o > para indicar que el file se tiene que abrir en lectura y escritura

  • se empieza con | , se ve como un comando al que se pasa el output

  • se termina con | , se ve como un comando del que se retira el input

    open /usr/src/linux/README

    Abre el file

    open log >> /tmp/log

    Abre el file log y pasa el contenido a /tmp/log, sin sobreescribirlo

    open <file;

    Abre el file para el cambio

    open(FILE, “<mifile;”);

    Como arriba, sólo que después será posible actuar sobre FILE

  • pop Extrae y restituye el último valor de un array reduciéndole en 1 las dimensiones. Si el array está vacío, restituye ”

  • print Imprime una cadena o una lista de cadenas. Restituye 1 si se ha ejecutado con éxito 0 si no

    escribe “Hello world\n”;

    ¡todas las veces que veais este ejemplo!

    $bla = 3
    escribe “El valor de ‘bla’ es $bla\n”;

    muestra “el resultado de ‘bla es 3”

  • push Añade uno o más elementos al final del array ampliando su longitud

    @bla = (“a”);

    $arr = “xterm”;

    push(@bla, “eek”, $arr, 12.5)

    @bla resulta ( “a”,”eek”, $arr, 12.5);

  • quotemeta Restituye una variante del argumento en el que los eventuales metacarácteres aparecen con el añadido del carácter backslash ( \ )

    quotemeta “.*” restituye “\.\*”

    rand La función random. Pasando un argumento numérico a la función, está devolverá un valor casual comprendido entre 0 y el número indicado. Si no se proporciona ningún argumento, devolverá un valor comprendido entre 0 e 1, extremos incluidos

  • readlink Pasándole un link como argumento, la función devuelve el nombre del file ( o directorio) al que se dirige ese file

  • rename Vuelve a nombrar un file: restituye 1 si la operación se ha realizado con éxito, 0 en caso contrario

  • rmdir Quita el directorio indicado como argumento de la función

    rmdir “temp_dir”;

  • shift Extrae el primer valor del array y lo restotuye, acortando en 1 la longitud del array y desviando los elementos restantes. En cierto sentido, es lo contrario de push. Si el array está vacío, lo deja vacío y devuelve un valor “undef”.

    @bla = (“a”, “xterm”, 12.5);

    $v = shift @bla;

    # @bla è (“xterm”, 12.5) e $v è “a”

  • sin Función matemática: restituye el seno de un determinado valor

  • sleep Espera los segundos indicados como argumento de la función.

  • split Busca particulares secuencias de caracteres y descompone la cadena en una serie de subcadenas, restituyendo la lista generada (en contexto escalar) o el número de subcadenas generadas. Se explicará mejor más adelante, tras las explicaciones sobre las expresiones regulares.

  • sqrt Función matemática: calcula la raíz cuadrada.

  • symlink Crea un link simbólico. La sintaxis es:

    symlink OLDFILE, NEWFILE

    En los sistemas que no prevén los link simbólicos, la función saldrá con un error. En este caso véase la función link().

  • system Ejecuta un programa. Es parecido a exec, pero después de terminar la ejecución del programa regresa en vez de salir.

    system (“comando”, “istrucciones”)

  • undef Toma el nombre de una variable y la coloca come indefinida. Sin argumentos, restituye un valor indefinido. Undef no restituye nunca ” o 0.

    undef %bla;

    se desembaraza del hash %bla

    undef $eek;

    se desembaraza del escalar $eek

    $eek = undef;

    como arriba

  • unlink Borra un file o una lista de file.

    unlink “tempfile”;
    unlink “tempfile”, “altrifile”;

  • unshift Añade una lista de elementos al inicio del array y restituye el número de elementos.

    @bla = (“a”, “b”);
    $arr = “xterm”;
    unshift(@bla, “eek”, $arr, 12.5); # @bla y (“eek”, “xterm”, 12.5,

  • warn Emite un ‘warning’ en el canal STDERR, como die pero sin salir.

    warn “debugger enebled” if $debug;

  • <> Lee una línea de STDIN y la restituye.

    $_ = <>;

    lee una línea en $_

    chop;

    ejecuta chop en \n

    print “Has escrito ‘$_’\n”;

    muestra el output, o bien lo que se ha digitado precedido de “Has escrito”

Variables especiales en PERL

El perl pone a disposición un conjunto bastante rico de variables especiales, o sea variables gestionadas directamente por el intérprete que contienen parámetros muy útiles.
En muchos casos puede ser útil pasar de los parámetros en la línea de instrucción a nuestro script Perl, por ejemplo con:

perl script.pl argumento

Esto se puede hacer perfectamente recordando que los parámetros que nosotros pasamos se almacenan en el array @ARGV (¡mayúscula!); este array es especial, pero se comporta exactamente como los demás array: $ARGV[0] indica el primer elemento del array, $#ARGV indica el último, etc. Veamos como ejemplo la “reescritura” de la instrucción ‘grep’ de los sistemas Unix: esta instrucción muestra las líneas del file de texto que contienen la cadena pasada como argumento al programa; por tanto, se escribirá un script que busca en el file de texto el argumento que nosotros pasamos a nuestro script.

#!/usr/bin/perl
$ARGV[0] || die “tienes que especificar la cadena de buscar\n”;
@file = `ls -1`;
chop(@file);
foreach $file (@file) {
-T $file || next;
open(FILE, “<$file”) ||next;
while ($r = ) {
$r =~ /$ARGV[0]/ && print “$file: $r”;
}
close (IN);
}

Quizá el ejemplo resulta algo general, pero puede ser útil para ilustrar las potencialidades de @ARGV; no os preocupéis si no entendéis foreach, open y otros: más adelante se explicarán. Un ejemplo más simple puede ser:

#!/usr/local/bin/perl
$filename = $ARGV[0];
open(FILE, “< $filename”) || die “¡Error!\n\n”;
while ($riga = ) {
print “$riga”;
}

En este ejemplo, el script espera que se le pase como argumento el nombre del file (segunda línea) sobhre el que ejecuta determinadas operaciones (en concreto, abre el file en lectura o, si no existe, se muestra un mensaje de error; después, imprime cada línea de ese file) Otro tipo de variables interesante es el de las variables de ambiente, que el intérprete toma del sistema y memoriza en el hash %ENV. Este hash contiene todas las variables de ambiente del sistema, que pueden ser seleccionadas con $ENV{variable}. Para ver su funcionamiento, hay que probar el siguiente script:

#!/usr/bin/perl
print “Path è: $ENV{PATH}\n”;

Obviamente, dicho script funciona con todas las variables y además es posible modificarlas (cuidado para no armar un lío). Para ver sobre qué variables podéis actuar, ejecutad:

$ set |more

que mostrará las variables con sus respectivos valores.

?

Variables y estructura de los datos en PERL

En los script in perl, los datos temporales se mantienen en variables; éstos se comportan en líneas generales como las variables de ambiente, pero no son lo mismo.

El tipo principal de variable en perl es el escalar. Un escalar es una cadena, o un número que no necesita ser convertido como en C. Además, todos los escalares pueden ser enteros o números en coma móvil, que el perl se ocupará de representar como enteros, si es posible, para mejorar la velocidad de ejecución.

Cada variable tiene un nombre que comienza siempre con un carácter especial que indica el tipo, seguido por un nombre de al menos una letra. Todos los nombres de las variables son casas-sensitivas, por lo que $variable es diferente de $Variable y de $VaRiAbLe.

El carácter espacial del que se hablaba es $, y se utiliza tanto al asignar una variable como cuando se usa su valor.

$bla = 1; asigna 1 a la variable escalar $bla

$bla = “1”;
asigna a bla la cadena “1”, que equivale a sobre

$ops = $bla +1;
$ops es 2

$bla = “adiós\n”;
\n es un regreso al inicio

print $bla;
visualiza adiós

En los script de shell, el carácter $ se usa sólo cuando se solicita el valor de una variable, no cuando se le asigna:

bla = 1 $bla En los script, las cadenas están dentro de “” o ” , con la diferencia de que entre “” las variables serán interpoladas y entre ” las variables se considerarán literalmente. Cada vez que puede aparecer una ambigüedad, como largo puede ser el nombre de una variable, $variabile puede escribirse como ${variabile}.

$bla = “eeek!”;

$blabla = “uff!”;

print “$blabla\n”;
visualiza “uff”

print “${bla}bla\n”
visualiza “eeek!bla”

$bla = “eek!”;

$msg = “$bla me has asustado”;
$msg contiene “eeek! me has asustado

$msg2 = ‘$bla me has asustado’;
ahora contiene “$bla me has asustado

En perl, como en el shell scripting (e diferentemente del C) no hay que expresar las variables antes de usarlas: la primera vez que se utiliza una variable, se expresa. Intentar la lectura de un valor inexistente lleva a tener una cadena vacía que, en contexto numérico, se interpreta como 0.
Las variables cuyo nombre empieza (tras el canónico $) con un carácter especial, que no es una letra, se consideran ‘reservadas’ (una lista se puede encontrar en man perlvar en perl5). Estas variables cambian algunos comportamientos del perl según en propio valor. Una de éstas en la variable $_ , a la que se deja libre para permitirle al usuario que inserte datos temporalmente, y tiene además la particularidad de que muchas funciones operan con $_ si no está equipado con algún valor.

$_ = “bla bla bla\n”;

print;
visualiza el contenido de $_

Daos cuenta de que no todas las funciones asumen $_ como defecto, incluso si esto funciona con todas las funciones en las que tiene sentido asumir la variable $_ . En caso de duda, se puede recurrir a un piccolo script de un par de líneas para ver si la función que interesa puede trabajar con $_ Otras variables importantes reservadas son:

$$ muestra el PID del programa
$< muestra el UID del usuario que ha ejecutado el programa $0 muestra el nombre del programa $! muestra el estado de la última llamada del programa $? muestra el estado de regreso de la última operación de ejecución de un proceso externo $@ muestra el último mensaje de error producido por el script Otro tipo de dato es el array; un array es una lista numerada de escalares. El array se identifica por el símbolo @, del mismo modo que $ indica el escalar. Todos los array están numerados a partir de 0: el primer elemento asume el número 0; el segundo, 1 y así sucesivamente. Los elementos se insertan en un array bajo la forma de una lista separada por comas y entre paréntesis. El elemento n del genérico array @array se define como $array[n]. En este caso se usa $ en lugar de @ porque se refiere a un escalar y no a todo el array. $var = 1; define una variable @array = ("bla", 34, "uff", $var); define el array; daos cuenta de que un elemento se define con el valor de $var $segundo = $array[1]; toma el segundo valor del array y se lo asigna a $secondo, que se convierte en 34 @eek = @array[0, 2]; @eek se convierte en ("bla", "uff"), ya que toma el primer y tercer valor de @array @urka = (@array, @eek); éste NO es un array de array, pues los array siempre son array de escalares. Lo que sucede es que todos los valores de @array e @eek son copiados en @urka, que se convierte en ("bla", 34, "uff", 1, "bla", "uff") Hay funciones que operan sobre los array, añadiendo elementos al final, quitándolos, extrayendo los que satisfacen una condición dada, ordenándolos, etc. La que se llama "size" de un array (es decir el número de elementos menos uno) llamado @array es dado por $#array. Para los array vacíos, ésta se asume como -1. @array = ("bla", "bla", "bla", "bla"); print $#array, "\n"; mostrará 3, y no 4 (fijaos en que el símbolo # en $#array no introduce un comentario). Hemos visto que en una cadena entre "", las variables se interpolan de manera que "bla$eek" significa "blabla" si $eek es bla. Esto se aplica también a los array. Es necesario tener cuidado con una cosa: print "mi dirección es root@localhost\n"; <- NO funciona print "mi dirección es root\@localhost\n"; <- funciona Esto sucede porque el carácter @ se considera especial y, si se quiere que aparezca literalmente (o sea que se considere como un simple carácter, no como un array), es necesario introducirlo con \ , que que protege el siguiente carácter de una interpretación diferente de la literal, como ocurre con otros caracteres como " o \. En este caso, \@ se conoce como carácter de escape; veamos otros: \\ \ \" " \$ $ \@ @ \' ' \a BELL \b BS (backspace) \e ESC \n LF (Line - feed) \r CR (Carriage return) \0n Número octal representado por 'n' \xn Número decimal Si queréis divertiros probad a lanzar este script: #!/usr/bin/perl print "\a"; Qui \a se considera un carácter de escape, y no será mostrado \a, como esperábais. Para ver \a, el script tiene que ser: #!/usr/bin/perl print "\\a\n"; \n no es estrictamente necesario, pero es útil para ver \a en una línea vacía sin el prompt Como alternativa, se puede escribir lo siguiente: print 'mi dirección es root@localhost', "\n"; que muestra mi dirección es root@localhost. Pero cuidado a no introducir en la expresión anterior variables que tienen que ser interpoladas: ¡simplemente no conseguiríamos la interpolación! El tercer (y último, por lo que nos respecta) tipo de datos en perl es el hash, llamado también array asociativo. Los hash se introducen con el símbolo % y contienen escalares indicizados por otros escalares. El mejor modo para entender los hash consiste en pensar en un vocabulario: cada hash contiene valores (las definiciones en el vocabulario) asignados a los identificadores (las palabras), y las operaciones base son añadir o quitar palabras o cambiar su valor, controlando si cada una de ellas existe o o no en el vocabulario. %bla = ("eek", 34, "uff", 18, "cero", "nada); fíjate que en la expresión anterior todas las cademas se podrían haber escrito también entre '' Por claridad, los hash se pueden escribir también como: %bla = ( "eek" => 34,
“uff” => 18,
“cero” => nada,
)

Continuamos con los ejemplos:

print $bla{“eek”}, “\n”;
muestra 34

$s = ‘cero’;

@arr = ($bla{“uff”},$bla{$s};
@arr se convierte en (18, “nada”)

Estos tres tipos de variables (escalares, array y hash) pueden perfectamente tener el mismo nombre: en el mismo código se pueden encontrar el escalar $abc, el array @abc y el hash %abc.
Veamos una última cosa: intentad ejecutar este script:

#!/usr/bin/perl
print “¿Cómo te llamas?\n”;
$nombre = ;
print “Hola $nombre\n”;

Como habréis notado, el script se interrumpe pidiéndonos nuestro nombre (pero podría pedir cualquier otra información). ¿Qué está pasando? En fin, es suficiente saber que el símbolo es el handler del file de input estándar, es decir un file siempre abierto durante la ejecución del programa y que representa el teclado del terminal de quien ejecuta el script. Con la línea $nombre = se le dice al script que almacene en la variable $nombre lo que el usuario teclea hasta que termina con la tecla enviar. Los canales estándar de comunicación son 3 y a cada uno está asociado un handler:

standar input
standard output
standard error

Stdout se puede ver como el canal a través del cual se emite el output. STDERR es parecido a STDIN, pero se utiliza normalmente para mostrar los mensajes de error.

Qué es el Perl

Antes de nada, un poco de filosofía. Al perl se le conoce a menudo como “lenguaje de scripting”, a diferencia de los lenguajes de programación, ya que originariamente se pensó no para grandes trabajos, sino para la automatización de determinados tasks. Con los años, el perl ha ido siendo más y más potente, utilizándose para proyectos cada día más relevantes, si bien éste no era su cometido originario.

El Perl (“Processing Estraction Report Language”, para quien lo aprecia; “Pathologically Electric Rubbish Lister”, para quien le fascina, como sugiere el autor) es un lenguaje dirigido principalmente al tratamiento de stringhe y file de texto. Lo que en Perl resulta absolutamente natural hacer es efectuar búsquedas de secuencias de carácteres dentro de stringhe (pattern matching), sustituciones de substringhe (pattern substitution), operaciones sobre file de textos estructurados en campos y record o bien no estructurados. Por estas razones, el Perl se utiliza con fuerza en la escritura de procesos CGI instalados en un servidor web, o para el desarrollo de procesos de mantenimiento de las actividades de un servidor. Por los mismos motivos, el Perl no resulta, sin embargo, indicado para desarrollar procesos de puro cálculo científico o programas que necesitan una gran velocidad y precisión de cálculo o elaboraciones numéricas complejas.
Pero el Perl se convierte en una necesidad para quien tenga que manejar un sitio web que no esté compuesto sólo de texto e imagen: con este lenguaje, es posible automatizar algunas operaciones útiles, desde las más simples solicitud de una dirección e-mail) a las más complejas (como registrar datos de ususarios, etc.). ¿Quién no se ha topado alguna vez con un sitio en el que se nos pedía la dirección e-mail para inscribirnos en una mailing-list, o quién no ha visto en algunas páginas algo como “Visitante número nnnnnnn”, o a quién no le han pedido que rellenase módulos de inscripción o registro? ¡Creo que todos!
Pues bien, por debajo de todo esto, hay líneas y líneas de Perl (¡en la mayor parte de los casos!) que realizan lo que el usuario ha tecleado y lo restituyen al webmaster en formato inteligible o mejor (sobre todo para registros e inscripciones, en los que hay bastantes campos que rellenar: nombre, apellidos, etc.) formateado en diversos campos (de base de datos) o, en el mejor de los casos, haciéndolo todo solo: tomemos por ejemplo a un usuario que quiere tener un espacio web gratis y que tiene que registrarse: se encontrará ante muchas preguntas que responder, y al final tendrá que pulsar la tecla “envía” y pasar el asunto al webmaster, que se ocupará de confirmar la inscripción. Quien haya hecho esto al menos una vez se habrá dado cuenta de que la confirmación de inscripción realizada llega inmediatamente (¡hablamos de algunos minutos como máximo!): pues bien, aquí no es el webmaster el que trabaja a la velocidad de la luz, sino un complicado script que recibe las informaciones y las elecciones del ususario, asignándole un nombre de usuario y una clave, preparando un directorio en el servidor que pueda recibir los file del usuario, file que, por otra parte, quedará protegido de otros usuarios que pretendiesen modificarlo, etc.; en definitiva, se preocupa de enviarle al usuario un mensaje (que normalmente es un modelo en el que se incluyen sus datos) para advertirlo de que la operación se ha completado con éxito. Y no nos olvidemos de que el mismo script controla que las elecciones del usuario sean sensatas: por ejemplo, controlando que la dirección e-mail sea válida (en el sentido de que esté en la forma usuario@dominio y no usuario_dominio, por ejemplo).

En definitiva, el Perl es sin duda una mina de oro para el webmaster que tenga determinadas exigencias, y aprender las bases es útil para poterder iniciar a escribir los propios script de automatización (pero no sólo, se pueden escribir también auténticos programas) y sucesivamente implementarlos en el propio servidor, sea o no local.

El intérprete perl no compila nunca el códice en códice-máquina, como hacen los compiladores C: cada vez que se ejecuta un script en perl, se interpreta “al vuelo”.

Hay 2 versiones de perl: el perl4 y su sucesor, el perl5. Éste es, en general, compatible con el perl4, y tiene además features adicionales. En este documento se hará referencia sobre todo al perl5, ya que debería ser la release más utilizada.

Introducción al Perl

El objetivo de este documento es explicar las bases de la programación en perl. Intentaremos hacerlo en líneas generales y centrándonos en las “ideas” en vez de en los detalles, comparándolos cuando sea posible con los lenguajes C y de shell scripting. El fin último de este documento es capacitaros para leer, entender, modificar los script in perl y, en definitiva, para escribir los vuestros.

No se asume que seais programadores, pero tampoco se os explicará qué son un file o una pipe; se necesita un conocimiento mínimo del mundo Unix para que podáis entender. De hecho, el lenguaje Perl casa perfectamente con el sistema UNIX; aunque hoy se hayan efectuado porting sobre otras muchas plataformas (Windows 9x/NT, OS/2, MS-DOS, ecc …), el entorno natural para desarrollar y utilizar script en Perl es UNIX, donde es posible integrar y hacer interaccionar los script con los numerosísimos instrumentos incluidos en el sistema (sed, awk, grep, mail ecc. ) y obtener lo mejor del lenguaje.
En este documento hay mucho material, incluso bastante condensado; una buena idea puede ser leerlo de principio a fin sin memorizar, al inicio, nada, salvo las bases, suficiente para hacerse una idea general; el segundo paso consiste en leer con mayor atención, intentando entender con claridad cómo funciona perl. No olvidéis, durante la lectura, probar los ejemplos que se proponen con las herramientas del texto para comprobar el funcionamiento y, eventualmente, intentar modificarlos para descubrir las innumerables posibilidades que ofrece este lenguaje.

Obviamente, se trata sólo de una selección de las principales instrucciones, ya que el perl cuenta con muchas más de las que aquí se han incluido, algunas de las cuales tienen, asimismo, muchas más opciones o posibilidades de las que presentaremos aquí. Probablemente habrá también algún descuido sobre la semántica del lenguaje: ¡perdonádnosla! En cualquier caso, recurrid siempre a la documentación.