lunes, 15 de abril de 2013

Perl: Tratamiento de URLs, partes de la URL


-->
Algunas veces necesitamos analizar la validez de una cadena URL para descargar una página web, o sea necesitamos saber si está bien escrita.

Afortunadamente, en Perl, existe un módulo llamado URI, el cual permite realizar operaciones con las distintas partes de una URL sin tener que recurrir en forma profunda a las expresiones regulares.

Un ejemplo de una cadena URL completa podría ser:
http://user:pass@example.int:4345/hello.php?user=12#parte

Donde sus partes son:
  • Scheme =>http
  • Información de usuario =>user:pass
  • Host => example.int
  • Puerto =>4345
  • Path =>hello.php
  • Query =>user=12
  • Fragment =>parte

Con esta clase, se le dice adiós al procesamiento de los símbolos de la URL (://, /, :, ?, #).
Una vez que verificamos la sintaxis, estaríamos en forma para llamar a la URL y descargar la página web si lo deseamos, algo que podríamos ver en ( -->
http://otroblogdetecnologias.blogspot.com/2013/04/realizar-una-solicitud-una-pagina-web-y.html ).



El siguiente programa, solicita en la línea de comandos una URL y muestra sus partes, seguido a eso, asigna un valor "errado" a la variable que contiene la URL y verifica la sintaxis de la misma.
El ejemplo es un código muy básico, entiendo que podrían existir muchas cosas más que se les puede ocurrir con el procesamiento de una URL.



------------------------------ CORTAR AQUI ------------------------------
#!/usr/bin/perl
use 5.006;
use strict;
use URI;

#recibe como parametro la URL a verificar
my $direccion=$ARGV[$1];

print "URL => $direccion \n";
verURL($direccion);
#a $direccion le asigno un valor que no es valido
#para probar la funcion
$direccion="pagina.com";
if (verificarSintaxisURL($direccion)){
    print " PROGRAMA PRINCIPAL => URL VALIDA\n";
}else{
    print " PROGRAMA PRINCIPAL => URL NO VALIDA\n";
}
###### FIN PRINCIPAL #####

#################################################
#funcion de prueba tomada de O'Reilly Perl & LWP, capitulo 4 URLs
sub verURL{
    my ($direccionE)=@_;
    my $urlE = URI->new($direccionE);
    #ejemplo de cadena URL completa, con todos sus atributos
    # my $urlE = URI->new('http://user:pass@example.int:4345/hello.php?user=12&ninguna=1');
    print "===== PARTES DE LA URL=====\n";
    print "Scheme: ", $urlE->scheme( ), "\n";
    print "Userinfo: ", $urlE->userinfo( ), "\n";
    print "Hostname: ", $urlE->host( ), "\n";
    print "Port: ", $urlE->port( ), "\n";
    print "Path: ", $urlE->path( ), "\n";
    print "Query: ", $urlE->query( ), "\n";

}

##################################################
#verifica que la url contenga http o https
#verifica que tenga la parte del host
#evalua la seccion, si ocurren errores devuelve falso
##################################################
#devuelve 0 cuando es falso y 1 cuando es verdadero
sub verificarSintaxisURL{
    my ($direccionE)=@_;
    my $retorno=1; #comienza con verdadero
    print "===== VERIFICAR SINTAXIS DE LA URL=====\n";
    eval{
        my $urlE = URI->new($direccionE);
        if (defined($urlE->scheme( ))){
            if(($urlE->scheme( )=~ /http/)||($urlE->scheme( )=~ /https/)){
                print "La URL contiene => http|https \n";
            }else{
                $retorno=0;
            }
        }    
        if (defined($urlE->host( ))){
            if($urlE->host( ) eq ""){
                $retorno=0;
            }
            print "La URL tiene Host => \n";        
        }else{
            print "La URL NO TIENE Host => \n";
            $retorno=0;
        }
    };
    if($@){
        print "Se encontro un error durante el tratamiento de la URL, URL NO VALIDA\n";
        $retorno=0;
    }
    $retorno; 
}

###### FIN DEL PROGRAMA ##### 
------------------------------ CORTAR AQUI ------------------------------ 

viernes, 12 de abril de 2013

Perl: Creación de un módulo para agrupar funciones


En este artículo se publican dos archivos:
  • El primero es para el llamado de las subrutinas.
  • El segundo es para la definición de rutinas.

En Perl podemos crear módulos para agrupar las funciones al estilo programación procedimental ó también hacer módulos que respondan al modelo de objetos.

A continuación un ejemplo al estilo procedimental:

------------------------------ CORTAR AQUI ------------------------------
#!/usr/bin/perl
package moduloPrueba;
use strict;
use Exporter;
use warnings;

#Archivo moduloPrueba.pm
###########################################
#ejemplo adaptado de
# Bruno Contreras-Moreira
# http://www.eead.csic.es/compbio
# TEORIA: Modulos, clases y objetos
###########################################

our @ISA    = qw(Exporter);

########### LO QUE EXPORTA EL MODULO ###################
#definicion en forma de lista de las cabeceras de 
#funciones y variables globales que podran ser
#utilizadas desde los programas

our @EXPORT = qw( subrutina2 $variableGlobal1 $VERSION); 


########### VARIABLES GLOBALES ###################
# variables globales del modulo se coloca en forma 
# de lista en @EXPORT al inicio del programa
our $variableGlobal1;
our $VERSION=1.0;

#################################################
#definicion de una rutina interna. Esta no se encuentra en la lista
#de elementos a exportar @EXPORT
sub subrutina1_interna
{
    my ($parametros) = @_;
    
#    print "Estoy en subrutina1-> $parametros"
    #cargo un valor y lo devuelvo para prueba
    my $resultados = 1;    
    return ($resultados)  
}

#################################################
sub subrutina2
{    
    #uso la rutina interna pasandole un parametro
    my $datos = subrutina1_interna(2);
    
    print "Estoy en subrrutina2\n";
    #asignacion de datos a una variable global al modulo
    $variableGlobal1 = $datos;
}

1;
------------------------------ CORTAR AQUI ------------------------------

El archivo para utilización del módulo.

------------------------------ CORTAR AQUI ------------------------------
#!/usr/bin/perl
# Archivo pruebaModulo.pl
###########################################
#ejemplo adaptado de
# Bruno Contreras-Moreira
# http://www.eead.csic.es/compbio
# TEORIA: Modulos, clases y objetos
#
#Una muestra de agrupacion de funciones en un modulo
#Este ejemplo no utiliza el manejo de modulos en forma de clases
#
###########################################

use 5.006;
use strict;
use warnings;

#llamamos al modulo que creamos 
use moduloPrueba;

subrutina2();
print "$variableGlobal1 \n";
print "$VERSION \n";

------------------------------ CORTAR AQUI ------------------------------


Enlace fuente: --> TEORÍA: Módulos, clases y objetos

viernes, 5 de abril de 2013

Perl: Realizar una solicitud a una página web y descargarla

Perl: Realizar una solicitud a una página web y descargarla


Algunas veces, queremos trabajar con una copia de un sitio web y descargar la página.
Para hacerlo en Perl, se utilizan los módulos LWP::UserAgent y HTTP::Request.
A continuación un ejemplo resumido con una función que visita una página web y la guarda en un archivo de texto.
Este ejemplo, se probado utilizando un servidor Apache en la misma máquina.
En la línea

$ua->agent("Mozilla/5.0 (X11; Linux i686; rv:16.0) Gecko/20100101 Firefox/16.0"); se

Se ha configurado la cadena correspondiente a un agente Firefox, esta cadena puede dejarse vacia o colocar una frase identificatoria para nuestro programa.

Se puede acceder a un listado de las cadenas o firmas que realizan los distintos tipos de navegadores en 
-->http://www.user-agents.org/

------------------------------ CORTAR AQUI ------------------------------
#!/usr/bin/perl -w
#######################################################
#Realizar una solicitud a una direccion web
#Recibir la respuesta y guardar en archivo
#######################################################

use strict;
use LWP::UserAgent;
use HTTP::Request;

my $urlP="http://127.0.0.1";
my $pathP="temporal.txt";
solicitarPagina($urlP,$pathP);

######################################################
# Trae la pagina y la guarda en un archivo 
######################################################
sub solicitarPagina{
 my ($urlBuscar,$archivo)=@_;
 ############################################
 my $ua=LWP::UserAgent->new;
 $ua->agent("Mozilla/5.0 (X11; Linux i686; rv:16.0) Gecko/20100101 Firefox/16.0");
 
 #si tiene proxy habilitar esta linea
# $ua->proxy(['http','ftp'],'http://192.168.1.1:3128');

 my $req=HTTP::Request->new(GET=>$urlBuscar);
 my $response= $ua->request($req);
 my $content=$response->content();
 ############################################
 # abrir archivo segun parametro
 open(FH,">",$archivo);
 ############################################
 print FH $content;
 close(FH);
}

------------------------------ CORTAR AQUI ------------------------------

martes, 2 de abril de 2013

Perl: Manejo de cadenas


En este artículo se trata en forma resumida lo siguiente:
  • Obtener subcadenas.
  • Encontrar subcadenas dentro de una cadena.
  • Convertir a minúsculas.
  • Convertir a mayúsculas.
  • Distintos formatos de salida, que pueden ser aprovechados para escribir en pantallas o en archivos.
En Perl, se puede utilizar la función index(cadena, subcadena_buscada)

#devuelve el valor indice de la cadena
my $encontrar=index($cadena,"es");


  • Si el valor es -1-> indica que la cadena no se encontró.
  • Si el valor es 0-> indica que la cadena esta al principio.
  • Si el valor es mayor a 0-> indica el lugar donde se encuentra la cadena.

Enlaces

PLEAC-Perl -> http://pleac.sourceforge.net/pleac_perl/ es un buen sitio para ejemplos dedicados a temas específicos.

------------------------------ CORTAR AQUI ------------------------------
#!/usr/bin/perl

use 5.006;
use strict;
use warnings;

#cadena principal
my $cadena="Esta es una cadena con texto";

#obtiene una subcadena
my $subcadena=substr($cadena,0,4); #obtiene "Esta"

#devuelve el valor indice de la cadena
my $encontrar=index($cadena,"es");

#Convertir a minusculas con \L\E
#Convertir a mayusculas con \U\E
print "Cadena formateada en minusculas => \L $cadena \E \n";
print "Cadena formateada en mayusculas => \U $cadena \E \n";
print "Una subcadena => $subcadena \n";
print "Trae el numero de indice de la cadena encontrada => $encontrar \n";

#######ejemplos de formateo de salidas########
print "== FORMATEO DE SALIDAS==\n";
printf "%g %g %g\n", 5/2, 51/17, 51 ** 17;
printf "entero %d !\n", 17.85;
printf "%6d\n", 42; # la salida es completada hasta seis digitos
printf "entero %2d\n", 2e3 + 1.95; # 2001
printf "10 espacios %10s\n", "wilma";

printf "6 decimales -- %12f\n", 6 * 7 + 2/3; # looks like ```42.666667
printf "3 decimales -- %12.3f\n", 6 * 7 + 2/3;# looks like ``````42.667
printf "%12.0f\n", 6 * 7 + 2/3;# looks like ``````````43

------------------------------ CORTAR AQUI ------------------------------

Perl: Tablas hash


Perl: Tablas hash

A continuación el manejo de tablas hash en Perl en forma resumida.
A diferencia de los arreglos, las tablas hash permiten el acceso por medio de índices llamados claves en vez de utilizar valores numéricos para acceder al contenido.
Una tabla hash contiene dos valores a los cuales se hacen referencia, la clave y el valor asociado a esa clave.
El libro Learning Perl 5,de Schwartz explica bastante bien el tema, los ejemplos han sido adaptados del mismo.
Al final del artículo un ejemplo para copiar/pegar e ir probando.

Inicializar una tabla hash

El símbolo porcentaje % se refiere a la tabla hash, ejemplo %tabla_hash.

Ejemplos de inicializaciones
my %tabla_hash=(
"fred"=>"flintstone",
"dino"=>undef,
"barney" =>"rubble",
"betty" =>"rubble",
);

Otra forma es definirlo como array organizando cada par clave-valor.
my %otra_tabla=(“clave1”, 1,”clave2”, 2, “clave3”, 3);

Acceder y asignar valores a una tabla hash

Para acceder al contenido de una tabla hash se invoca el valor de la clave.
$valor=$tabla_hash{$clave} Esto asigna el contenido de la tabla hash a una variable. Se utiliza las llaves para referenciar los valores.
$tabla_hash{$clave}=0 Para guardar el valor cero en la tabla hash.
$contador = keys %tabla_hash Contar el número de elementos de una tabla hash.


*** Especial atención a lo siguiente: el símbolo $ corresponde cuando se asignan valores en forma escalar. El signo % se utiliza para referirse a la tabla completa.


Funciones para tablas hash

keys, asigna a un arreglo el listado de claves de una tabla hash.
value, asigna a un arreglo el listado de valores de una tabla hash.

Uso de las funciones keys y values
my %tabla_hash = ("a" => 1, "b" => 2, "c" => 3);
my @claves = keys %tabla_hash;
my @valores = values %tabla_hash;


each Devuelve un par clave-valor, se utiliza para recorridos de una tabla hash.
while ( ($clave, $valor) = each %tabla_hash ) {
print "$key => $valor\n";
}


exists Verifica la existencia de una clave
if (exists $tabla_hash{"algo"}) {
print "existe en la tabla algo\n";
}



delete Borra un elemento de la tabla según un valor de clave asignado.
my $clave = "miclave";
delete $tabla_hash{$clave}; 

 ------------------------------ CORTAR AQUI  ------------------------------

#!/usr/bin/perl

use 5.006;
use strict;
use warnings;

############################################
# Manejo de tablas hash
# Ejemplos basados en Schwartz - Learning Perl 5
############################################
# Definir una tabla hash y recorrerla.
############################################

my %tabla_hash=(
    "fred"=>"flintstone",
    "dino"=>"nada",
    "barney" =>"violeta",
    "betty"    =>"rubble",
);

my ($clave, $valor,$unavariable,$otraclave);

############################################
#recorrer tabla hash
print "\n============= Recorrer una tabla has utilizando while ===================\n";
while (($clave,$valor)=each %tabla_hash){
    print "$clave -> $valor \n";
}

############################################
#otra forma de recorrerla
print "\n============= Otra forma de recorrer una tabla has utilizando foreach ===================\n";
foreach $clave (sort keys %tabla_hash){
    $valor=$tabla_hash{$clave};
    print "$clave -> $valor \n";    
}

#asignacion de un valor a la tabla hash
$unavariable=10;
$otraclave="dino"; #establece la clave a buscar
$tabla_hash{$otraclave}="amarillo";
print $tabla_hash{$otraclave}."\n";

 ------------------------------ CORTAR AQUI  ------------------------------

Perl: Arrays



Perl: Arrays

A continuación el manejo de arrays en Perl en forma resumida.
Al final del artículo un ejemplo para copiar/pegar e ir probando.

Inicializar un array

El arroba @ se refiere a todo el array, ejemplo @nombre_array es todo el array.
Range operator .. , se utiliza para definiciones de un rango de valores, ejemplo (1..5) es para valores de uno a cinco.
Operador qw. El operador qw permite el uso de valores sin utilizar comas y comillas.
@arreglo= qw (uno dos tres) es lo mismo que @arreglo=(“uno”, “dos”, “tres”).

Ejemplos de inicializaciones
  • @arreglo= qw (un dos tres). Cargar valores en forma de lista.
  • @arreglo=(1..5). Cargar los números del uno al cinco.
  • @arreglo1=@arreglo2. Copiar un array en otro.

Acceder a los valores de un array

$#nombre_array indica la posición del último elemento de un arreglo, comenzando desde cero.
$arreglo[índice] Acceder a un elemento del arreglo.
$arreglo[índice]=0 Asignar valor cero a un arreglo.

***** El uso de índices negativos cuenta desde el final del array.

Asignación de valores a variables

Se pueden asignar valores a variables de la siguiente forma:
($fred,$barney,$dino)=(“peble”,”nada”,undef)


Si se colocan valores diferentes de cada lado se tiene lo siguiente:
($fred,$barney)=(“peble”,”nada”,undef) dos variables, un valor ignorado “el último”.
($fred,$barney,$dino)=(“peble”,”nada”) a $dino se le asigna undef

Funciones para acceso a arrays

pop, vacía un array, si el array está vacío entonces entrega undef.
push, inserta un valor al arreglo, push(@arreglo,0) o puede ser push @arreglo,0 sin los paréntesis.
shift, obtiene un elemento del array el primero de la lista.
unshift, agrega elementos a un array.

@arreglo = qw / uno dos tres /;
$m = shift(@arreglo); # $m obtiene gets "dino", @array now has ("fred", "barney")
$n = shift @array; # $n gets "fred", @array now has ("barney")
shift @array; # @array is now empty
$o = shift @array; # $o gets undef, @array is still empty
unshift(@array, 5); # @array now has the one-element list (5)
unshift @array, 4; # @array now has (4, 5)
@others = 1..3;
unshift @array, @others; # @array now has (1, 2, 3, 4, 5)

El operador reverse permite invertir el contenido de un array.

Archivo arreglo.pl
------------------------------ CORTAR AQUI ------------------------------
#!/usr/bin/perl



use 5.006;

use strict;

use warnings;



############################################

# Manejo de arrays

# Ejemplos basados en Schwartz - Learning Perl 5

############################################

# Definir un arreglo y recorrerlo.

############################################

my @arreglo = qw/ cinco seis uno dos tres cuatro /;

my $elemento;

foreach $elemento (@arreglo) {

    print "$elemento \n";

}

print "Cantidad elementos: $#arreglo \n"; 



#Ordena el array

my @ordenado= sort (@arreglo);

print "Ordena el arreglo alfabeticamente ->\n";

print " @ordenado \n";



#############################################

# Distintos tipos de asignaciones y uso de funciones

#############################################



@arreglo = qw /  uno dos tres cuatro /; 

my $primero = shift(@arreglo); # $primero recibe "uno"

my $segundo = shift @arreglo; # $segundo recibe "dos"



print "Valor primero-> $primero \n";

print "Valor segundo-> $segundo \n";



shift @arreglo; # @arreglo vacio

my  $sinValor = shift @arreglo; # $sinValor obtiene undef, @arreglo vacio

unshift(@arreglo, 5); #inserta el valor 5

unshift @arreglo, 4;  #inserta el valor 4

@ordenado = 1..3; #asigna del 1 al 3

unshift @arreglo, @ordenado; # inserta los elementos de @ordenado al array @arreglo (1, 2, 3, 4, 5) 

print "\n Valor final del array---> @arreglo \n";



------------------------------ CORTAR AQUI ------------------------------

Lector de direcciones de EMAIL en Perl.


A modo de agrupar conocimientos, he realizado un script que permite obtener direcciones de email desde archivos en código ASCII.
El script hace lo siguiente:
  • Realiza una copia del archivo .eml en un archivo temporal.
  • Elimina los símbolos del primer archivo copiando los datos a un segundo archivo temporal
  • Busca líneas que contienen el carácter arroba.
  • Procesa las lineas separandolas en palabras para luego seleccionar lo patrones que corresponden a direcciones de correo.
 En Linux/Unix crear un archivo y asignarle permiso de ejecución ej: chmod 755 archivo.pl

-------------------------------------------- CORTAR AQUI ------------------------------------------------------- 

#!/usr/bin/perl

############################################################################################
#Autor: http://otroblogdetecnologias.blogspot.com
#Funcion: Extraer mails desde archivos ingresados en la línea de comandos;
#=================================
#Descripcion del Algoritmo
#=================================
#Realiza una copia del archivo .eml en un archivo temporal.
#Elimina los simbolos del primer archivo copiando los datos a un segundo archivo temporal
#Busca las lineas que contienen una arroba
#Procesa las lineas separandolas en palabras para luego seleccionar los patrones de correo
############################################################################################
my $content;
my $arTemporal1="temporal.eml";
my $arTemporal2="temporal2.eml";
my $arFinal="final.txt";

if ($#ARGV==-1) {
    #sin parametros
    ayuda();
} else {
    ############################################
    #limpia el archivo de reporte final
    open(FINAL,">",$arFinal) or die;        
    close(FINAL);
    ############################################
    # abrir archivo segun parametro
    copiarArchivo($ARGV[0],$arTemporal1);
    eliminarSimbolos($arTemporal1,$arTemporal2);    
    open(FH, $arTemporal2)or die;
    ############################################
    while (){
        chomp;
        #del archivo temporal obtiene las lineas con arroba
        if (/\@/) {
            $content=$_;
            procesarLinea($content);
        }        
    }    
    close(FH);    
}

##################################################
#Realiza una copia a un archivo temporal
##################################################
sub copiarArchivo{
        my ($archivo1,$archivo2)=@_;
        print $archivo1;
        open(ARCHIVO1,"<",$archivo1) or die;
        open(ARCHIVO2,">",$archivo2) or die;        
        while(){
            print ARCHIVO2 $_;
        }
        close(ARCHIVO1);
        close(ARCHIVO2);            
}

##################################################
#elimina los simbolos que no son utilizados y suplanta por espacios
##################################################
sub eliminarSimbolos{
    my ($archivo1,$archivo2)=@_;
    print $archivo1;
    open(ARCHIVO1,"<",$archivo1) or die;
    open(ARCHIVO2,">",$archivo2) or die;        
    while(){
        #expresion que suplanta los simbolos cualquiera sea la ocurrencia
        #dentro de la linea leida            
        if(s/<|>|'|"|=|\;|\,|\&gt|\:/ /g){                
            print ARCHIVO2 $_;
        }
    }
    close(ARCHIVO1);
    close(ARCHIVO2);                
}

##################################################
#lee linea por linea obteniendo los patrones correspondientes a cuentas
#de correo
##################################################
sub procesarLinea {
    my ($linea)=@_;    
    my @arreglo;
    @arreglo= split /[\s|\t]+/, $linea;

    open(FINAL,">>",$arFinal) or die;        
    foreach $ar (@arreglo) {
        #obtiene las direcciones de correo por expresion regular.
        if($ar=~ /@(.)+\.[com]?/){
          print "$ar \n";
          #imprime en el reporte
          print FINAL $ar,"\n";            
        }    
    }
    close(ARCHIVO2);
}

##################################################
## ayuda
##################################################
sub ayuda {
    print("##############################################################\n");
    print("Obtiene direcciones de email desde archivos con formato texto \n");
    print("##############################################################\n");
    print("No se ingreso el nombre del archivo \n");
}

-------------------------------------------- CORTAR AQUI -------------------------------------------------------  



Perl: Manejo de archivos


Otra función necesaria cuando se realizan programas es la lectura/escritura de archivos.
En Perl se maneja de la siguiente manera.

En la variable $archivo1 se guarda el nombre del archivo entre comillas.
$archivo1=”notas.txt”;


open(ARCHIVO1,"<",$archivo1) or die “mensaje al
   usuario: $!”;

Leer archivo y asignarlo al manejador ARCHIVO1.
open(ARCHIVO2,">",$archivo2) or die “mensaje al
   usuario: $!”;
Escribir en archivo utilizando el manejador ARCHIVO2.
open(FINAL,">>",$arFinal) or die “mensaje al
   usuario: $!”;
Insertar al final del archivo sin borrar el contenido completo del mismo, utilizando el manejador de archivos FINAL.

 Se puede utilizar la función print para escribir en los archivos. Ej:
print FINAL $ar,"\n";



Para recorrer el archivo y mostrarlo en pantalla se utiliza un ciclo como este:

        while( < ARCHIVO1 > ){
            print $_;
        }
 
Donde ARCHIVO1  es el manejador de archivo utilizado en la función

open(ARCHIVO1,"<",$archivo1) or die "mensaje al usuario: $!"



Un ejemplo de una función que realiza un recorrido de archivo e imprime en otro.


##################################################
#Realiza una copia a aun archivo temporal
##################################################
sub copiarArchivo{
        my ($archivo1,$archivo2)=@_;
        print $archivo1;
        open(ARCHIVO1,"<",$archivo1) or die;
        open(ARCHIVO2,">",$archivo2) or die;        
        while(< ARCHIVO1 >){
            print ARCHIVO2 $_;
        }
        close(ARCHIVO1);
        close(ARCHIVO2);            
}
Fin del articulo

Perl: Leer directorios del sistema


A veces es necesario leer un listado de nombres de archivos desde un directorio específico.
A continuación un ejemplo que recibe como parámetro desde la línea de comandos una ruta de directorio y muestra en pantalla un listado de los archivos y directorios que se encuentran dentro.

Tiene una característica especial, dado que mostrará solamente los archivos con extensión .txt. Este ejemplo puede ser fácilmente adaptado o otras tareas.


-------------------------------------------- CORTAR AQUI ------------------------------------------------------- 
#!/usr/bin/perl
use 5.006;
use strict;
use warnings;
#######################################################
# Recupera los nombres de archivos y directorios dentro de una ruta
# especifica escrita desde la linea de comandos
#######################################################
my $directorio="/home/";
my $archivo;

if ($#ARGV==-1) {
    #sin parametros
    exit
} else {
    $directorio=$ARGV[0];
    opendir DH,$directorio or die "no se puede abrir el directorio: $!";
    foreach $archivo (readdir DH){
        #busca archivos .txt
#comentar el if si se desea tener un listado completo del directorio
#        if ($archivo=~ /\.txt/){
            print "$archivo \n";
#        }
    }#foreach
    closedir DH;
} 
-------------------------------------------- CORTAR AQUI ------------------------------------------------------- 

viernes, 29 de marzo de 2013

Perl: Fecha y hora del sistema


A veces se necesita obtener la fecha y hora del sistema para un script.
A continuación un script que hace lo siguiente:
  • Ejecuta el comando date en Unix/Linux y devuelve los datos concatenados.
  • Ejecuta el comando date y extrae los valores de fecha y hora en variables separadas.
-------------------------------------------- CORTAR AQUI -------------------------------------------------------
#!/usr/bin/perl

use strict;

use warnings;

#Leer valores de fecha y hora del sistema, para sistemas operativos Unix/Linux

#ejecutar comando date y devolver el valor a una variable

my $nombreArchivo=`date +%Y%m%d%H%M%S`;

#limpiar caracteres de nueva linea

$nombreArchivo=~s/\n//g;

print "Variable con resultado de ejecucion de comando -> $nombreArchivo \n";



#Tomar hora del sistema. Guardar valores de fecha y hora en variables, en sistemas Unix/Linux

my $ANO=`date | cut -c25-29 | tr -d ' '`;

my $MES=`date | cut -c5-7 | tr -d ' '`;

my $DIA=`date | cut -c9-10 | tr -d ' '`;

my $HORA=`date | cut -c12-13 | tr -d ' '`;

my $MINUTOS=`date | cut -c15-16 | tr -d ' '`;

my $SEGUNDOS=`date | cut -c18-19 | tr -d ' '`;



print "Fecha tomada del sistema -> ";

print "$ANO $MES $DIA $HORA $MINUTOS $SEGUNDOS \n";

-------------------------------------------- CORTAR AQUI -------------------------------------------------------

Como procesar argumentos desde la línea de comandos en Perl al estilo Unix Ejemplo 2)


-->
En Perl se puede codificar de distintas maneras la solución de un problema.
A continuación un segundo ejemplo de procesamiento de argumentos recibidos desde la línea de comandos, sin utilizar un módulo de manejo de argumentos.
En este ejemplo, se pueden recibir las siguientes opciones:
  • -d algo: llama al proceso 1.
  • -a algo: llama al proceso 2.
  • -h : llama a ayuda.


El formato de llamado del script puede ser.

 
[usuario@maquina]$  miPrograma.pl  
 
[usuario@maquina]$  miPrograma.pl -a algo

[usuario@maquina]$  miPrograma.pl -d algo

-------------------------------------------- CORTAR AQUI -------------------------------------------------------
#!/usr/bin/perl

use strict;

##################################################

#indice para verificar el valor del argumento

my $j=0; 

my $directorio;

my $archivo;

##################################################

#Procesamiento de parametros de linea de comando

if ($#ARGV==-1) {

    print "Sin argumentos\n";

    ayuda();

} else {

    print("##########################\n");

    print("Cantidad argumentos-> $#ARGV\n");

    print("##########################\n");

    if($#ARGV!=1){

        #se espera la opcion ej -a o -d seguida de una cadena

        print "\n No se ha pasado la cantidad correcta de argumentos \n";

        exit;

    }

    for (my $i=0;$i <= $#ARGV; $i++){

        if($ARGV[$i] eq "-h"){

            ayuda();

        }        

        if($ARGV[$i] eq "-d"){

            $j=$i+1;

            if($j<=$#ARGV){

                $directorio=$ARGV[$j];

                print "Directorio-> $directorio\n";

                proceso1;

                exit;

            }else {

                ayuda();

            }

        }else{            

            if($ARGV[$i] eq "-a"){

                $j=$i+1;

                if($j<=$#ARGV){

                    $archivo=$ARGV[$j];

                    print "Archivo-> $archivo\n";

                    proceso2;

                    exit;

                }else {

                    ayuda();

                }

            }else{

                ayuda();

                exit;    

            }

        }

    }#for ($i=0;$i <= $#ARGV; $i++)

}#if ($#ARGV==-1) {

##################################################

    

sub proceso1{

    print "Proceso 1\n";

}

sub proceso2{

    print "Proceso 1\n";

}

sub ayuda{

    print "\n TEXTO DE AYUDA \n";

}
-------------------------------------------- CORTAR AQUI -------------------------------------------------------

Como procesar argumentos desde la línea de comandos en Perl al estilo Unix Ejemplo 1)


