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;