El lenguaje Perl
Qué es Perl
Perl es un lenguaje de programación, estructurado en el lenguaje 'C', está
diseñado para facilitar la manipulación de textos, archivos y procesos.
Algunas de las principales facilidades del lenguaje PERL son:
sin problemas
de ejecución.
Al igual que cualquier script de los diferentes interpretadores de
comandos (Shells), permite almacenar y ejecutar sin problema un
script en particular desde el sistema operativo.
Permite la manipulaci`on de la estructura de cualquier archivo en el
ambiente Unix. Toda la traducción Lógica de Oracle Libraries, se estructuró en
scripts elaborados en PERL, sus resultados fueron excelentes y la traducción
fue exitosa.
Cómo Ejecutar Perl
Para ejecutar un programa en perl basta crear un archivo en el sistema
operativo con permisos de ejecución en ingresar como primer entrada (primera
linea) la siguiente instrucción :
#!/usr/
local/bin/perl
donde los caracteres #! indican que los caracteres siguientes
representan un interpretador de comandos, la ruta (path) /usr/local/bin
determina el directorio donde se encuentra el interpretador de comandos,
posteriormente el nombre del interpretador de comandos, para el caso del
lenguaje perl se denomina perl. Para encontrar la ruta de perl
se emplea el comando del sistema operativo which de la siguiente forma
:
which perl
Una vez creado el archivo con la primera linea en seguida se escribe el
programa y posteriormente se ejecuta.
Cuando se emplean argumentos en un programa como en el siguiente caso :
programa.pl argumento1 argumento2
Los argumentos se almacenan en el vector
posición @ARGV, para
posteriormente manipularlos en el codigo del programa, ejemplo :
sumar.pl 1 2
Para extraer los 2 números dados como argumentos iniciales, se emplea la
función shift de la
siguiente forma :
$variable = shift(@ARGV);
$variable2 = shift(@ARGV);
o simplemente
$variable = shift;
$variable2 = shift;
ya que la función shift actua por defecto sobre @ARGV
En el anterior caso $variable
toma el valor de 1 y $variable2 toma el valor de 2. Cuando de concatena una una
comando del sistema operativo con un programa en perl, ya sea como
entrada o ya sea como salida, la información se manipula dentro del programa con
los archivos especiales STDIN para la
información de entrada y STDOUT para la
información de salida, ejemplo :
cat archivo | programa.pl
En el anterior caso se emplea el comando del sistema operativo cat, el cual
suministra toda la información de 'archivo' y se concatena con un programa en
perl que se denomina 'programa.pl', el cual recibe la información en el
archivo especial STDIN.
programa1.pl | programa2.pl
En el anterior ejemplo se emplea un programa en perl 'programa1.pl'
para suministrar la información a otro programa en perl 'programa2.pl',
en primer programa la infromación se suministra en el archivo especial STDOUT y el
segundo archivo se recibe en el archivo especial STDIN.
Entradas, Salidas y Ambiente en Perl
A continuación se presenta la descripción de la entradas, salidas y ambiente
manipulado en el lenguaje perl
Entradas : Las entradas en perl, es el sumnistro de la
información ya sea por medio de la función open o por
medio de la entrada estandar denominada STDIN,
este archivo especial se emplea para manipular la información proveniente de
la línea de comando o en alguno de los casos del teclado, ejemplo : si se ejecutara en el sistema operativo 'cat archivo | programa.pl'
y en programa.pl se emplara las siguientes intrucciones :
while (<STDIN>) {
print;
}
La infromación proveniente de 'archivo' dirigida por el comando
'cat' se manipula en un ciclo 'while' se imprime en pantalla.
De esta forma se emplea la entrada estandar STDIN en
el flujo de información del lenguaje perl.
Salidas : Las salidas en perl se emplean por medio de la
función open o por la
salida estandar denominada STDOUT,
este archivo especial manipula toda la información que saldrá durante la
ejecución del programa, si no se define con la función open o en le
definición de un reporte la
salida estandar STDOUT,
la información que se imprimirá con la función print saldrá
directamente a pantalla si no existe ninguna concatenación a otro programa u
otro comando en la línea de comandos, de lo contrario se direccionará al
comando o a otro programa que se concatene en le ejecución desde la línea de
coamando, ejemplo : open (ARCH, '/etc/passwd') || die "$!\n";
while (<ARCH>) {
print STDOUT;
}
la instrucción 'print STDOUT;' se resume a 'print;' puesto que la
función print imprime por defecto en STDOUT
De este forma la información proveniente del archivo especial ARCH se
imprime por medio de la función print en la
salida estandar STDOUT,
la cual saldrá en pantalla.
Ambiente : el ambiente en el lenguaje perl se manipula por
medio del vector
asociado %ENV, cuyas
claves pertenecen a la varibale de ambiente y su valor al valor de dichas
varibales, por ejemplo :
Si se quiere imprimir el valor de la varibale de ambiente PATH, dentro de
un programa en perl, se emplea la siguiente instrucción :
print "$ENV{'PATH'}\n";
donde '\n' representa un fin de línea
Además de las entradas y salida dentro de un programa y el
ambiente se emplea los argumentos los cuales se almacenan en el vector
posición @ARGV, de
esta forma se puede manipular cualquier argumento que acompan~e en la
ejecución desde la linea de comandos al programa en perl, ejemplo :
Si se quiere imprimir los 2 primeros argumentos incluyendo el nombre del
programa, se realiza de la siguiente forma :
print "Programa : $ARGV[0]\n";
print "Argumento 1 : $ARGV[1]\n";
print "Argumento 2 : $ARGV[2]\n"; # donde '\n' es un fin de línea
si se ejutara 'programa.pl hola mundo', la impresión sería :
Programa : programa.pl
Argumento 1 : hola
Argumento 2 : mundo
Términos y Estructura Lógica
Es necesario conocer algunas reglas y términos que rigen en la creación de
programas en en el lenguaje perl que a continuación se presentan:
print "Hola\n" ; # se Imprime 'Hola' con un fin de linea
^ -> caracter de finalización
&sumar ; # se ejecuta la subrutina 'sumar'
^ -> caracter de finalización
En el anterior ejemplo se muestra dos instrucciones las cuales se
determinan explícitamente con el caracter de finalización ";".
' : la comilla simple se emplea para denotar una cadena de
carcateres, si se quisiera asignarle la cadena 'aaa' a una variable
se hiciera de la siguiente forma : $variable = 'aaa';
" : la comilla doble se emplea para denotar cadenas de caracteres
pero incluyendo caracteres
especiales o términos
reservados dentro de su contexto, ejemplo : $variable = 'aaa';
$variable1 = "$variable xxxxx \n";
$variable2 = '$variable xxxxx \n';
El valor de variable1 sería igual a 'aaa xxxxx ' y además
un fin de linea (\n equivale a un fin de linea)
El valor de varibale2 sería igual a '$variable xxxxx \n'
ya que se empleó comillas sencilas (' ') las cuales
no aceptan el valor de términos ni caracteres especiales.
` : este tipo de comillas se emplea para ejecutar un comando del
sistema operativo, ejemplo :
Si se quisiera ejecutar 'cat archivo' en el sistema operativo y la salida
asignarla a una variable
se haría de la siguiente forma :
$variable
=
`cat archivo`;
Estructura lógica : en el lenguaje perl se emplea los
modos logicos si (if), de lo
contrario condicional (elsif) como determinante (else), mientras (while), a
menos (less), para cada (foreach) ,
continue (continue), estos modos lógicos se muestran a continuación:
Subrutina
: Una forma de ejecutar un estructura en perl, es empleando las subrutinas,
las cuales se conforman por una parte de estructura perl que permite
realizar ciertas funciones
que se pueden emplear en la ejecucuión de el programa principal. Es el caso de
una subrutina
empleada para ingresar un valor por medio del teclado cada vez que sea
necesario, la definición de la anterior subrutina
es la siguiente : sub ingreso { # definición de la subrutina
local ($variable); # declara la variable local $variable
$variable = <tty> # asigna a $valor lo digitado en pantalla
return $variable; # retorna el valor de lo digitado
}
Para ejecutar la subrutina
anterior simplemente se emplea el caracter "& " precedido del
nombre de la subrutina,
para el caso anterior si se quiere asignar el valor retornado por la subrutina
a una variable
en cualquier parte del programa se haría de la siguiente forma :
$variable = &ingreso;
Operadores Lógicos : los operadores lógicos permiten evaluar si
una condición es verdadera o falsa cuando existen 2 o mas eventos, es el caso
de el valor de una variable,
puede ser positivo o negativo, o el caso del dos variables,
ambas pueden ser positivas y así como estos 2 ejemplo de eventos pueden exitir
muchos mas; en perl se puede evaluar o crear una condición utilizando
los operadores lógicos, y de esta forma se puede crear una condición con los
valores verdaderos, falso y los operadores lógicos :
A continuación se presentan los diferentes operadores lógicos empleados en
perl :
- | : este operador es el operador lógico 'o', empleado en las expresiones
regulares para evaluar 2 eventos de comparacion, los cuales generan un
valor lógico verdadero o falso, para que la condición se cumpla por lo menos
alguno de los 2 eventos se debe cumplir, ejemplo :
se debe realizar un grupo de instrucciones si en $variable
existe la cadena de caracteres 'Hola' o la cadena 'Saludo', la forma
siguiente permite evaluar esta esta condición :
if (variable =~ /Hola/|/Saludo/) {#compara 'Hola' o 'Saludo'
.....
}
Ademas de actuar sobre expresiones
regulares este operador se emplea para evaluar eventos que involucren
valores de variables,
ejemplo :
Se quiere evaluar si $variable
equivale a 5 'o' $varibale es menor que 1, el operador "|" actua de
la siguiente forma :
if ($variable == 5 | $variable < 1) { ....
|| : Al
igual que el operador anterior trabaja como un operador lógico 'o', pero con
la diferencia de que este operador trabaja sobre instrucciones y no en expresiones
regulares como en el caso anterior, para este operador ejecuta el primer
grupo de instrucciones que se pueda ejecutar o retorne un valor verdadero,
ejemplo :
Normalmente en perl se emplea este operador cuando se quiere abrir un
archivo y desplegar en pantalla el error cuando no se puede ejecutar, el
operador evalua la apertura del archivo, si este se puede abrir continua y
no realiza la otra instrucción, si po algun motivo no se puede abrir el
archivo ejecuta la segunda instruccion que retorna en pantalla el error de
apertura, de esta forma :
open (ARCH,'texto'); # se abre el archivo 'archivo'
die "Error en apertura : $!\n"; # imprime el error de salida
Para evaluar las dos intrucciones con el operador "||" sería
:
open (ARCH,'texto') || die "Error en apertura : $\n";
De esta forma se verifica el error cuando no se puede abrir un archivo
- ^ : este operador permite verificar en expresiones
regulares si dos eventos se cumplen de una manera exclusiva, la
evaluación retorna verdadera si alguno de los dos eventos ocurre, si por el
contrario ambos retornan un valor vardadero o ambos retornan un valor flaso
el operador retornara un valor falso, ejemplo : si se quiere encontrar en un
variable
2 cadena de caracteres mutuamente exclusivas, alguna de ellas debe estar
presente pero no las dos al mismo tiempo, esta condición se puede evaluar de
la siguiente forma :
if ($variable =~ /cadena1/^/cadena2/) { ...
El operador "^" tambien se lo emplea para evaluar valores de
varibles.
- & : este operador trabaja como un operador lógico 'y' en expresiones
regulares, permite confrontar 2 eventos los cuales deben retornar
valores verdaderos para que este operador retorne un valor verdadero, o
tambien permite evaluar eventos que involucren valores de variables,
ejemplo:
se quiere ejecutar un grupo de instrucciones si exite en $variable
la cadena de caracteres 'XXX' y el valor de $variable2 equivale a 5; la
anterior condición se la evalua de la siguiente forma :
if ($variable =~ /XXX/ & $variable2 == 5) { ..
- && : Al igual que el operador anterior trabaja como un
operador lógico 'y', pero con la diferencia de que este operador se emplea
sobre instrucciones y no en expresiones
regulares como en el caso anterior, para este operador todas las
instrucciones deben ejecutarse o de lo contrario ninguna se ejecutar`a,
ejemplo :
Se quiere incrementar el valor de $variable
si sólo se puede abrir el archivo 'TEXTO', en este caso las intrucciones se
ejecutan de la siguiente forma :
open (ARCH,'TEXTO') && ++$variable;
Si se involucra mas de 2 instrucciones, se ejecutarán si y solo si todas
se puedan ejecutar.
- ! : este operador permite realizar una evaluación negativa de
un evento, ejemplo :
Se quiere realizar un grupo de intrucciones si no existe $variable
:
if (! $variable) {
...
}
Operadores de Archivo : estos operadores se emplean para
verificar en el sistema operativo los permisos de un archivo, o su naturaleza,
de ejecución, texto plano, etc. A continuación se muestra los diferentes
operadores :
- -r : indica si el archivo tiene permiso de lectura, ejemplo :
if (-r $variable) { # verificación
print "$variable : de lectura\n";
}
Donde $variable es la variable donde se almacena el nombre del archivo.
De esta forma se emplean todas las opciones que se describen mas adelante
:
- -w : indica si el archivo tiene permiso de escritura
- -x : si el archivo tiene permiso de ejecución
- -T : si el archivo es tipo texto
- -e : si el archivo existe
- -z : si el archivo tiene taman~o cero
- -s : si el archivo no tiene taman~o cero
- -f : si el archivo es plano
- -d : si es un directorio
- -l : si es un enlace simbólico
- -t : si el objeto está abierto en una terminal
- -B : si es binario (opuesto a -T)
- -M : número de días después de la última modificación, ejemplo
:
$variable = -M '/etc/format';
En el anterior caso $a obtiene el valor en dias a partir de la última
modificación del archivo '/etc/format';
- -A : número de días después del último acceso (última lectura)
- -C : número de días después del último cambio
Términos Reservados
En perl los términos reservados son caracteres o conjunto de
caracteres que simbolizan una asignación, una operación o un evento específico,
estos términos se los muestra a continuación :
Términos
de Asignación
Términos
de Operación
Términos
de Comparación
Términos
de Evento
Términos
de Asignación
Los términos descritos a continuación se emplean para dar valores a cualquier
variable
en perl :
= El término
`igual` se emplea para asignarle un valor a la expresión que se encuentre en su
extremo izquierdo con el resultado de la expresión que se encuentre en el
extremo derecho; este operador es muy útil para inicializar valores de varibles
o para la aplicación de cualquier función a una variable,
ejemplo :
$variable = 'hola mundo'; # inicialización de variable
$variable = chop($varibles) # aplicación de una función
=~
Este término se emplea para aplicar una expresión regular a cualquier
expresión que se encuentre en el extremo izquierdo del término, ejemplo : $varible =~ s/HOL/sss/; # reemplaza HOL x sss en $variable
Los siguientes términos
de asignación combinan un término
de operación y el caracter '=', con el fin de
ejecutar dos eventos específicos, la regla que se muestra a continuación
representa la interpretación de estos términos :
$varibale OPCION= valor; # donde opción puede ser
# ( +, ., |, &, %, <<, >> , *, **, -)
Cada opción representa un término
de operación los cuales permiten definir la operación que se realiza
conjunto con la asiganción, esta clase de términos equivale a realizar la
asignación y la operación explícitamente de la siguiente forma :
$variable = $variable OPCION valor;
Como se puede verificar el término
de operación representado por la OPCION actua sobre $variable y
valor y posteriormente el resultado se lo asigna a $variable,
de esta forma se explica el funcionamientos de los términos
de asignación compuestos de la forma mensionada anteriormente.
A continuación se presenta los diferentes términos de esta naturaleza :
- += :
asignación y adición; este término se emplea para adicionarle cierto valor a
una variable,
ejemplo :
$variable = 5;
$variable += 6; # el resultado se $variable es 11
- -= :
asiganción y sustracción; funciona de igual forma que el término anterior,
pero en este caso restando, ejemplo :
$variable = 10;
$variable -= 6; # el resultado de $variable es 4
- .
= :
asignación y concatenación; este término se emplea para adicionarle a un
valor una cadena de caracteres, ejemplo : $variable = 'Hola ';
$variable .= 'Mundo'; # el resultado de $varibale es 'Hola Mundo'
- **=:
asiganción y exponenciación; eleva la expresión del extremo izquierdo a la
potencia del extremo derecho, asignandole el resultado a la expresión del
extremo izquierdo, ejemplo :
$variable = 5;
$variable **= 2; # el resultado de $variable es 25
- *= :
asignación y multiplicación; funciona de igual manera que el término
anterior pero multiplicando los valores de los extremos, ejemplo :
$variable = 5;
$varibale *= 2; # el resultado de $variable es 10
- /= :
asiganción y división; de igual forma que el término anterior pero
dividiendo los dos extremos, ejemplo :
$variable = 10;
$variable /= 2; # el resultado de $variable es 5
- %= :
asiganción y modulo; este término se emplea para determinar el módulo de la
dicisión entre las expresiones de los dos extremos, ejemplo :
$variable = 5;
$variable %= 2; # el resultado de $variable es 1
- <<= :
asignación y crecimiento binario; este término permite generar una
progresión geométrica binaria a partir del valor de la expresión del extremo
izquierdo, ejemplo :
5, 10, 20, 40, 80 # progesión geométrica binaria a partir de 5
3, 6, 12, 24, 48 # progesión geométrica binaria a partir de 3
$variable = 5;
$variable <<=3; # retorna el tercer termino de la
# progresión geometrica binaria
# a partir de 5, en este caso 20
- >>= :
asignación y decrecimiento binario; este término funciona de igual forma que
el anterior pero generando una progresión del resultado de la división entre
la expresión del extremo izquierdo por 2, un número de veces especificado
por el valor del extremo derecho, ejemplo :
100, 50, 25, 12, 6 # progresión geometrica binaria decreciente
$variable = 70
$variable >>= 3 # retornará el tercer término
# de la progresión progresión
# geométrica binaria, en este caso 17
- |= :
asignación y comparación binaria; este término se emplea para realizar una
comparación logica 'o' entre los valores binarios de dos números, los cuales
estan representados por los valores de los dos extremos del término, ejemplo
:
2 valor binario es 1 0
3 valor binario es 1 1
La comparación lógica 'o' entre binarios sigue la regla :
1 o 1 = 1
1 o 0 = 1
0 o 1 = 1
0 o 0 = 0
En el caso anterior la comparación lógica 'o' entre
2 y 3 da como resultado :
1 0
1 1
=======
1 1 -> cuyo valor en decimal es 3
En, perl :
$variable = 2;
$variable |= 3; # el resultado de $variable es 3
- &= : igual
que en el caso anterior pero con la comparación logica 'y', ejemplo :
La comparción lógica 'y' entre binarios sigue la siguiente regla :
1 y 1 = 1
1 y 0 = 0
0 y 1 = 0
0 y 0 = 0
En el caso de comparar 2 y 3 el resultado sería
1 0
1 1
=======
1 0 -> cuyo valor en decimal es 2
En perl :
$variable = 2;
$variable &=3 # el resultado de $variable es 2
Términos
de Operación Estos términos permiten desarrollar operaciones a las
expresiones o variables
presentes en cualquier instrucción de perl :
Las operaciones matemáticas fundamentales adición, sustracción,
multiplicación y división se pueden aplicar en perl con los simbolos
+ , - , * y / respectivamente.
A continuación se presentan cada uno de los términos
de operación empleados en perl :
**
Este término se emplea para obtener la potencia de un valor numérico,
ejemplo : $variable = 5;
$variable**2; # eleva $variable al cuadrado
# el resultado será 25
.
Este término se emplea para concatenar dos cadenas de caracteres, ejemplo:
$variable = 'Hola'; # asigna a $variable 'Hola'
$variable.' Mundo'; # concatena a $varibale ' Mundo'
# el resultado sera 'Hola Mundo'
x
Este término multiplica n veces la cadena de caracteres especificada.
ejemplo : '-' x 80; # equivale a una cadena de 80 caracteres '-'
%
Permite obtener el modulo de la división entre dos números, ejemplo : $variable = 5 % 2; # el resultado de $variable es 1
|
Este término cuando se lo emplea entre 2 valores numéricos, permite
realizar una compración
'o' binaria entre ellos, ejemplo : $variable = 3 | 2 # el resultado de $variable es 3
&
Este término cuando se lo emplea entre 2 valores numéricos, permite
realizar una compración
'y' binaria entre ellos, ejemplo : $variable = 3 & 2 # el resultado de $variable es 2
Términos
de Comparación Los términos de compración permiten confrontar dos
expresiones y generar un resultado ya sea lógico o numérico, estos términos se
describen a continuación :
==
Término empleado para comparar dos valores num`ericos iguales, el
resultado de la compración es un valor lógico, verdadero o falso, ejemplo : if ($variable == 1) { # evalua si $variable es 1
......
}
eq
Se emplea para comparar dos cantidades iguales no numéricas, ejemplo : if ($variable eq 'ww') { # evalua si $variable es 'ww'
......
}
!=
Este operador se emplea para comparar dos cantidades numéricas diferentes,
ejemplo : if ($variable != 1) { # evalua si $varibale es diferente de 1
.....
}
ne
Se utiliza para comparar dos cantidades no numéricas diferentes, ejemplo :
if ($variable ne 'ww') { # evalua si $variable es diferente a 'ww'
......
}
<
Este término se emplea para verificar el taman~o de una cantidad numérica
con respecto al valor del extremo derecho, funciona como el operador
matemático menor que, ejemplo : if ($variable < 1) { # verifica si $variable es menor que 1
......
}
>
Este término se emplea para verificar el taman~o de una cantidad numérica
con respecto al valor del extremo derecho, funciona como el operador
matemático mayor que, ejemplo : if ($variable > 1) { # verifica si $variable es mayor que 1
......
}
Para los términos menor o igual y mayor o igual se emplean los términos :
<=
y >l respectivamente.
lt
Este término se emplea para comparar según el orden dos cadenas de
caracteres no numéricas, verifica si la cadena del extremo izquierdo es menor
en orden que la cadena del extremo derecho, ejemplo : 'a' lt 'b' # verdadero
'aa' lt 'b' # verdadero
'ba' lt 'b' # falso
gt
Este término se emplea para comparar según el orden dos cadenas de
caracteres no numéricas, verifica si la cadena del extremo izquierdo es meyor
en orden que la cadena del extremo derecho, ejemplo : 'b' ge 'a' # verdadero
'b' ge 'aa' # verdadero
'b' ge 'ba' # falso
Para los términos menor o igual y mayor o igual en cantidades no numéricas
se emplean los términos : le y ge respectivamente.
cmp
Término empleado para comparar caracteres, retorna -1, 0, 1 ; en el caso
de que los caracteres comparados sean iguales, retorna 0, en el caso de que el
primer patrón de la comparación se encuentre al comienzo del otro patrón
retorna 1, de lo contrario retorna -1. ejemplo: 'hola' cmp 'hola' # retorna 0
'holas chicas' cmp 'hola' # retorna 1
'hey hola' cmp 'hola' # retorna -1
'hey hola chicas' cmp 'hola' # retorna -1
'algo diferente' cmp 'hola' # retorna -1
<=>
operador para comparar valores numéricos, retorna -1, 0, 1; en esta
comparación si el número comparado es igual al patrón de comparación retorna
0, si el número del patrón comparado es mayor que el número del patrón a
comparar retorna 1, de lo contario -1. ejemplo: 12 <=> 12 # retorna 0
12 <=> 13 # retorna 1
12 <=> 11 # retorna -1
=~
Este térmico se emplea tanto para asignar (ver Términos
de Asignación)) como para comparar la existencia de patrones de compración
(ver Expresiones Regulares), en este caso se mostrará la utilización de este
término como una comparación, ejemplo : if ($varible =~ /HOl/) { # verifica si $varible contiene 'HOl'
.....
}
!~
Este término se emplea para negar la existencia de un valor, utilizando
expresiones regulares, como se muestra a continuación : if ($variable !~ /HOl/) { # verifica si $varibale no contiene 'HOl'
.....
}
..
Este término actua sobre rangos. ejemplo : if (100..103) { # verifica si esta entre 100 y 103
....
}
Términos
de Evento Cada uno de estos términos
de evento tienen un significado muy espcial en perl, ya que
representan las convenciones propias del lenguaje que permiten manipular la
información procesada en cualquier programa. Para lograr entender estos términos
de eventos es necesario conocer donde se emplean; algunos de estos
términos son muy útiles en la manipulación de archivos, cuando se habla de
manipular un archivo se refiere a manejar información que se tiene en ellos,
modificarla o transformarla con la aplicación de instrucciones propias de
perl. Para realizar esta manipulación es necesario abrir los archivos
como se muestra en la función open(), una
vez que se abre el archivo y se asigna a una variable,
se puede dar inicio a la manipulación, para el ejemplo se abrirá el archivo
'prueba' y se asignará al manejador 'ARCH' de esta forma : open(ARCH,'prueba');
Posteriormente se manipulará la información del archivo en un ciclo "while"
denotado de la siguiente forma :
while (<ARCH>) {
.... # grupo de instrucciones
}
este ciclo analizará toda la información del archivo hasta llegar al final
del archivo 'prueba' (<ARCH>).
Una vez abierto el archivo e ingresado en un ciclo para su manipulación se
tiene listo el ambiente para explicar algunos términos
de eventos :
$/
El separador del registro de entrada, por defecto es 'nueva linea', cuando
se lee un archivo se puede especificar con este término cómo deberán ser los
registros de entrada; si se quiere procesar cada palabra del registro este
deberá debe tener el valor de un espacio en blanco, si se quiere procesar el
archivo totalmente este término debe llevar el valor de fin de archivo. Este
es una ejemplo de como emplear este término :
Si se tiene el archivo 'prueba' como :
linea1 : palabra11 palabra12 * palabra13
linea2 : palabra21 * palabra22 palabra23
Si no se define el valor de "$/", el
valor por defecto que tendria este término es fin de linea "\n" (ver caracteres
especiales, lo que significa que cada registro del archivo estará
delimitado por un fin del linea, en otras palabras cada linea del archivo
representa un registro de entrada; los registros serían :
registro1 : "palabra11 palabra12 * palabra13"
registro2 : "palabra21 * palabra22 palabra23"
Ahora bien si antes de iniciar el ciclo de manupilación del archivo (while ..) se
definiera el valor de "$/" con el
caracter '*' ( $/ = '*'; )
cada registro de entrada estará delimitado por los caracteres '*' presentes en
el archivo, para el caso del archivo prueba los registros de entrada serían :
registro1 : "palabra11 palabra12 *"
registro2 : " palabra13
palabra21 *"
registro3 : " palabra22 palabra23"
Por último si se definiera el valor de "$/" con el
caracter espacio en blanco ($/ = ' ';), los
registros de entrada serían :
registro1 : "palabra11 "
registro2 : "palabra12 "
registro3 : "* "
registro4 : "palabra13
palabra21 "
registro5 : "* "
registro6 : "palabra22 "
registro7 : "palabra23"
$_
Este término representa el valor del registro actual en una manipulación
de un archivo, en el caso anterior, sería el valor de cada registro en el
ciclo (while ..),
ejemplo :
Si se quiere imprimir el archivo prueba una vez abierto el programa sería :
open (ARCH,'prueba');
while(<ARCH>) {
print $_; # imprime el valor de cada registro
} # de entrada
$.
Representa el número actual de registro de entrada que se está procesando,
si en el ejemplo anterior se imprimiera también este término, se obtendria una
seria de números enteros desde 1 hasta el número total de registros de
entrada.
$\
El separador del registro de salida, determina el caracter que acompan~ará
al registro de entrada cuando se emplea la función print, si en
el caso anterior para $/ = '*' y
$\ =
'@' los registros que se imprimen de la siguiente forma : registro1 : "palabra11 palabra12 *@"
registro2 : " palabra13
palabra21 *@"
registro3 : " palabra22 palabra23@"
$$
Número del proceso para el programa cuando se ejecuta.
$0
Nombre del archivo en donde se encuentra el programa.
$!
Descripción del error al ejecutar cualquier orden de un programa (al
ejecutar una función), es muy común emplearse con la función die para
retornar el error cuando no se puede abrir un archivo, ejemplo : open(ARCH,'archvio') || die "$!\n";
$,
Separador de campo, este término se emplea con la función print para
asignar la cadena de caracteres que permiten separar la impresión de una lista
de valores, ejemplo : $, = '@';
print ('hola','mundo); # imprime 'hola@mundo'
$"
Separador de campo para vectores,
este término funcione de igual forma que el término anterior pero en la
impresión de vectores ,
como se muestra en el siguiente ejemplo : $" = '*';
@vector = ('hola','mundo);
print "@vector"; # imprime 'hola*mundo'
.
$%
Representa el número de página actual seleccionada, para elaborar reportes de
impresión.
$=
representa la longitud de página (lineas a imprimir), por defecto es 60,
este término junto con el anterior definen la paginación de un reporte en
perl.
$-
Número de líneas reales a imprimir, este término define el taman~o de
p`agina en líneas que se va a emplear para la impresión.
$~
Nombre actual del reporte.
$^
Nombre actual del encabezado del reporte.
$|
Este término cuando su valor es diferente de cero (0), obliga a imprimir
el reporte o
salida seleccionada con la función select() .
Los siguientes términos actuan sobre las expresiones regulares para
determinar los patrones de compración :
$&
Representa el valor de la ultima cadena de caracteres comparadas
exitosamente, mirar el ejemplo de los 2 siguientes términos.
$` y $'
Estos dos términos se utilizan conjuntamente para separar cadenas de
caracteres comparadas exitosamente. ejemplo : $variable = 'holaAWASque tal';
$variable =~ /AWAS/; # severifica AWAS en $variable
print "$`:$&:$'"; # imprime hola:AWAS:que tal
Donde $& representa el patrón de comparación , $` y $'
representan las cadenas que acompan~an en sus extremos al patrón de
comparación.
Variables
Las Variables
en perl son espacios reservados para almacenar información de cualquier
tipo, en dichos espacios se puede asignar, limpiar o incrementar información,
a diferencia de un valor constante ya sea una letra, un número, o cualquier
carcacter o cadena de caracteres las variables
son valores que estan cambiando durante la ejecución de un programa en perl
. En perl no se hace una declaración explícita de las variables,
las variables
se definen automáticamente cada vez que se emplean en cualquier parte del
programa. A diferencia del lenguaje "C", en perl cada vez que
se quiere emplear una varible solo basta escribir la instrucción donde se
emplea y la variable
queda definida con el tipo de valor que se le asigne en la instrucción,
ejemplo :
Si se quisiera emplear un variable
denominada 'valor' que se inicialice con el valor de 1, solo basta escribir la
siguiente instrucción :
$valor = 1;
Si se define una variable
con un valor numérico y posteriormente se emplea en un en un contexto de tipo
carcater, no existe ningún error puesto que perl asume la variable
de tipo carcater; En el caso donde se defina la variable
de tipo carcater y posteriormente se emplee en un contexto numérico, perl
valida si todos los elementos de la variable
son numéricos de lo contario emplea el valor de la variable
como cero (0), ejemplo :
$variable = 'a';
$variable2 = $variable+1; # el resultado es 1;
$variable3 = $variable*2; # el resultado es 0;
print $variable # imprime 'a';
En el anterior caso se emplea el valor de cero (0) para $variable
en la suma y la multiplicación puesto que inicialmente posee un valor no
numérico; el valor de $variable
se sigue conservando.
En perl existen tres clases de variables
que son :
Expresiones Regulares
Las expresiones regulares en perl permiten evaluar o comparar la
existencia de un patrón de comparación en una cadena o un valor determinado;
si se tiene un archivo de muchas lineas y se quiere imprimir las lineas que al
comienzo tengan el caracter "*", o se quiere reemplazar todas las
palabras SERVIDOR por el valor de una
variable,
se debe emplear las expresiones regulares. Exiten 3 clases de expresiones
regulares que se describen a continuación :
Funciones
Las funciones
son instrucciones especiales que permiten procesar información a partir de
unos parámetros iniciales y dan como resultado una información específica.
Normalmente las funciones
actuan sobre un grupo de parámetros, los cuales se encierrean en paréntesis y
se los separa por comas ","; cuando se escribe una función sin parámetro
generalmente actua sobre el valor actual del registro de entrada denotado por
el término $_; si una
función actua por defecto sobre $_ basta
escribir el nombre de la función y automáticamente se actualiza $_ con el
valor retornado así :
$_ = 'ab';
chop; # quita el último caracter de $_
# el nuevo valor de $_ será 'a'
Estos serán los términos empleados para describir las funciones
:
# : un número, no se emplea una variable
valor : un número cualquiera o una variable con valor numérico
dir : el nombre de un directorio
lista : una lista de valores o variable también puede ser un vector
tal como $a,'ab,$b o @vector; cada valor separado por coma ",".
archivo : una cadena de caracteres que describen el nombre especial de un
archivo abierto por la función open
$variable : una variable, no es un valor constante
expresión : hace referencia a cualquier tipo de validación, en la descripción
de cada función se especifica la expresión.
@vector : el nombre de un vector
%vector : el nombre de un vector asociado
.... : un grupo de instrucciones
abs valor
atan2 (valor1, valor2)
chdir (dir)
chmod #, lista
chop lista
chown valor1, valor2, lista
chr valor
close (archivo)
closedir (dir)
cos val
defined (expresión)
delete $vector{clave}
die lista
each %vector
eof (archivo)
exec lista
exists (expresión)
exit (expresión)
exp valor
getc archivo
getpgrp PID
getlogin
getppid
gmtime
grep (expresión, lista)
hex valor
index (valor, cadena , posición)
int valor
join (valor, lista)
keys %vector
kill #, lista
last palabra
lc valor
lcfirst valor
length valor
link valor1, valor2
local (lista)
localtime
log valor
mkdir (dir, #)
next palabra
ord valor
pop @vector
open (archivo, valor)
opendir (archivo, dir)
print lista
printf (archivo, formato, lista
push (@vector, lista)
rand valor
redo (valor)
rename (nombre1, nombre2)
reset expresión
return lista
reverse lista
rindex (valor, cadena, posición)
rmdir dir
scalar vector
select (archivo)
shift @vector
sin valor
sleep valor
sort subrutina expresión
splice (@vector, elemento, numero_elemento)
split (/patrón/, expresión, número)
sprintf (formato, lista)
sqrt valor
substr (valor, longitud, posición)
system lista
uc valor
ucfirst valor
unlink lista
undef valor
unshift (@vector, lista)
values %vector
write archivo
A continuación de presentan la descripción de cada una de las funciones
:
abs valor
Retorna el valor absoluto de valor.
atan2
valor1/valor2
esta función permite retornar el valor de la arcotangente de (valor1/
valor2) en el rango de -PI a PI.
chdir
(dir)
cambia del directorio actual de trabajo al directorio especificado por
dir.
chmod #,
(lista)
cambia los permisos a la lista de los archivos, en esta función se emplea
numeros que son utilizados por el comando chmod
del sistema operativo, si se quisiera otorgarle los permisos de ejecución a
'archivo' sería : chmod 0755 archivo;
chop
(lista)
chop $variable
quita el ultimo carcater de una variable y
retorna el carcter suprimido. Si se utiliza lista actúa sobre todos los
elementos de la lista. Actúa por defecto sobre $_.
chown valor1,
valor2 lista
Cambia de propietario a una lista de archivos o directorios, donde valor1
es el número de usuario y valor2 es el número de grupo.
chr valor
restorna el carcater representado por valor en codigo ASCII.
close
(archivo)
Cierra las entradas o archivos especiles (archivo) abiertos por la función
open.
closedir
(dir)
Cierra el directorio (dir) abierto por la función opendir
cos
(valor)
retorna el coseno de x expresado en radianes.
defined
(expresión)
retorna un valor booleano; se emplea para determinar si una variable
se encuentra definida explícitamente, que en algún lugar del programa se
defina con un valor ya se nulo o no nulo, también se valida esta función en
una instrucción como en el siguiente caso : print "funciona\n" if defined ($variable = pop(@vector));
En el anterior ejemplo la función definied se emplea sobre una
asiganción de una variable,
si existe @vector y por
lo menos un elemento en él, la funcíon pop retornará
un valor el cual se le asignará a $variable,
la función definied retornará un valor verdadero (ya que se $variable
adquiere un valor) y se imprimirá "funciona" con un final de linea.
delete $vector{'clave'}
borra el elemento especificado del vector
asociado.
die lista
imprime el valor de lista para la salida estandar de errores, esta función
se utiliza para imprimir los errores que se presentan en la ejecución de una
expresión, ejemplo : open(archivo, valor) || die "no puede abrir archivo: $!\n"
each %vector
esta función retorna 2 valores consistentes de un vector
asociado, como en el siguiente ejemplo : while (($clave, $valor) = each %ENV) {
print "$clave = $valor\n";
}
En el anterior ejemplo se emplea un ciclo (while) el
cual permite evaluar todos los valores del ambiente (ENV) por medio
de la función each, la cual
retorna cada ciclo 2 valores cada uno de estos se asigna a $clave y $valor
respectivamente y posteriormente se imprime estos dos valores retornados hasta
finalizar el ciclo (finaliza el ciclo cuando se ha asignado todos los valores
del ambiente).
eof
(archivo)
indica la finalización de la lectura del archivo.
exec
lista
ejecuta una lista de comandos del sistema operativo y sale inmediatamente
del programa que se esta ejecutando, si se quiere retornar una vez ejecutado
el comando del systema operativo de debe emplear la función system,
ejemplo : exec 'ls -l'; # ejecuta 'ls -l' y sale automáticamente
exists
(expresión)
esta función permite conocer si una variable
existe. a diferencia de la función defined se
emplea en vectores
asociados para determinar si por lo menos existe el campo llave en el vector, si
se empleara la función defined,
además de existir el campo llave debe tener un valor ya sea nulo o no nulo :
Cuando se evalua un variable
if $variable,
retorna un valor verdadero si la variable
tiene un valor diferente de nulo, por lo tanto se puede concluir : toda variable
que retorne un valor verdadero esta definida, y toda variable
que se encuentre definida existe, pero no toda variable
que exista se encuentra definida y no toda variable
definida retorna un valor verdadero.
exit
(expresión)
evalua la expresión y sale inmediatamente de la ejecución del programa, la
expresión pude ser cualquier función o una asignación o una ejecución.
exp valor
retorna el número (e) elevado a la potencia representada por valor,
ejemplo : $variable = exp 1;
Retornará el valor de 2.71828182845905, actua por defecto sobre $_ .
getc
archivo
esta función retorna el valor del siguiente caracter que ingresará en el
registro de entrada, por ejemplo :
Se quiere leer el archivo 'texto.txt' y manejarlo en un ciclo linea por
linea e imprimir si el primer caracter de la siguiente linea es 'S'
open(ARCH,'texto.txt') || die "$!\n";
while (<ARCH>) {
$variable = getc ARCH;
print if $variable eq 'S'
}
getpgrp
PID
retorna el número del grupo de procesos actuales, si se emplea con la
opción cero (0) retorna el número del proceso actual.
getlogin
retorna el login actual en que se esta trabajando.
getppid
retorna el número del proceso padre, si se estuviera ejecutando un
programa en perl desde la linea de comandos, el proceso padre sería el
proceso del shell.
gmtime
permite obtener el formato tiempo con respecto al meridiano cero (0) en 8
elementos de la siguiente forma (para obterner el formato de tiempo local se
emplea la función localtime):
($sec,$min,$hora,$mdia,$mes,$an~o,$sdia,$adia) = gmtime;
donde :
$sec = segundos (0-59)
$min = minutos (0-59)
$hora = hora (0-23)
$mdia = día del mes (1-31)
$mes = mes (1-12)
$an~o = an~o (dos digitos)
$sdia = día de la semana (0-6)
$adia = día del an~o (0-365)
grep
(expresión, lista)
evalua expresión en la lista de valores y retorna los valores que fueron
evaluados positivamente. ejemplo : @vector1 = grep (/^#/, @vector);
en este caso evalua en todos los elementos de vector, si
existen elementos que inicien con el caracter '#' se almacenan en el vector
vector1.
hex valor
retorna el valor decimal de valor que se interpreta como un valor
hexadecimal.
index (valor,
cadena , posición)
index (valor,
cadena)
retorna el valor de la posición de la primera ocurrencia de 'cadena' en
'valor', a partir de la posición especificada por 'posición' (si se quiere el
valor de la última ocurrencia se utiliza la función rindex ), si
no se especifica 'posición' empieza desde la posición cero (0) que representa
la primera posición en un cadena de caracteres; si 'cadena' no se encuentra en
'valor' el valor retornado es -1. Ejemplo : $variable1 = index ($variable, 'h', 3);
Para los siguientes valores de $variable
los valores de $variable
serían :
'xxhxx' resultado -1
'xxxh' resultado 3
'xxxx' resultado -1
En el primer caso se encuentra 'h' en la cadena pero no apartir de la
posición tres (3), se encuentra en la posición 2 (se empieza a contar a partir
de cero (0)), en el segundo caso se encuentra en la posición 3 y en el último
caso no se encuentra.
int valor
retorna la parte entera de valor, ejemplo : $variable = int 3.1416; # el valor de $variable será 3
join (valor,
lista)
retorna los elementos de lista separados por la cadena valor, ejemplo : $variable = 'mundo';
$variable1 = join (' : ', 'hola',$variable);
El valor de $variable1 será "hola : mundo".
keys %vector
retorna las llaves del vector
asociado vector, en
orden descendente de taman~o, ejemplo : $vector{'hola'} = 'saludo';
$vector{'mundo} = 'saludo';
$variable = join (' : ', keys %vector);
El valor de $variable
será "mundo : hola".
kill #,
lista
esta función permite enviar una sen~al para concluir un proceso, el número
'#' indica la severidad del la conclusión desde 1 hasta 9 donde 1 indica
reiniciar el proceso y el 9 indica la terminación definitiva del proceso,
ejemplo : kill 9, 1578, 678 # termina los procesos 1578 y 678
last
palabra
esta función indica la salida para un ciclo determinado por palabra, si no
se especifica palabra ocurrirá la salida del ciclo actual, ejemplo: linea: while (<STDIN>) {
last linea if /^$/;
print;
}
En este ejemplo si se presenta un línea vacía entonces se sale
inmediatamente del ciclo especificado por la palabra 'linea', mas no del
programa.
lc valor
retorna una cadena de caracteres especificada por valor en letras
minúsculas, ejemplo : lc 'HHHxxxOOO' # retorna 'hhhxxxooo'
lcfirst
valor
esta función retorna el primer la cadena de caracteres valor con el primer
caracter en minúsculas, ejemplo : $variable = 'HOLA COMO';
$variable = lcfirst $variable;
El valor de $variable
será 'hOLA COMO'.
length
valor
retorna la longitud en caracteres de valor.
link valor1,
valor2
crea un copia del archivo valor1 y la denomina valor2.
local
(lista)
declara las variables
especificadas en lista como variables
locales,
esta función se emplea para trabajar localmente en subrutinas.
localtime
permite obtener el formato de tiempo local en 8
elementos de la siguiente forma (para obterner el formato de tiempo con
respecto al mediriano cero (0) se emplea la función gmtime): ($sec,$min,$hora,$mdia,$mes,$an~o,$sdia,$adia) = localtime;
donde :
$sec = segundos (0-59)
$min = minutos (0-59)
$hora = hora (0-23)
$mdia = día del mes (1-31)
$mes = mes (1-12)
$an~o = an~o (dos digitos)
$sdia = día de la semana (0-6)
$adia = día del an~o (0-365)
log valor
retorna el logaritmo (en base {e}) de valor, ejemplo : $variable = log 2.71828182845905; # el valor de $variable será 1
mkdir (dir,
#)
crea el directorio dir con los permisos especificados con el número #,
ejemplo : mkdir (dir, 0755); # crea el directorio dir, con permiso de escritura
# para el usuario y de lectura para el grupo y otros
next
palabra
ignora la actual iteración en un ciclo y continua con la siguiente
iteración del ciclo especificado por palabra, si no se define palabra la
siguiente iteración se realiza en el ciclo actual, ejemplo : linea :while (<STDIN>) {
next linea if /^ /;
print;
}
En el anterior ejemplo no imprime la linea que comience con un espacio en
blanco.
ord valor
retorna el valor ascii del primer caracter de valor, si se omite valor
actua sobre $_ .
pop @vector
borra y retorna el último valor vector.
open (archivo,
valor)
esta una de las funciones
principales de perl puesto que permite la manipualación de archivos,
entradas y salidas por medio de archivos especiales .
Esta función tiene como parámetros, una cadena que identifica el nombre del
archivo especial, este nombre permitirá identificar en el resto del programa
la información proveniente del segundo parámetro el cual puede ser un archivo,
un comando de entrada, una salida o un comando de salida. a continuación se
presenta la descripción del segundo parámetro de la función open :
- Un Archivo de Entrada : cuando el segundo parámetro contiene el
valor de un archivo, inmediatamente el archivo se abre en modo de lectura
para suministrar toda la información que contiene y sea manipulada en un
ciclo como un archivo especial con el nombre del primer parámetro de la
función
open, la
información se manipula por medio del registro de entrada ($_ ) en forma
de paquetes de información cuyo taman~o y logitud se define con el separador
del archivo de entrada ($/), cada
ciclo representa un nuevo valor de registro, una nueva actualización del
término $_,
como se muestra a continuación : open (ARCH, '/ect/passwd') || die "$!;
while (<ARCH>) {
print;
}
En el anterior ejemplo se abre el archivo '/etc/passwd' y se lo asigna al
archivo especial ARCH, el cual por medio del ciclo while
suministra la información para que esta se imprima por medio de la función
print.
La función print actua
por defecto sobre $_, por lo
tanto print;
equivale a print $_; de esta
forma se explica como ingresa la información al archivo especial ARCH por
medio de registros los cuales se asignan al término $_ en cada
ciclo.
- Un Comando de Entrada : cuando el segundo parámetro equivale a
un comando de entrada en el sistema operativo, entendiendose como comando de
entrada aquel comando que genera un salida de información sin error
alguno, como por ejemplo el comando 'finger', el comando 'who', o una serie
de comandos 'finger | grep
usuario', los cuales generan una salida; se trata la información de la misma
forma como se manipula un archivo de entrada descrito anteriormente, en
principio la información proveniente de un comando equivale a la información
proveniente de un archivo, ejemplo :
open (ARCH,'finger|') || die "$!\n";
while (<ARCH>) {
print;
}
Para identificar un comando de entrada, el segundo parámetro de la
función open termina con el caracter '|' como se muestra en el ejemplo.
En el anterior ejemplo se imprime la información de la misma forma como
se imprimió en el caso anterior.
Ademas de un comando de entrada se puede manejar la entrada del teclado
con la función open; de
esta forma cada vez que se quiera emplear un ingreso por pantalla se hará
referencia al archivo especial que se le asigne en la función open de la
siguiente forma :
open (TTY,'/dev/tty') || die "$!\n";
print 'Ingrese un valor :';
$variable = <TTY>;
En el anterior ejemplo se emplea en el sistema operativo el archivo
especial '/dev/tty' el cual representa el manejo de la terminal en que se
corre el programa, de esta forma se le asigna a este manejo el nombre de
'TTY' y se lo trata como un archivo especial en el resto del programa,
haciendo referencia como <TTY> cada vez que se necesita ingresar
información por pantalla.
- Un Archivo de Salida : cuando se quiere almacenar cualquier
salida de un programa en un archivo específico se emplea un archivo de
salida. La función open permite
crear el archico y relacionarlo con un archivo especial cuyo nombre se
especifica en el primer parámetro de la función; la información cada vez que
se imprime con la función print
especificando el archivo especial se dirige y se almacena al archivo creado.
Cuando se abre un archivo de salida existen dos posibilidades de abrirlo, la
primera es crear un nuevo archvio de salida y la segunda es verificando si
el archivo existe, si existe le adiciona toda la salida, si no existe
simplemente lo crea, ejemplo :
open (ARCH,'/etc/passwd') || die "$!\n";
open (SALE,'>archivo_nuevo') || die "$!\n";
open (ACT,'>>archivo_existente') || die "$!\n";
while (<ARCH>) {
print SALE;
s/^ *//;
print ACT;
}
En el anterior ejemplo se muestra claramente la aplicación de las dos
formas de abrir un archvivo de salida, para el caso de SALE se emplea el
símbolo > que repesenta la primera forma de apertura, crear un
nuevo archivo de salida, para ACT se empleó el símbolo >> que
representa la segunda forma de abrir un archivo, verifica si ya está creado
y le adiciona la información de lo contrario lo crea, en seguida se empleó
un ciclo para manipular ARCH que repesenta un archivo
de entrada , imprimiendo cada resgistro de entrada ($_) en SALE
que representa al archivo 'archivo_nuevo', e imprimiendo en ACT que
repesenta el archivo 'archivo_existente', el registro de entrada sin espacios
en blanco al comienzo.
- Un Comando de Salida : cuando se desea mandar la información a
una salida en el sistema operativo, para que se procese, se emplea los
comandos de salida, por ejemplo :
open (ARCH,'/etc/passwd') || die $!\n";
open (SALE, '|more') || die "$!\n";
while (<ARCH>) {
print SALE;
}
El comando de salida se identifica en la función open cuando el carcater "
|" se encuentra al comienzo del comando (en el anetrior caso '|more').
En el anterior ejemplo se emplea ARCH, como un archivo
de entrada y además se asigna el comando de salida 'more' a un archivo
especial SALE; lo que siginifica que por cada impresión hecha por la función
print al
archivo especial SALE, se enviará la salida al sistema operativo y se
ejecutará el comando more para desplegarla pantalla por pantalla.
Un comando de entrada debe ser capaz de generar información cada vez que
se ejecute, un comando se salida debe ser capaz de procesar la información
que reciba.
Normalmente la función open se
acompan~a del operador lógico || y la
función die para
obtener el error si por cualquier razón no se puede ejecutar la función.
opendir
(archivo, dir)
permite manejar un directorio en un archivo especial similar a manejar
archivos con la función open, la
información que se maneja por medio del archivo especial especificado por
archivo, se la procesa con la función readdir, de
la siguiente forma : opendir (DIR, '.') || die "$!\n";
@vector = readdir DIR;
El anterior ejemplo se abre el directorio actual en el archivo especial DIR
y se almacena el nombre de los directorios en vector por
medio de la función readdir.
print
(archivo expresión)
imprime expresión en el archivo especial archivo abierto por la función open , si se
omite archivo imprime sobre la salida estandar STDOUT
(generalmente es la pantalla a menos que se defina STDOUT en
alguna parte del programa), si se omite expresión imprime $_, ejemplo : print (SALE $variable, $variable2, 'hola');
# imprime en el archivo especial SALE los valores $variable, $variable2, 'hola'
print $variable, $variable, 'hola';
# imprime en STDOUT los valores de $variable, $variable, 'hola'; si STDOUT
# no se define en alguna parte imprime en la pantalla
print;
# imprime el registro de entrada $_ en STDOUT
print ((1+2)*3, "\n");
# imprime en STDOUT 9 y un fin de linea
print (chop($variable), $variable);
# imprime en STDOUT el último caracter de $variable y $variable
printf
(archivo formato, lista)
esta función imprime lo especificado en lista en el archivo especial
especificado por archivo, en la forma especificada por formato. Cuendo se
refiere a forma indica la manera como se imprimiran los valores, si son
caracteres, decimales etc ademas de especificar su longitud, para mayor
claridad refierase a la función sprintf.
cuando se omite el archivo especial se imprime en la salida estandar ( STDOUT).
push (@vector,
lista)
adiciona los elementos de especificados en lista al final del vector
especificado por vector.
rand
valor
retorna un número randómico
desde 0 hasta valor, si valor se omite el valor va desde 0 hasta 1.
redo
(valor)
reinicializa el las iteraciones de un ciclo. ejemplo: linea : while(<ARCHIVO>) {
....
for (1..5) {
....
print;
redo linea if $variable == 1;
}
}
En este caso se reinicia el ciclo a partir de la instrucción while cuando
el valor de $variable
es 1.
rename
(nombre1 , nombre2)
cambia de nombre un archivo, el archivo nombre1 lo denomina nombre2.
reset
expresión
se emplea para inicializar las variables
expecificadas en expresión, ejemplo :
reset
'a-z'; # inicializa las variables
que tengan letras minusculas.
return
lista
esta función retorna el valor especificado en lista dentro de una subrutina,
ejemplo : sub sumar {
local ($variable);
for (1..5) {
$variable *= 2;
}
return $variable;
}
En el anterior ejemplo l asubrutina sumart retorna el valor de $variable,
cada vez que se ejecuta o se llama la subrutina.
reverse
lista
retorna la lista de valores lista en orden opuesto, si lista es un vector,
retorna los elementos del vector en el
orden opuesto. ejemplo : print (reverse @vector);
# imprime los elementos de vector en orden opuesto.
rindex
(valor, cadena, posición)
retorna el valor de la posición de la última ocurrencia de 'cadena' en
'valor', a partir de la posición especificada por 'posición' (si se quiere
obtener el valor de la primera ocurrencia se emplea la función index), si no
se especifica 'posición' empieza desde la posición cero (0) que representa la
primera posición en un cadena de caracter es; si 'cadena' no se encuentra en
'valor' el valor retornado es -1. Ejemplo : $variable1 = rindex ($variable, 'h', 3);
Para los siguientes valores de $variable
los valores de $variable
serían :
'xxhxx' resultado -1
'xxxxhh' resultado 5
'xxxx' resultado -1
En el primer caso se encuentra 'h' en la cadena pero no apartir de la
posición tres (3), se encuentra en la posición 2 (se empieza a contar a partir
de cero (0)), en el segundo caso la última ocurrencia se encuentra en la
posición 5 y en el último caso no existe ninguna ocurrencia.
rmdir
dir
borra el directorio especificado por dir siempre y cuando se encuentra
vacio.
scalar vector
si vector es un
vector
asociado, retorna VERDADERO o FALSO en caso de que tenga o no tenga
elementos definfidos; de lo contrario si es un vector
posición retorna el número de elementos que posea el vector.
select
(archivo)
permite determinar el archivo especial por defecto para las funciones
print y write, además
de aplicar los términos como lomgitud de página, número de lineas en un reporte.
ejemplo : select (ARCH);
print;
$^ = 'encabezado de ARCH';
En el anterior caso se selecciona el archivo especial ARCH para imprimir
por defecto el registro de entrada $_ por medio de
la función print y
además define el encabezado para el archivo especial ARCH que representa la
parte de un reporte .
shift @vector
borra y retorna el primer elemento del vector
especificado por vector.
sin valor
retorna la función seno de valor expresada en radianes.
sleep
valor
hace una pausa especificada en segundos por valor.
sort subrutina,
expresión
ordena los elementos especificados en expresión de acuerdo a subrutina,
la subrutina
involucra un patrón de comparación ya sea numérico o de tipo carcater, a
continuación se muestra la definición de las subrutinas
y el uso de esta función : @vector = (1, 2, 3, 10, 20);
sub numérico {
$a <=> $b;
}
sub caracter {
$c cmp $d;
}
$variable = sort numérico @vector;
$variable1 = sort caracter @vector;
el resultado de $variable es '1 2 3 10 20'
el resultado de $variable1 es '1 10 2 20 3'
Si se omite el párametro de la subrutina
el ordenamiento lo hace tipo carcater
Para ordenar descendente se emplea
la función reverse,
así :
sort reverse @vector # ordenamiento tipo caracter descendente
splice (@vector,
elemento, #numero_elemetos, valores)
Remueve, remplaza o adiciona elementos a un vector;
ejemplo 1
splice
(@vector,
5, 2, 'hola');
remplaza en vector 2
elementos a partir del elemento 5 ( reemplaza $vector[5] y
$vector[6] )
con el valor de 'hola' ( el elemento $vector[5]
tomará el valor de 'hola' y se borrará el elemento $vector[6]).
Si en lugar de 2 elementos el valor fuera 0 elementos, simplemente se
adicionaría el valor de 'hola' ( $vector[5]
toma el valor de 'hola' adicionadose como nuevo elmento de vector,
$vector[6] tomará el valor de $vector[5]
antes de la insercción, $vector[7]
tomará el valor de $valor[6] antes de la insercción y asi susesivamente.
ejemplo 2
splice
(@vector,
5, 2);
en este caso se borarrían 2 elementos de vector
apartir del elemento 5 (se borrarían $vector[5] y
$vector[6]).
ejemplo 3
splice
(@vector,
5);
en este caso, simplemente se borrarían todos los elementos de vector a
partir del elemento 5.
split
(/patrón/, expresión , número)
esta función toma expresión de tipo caracter y retorna el resultado en un
vector.
Especificamente divide expresión de acuerdo con el patrón de división
(/patrón/); si se especifica número se determina cuantas divisiones se
realizarán, este valor es opcional. Ejemplo : @vector = split (/x/,$_,3);
supongamos que el registro de entrada ($_) tiene el
valor de 'AxBxCxDxFE'.
El vector
'vector' se creará con 3 campos cada uno con los siguientes valores:
A, B, C
Si no se hubiera especificado el valor 3 el vector
'vector' se crearía con los siguientes 5 campos:
A, B, C, D, FE
ejemplo 2
@vector = split
(/x/)
en este caso opera todas las lineas del registro de entrada (este caso se
emplea para registros simples como una variable o
un valor tipo caracter).
Si se omitiera el patrón (/patrón/), la division se realiza de acuerdo a
espaciadores, ya sean espacios en blancos o tabulaciones.
El resultado se lo puede asignar a un grupo de variables
en lugar de un vector.
Si se emplea paréntesis en el patrón de división (/(patrón)/) se crea un
campo para los valores del patron; en el caso del primer ejemplo, se crearían
campos para cada uno de los valores 'x'.
sprintf
(formato, lista)
esta función retorna los valores especificados en lista en la forma
especificado por formato.
El formato de una salida se refiere a la clase de información retornada, su
longitud y en el caso de variables
numéricas su presición. Para identificar el formato se especifica con las
siguientes letras precedidad del caracter "%" :
s : para un valor tipo caracter
c : para un solo caracter
d : para un valor decimal
ld : número decimal tipo long
u : número no signado
lu : número decimal no signado tipo long
x : número hexadecimal
lx : número hexadecimal tipo long
o : número octagonal
lo : número octagonal tipo long
e : exponecial
f : número ajustado, aproximado
g : núemro sin decimales
por ejemplo :
%5.3s imprime de 5 posiciones 3 de ellas una cadena tipo caracter
%5.3d imprime de 5 posiciones 3 de ellas un número decimal
%5.3f imprime con un precisión de 5 enteros y tres decimales un nuero real
%5.3e imprime un número con 1 posición entera expresado en potencias de 10
(ej 1.23e+01, 1.4e-03), con una precisión de 3 decimales en ocupando
5 posiciones
sqrt
valor
retorna el valor de la raiz cuadrada de valor.
substr
(valor, longitud, posición)
retorna desde valor la cadena de caracteres de de taman~o especificado por
longitud iniciando desde el número de caracter especificado por posición (la
posición de los caracteres se inician a partir de cero (0)), ejemplo : $variable = 'hola a todos'
print (substr ($variable,0,4)); # imprime 'hola'
Si se omite posición retorna los caracteres desde el valor especificado por
lonogitud hasta el final de la cadena.
system
lista
esta función se emplea para ejecutar lineas de coamndo en el sistema
operativo, a diferencia de la función exec, permite
continuar en el programa una vez ejecutados los comandos, ejemplo : system ('cat archivo|more');
Ejecuta el comando cat sobre archivo concatenado con el comando more, lo
cual permite revisar el archivo página por página y posteriormente continua
con con la ejecución del programa.
uc valor
retorna en mayúsculas la cadena de caracteres especificada por valor,
ejemplo : uc ('hola mundo'); # retorna 'HOLA MUNDO'
ucfirst
valor
retorna el primer caracter en mayúsculas de la cadena especificada por
valor, ejemplo : ucfirst ('hola mundo'); # retorna 'Hola mundo'
unlink
lista
borra una lista de archivos especificados por lista. Se puede emplear el
metacaracter '*', si se quiere borrar todos los archivos con extención '.back'
se haría de la siguiente forma : unlink <*.back>;
undef
valor
esta función permite quitar la definición de una variable,
un vector
o una subrutina,
de la siguiente forma : undef $variable
undef @vector
undef %vector asociado
undef &subrutina
unshift
(@vector,
lista)
inserta al comienzo de un vector los
campos especificados por lista.
values %vector
retorna los valores del vector
asociado, en el orden ascendente del taman~o de la clave, ejemplo : $vector{'ss'} = 'hola';
$vector{'s'} = 'holas';
print (join(' ', values %vector));
# imprime 'holas hola'
write
archivo
permite escribir en el archivo especial especificado por archivo los
registros formateados por instrucción format en la
definición de un reporte de
un reporte,
ejemplo : select (REP);
write;
En el anterior caso se selecciona el reporte
especificado por el archivo especial REP (definido por la instrucción format),
posteriormente se escribe el reporte con
la función write, cuando
se selecciona un archivo especial la función write actua
por defecto sobre el archivo especial seleccionado como en el anterior caso.
Utilidades
En esta sección se mostrará algunas de las herramientas de las cuales dispone
el lenguaje perl, entre estas herraminetas tenemos :
Referencias de Perl
Página
de Ayuda en HTML del Sistema (en Inglés)
Grupos de Discusión
Pagina sobre Perl en www-cgi.cs.cmu.edu