Make your own free website on Tripod.com
PROGRAMACION

Curso de perl

Home
Descripción del PC
Curso de assembler 1 (sistema DOS)
Curso assembler 2 (manejo de interrupciones del BIOS)
Curso de perl
Manual de Linux
CYGWIN
Contact Us

Perl

Perl es un acronimo de Practical Extraction and Report Language. Este fue diseñado por Larry Wall como una herramienta para escribir programas en ambientes UNIX y es mantenida y actualizada por el autor.

Principalmente sirve para labores de procesamiento de texto, lo cual lo hace en una forma facil y clara, tambien sirve para la programacion de software de sistemas y de redes, y ahora tambien para programar aplicaciones web. No es un lenguaje compilado, aunque tampoco es del todo interpretado, es algo intermedio (un poco complicado, verdad?).

La estructura completa de Perl deriva ampliamente del lenguaje
C. Perl es un lenguaje imperativo, con variables, expresiones, asignaciones, bloques de código delimitados por llaves, estructuras de control y subrutinas.

Perl se simboliza generalmente por un dromedario (camello arábigo).

Plataformas donde se puede ejecutar los script de perl: Linux, Unix, DOS, Windows, etc.

Con Perl se puede programar casi todo (hay librerías -módulos- para casi cualquier cosa que se nos ocurra), pero hay aplicaciones que requieren mucha rapidez en las cuales es mejor utilizar otros programas compilados (la ejecución a través del intérprete introduce retardos).

En primer lugar para ejecutar un programa en PERL podemos hacer dos cosas:
Llamar desde la línea de comandos al interprete PERL, pasando como parámetro el nombre del programa: % perl primer.pl

La extensión .pl no es necesaria, pero se suele poner.

Para ejecutar sin necesidad de invocar el interprete perl se puede añadir a la primera linea del programa:

#! /usr/bin/perl

Luego cambiamos los permisos del fichero fuente, para poderlo ejecutar. Esto se hace con la instrucción chmod (valido solo para sistemas unix/linux):

chmod u+x primer.pl

Luego:

% primerl.pl

Si usan el paquete cygwin (emulador de linux sobre windows) y se bajan todo el paquete de los devels tienen el perl completo. Yo hago esto desde maquinas windows. Para los que no conocen cygwin revisen esto:

http://prog-asm.blogspot.com/2007/01/cygwin.html


Primer programa "Hola Mundo":

#!/usr/local/bin/perl
print "Hola, Mundo!\n";

La primera linea invoca al interpretador de perl,(esto puede cambiar de sistema en sistema), la segunda linea imprime la cadena Hola, Mundo, todas las lineas se deben terminar con " ; ". Hasta ahora es facil.

Programa sencillo de suma de dos numeros:

#!/usr/local/bin/perl
$a=<STDIN>;
$b=<STDIN>;

chop ($a); # el chop le quita el ultimo caracter es decir el enter
chop ($b);
print( $a + $b);


Programa ejemplo de uso de if

#!/usr/local/bin/perl

print ("Ingrese un numero:\n");

$numero = <STDIN>;

chop ($numero); # el chop le quita el ultimo caracter es decir el enter o cambio de linea

if ($numero<10)

       {

          print ("El numero es mayor que 10.\n");

       }

  print ("El numero es mayor que 10, fin de programa.\n");

Hay caracteres especiales (retorno de carro, tabulador, etc) que se representan mediante la barra de escape:

  • \n retorno de carro a una nueva línea
  • \t un tabulador (8 espacios)
  • \a un pitido por el altavoz del PC
  • \\ el caracter \ (para usarlo como parte de la cadena)
  • \" el caracter " (para usarlo como parte de la cadena)

Leer los parámetros de la línea de comandos

Igual que en C++ tenemos dos variables argc y argv para acceder a los parámetros que nos han pasado a través de la línea de comando, en Perl podemos usar dicha información a través de un array especial llamado ARGV

   
                           $argv1 = $ARGV[0];
    $argv2 = $ARGV[1];
   
                           $argc  = $#ARGV;

Cada posición del array contiene un parámetro.

Tipos de datos

En Perl existen dos tipos de datos, numeros y strings, pero entre los numeros estan los enteros y los reales.

Ejemplos:

4,7.5,"hola"

Float : Ej: 1.25,4.25e45,-6.5e24,-1.2E-23

