Como buenos Administradores de sistems es hora de que os metáis en el fabuloso mundo de PERL, una herramienta imprescindible para todo buen administrador. He aquí una pequeña iniciación a este mundo, lo que podríamos denominar "guía básica de PERL", sacada de varios manuales y apuntes propios.Iré añadiendo los ejemplos y actualizándola en la mayor medida que pueda. Podéis encontrarla siempre que la necesitéis en cursos online o al final del blog en "articulos destacados". Seguramente tenga muchas fallas, no dudeis en corregirlas en los comentarios. Espero que esta guía te muestre lo que buscas.
INDICE
1- TIPOS DE DATOS
- Datos escalares
- Datos Array
- Datos Hash
- Datos Booleanos
- Combinando datos escalares, arrays y hashes
- Funciones sobre datos Hashes
2- ESTRUCTURAS DE CONTROL
- Lógica de Perl
- Clases de estructuras
- Nomenclatura
- Operadores lógicos
- Preferencias en operadores lógicos
- Operadores de comparación
- Operador Triario
- Control de flujo
3- SUBRUTINAS
- Definición de subrutina
- Modismo @_
- Función return
- Función wantarray
4- EXPRESIONES REGULARES
- Operador m// (empareja)
- Operador s/// (substitución)
- Modificador '/x'
- Operador split
- Sentencias de Escape
- Conversión Perl cadena/numérica
5- VARIABLES
- Variable $!
- Variables sensibles al contexto
- Variables contextuales multitipo y multiestado
- La Variable $_
- Variables predefinidas en Perl
- Variables Privadas
6- FUNCIONES
- Depurador Perl
- substr
- index y rindex
- reverse
- length
- chop y chomp
- push y pop
- shift y unshift
- splice
7- MANEJO DE ARCHIVOS
- Lectura de Datos
- Lectura de Ficheros
8- MODULOS
1.- TIPOS DE DATOS EN PERL
Existen tres tipos de datos esencialmente en perl y algunos tipos de estructuras:
SCALAR: Pueden guardar un solo valor
$escalar
ARRAY: Guardan una colección de valores indexados por posición
@arreglo, $arreglo[2]
HASH: Guardan una colección de valores indexados por llave alfanumerica
%hash, $hash{llave}
CODE: Apuntan a codigo con nombre, funciones %func() o simplemente:
func()
FORMAT: Apuntan a definiciones de formato de salida
format Formato = (...)[7]
FILEHANDLE: Permiten el manejo de archivos o de directorios
FH
GLOB: Se refiere a cualquiera de los tipos de datos anteriores que tengan el mismo nombre despues del prefijo identificador:
*glob se refiere $glob, @glob, %glob, &glob, filehandle glob y formato glob
Algunos ejemplos de datos:
Datos Escalares: Una variable escalar puede almacenar un número, una cadena de caracteres o una referencia.
$n = 42; # Numero
$nombre = "juan"; # Cadena
$color = 'rojo'; # Cadena
Las cadenas con comillas dobles permiten la interpolación de variables:
$a = 1;
print "$a"; # Imprime un 1
print '$a'; # Imprime $a
· Ejemplo: Variables seguidas de letras ("variable_letras.pl")
#!/usr/bin/perl
$que = "chuleta";
$n = 3;
print "Antonio comio $n $ques. \n";
print "Antonio comio $n ${que}s .\n";
Datos Array:
@puntuaciones = (32, 45, 16, 5);
Datos Hash:
%favorito = (
joe => 'rojo',
sam => 'azul',
);
Datos Booleanos:
$fruta = '0'; # Falso
$fruta = '5'; # Verdadero
$fruta = "5 mangos"; # Verdadero
Ejemplos: Valores Booleanos
$falso = 0; # el número cero
$falso = 0.0; # el número cero como flotante
$falso = '0'; # el ''string'' cero
$falso = ""; # el ''string'' vacío
$falso = undef; # el valor devuelto por undef
Si, específicamente, quiere asegurarse de tener un resultado 1/0
(como en el lenguaje C), necesita realizar el cálculo siguiente:
my $resultado_real = $resultado_booleano ? 1 : 0;
Combinando datos escalares, arrays y hashes
$puntuaciones[2] # un elemento de @puntuaciones
$favorito{joe} # un valor de %favorito
@puntuaciones[2, 3, 1] # tres elementos de @puntuaciones
@favorito{'joe', 'sam'} # dos valores de %favorito
El número de elementos en un array puede ser obtenido evaluando el
array en contexto escalar o con la ayuda del sigil $#. Éste último
da el índice del último elemento dentro del array, no el número de
elementos.
$numero = @amigos;
$#amigos; # el índice del último elemento en @amigos
$#amigos+1; # normalmente el número de elementos en @amigos,
# que es uno más que $#amigos porque el primer
# elemento tiene el índice 0, no 1
Funciones sobre datos hashes
# guarda en el array @nombres_de_clientes
# todas las claves del hash %direcciones
@nombres_de_clientes = keys %direcciones;
# guarda en @direcciones_de_email
# todos los valores de %direcciones
@direcciones_de_email = values %direcciones;
2.- ESTRUCTURAS DE CONTROL
Lógica de Perl
1 Cualquier cadena es true con la excepción de las cadenas "" y "0".
2 Cualquier número es true excepto el 0.
3 Cualquier referencia es true.
4 Cualquier valor undefined es false.
Perl tiene varias clases de estructuras de control.
* Control de ciclos: do, while, for, foreach, continue.
* Control de sentencias: if, else, unless, until, elsif.
* Control de flujo: goto, elsif, next, last, redo, return.
La nomeclatura ed estas estructuras deben de tener esta forma:
* Las CONDICIONES están rodeadas por paréntesis () y
* Los BLOQUES rodeados por llaves {}
* Las expresiones opcionales por corchetes cuadrados []
* Las ETIQUETAS deben llevar al final dos puntos ':';
Ejemplos estructuras:
[ETIQUETA] while CONDICION BLOQUE [continue BLOQUE ]
[ETIQUETA] until CONDICION BLOQUE [continue BLOQUE ]
[ETIQUETA] foreach [VARIABLE] (LISTA) BLOQUE [continue BLOQUE]
[ETIQUETA] for (EXPRESION_1;EXPRESION_2;EXPRESION_3) BLOQUE
if CONDICION BLOQUE [[elsif BLOQUE] else BLOQUE]
unless CONDICION BLOQUE [else BLOQUE]
Para una sola sentencia
DECLARACIÓN if CONDICIÓN
DECLARACIÓN unless CONDICIÓN
DECLARACIÓN while CONDICIÓN
DECLARACIÓN until CONDICIÓN
DECLARACIÓN foreach LISTA
· Ejemplo: if y unless ("sentcontrol_if.pl")
· Ejemplo: do while ("sentcontrol_dowhile.pl")
· Ejemplo: for y foreach ("sentcontrol_foreach.pl")
Operadores lógicos
EXPRESION_1 and EXPRESION_2;
EXPRESION_1 or EXPRESION_2;
EXPRESION_1 && EXPRESION_2;
EXPRESION_1 || EXPRESION_2;
EXPRESION_1 eq EXPRESION_2;
EXPRESION_1 == EXPRESION_2;
Preferencias en operadores lógicos
_______________________________________________
left terms and list operators (leftward)
left ->
nonassoc ++ --
right **
right ! ~ \ and unary + and -
left =~ !~
left * / % x
left + - .
left << >>
nonassoc named unary operators
nonassoc < > <= >= lt gt le ge
nonassoc == != <=> eq ne cmp ~~
left &
left | ^
left &&
left || //
nonassoc .. ...
right ?:
right = += -= *= etc.
left , =>
nonassoc list operators (rightward)
right not
left and
left or xor
_______________________________________________
+ info: # perldoc perlop
· Ejemplo: Operaciones Lógicas 1 ("op_log1.pl")
· Ejemplo: Operaciones Lógicas 2 ("op_log2.pl")
*** Utilizando and y or nunca se llega a cumplir la operación
lógica si print $a es "true". Utilizando && y || siempre se da
preferencia a la operación lógica antes que a el operador print.
Ahora miremos esta tabla comparativa sacada con el modulo Deparse:
"perl -MO=Deparse -p archivo.pl", esto nos mostrara la forma en que
esta parentizado Perl el archivo de ejemplo "op_log2.pl":
op_log2.pl Parentización PERL
____________________________________________
$a = 4; $a = 4;
$b = "hola"; $b = 'hola';
$d = print ($a and $b); $d = print($a && $b);
print $d; print $d;
$e = print $a and $b; $b if $e = print($a);
print $e; print $e;
$f = (print $a && $b); $f = print($a && $b);
____________________________________________
Operadores de comparación
Comparación Numerico Cadena
______________________________________________
Igual == eq
distinto != ne
Menor que <> gt
Menor o igual que <= le Mayor o igual que >= ge
Comparación <=> cmp
______________________________________________
· Ejemplo: comparación cadenas ("comp_cadenas.pl")
Operador triario
if CONDICION BLOQUE else BLOQUE puede expresarse:
[DECLARACION] [(] CONDICIÓN ? EXPRESION_1 : EXPRESION_2 [)];
Control de Flujo
Las palabras clave de control de flujo next, last, return y redo
son expresiones, por lo que pueden ser usadas con los operadores
"cortocircuito". Perl tambien cuenta con dos construcciones para
bucles:
resultados = grep { ... } lista
resultados = map { ... } lista
grep devuelve todos los elementos de lista en que el bloque subor-
dinado evalúa a verdadero. map evalúa el bloque subordinado por
cada elemento de lista y devuelve una lista de los valores resul-
tantes. Estas construcciones permiten un estilo simple de progra-
mación funcional.
3.- SUBRUTINAS
Las rutinas nos permitirán reutilizar código y tenerlo más orga-
nizado ya que podremos acceder a éste desde cualquier parte del
programa e incluso desde otros programas.
Las subrutinas se definen con la palabra clave sub:
foo(); # paréntesis necesarios aquí...
sub foo { ... }
foo; # ... pero no aquí
Una lista de argumentos pueden ser indicados después del nombre de
la subrutina. Los argumentos pueden ser escalares, listas o hashes.
foo $x, @y, %z;
Los elementos de @_ pueden ser accedidos con los subíndices de la
forma normal.
$_[0], $_[1]
Un modismo común es asignar @_ a una lista de variables con nombres.
my($x, $y, $z) = @_;
Otro modismo es sacar los parámetros de @_. Esto es muy común
cuando la subrutina toma un sólo argumento.
my $x = shift; # Si no se dice nada, nos referimos a @_
Las subrutinas pueden devolver valores.
return 42, $x, @y, %z;
La expresión devuelta es evaluada en el contexto de la llamada de
la subrutina; esto puede sorprender al desprevenido.
sub lista { (4, 5, 6) }
sub array { @x = (4, 5, 6); @x }
$x = lista; # devuelve 6 - último elemento de la lista
$x = array; # devuelve 3 - número de elementos de la lista
@x = lista; # devuelve (4, 5, 6)
@x = array; # devuelve (4, 5, 6)
Una subrutina puede descubrir su contexto de llamada con la función
wantarray.
sub cualquiera { wantarray ? (1, 2) : "Naranjas" }
$x = cualquiera; # devuelve "Naranjas"
@x = cualquiera; # devuelve (1, 2)
4.- EXPRESIONES REGULARES
Una expresión regular es un modelo o una forma de comparar con una
cadena de caracteres. Esta comparación es conocida con el nombre de
pattern matching o reconocimiento de patrones, permite identificar
las ocurrencias del modelo en los datos tratados. se pueden dividir
en: (Comparación) (Sustitución) (Traducción).
(Expresiones Regulares de Comparación)
· Ejemplos: Expresiones regulares ("expresiones_regulares.pl")
Caracteres de control que definen modelos complejos de rutinas de
comparación:
Simbolo | Descripción | Clase | Negación
_______________________________________________________________
\w Caracteres alfanuméricos [0-9a-zA-Z] \W
\s Espacio '' \S
\d Caracteres numéricos [0-9] \D
\A Inicio de cadena X \Z
\b Inicio y fin de cadena X \B
_______________________________________________________________
· Ejemplo: Area de circunferencia ("circunferencia.pl")
Caracteres de control, secuencias de Escape:
_______________________________________________________________
\a Alarma (beep!)
\b Retroceso
\n Nueva línea
\r Retorno de carro
\t Tabulador
\f Formfeed
\e Escape
\007 Cualquier carácter ASCII en octal
\x7f Cualquier carácter ASCII en hexadecimal
\cC Cualquier caracter de control (CTRL+C)
\u Cambia el siguiente caracter a mayusculas
\U Cambia a mayusculas todo el contenido.
\l Cambia el siguiente caracter a minusculas
\L Cambia a minusculas todo el contenido.
\E Final de cambio a mayusculas o minusculas
_______________________________________________________________
Caracteres genéricos que aumentan la flexibilidad en la construcción
de patrodes de búsqueda:
Caracter Descripción
_______________________________________________________________
^c. La linea que empieza por el caracter c
$c La linea que termina por el caracter c
. Cualquier caracter excepto el \n
c+ Una o mas instancias del caracter c
c* Cero o mas instancias del caracter c
c? Cero o una instancia del caracter c
c{N} N instancias del caracter c
c{N,} Al menos N instancias del caracter c
c{N,M} Entre N y M instancias del caracter c
_______________________________________________________________
(Expresiones Regulares de Sustitución)
El operador m// (empareja) permite comprobar un emparejamiento por
medio de una expresión regular. (Para abreviar, el precedente m
puede ser omitido.) En el caso más simple, una expresión como:
$x =~ m/abc/
evalúa a verdadero si y sólo si el string $x empareja con la
expresión regular abc.
$x =~ m/a(.)c/; # captura el carácter entre 'a' y 'c' y lo
# guarda en $1
El operador s/// (sustitución) especifica una operación de búsqueda
y reemplazo:
$x =~ s/abc/aBc/; # Convierte la b en mayúscula
$x =~ m/abc/i; # emparejamiento independientemente de si
# están en mayúscula o minúscula
$x =~ s/abc/aBc/g; # búsqueda y reemplazo global (a lo largo de
# todo el string)
Las expresiones regulares pueden ser densas y crípticas. Esto es
porque la sintaxis de las expresiones regulares es extremadamente
compacta, generalmente usando caracteres sueltos o pares de
caracteres que representan sus operaciones. Perl alivia un poco
este problema con el modificador '/x' que permite a los programador
es poner espacio en blanco y comentarios dentro de las expresiones
regulares:
$x =~ m/a # empareja una 'a'
. # empareja cualquier carácter
c # empareja una 'c'
/x;
Un uso común de las expresiones regulares es el de especificar de
limitadores de campos al operador split:
@palabras = split m/,/, $línea; # divide la $línea de valores
# separados por comas
El operador split complementa la captura de string. La captura de
string devuelve las partes de un string que emparejan con una
expresión regular; split devuelve las partes que no emparejan.
Perl convierte automáticamente los valores de su representación
numérica a su representación como cadena. Ejemplos:
$n = 0 + "123"; # contexto numérico $n == 123
$n = 0 + "123xyz"; # contexto numérico $n == 123
$n = 0 + "\n123xyz"; # contexto numérico $n == 123
$n = 0 + "x123xyz"; # no hay número al comienzo $n == 0
$n = 0 + "x123"; # no hay número al comienzo $n == 0
$n = 0 + oct("x123"); # $n == 291
5.- VARIABLES
La Variable $!
En un contexto numérico, la variable escalar $! retorna el valor
numérico de la variable del sistema errno, la cual contiene el
último error encontrado durante una llamada al sistema o a ciertas
funciones de la biblioteca estándar C. En un contexto de cadena
devuelve la cadena producida por la función perror():
root@rootmachine# perl -de 0
DB<1> open $FILE, "fichero"
DB<2> print "$!"
No existe el fichero o el directorio
DB<3> print $!+0
2
DB<4> print $!
No existe el fichero o el directorio
Variables sensibles al contexto
root@rootmachine# perl -de 0
DB<1> use Scalar::Util qw{dualvar} # lmportamos el modulo Scalar
DB<2> use Lingua::EN::Words2Nums # Importamos el módulo Lingua
DB<3> $x = "one thousand two hundred thirty one"
DB<4> $x = dualvar words2nums($x), $x # Creamos una variable dual
DB<5> print "$x plus one is ".($x+1) # Observe la salida ...
one thousand two hundred thirty one plus one is 1232
DB<6> use Roman # Otro ejemplo ...
DB<7> $y = 457
DB<8> $y = dualvar $y, roman($y)
DB<9> p 0+$y." en números romanos es '$y'"
457 en números romanos es 'cdlvii'
· Ejemplo: Numeros Romanos ("num_roman.pl")
Variables contextuales multitipo con mas de dos tipos.
· Ejemplo: Contextual Return ("mult_context_var.pl")
· Ejemplo: Localtime ("localtime.pl") ACTIVE variable multiestado
La Variable $_
La variable especial $_ es el argumento por defecto para un gran
número de funciones, operadores y estructuras de control. Asi pues
estas dos expresiones son lo mismo:
print;
print $_;
Otro ejemplo: La función length devuelve la longitud en caracteres
de la expresión que se le pasa como argumento. Si se omite la
expresión usará la "variable por defecto" $_
root@rootmachine# perl -wde 0
DB<1> $_ = "Hello World!\n"
DB<2> p length
13
Variables Predefinidas en Perl
root@rootmachine# perldoc perlvar
Variables Privadas: Se declaran usando el operador my:
my $a = 4;
{
my $a =
my $b =
$a = ($a < $b)? $a : $b print "$a\n"; } print "$a\n";
Estas variables tienen como ámbito el bloque que las rodea. Asi la declaración de la variable léxica $a en la línea 3 oculta la variable léxica declarada en la línea 1. Las modificaciones de $a en el bloque de las líneas 2-7 no afecta a la variable $a declarada en la línea 1. Si no esta dentro de ningún bloque, el ámbito de la variable será el fichero actual. A partir de ahora usaremos el depurador para ver la conducta de
Perl con estas sentencias:
root@rootmachine# perl -de 0
DB<1> $days = 5;
DB<2> x $days
0 5
Operadores de Cadena
"hola"."chicos" # es lo mismo que "holachicos"
"HLP"x2 # es HLPHLP
$s .= " un poco mas"; # Lo mismo que $s = $s . " un poco mas";
Si se quiere obtener uno o mas elementos de una cadena se usa
substr, veamoslo en el depurador:
root@rootmachine# perl -de 0
DB<1> $x = 'hola mundo'
DB<2> p substr($x,5) # Muestra a partir de la 5
mundo
DB<3> p substr($x,5,3) # Muestra 3 a partir de la 5
mun
DB<4> p substr($x,-2) # Segunda desde el final
do
DB<5> p substr($x,2,2,'mi') # Sustituimos
la
DB<6> x $x # Indice y Valor
0 'homi mundo'
Función index y rindex: busca subcadenas dentro de una cadena
desde el principio y desde el final.
root@rootmachine# perl -de 0
DB<1> $x= 'hola mundo'
DB<2> p index $x, 'mundo'
5
DB<3> p index $x, 'o'
1
DB<4> p index $x, 'o', 3
9
DB<5> p rindex $x, 'o'
9
DB<6> p rindex $x, 'o',4
1
Función reverse invierte los elementos de una cadena.
root@rootmachine# perl -de 0
DB<1> $x = 'hola mundo'
DB<2> $y = reverse $x
DB<3> p $y
odnum aloh
Función length retorna la longitud de una cadena.
root@rootmachine# perl -de 0
DB<1> $x = 'hola mundo'
DB<2> p length $x
10
Función chop y chomp elimina el ultimo elemento de una cadena.
(chomp solo lo elimina si es un retorno de carro o separador de
lectura).
root@rootmachine# perl -de 0
DB<3> chop $x
DB<4> p $x
hola mund
DB<5> chomp $x
DB<6> p $x
hola mund
DB<7> $x .= "\n"
DB<8> p $x
hola mund
# retorno de carro
DB<9> chomp $x
DB<10> p $x
hola mund
Hay varias funciones para trabajar con arrays Las mas básicas son
push, pop, shift, unshift y splice donde:
push # Coloca un elemento al final del array
pop # Coge un elemento del final del array
shift # coloca un elemento al principio del array
unshift # Coge un elemento al principio del array
splice # Coloca un elemento en cualquier punto del array
· Ejemplo: Función Array ("funcion_array.pl")
· Ejemplo: Buscar en un Array ("buscar_array.pl")
· Ejemplo: Chop ("chop.pl")
7.- MANEJO DE ARCHIVOS
Lectura de datos. El operador
entrada estándar. Asi en:
$line =
La variable $line contiene el retorno de carro leído. Es por eso
que se usa el operador chomp el cual elimina el retorno de carro
·final:
$line =
chomp($line); # $line contiene ahora "hola"
Lectura de ficheros. En general un fichero se abre mediante la
función open:
root@rootmachine# perl -de 0
DB<1> open $F, "> /tmp/file.txt" # apertura en modo escritura
DB<2> print $F "hello world\n"
DB<3> close($F)
DB<4> open $F, "/tmp/file.txt" # apertura en modo lectura
DB<5> $x = <$F>
DB<6> print $x
hello world
· Ejemplo: Apertura de Fichero ("open_file.pl")
8.- MODULOS
Instalción de modulos en Perl:
root@rootmachine# cpanp
CPAN exploration and module installation
Synasix de llamada del modulo:
use Scalar::Util qw{dualvar} valor doble?
No hay comentarios:
Publicar un comentario