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
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.