Integer : Ej: 12,15,-2004,3485

0377 # 377 octal <=> 255 decimal

-0xff # ff negativo en hexadecimal <=> -255 decimal

Strings : Ej: "hola",'Como estas'

Para senalar los strings hay dos formas de hacerlo:

Single quoted : Ej:'hola' # h,o,l,a
'don\'t' # d,o,n,',t
'' # string nulo
'donde\\vas' # d,o,n,d,e,\,v,a,s
'hola\n' # h,o,l,a,\,n
'hola
tu' # h,o,l,a,[enter],t,u ( 11 caracteres )

Double quoted Ej:"hola mundo\n"

# hola mundo[enter]


"cola\tsprite"

# cola[tab]sprite

Como vimos en estos ejemplos en los double quoted strings, se reconocen cosas como \n,\t,etc. mientras que con single quoted no, pero tiene la ventaja de poder escribirse literalmente lo que se pone entre ellos.

Operadores

Los aritmeticos basicos:(suma, resta, multiplicacion, division)

+, -, *, /


Los de comparación:
Aritmeticos        String
        ==                  eq
         =                   ne
<                     > gt
<= le >= ge

Concatenación:

"Hola"."mundo" # "Holamundo"
"juan"." "."pedro" # "juan pedro"

Repeticion:

"juan"x3 # "juanjuanjuan"
"pedro"x(4+1) # "pedropedropedropedropedro"


Interpolacion de variables escalares en strings