Se puede procesar argumentos recibidos desde la linea de comandos del sistema en un script.
Se propone un sencillo ejemplo que hara lo siguiente:

  • Mostrar el nombre del script.
  • Mostrar la cantidad de argumentos recibidos.
  • Mostrar los valores contenidos dentro del arreglo de argumentos estandar #ARGV.
El ejemplo no realiza un análisis sintáctico de las opciones recibidas.

-------------------------------------------- CORTAR AQUI -------------------------------------------------------
#!/usr/bin/perl
use strict;
use warnings;


#Ejemplo 1): leer valores de la linea de comandos y mostrar el nombre del script

#invocar nombreScript argumento1 argumento2

print "Nombre del script -> $0 \n";
print "Cantidad de argumentos recibidos comienza desde cero hasta $#ARGV \n";
#recorrer argumentos recibidos desde linea de comandos

for (my $i=0;$i <= $#ARGV; $i++){

    print "Argumento -> $i -> $ARGV[$i]\n";

}

-------------------------------------------- CORTAR AQUI -------------------------------------------------------


Como procesar opciones desde la línea de comandos en Perl al estilo Unix con GetOpt::Long


Algunas veces queremos que los scripts que escribimos en Perl funcionen recibiendo opciones desde la línea de comandos al estilo Unix. [usuario@maquina]$ miPrograma.pl -a algo -d otracosa Existe un módulo en Perl que permite el manejo de estas opciones. El mismo se llama Getopt::Long. También se puede hacer manualmente, pero en este caso deberíamos verificar la sintaxis por nuestra cuenta analizando la cadena, opción que no será tratada en este artículo. El ejemplo recibe las siguientes opciones:
  • -d una cadena.
  • -a una cadena.
  • Ayuda : muestra la ayuda del comando.