Si una variable es puesta en un string double quoted (") se interpola el valor de la variable.

#!/usr/local/bin/perl
$a="javier";
$b="hola $a";
print ($b);

Esto imprime hola javier

Y si una variable se pone entre single quoted (') no se interpola el valor de la variable.

#!/usr/local/bin/perl
$x="hola";
$y='$x amigo';
print ($y);

Esto imprime $x amigo

En los strings existen tambien algunos modificadores: \U,\u,\L

Cambia a mayuscula:

#!/usr/local/bin/perl
$b="\Ujuan";
print ($b);

Imprime: JUAN (mayuscula)

Otros ejemplos:

$capjuan="\u$juan";
# $capjuan=Juan

$pedro="\LPEDRO";
# $pedro="pedro"

$cappedro="\u\LPEDRO";
#cappedro="Pedro"

$maypedro="PEDRO";
$cappedro="\u\L$maypedro";
# $cappedro="Pedro"

Que pasa si usamos una variable antes de darle un valor, se asigna como cero si es numero o "" si es como string.

#!/usr/local/bin/perl
$a=3;
$b=$a+$c;
print ($b);

Imprime el valor 3

$x="hola";
$y=$x.$z;
# $y="hola"

Imprime la cadena hola

Exponenciación:

$x = 2 ** 4; se interpreta 2 elevado a la cuarta potencia

Programa de ejemplo de exponenciación:

#!/usr/local/bin/perl

print ("Introduzca el exponente:\n");
$exponente = <STDIN>;
print ("Introduzca la base:\n");
$base = <STDIN>;
chop ($exponente);
chop ($base);
print ("la operacion es: ", $base ** $exponente, "\n");

Cadena de caracteres:

Definir el contenido entre comillas simples, no interpretandose ningún carácter especial contenido entre ellas, un ejemplo podría ser :

 $palabra = 'perros';

Definir el contenido entre comillas dobles , interpretándose cualquier carácter especial contenido entre ellas a la hora de la impresión de la cadena, un ejemplo podría ser:

 $palabra = " perros \n";

Por  último, podemos definir varias variables al mismo tiempo utilizando los paréntesis por ejemplo:

 

($palabra1,$palabra2,$palabra3) = ("JUAN","PEPE","LUIS");
                           
 
 

El tipo de dato array de escalares es denotado mediante un nombre de variable precedido del símbolo @. Un ejemplo de inicialización de una variable de este tipo podría ser:

@frutas = ("manzana","pera","naranja","fresa");
 

El número de elementos menos uno de un array de escalares se puede obtener mediante el nombre de la variable precedido de los simbolos $#, por ejemplo si queremos obtener el número de elementos de @frutas haríamos:

#!/usr/local/bin/perl

@frutas = ("manzana","pera","naranja","fresa");

$numero_de_elementos = $#frutas+1;

print ($numero_de_elementos);

Imprime el numero 4 (hay 4 frutas en el array)

 

 

 

Resumen de funciones de Perl

A continuación se describen algunas de las funciones más utilizadas en la programación de un perl script, esto no pretende ser un manual de referencia,  pueden usar el comando man perl:

abs: devuelve el valor absoluto de la expresión pasada.

chmod: cambia los permisos de los ficheros dados.

chop: recorta y retorna el último carácter de una cadena.

chown: cambia el propietario de los ficheros dados.

close : cierra un fichero.

cos: devuelve el coseno del ángulo dado en radianes.

defined: sirve para comprobar si existe una variable, formato, subrutina,etc..

delete: borra un valor de un array asociativo a través de su clave.

die: imprime en la salida del error estándar un mensaje pasado como parámetro cuando ocurre un error en la ejecución de una sentencia.

eof: retorna verdadero si el final del fichero dado.

eval:  evalua la expresión pasada como si se tratase de un pequeño programa perl.

exec: ejecuta lo que pasemos como parámetro y sale del programa.

exit: hace que salgamos del perl script devolviendo al sistema operativo el valor pasado como argumento.

exp: retorna el número e elevado a la potencia pasada como parámetro.

fileno: devuelve el descriptor del manejador del fichero pasado como parámetro.

fork: realiza una llamada fork.

getc: lee el siguiente caracter del fichero especificado.

hex: devuelve el valor decimal del numero hexadecimal pasado como parámetro.

index: devuelve la posición de la primera ocurrencia de una cadena en otra.

int: devuelve la parte entera del parámetro pasado.

join: une las cadenas pasadas como argumento con un separador también pasado como argumento.

keys: devuelve todas las claves de un array asociativo.

length: devuelve la longitud en caracteres del parámetro pasado.

local: declara como locales las variables pasadas como argumentos.

log: devuelve el logaritmo del número dado.

mkdir: crea un directorio en el camino dado.

oct: devuelve el valor decimal del numero octal pasado como parámetro.

open: abre el fichero fichero dado asociandole un manejador de fichero especificado también como parámetro.

pop: retorna y borra el ultimo elemento del array dado.

print: muestra en la salida standard o en el fichero especificado la expresión dada.

push: añade el valor dado al final del array pasado como parámetro.

rand: devuelve un numero aleatorio entre 0 y el valor pasado como argumento.

read: lee un determinado numero de caracteres desde el fichero pasado como argumento.

rename: sirve para renombrar un fichero.

require: sirve para incluir código externo en nuestro guión.

return: devuelve un valor desde una subrutina.

rmdir: borra un directorio.

seek: sitúa un puntero a fichero en un lugar determinado.

select: sirve para seleccionar el manejador de fichero que será utilizado por defecto para la salida de los comandos o funciones que no especifiquen un determinado manejador de fichero como parámetro.

shift: devuelve el primer valor del array dado borrandolo posteriormente.

sin: devuelve el seno del ángulo pasado en radianes.

sleep: causa que el perl script o guión se detenga el número de segundos especificados.

sort: ordena el array dado.

split: divide una cadena en subcadenas según el separador especificado.

sqrt: devuelve la raiz cuadrada del número pasado.

system: igual que exec pero no se sale del perl script.

tell: devuelve la posición actual del puntero a fichero del manejador de fichero especificado.

values: devuelve todos los valores del array asociativo dado.

write: escribe un registro con formato en el fichero asociado a ese formato

 

Función

Descripción

abs($x)

Valor absoluto

cos($x)

Coseno en radianes

exp($x)

Exponencial (ex)

hex($x)

Transforma un numero Hexadecimal a decimal

int($x)

Devuelve la parte entera del número

log($x)

Logaritmo natural (base e)

srand($x)

Inicializa el generador de números aleatorios

rand($x)

Devuelve un número real en el intervalo [0,x)

sin($x) 

Seno en radianes

sqrt($x)

Raíz cuadrada

 

Operaciones sobre arreglos

Push y Pop

Una comun utilizacion de los arreglos es como stacks, donde los nuevos valores son agregados y borrados por el lado derecho del arreglo. Push() es utilizado para agregar elementos y pop() para sacar.

    
    @lista=(1,2,3);
   
                           push(@lista,5);
    # @lista=(1,2,3,5)
 
 
   
                           $a=pop(@lista); 
    @a=(1,2,3)
   
                           # $a=5,

Shift y Unshift()

Al igual que Pop y Push estos sacan y meten elementos de un arreglo, pero lo hacen por el lado izquierdo.

Ej: @a=(1,2,3);
    unshift(@a,0); 
    #
                           @a=(0,1,2,3);
 
    $x=shift(@a); 
    #
                           $x=0 , 
 
   
                           @a=(1,2,3)  
    unshift(@a,5,6,7)
                           
    # @a=(5,6,7,1,2,3)

El operador reverse

reverse() invierte el orden de los elementos de un arreglo, retornando la lista invertida.

              
                           
Ej:
                           @a=(1,2,3);
    @b=reverse(@a);
    # @b=(3,2,1) 
  
    @c=reverse(1,2,3);
                           
    # @c= (3,2,1)
 
Notemos que la lista que se le pasa como parámetro permanece inalterable.
                           Si nosotros queremos dejar la lista invertida ahí mismo debemos hacer : @a=reverse(@a) 

Sort

Sort toma una lista y la ordena ascendentemente ( segun codigo ASCII ) y retorna la lista ordenada.

Ej: @a=sort("grande","pequeño","chico"); 
    #
                           @a=("chico","pequeño","grande");
 
 
    @b=(1,2,4,8,16,32,64);
   
                           @c=sort(@b); 
    # @c=(1,2,16,32,4,64,8)
 

Como vemos en este ultimo ejemplo sort()ordena por strings, no numericamente.

Chop

chop() trabaja igual que en variables escalares, le saca el ultimo caracter a cada elemento del arreglo.

Ej: @a=("hola","mundo\n","felices dias");
   
                           chop(@a); 
    # @a=("hol","mundo","felices dia")

Operaciones raras

@a=(1,2,3,4,5);
($b,$c,$d)=@a;   
                           
#
                           b=1 c=2 d=3

                           
                           
 
@a=(1,'b',2,'c');
$b,@a)=@a;       
# b=1 a=('b',2,'c')

                           
                           
 
@a=('hola','tu');
@b=(1,2,@a,7,8);  
# b=(1,2,'hola','tu',7,8)

                           
                           
 
@a=(1,2,3,4,5);
@b=@a[1,3];      
                           
#
                           b=(2,3,4)

                           
                           
 
@b=(1,2,3,4,6)[0,1];  
# b=(1,2)

                           
                           
 
@a=(7,8,9);
@b=(1,2,0);
@c=@a[@b];       
                           
#
                           c=(8,9,7)
 

 

 

 

Estructuras de control:

Maneja las clasicas: if, for, while

if,elseif,else

La estructura de un if es la siguiente :

if ( .... ) {
   
                           ......;
    ......;
}
elsif ( .... ) {
    ......;
   
                           ......;
}
elsif ( .... ) {
   
                           ......;
    ......;
}
else ( .... ) {
    ......;
   
                           ......;
}
 

Notemos que los elsif y el else van solo si el usuario desea varias preguntas, se podria usar por ejemplo :

 

#!/usr/local/bin/perl
print ("Introduzca su edad:\n");
$a = <STDIN>;
if ( $a < 18 )

{
print "Tu eres menor de edad\n";
}
else
{
print "Eres un adulto\n";
}
 

While y until

La forma del while es :

while ( condicion ) {
....;
....;
}

Lo que esta entre llaves se ejecuta mientras sea veradera la condicion.

 

Ej: 
 
   
                           print "Cuantos años tienes?";
    $a=<STDIN>;
    chop($a);
    while
                           ( $a > 0 )
       {
       print
                           "El año pasado tenias $a años\n";
       $a--;
      
                           }

La forma del until es :

until ( condicion ) {
...;
...;
}

A diferencia del while el until se ejecuta al menos una vez , y se sigue mientras la condicion sea falso , es decir es similar al Repeat/Until de Pascal.

 

For

La forma general del for es :

for ( exp_inicial; exp_testeo; exp_increm){
...;
...;
}
Ej: for ( $x=0;$x<10;$x++)
      
                           {
       print "Llevas $x puntos\n";
      
                           }
 

Foreach

El foreach de Perl es muy similar al de C-shell , recibe una lista de valores y asigna cada uno de los valores de la lista a una variable de lectura . La estructura del foreach es :

foreach
                           $a ( @alguna_lista ) {
...;
...;
...;
}
Ej:
   
                           @a=(3,5,7,9);
    foreach $x (@a) {
     
                           $y=$x*3;
      print "$y\n";
      }
Imprime 9,15,21,27 .
 

If y unless

Hemos visto que todas las estructuras de control necesitaban de llaves, aunque solo fuera una instruccion; pero esto es incomodo por ejemplo para los if, es por eso que el if se puede usar de otra forma, poniendolo al final de lo que queremos ejecutar:

Ej:
print "Aqui es, Paulina" if ( $user eq 'Paulina' );

Tambien existe el unless, que hace todo lo contrario del if, es decir, ejecuta la accion si no se cumple la condicion del final:

Ej:
$a=45 unless ($a < 12 ); # b valdra 45 si a>=12
 
 
Manejo de archivos:
 

Procesamiento de archivos

Como en todo lenguaje en Perl se puede trabajar con archivos. Lo primero que se hace es abrirlo y luego leerlo :

 

    open(FILE,"file1");
   
                           while ( $a=<FILE> ){
    .....;
    }
   
                           close(FILE);
 

Lo que hicimos en la 1a linea es abrir el archivo de nombre file1 y a ese archivo le asignamos el "file handler" : FILE ( debe ser cualquier nombre pero en mayuscula ) . Luego con el while vamos leyendo linea a linea ( tambien podriamos haberlo hecho como con <STDIN> de asignar una variable de tipo arreglo a <FILE> y habriamos leido el archivo de una pasada ) . Finalmente algo muy importante, es cerrar el archivo .

Escribir en un archivo.

#!/usr/local/bin/perl

$file='hola.txt';

open (A,">$file");

 

# Abrimos para solo escritura el archivo hola.txt

 

print A "aprendiendo a escribir en archivos con perl\n";

print A "1 2 3 4 5 6 7 8 9\n";

 

close(A);Append a un archivo:

 

Este crea un archive llamado hola.txt y escribe en una linea y luego en la siguiente.

 
@l=('a',"\n",'b',"\n");
open(G,">>/user/jperez/d.txt");
# Abrimos para escritura pero append
print G @l;
close (G);
 

Veamos dos ejemplos mas interesantes:

 
open (A, "file") || die "No se puede abrir\n";
                     
                           |
                      |
                   
                           vale 1

Un programa que simula 'cp'

$#ARGV != 2 || die "use a.pl origen destino";
open (A,"$ARGV[0]")||die("No se puede leer el
                           origen");
open
                           (B,">$ARGV[1]")||die("No se puede escribir en el destino");
while(  )
   {
   print
                           B || die "No se pudo escribir";
   }
 
 

Inclusion de archivos

Al igual que en C, uno puede incluir otro archivo con codigo perl.
Con require incluimos un archivo, el cual no necesariamente tiene que tener un 'main', es decir pueden ser solo subrutinas.
Ejemplo:

 

#!/usr/local/bin/perl
 
require "otroarchiv.pl";
# sirve para agregar 
# el codigo que esta en el archivo otroarchiv.pl
                           

Otra forma es con eval, el cual en realidad no sirve en si para incluir archivos, sino que evalua expresiones.
Ejemplo:

$exp='$nombre="juan"; $apellido="perez"; $nombre.=$apellido; print
                           "hola $name\n";';
eval
                           $exp;
#
                           imprimira 'hola juanperez'

Entonces usando eval, podriamos incluir un archivo y que se ejecute:

$arch=`cat archivo`;
$eval $arch;
 
Como ejecutar comandos Linux desde script de Perl
 
Con system (comando)
 
Ejemplo:
 
System (ls)
 
Lista el contenido del directorio de ejecución
                           del script.
Tambien
                           funciona con comillas y sin comillas.
 
Otro ejemplo:
 
#!/usr/local/bin/perl
system ("pwd");
system ("ls");
system ("cat
                           eje1.pl");
 
Muestra la ruta del directorio, lista el contenido el directorio y abre el archive eje1.pl en
                           caso de que exista.
 

Igual que en C++ podemos usar la función exec para ejecutar programas externos, en Perl podemos hacer uso de la función system()

 

   
                           $valor =
                           system("ls -l");
    if($valor != 0) {
       
                           print "Error al ejecutar la orden";
    }

Otra opción es usar la función "`STRING`", que ejecuta el comando que indiquemos entre las comillas simples, y devuelve como array las líneas que ese comando mostrara:

    @output = `orden`;
 
Una de las principales fortalezas de Perl es interactuar bastante
bien con los recursos del sistema, y eso incluye
                           a Shell, sin embargo,
por lo regular es mejor tener todo tu código en un solo lenguaje y
siendo que todo lo que puedes hacer con shell
                           lo puedes hacer con Perl
es algo que debes considerar el reescribir tu programa en Perl para que
sea un poco mas sencillo en el sistema como un
                           todo.
 
Para borrar un archivo se me ocurren las siguientes
                           opciones:
 
$archivo="<poga aqui la ruta del archivo a
                           borrar>";
#Inicio
                           de alternativas, con system
system("rm $arhivo");
#con exec, el lo último que hacemos
exec("rm $archivo");
#con ``
`rm $archivo`;
#con open
                           (duh!)
open(AN,"rm $archivo");
close(AN); #(no nos importa su salida estandar)
 
#O como debe ser, con una función de Perl
unlink $archivo;
 
Hay cuatro principalmente, que son las mismas
                           que para ejecutar cualquier otro programa de UNIX desde Perl:
 
system()
exec()
open()
``
 
Explicación:
 
system(<comando>);
Te permite ejecutar un comando (o
script de shell) y pasarle todos los parametros
                           que quieras, sin
embargo,
                           no captura ni su salida estandar ni su entrada estandar y tu
programa en Perl espera hasta que termine (si no termina tu programa en
Perl esperará por siempre, a menos de que hagas
                           magia pesada con señales
que no viene al caso, simplmente asegurate de que tu programa termine).
<comando> Es una expresión que te permite
                           especificar lo que debe
hacerse de modo similar a como lo harías en el prompt de shell, si usas
"" puedes usar variables y todo lo demas.
System debe usarse cuando deseas que un comando
                           (que ya sabes que
resultado
                           tendrá) se ejecute cuando toda la información que necesitas
pasarle será en forma de parametros y no te interesa lo que escribe a
                           su
salida
                           estandard. Además, deseas que tu programa en Perl continue
corriendo DESPUES de ejecutar el comando.
 
exec(<comando>)
Con este también ejecutas un comando, pero nunca
                           regresa el control a tu
programa, de hecho, con exec terminas tu programa para inciar, en su
lugar, a otro (la peudes pasar todos los parámetros
                           que quieras). Como
se deduce, tampoco puedes enviar nada a su entrada o recoger nada de su
salida estandar.
exec se usa sobretodo cuando deseas que tu programa
                           en Perl prepare el
camino para un comando o programa escrito en otro lenguaje, me ha
llegado a pasar con un par de clientes de bases de datos y aplicaciones
que requieren mucha configuración del ambiente
                           en función de las tareas
a realizar.
 
open(<handle>,<comando>)
Como sabrás, open se suele usar para abrir archivos
                           ya sea para lectura
o escritura, pero tembién se puede usar para ejecutar un comando y
capturar ya sea su salida estandar o su entrada
                           estandar.
<handle> Es un identificador para tener tu file handle.
<comando>           
                           Es el comando UNIX a ejecutar y todos sus parametros, además,
si deseas capturar su entrada estandar debes anteponer un pipe "|"
mientras que si deseas capturar su salida estandar
                           debes terminar el
comando
                           con pipe "|". No puedes capturar a la vez la entrada y la salida
estandar.
Cuando ejecutas el comando con open, debes capturar toda la salida
estandard o alimentar su entrada estandard hasta
                           que termine, una vez
hecho esto, debes ejecutar close <handle>, es ese momento Perl ignora el
resto de la salida estandar del archivo o manda
                           un ^D a su entrada
estandar y espera a que termine el comando para regresar control a tu
script.
Open, como te imaginarás, se usa para ejecutar comandos o programas a
los que deseas pasar o recibir información de
                           su entrada o salida
estandard. En las ocaciónes en que uno tiene que usar programas
interactivos lo unico que se puede hacer es redireccionar, por ejemplo,
su entrada estandar a un archivo que escribamos
                           para el caso con
anterioridad
                           (de modo que el comando se convierte en algo como "temp >
comando par1 par2") y capturamos su salida estandar para ver los
resultados que nuestras instrucciones prehechas
                           tienen (el comando final
para el open será "temp > comando par1 par2 |").
 
Por último.
$algo=`comando`;
Al ejecutar un comando con `` se hace el equivalente a un open,
                           pero
solo
                           se captura la salida estandar del comando y se regresa completa
como valor de evaluar la expresión. En el ejemplo, $algo tendrá
                           todo lo
que
                           el comando <comando> haya escrito a su salida estandar.
Se usa esta forma de ejecución cuando no se desea generar mucho código
por la ejecución de programas sencillos de SO
                           y se desea capturar sus
resultados.
 
Ejemplo:
 
$algo = `ls`;
 print ($algo);
 
 
Otro ejemplo:
 
$algo = `ls`;
 $file='hola.txt';
open (A,">$file");
# Abrimos para solo escritura el archivo hola.txt
print A "mira coño de tu madre este es el resultado\n";
print A "$algo\n";
close(A);
 
Este programa ejecuta el comando ls y escribe
                           el resultado en un archivo llamado hola.txt.
 

Programación con sockets:

La programación con sockets es muy facil en PERL, porque un programa que en C ocupa 100 líneas de código, en perl se puede hacer en 5 o 6, gracias al módulo IO::Socket.

Para usarlo basta con poner:

use IO::Socket;

Para conseguir información en sistemas Linux deben poner:

perldoc IO::Socket

y de esta manera pueden leer bastante información.

Cliente de comandos sencillo:

#!/usr/bin/perl -w

use IO::Socket;

use Net::hostent;              # OO version of gethostbyaddr

 

$PORT = 9000;                  # pick something not in use

 

$server = IO::Socket::INET->new( Proto     => 'tcp',

                                 LocalPort => $PORT,

                                 Listen    => SOMAXCONN,

                                 Reuse     => 1);

 

die "can't setup server" unless $server;

print "[Server $0 accepting clients]\n";

 

while ($client = $server->accept()) {

  $client->autoflush(1);

  print $client "Welcome to $0; help for command list.\n";

  $hostinfo = gethostbyaddr($client->peeraddr);

  printf "[Connect from %s]\n", $hostinfo->name

   || $client->peerhost;

 

  print $client "Command? ";

  while ( <$client>) {

    next unless /\S/;   # blank line

    if    (/quit|exit/i)

         { last;                                    }

    elsif (/date|time/i)

         { printf $client "%s\n", scalar localtime; }

    elsif (/who/i )

         { print  $client `who 2>&1`;               }

    elsif (/cookie/i )

         { print  $client `/usr/games/fortune 2>&1`;}

    elsif (/motd/i )

         { print  $client `cat /etc/motd 2>&1`;     }

    else {

      print $client "Commands: quit date who cookie motd\n";

    }

  } continue {

     print $client "Command? ";

  }

  close $client;

}

Para probarlo, basta con ejecutarlo simplemente, y para conectarse a él, se puede poner algo así:

telnet 127.0.0.1 9000

Y nos aparecerá el servidor automáticamente, para poner comandos.

Estos ejemplos están extraidos de la página de manual perlipc, mas información con:

man perlipc

Y  luego se busca "IO::Socket" (con la barrita /).

 

Puerto serial

Para el control del puerto serial podemos usar el siguiente programa:

sysopen(PI,"/dev/ttyS0", O_RDWR|O_NDELAY) or

 die "No puede abrirse /dev/ttyS0: $!";   # Lo abro para leer

open(PO,"+>&PI") or

 die "No puede duplicarse PI: $!";   # Lo dup()eo para escribir

select((select(PO), $| = 1)[0]);   # Agitar de manos...

print PO "Esto va al puerto\n";

$r = <PI>;      # Esto lee del puerto...

print ($r);

 

Retardo

Esta función se usa para retardos menores de 1 seg:

select(undef,undef,undef,0.5); El ejemplo anterior define un retardo de 0,5 segundos.

Retardo de 3 seg aprox, en sistema unix/Linux esto no es tiempo real, por lo tanto es aprox.

$a=500;

select(undef,undef,undef,0.5);

select(undef,undef,undef,0.5);

select(undef,undef,undef,0.5);

select(undef,undef,undef,0.5);

select(undef,undef,undef,0.5);

select(undef,undef,undef,0.5);

print ($a);

 

Otra manera de lograr retardos es con la función sleep (retardos mayores de 1 seg)

 

Retardo de 5 segundos:

 

# retardo de 5 seg

 

$a=500;

sleep (5);

print ($a);