Para el caso de las opciones -d y -a deben ser excluyentes entre si, es decir no pueden ser invocadas ambas al mismo tiempo. -->
-------------------------------------------- CORTAR AQUI -------------------------------------------------------
#!/usr/bin/perl 
use strict;
use warnings;
use Getopt::Long;

# Lee los parámetros en una variable recibir_parametros
my $recibir_parametros = {};
GetOptions($recibir_parametros,
  'd:s',
  'a:s',
  'ayuda',
);



# Si se ha especificado el parámetro 'ayuda', imprimir la ayuda y terminar
$recibir_parametros->{ayuda} && imprimir_ayuda( 0 );
# Los parametros son mutuamente excluyentes
# si ambos estan definidos se corta la ejecucion
# evita estes tipo de llamadas ej: archivo.pl -a algo -d otracosa
if ( defined $recibir_parametros->{d} && defined $recibir_parametros->{a}) {
    imprimir_ayuda( 1 );
}



#este modelo acepta solamente uno u otro valor
#si se definio el paramaetro -d pero el valor viene vacio imprime ayuda
if( defined $recibir_parametros->{d}) {
  if(!($recibir_parametros->{d} eq "")){
      print "Se recibio: -a $recibir_parametros->{d}\n";
        #################################################
# llamar procedimiento hacer algo con -d   #################################################            
  }else{
      imprimir_ayuda( 1 );
  }
}else 
{
  if( defined $recibir_parametros->{a}) {
    if(!($recibir_parametros->{a} eq "")){
      print "Se recibio: -a $recibir_parametros->{a}\n";
      #################################################
      # llamar procedimiento hacer algo con -a
      #################################################      
    }else{
      imprimir_ayuda( 1 );
    }
  }else{
    imprimir_ayuda( 1 );
  }
}



sub imprimir_ayuda {
    my $exit_status = shift;
    print <<"END"
    Uso: $0 [-d ruta directorio_busqueda | -a archivo_con_texto]
    Obtiene direcciones de correo desde un directorio con archivos o 
    desde un archivo ingresado por el usuario.
       
    Los parámetros son obligatorios si no se indica lo contrario:
          -d     procesa todos los archivos de un directorio
          -a     procesa solamente un archivo especificado          
          -ayuda Imprime esta ayuda
          Los parametros -d y -a son excluyentes entre si!!
           
END
;


    exit $exit_status;

}


-------------------------------------------- CORTAR AQUI -------------------------------------------------------