Tutorial de iniciación a Perl en Español

¿Qué es Perl?

Perl es un Lenguaje de Programación cuya estructura es un derivado del Lenguaje C, también toma características de la programación shell, así como de otros lenguajes de programación, este lenguaje fue creado por Larry Wall en 1987.

Perl es uno de los lenguajes más utilizados en la actualidad, soporta tanto la programación estructurada como la programación orientada a objetos y la programación funcional, además tiene muchas funciones integradas para tareas comunes y acceder a los recursos del sistema, está muy extendido su utilización para la Administración de Sistemas, Desarrollo Web, Programación en red, Desarrollo de GUI y mucho más.

La Comunidad Perl trabaja constantemente para la actualización de módulos o para la creación de nuevos, es decir, existen módulos prácticamente para cualquier tarea que se deseé realizar. Strawberry o ActiveState son librerías de código abierto para Windows, que permiten la descarga de nuevos módulos creados por la Comunidad, en linux no es necesario ya que Perl suele venir instalado por defecto.

Instalación de Perl

Linux:

Perl generalemente ya viene instalado en los Sistema Linux por defecto, para ver la versión que tienes de perl abre una terminal y escribe el comando "perl -v".

Windows

En Windows no viene Perl instalado por defecto así que es necesario ir a la web oficial de Perl y aconsejo descargar una de las dos librerías de la Comunidad como Strawberry o ActiveState, ya que viene con cpan, y esto simplifica mucho tareas como la descarga de módulos o la actualización de versiones.

Sitio de descarga de Perl

Una vez descargado lo ejecutas como otro cualquier ejecutable de windows, hasta finalizar la instalación. En Windows se descarga en la raiz del Disco, generalmente en C:\, allí podrás ver la carpeta con todos los archivos de perl y en la carpeta "bin" el intérprete perl.exe, otro aspecto importante es convertir perl.exe en una variable de entorno de windows para que pueda ser ejecutado desde cualquier punto del sistema.

Convertir perl.exe en una variable de entorno

En el menú de Windows: Ir al panel de control >> Rendimiento y mantenimiento >> Sistema >> click en el tab "Opciones avanzadas" y click en el botón "Variables de entorno".

Doble click en PATH ...

Tutorial de iniciación a Perl en Español

He introduce la ruta a la carpeta bin del perl, en mi caso es ... C:\strawberry\perl\bin;

Le das a aceptar a todo, abres una consola de Windows y escribe perl -v, si todo ha sido correcto te mostrará la versión de perl ...

Mi primer archivo ejecutable con Perl

Antes de entrar de lleno en el lenguaje es necesario conocer aspectos básicos de Perl, los archivos perl llevan las extensión .pl, para escribir código recomiendo un editor como notepad++ ya que te remarca el código y viene con la opción de autocomplete, también puedes usar el bloc de notas o si estás en linux el editor de textos gedit.

Para este ejemplo crearemos en el escritorio una carpeta llamada "tutorial-perl", con el editor de código abres un nuevo documento y escribe el siguiente código ...

#Mi primera linea de codigo
print "Hola mundo";

Guárdalo como "prueba.pl" en la carpeta que acabas de crear. Ahora para ejecutar el archivo perl es necesario abrir una consola e ir a la ruta de la carpeta donde se encuentra el archivo, es decir >>> cd ruta

A continuación para ejecutar el archivo se llama al interprete de perl seguido del fichero >>> perl prueba.pl

Examina el código, para escribir comentarios se utiliza la almohadilla "#", esto no es tomado en cuenta por perl, es muy útil para ir describiendo las partes del código.

print es un comando de salida de datos que permite imprimir texto en la consola.

Comandos de entrada y salida de datos

En cualquier lenguaje de programación y Perl no es menos, existen una serie de comandos para la entrada y salida de datos, es muy básico, la entrada de datos como su propio nombre indica nos permite agregar datos al programa para realizar una determinada acción, es decir, si tienes un programa que suma dos números, primero ingresas un número y luego el otro, y esto te puede permitir realizar una acción determinada como sumarlos, restarlos, multiplicarlos, ... y finalmente obtener una salida con el resultado total.

Salida de datos - print

Para la salida de datos se utiliza el comando print seguido de la variable o la cadena de texto.

Ejemplo:

#Salida de datos
print "Hola Mundo \n";

Esto lo vimos anteriormente, excepto el salto de línea que se indica con "\n", a continuación puedes ver los indicadores más importantes que podrás usar para la salida de datos ...

\n	Nueva línea.
\t	Tabulacíon.
\r	Retorno de carro.
\f	Nueva hoja (formfeed).
\b	Espacio atrás (backspace).
\e	Secuencia de ESCape.
\u	Pasa a mayúscula el primer caracter de texto siguiente".
\U	Pasa a mayúscula todo el texto siguiente".
\l	Pasa a minúscula el primer caracter de texto siguiente".
\L	Pasa a minúscula todo el texto siguiente.
\E	Fin del efecto de los modificadores \U,\L.
\a	Emite un pitido.
\cC	Combinación de Control+Letra. En este caso Control-C.

Es interesante que practiques con el comando print e ir probando con los indicadores para ver lo que ocurre en cada caso.

Entrada de datos - STDIN | $ARGV

STDIN

Mediante STDIN se puede realizar una entrada de datos y asignar dicho valor a una variable.

Por ejemplo:

#Entrada de datos con STDIN
print "Introduce lo que quieras y pulsa enter ... ";
$entrada = <STDIN>;
print $entrada;

Veamos este código, con el comando print se imprime un mensaje que te solicita que ingreses lo que quieras, hay una variable llamada "$entrada" la cual recibe el valor <STDIN> lo cual indica que en ese punto de la ejecución del programa se realizará una entrada de datos, introduces el texto y pulsas la tecla "ENTER", finalmente nuevamente con print se muestra el valor de entrada de la variable "$entrada".

Practica introduciendo nuevos valores de entrada e imprimiendo su valor final con print.

$ARGV

$ARGV permite agregar parámetros al programa, si estás habituado al uso de la consola estarás acostumbrado a incluir parámetros, por ejemplo, introduce en la consola >>> "netstat -h", -h es un parámetro que te mostrará la sección de ayuda del programa netstat.

$ARGV funciona a modo de lista o array, es decir puede contener tantos elementos como se requieran, con la única condición que al llamarlos en la consola deberán ir separados por un espacio, esta parte puede ser algo más compleja si no has visto nada de arrays, así que tampoco te preocupes demasido si no lo entiendes de primera. Para este ejemplo puedes crear un archivo llamado "argv.pl" y le añades el siguiente código ...

#Entrada de datos con $ARGV
$ARGV[0];
print "El parametro 1 es ... " . $ARGV[0] . "\n";
$ARGV[1];
print "El parametro 2 es ... " . $ARGV[1] . "\n";

A continuación ejecutamos el archivo perl con dos parámetros ... >>> perl argv.pl uno dos

Como se puede ver en el código $ARGV[0] es el primer parámetro y $ARGV[1] el segundo, luego simplemente se imprimen sus valores en una cadena de texto concatenada, la concatenación se realiza mediante el punto ".", ésto lo veremos más adelante.

Puedes practicar creando nuevos parámetros e imprímelos con print para habituarte, ya que es de uso muy común en las aplicaciones de consola.

Variables y Constantes

VARIABLES

Las variables almacenan el valor asignado en la memoria, para acceder a dicho valor hay que hacerlo a través del nombre con el que se declaró, en Perl los nombres de las variables empiezan por el carácter "$" y no es obligatorio declarar el tipo de datos, ni tampoco indicar explicitamente de que se trata de una variable, aunque se puede hacer mediante la palabra reservada my, las variables pueden ir cambiando su valor a lo largo de la ejecución del programa, esto quiere decir que no son constantes, una variable puede almacenar un valor y ser cambiado tras una determinada acción.

Ejemplo:

#Variables
my $variable = "Hola soy una variable \n";
print $variable;
$variable = "Hola soy una variable \n";
print $variable;

CONSTANTES

Las constantes al contrario que las variables mantienen el valor constante, es decir, no pueden cambiar su valor en ningún punto de la ejecución, es útil para definir valores que no van a tener que ser sometidos a cambios, como podría ser el número pi, un importe fijo, un determinado número, ... Para declarar una constante en Perl se utilizan las palabras reservadas use constant, seguido del nombre y la asignación de su valor, como en el caso de las variables tampoco es necesario especificar el tipo de datos, ya que Perl lo interpreta atendiendo al valor asignado.

Ejemplo:

#Constantes 
use constant numero_pi => 3.14;
print "Numero pi es una constante: ".numero_pi;

Puedes practicar creando nuevas variables y constantes realizando los ejercicios mediante la entrada y salida de datos como se vió en el capítulo anterior.

Tipos de datos

En Perl existen tres clases de tipos de datos: Escalares, Listas y Hashes(listas asociadas).

Tipos de datos escalares

Los tipos de datos escalares pueden ser tanto números, como cadenas de texto o referencias, este tipo de datos sólo pueden albergar un valor, es decir a una variable le añades sólo un valor ... $variable = 1; para albergar más valores existen las listas o hashes que veremos más adelante.

Tipos de datos:

Números Enteros: son un conjunto de números que incluye a los números naturales distintos de cero (1, 2, 3, ...), los negativos de los números naturales (..., -3, -2, -1) y al 0.
Strings o cadenas de texto: Este tipo de datos incluye a todas las cadenas de texto, que pueden ir tanto entre comillas simples, como en comillas dobles.
Numeros Reales: incluyen tanto a los números racionales (positivos, negativos y el cero) como a los números irracionales; y en otro enfoque, trascendentes y algebraicos. Este tipo de datos permite realizar complejas operaciones matemáticas.

Es importante reseñar que los valores enteros nunca pueden empezar en cero, porque esto permite especificar un entero mediante su codificación octal o hexadecimal. La codificación octal siempre empieza en 0 y la hexadecimal en 0x

Ejemplos:

#string o cadena de texto
$string = "Hola Mundo";
print $string;
print "\n";

#string o cadena de texto
$string = 'Hola Mundo';
print $string;
print "\n";

#numero entero
$numero_entero = 568;
print $numero_entero;
print "\n";

#numero entero
$numero_entero = -560;
print $numero_entero;
print "\n";

#numero real
$numero_real = 11e-24;
print $numero_real;
print "\n";

#numero real
$numero_real = 0.2456;
print $numero_real;
print "\n";

#codificacion octal
$octal = 0333;
print $octal;
print "\n";

#codificacion hexadecimal
$hexadecimal = 0x12affe11;
print $hexadecimal;
print "\n";

Arrays - Listas

Los Arrays en perl permiten almacenar elementos que son indexados a partir de 0, es decir el primer elemento de un Array es 0, para declarar un array se utiliza la arroba "@", ejemplo -> @productos = ("ropa", "calzado");, los elementos van entre paréntesis y cada elemento separado por comas, también hay que tener en cuenta que para acceder a un elemento del Array se utiliza el tipo de dato de escalar, es decir, se interpreta a modo de variable indicando el número index, por ejemplo -> print $productos[1];, que devolvería "calzado". También reseñar que una lista puede albergar cualquier tipo de datos, ya sea un número entero, un string, ..., ejemplo -> @varios = ("cero", 1, "dos", 3);

Los Arrays multidimensionales permiten albergar otros arrays en un array, este procedimiento necesitan ir escalando a través de la indexación de cada uno de los Arrays empezando por el principal, por ejemplo -> @multi = (["hola", "adios"], [23, 50, 70, 49]);, para acceder por ejemplo al número 50 del segundo array -> $multi[1][1];

Ejemplo:

#lista
print "****LISTAS**** \n";
@numeros = (0, 1, 2, 3, 4, 5);
print @numeros;

#acceder a un elemento de la lista
print "\n Acceder a un numero de la lista ... ";
print $numeros[2];

#lista multidimensional
@multidimensional = ([0,1],["cero", "uno"]);
print "\n Array multidimensional ... ";
print $multidimensional[0][1];
print $multidimensional[1][1];

Arrays - Hashes(listas asociativas)

Las listas asociativas permiten asociar el valor de un elemento a una referencia o clave, este tipo de arrays se declaran mediante el signo del tanto por ciento "%", por ejemplo -> %asociativo = ("uno" => 1, "dos" => 2);, para extraer un elemento se utiliza la referencia, por ejemplo para extraer el número 2 -> print $asociativo{"dos"}.

Ejemplo:

#listas asociativas
print "****LISTAS ASOCIATIVAS**** \n";
%numeros = ("uno" => 1, "dos" => 2);
print %numeros;

#acceder a un elemento de la lista asociativa
print "\n Acceder a un numero de la lista asociativa ... ";
print $numeros{"dos"};

OPERADORES EN PERL

Operadores aritméticos

Signo	Acción
+	Sumas
-	Restas
*	Multiplicación
**	Exponenciación
/	División
%	Resto
.	Concatenación de cadenas de texto
x	Repetición de caracteres

Ejemplo:

#Operadores aritmeticos

my $numero1 = 4;
my $numero2 = 2;

print "SUMA ... ";
print $numero1 + $numero2;
print "\n";

print "RESTA ... ";
print $numero1 - $numero2;
print "\n";

print "MULTIPLICACION ... ";
print $numero1 * $numero2;
print "\n";

print "EXPONENCIACION ... ";
print $numero1 ** $numero2;
print "\n";

print "DIVISION ... ";
print $numero1 / $numero2;
print "\n";

print "RESTO ... ";
print $numero1 % $numero2;
print "\n";

print "CONCATENACION ... ";
print $numero1 . $numero2;
print "\n";

print "REPETICION DE CARACTER ... ";
print $numero1 x $numero2;
print "\n";

Operadores relacionales

Operador relacional	Numérico	Cadena de caracteres
Igualdad	==	eq
Diferencia	!=	ne
Inferior	<	lt
Superior	>	gt
Inferior o igual	<=	le
Superior o igual	>=	ge

Ejemplo:

#Operadores relacionales

my $numero1 = 4;
my $numero2 = 2;

print "IGUALDAD == ... ";

if ($numero1 == $numero2)
{
print "Los numeros $numero1 y $numero2 son iguales \n";
}
else
{
print "Los numeros $numero1 y $numero2 no son iguales \n";
}

print "Otra forma de hacerlo mediante eq ";
if ($numero1 eq $numero2)
{
print "Los numeros $numero1 y $numero2 son iguales \n";
}
else
{
print "Los numeros $numero1 y $numero2 no son iguales \n";
}

Otro operadores muy útiles y que sirven para encontrar patrones dentro de una cadena de texto son los siguientes ...

Signo	Acción
=~	Si el patrón es encontrado
!~	Si el patrón no es encontrado

Ejemplo:

$texto = "hola";
if ($texto =~ /la/)
{
print "El patron 'la' ha sido encontrado en $texto";
}
else
{
print "El patron 'la' no ha sido encontrado en $texto";
}

Operadores lógicos

Signo	Acción
&&	AND
\|\|	OR
!	NOT

Ejemplo:

my $numero1 = 2;
my $numero2 = 4;

#AND
if ($numero1 eq 2 && $numero2 eq 4)
{
print "Ejercicio AND ... Los numeros coinciden \n";
}
else
{
print "Ejercicio AND ... Los numeros no coinciden \n";
}

#OR
if ($numero1 == 2 || $numero2 == 20)
{
print "Ejercicio OR ... se encontro al menos una igualdad \n";
}
else
{
print "Ejercicio OR ... no se encontro igualdad \n";
}

#NOT 
if (!($numero1 > $numero2))
{
print "El $numero1 no es mayor que el $numero2 \n";
}
else
{
print "El $numero1 es mayor que el $numero2 \n";
}

Operador de selección

Este es un operador triario que permite hacer una cosa u otra dependiendo de la condición dada, se puede describir como el equivalente a una condicional simple con las sentencias if else, sintaxis -> condicion ? accion1 : accion2

Ejemplo:

my $numero1 = 1;
my $numero2 = 2;
$numero1>$numero2 ? print "$numero1 Es mayor" : print "$numerador1 Es menor";

Símbolos de puntuación

Los símbolos de puntuación también son considerados como operadores en Perl ...

Comillas simples '' - no hace sustituciones
Comillas dobles "" - si hace sustituciones
Delimitación para expresiones regulares //

Ejemplo:

$variable = 1000;
print "Comillas dobles: $variable \n";
print 'Comillas simples: $variable \n';

Con las comillas dobles $variable es sustituido por su valor, es decir 1000, con comillas simples no es tomado en cuenta el valor.

Control de flujo

Perl tiene una serie de estructuras de control de flujo, el control de flujo permite realizar acciones cuando se dá una determinada condición, sin el control de flujo la aplicación se ejecuta de modo lineal, es decir de arriba a abajo, gracias al control de flujo se pueden controlar determinadas acciones necesarias, que hacen que un programa sea dinámico.

Estructuras de control de flujo en Perl:

if

La sentencia if es una estructura que permite determinar si la condición es verdadera o falsa, para ello se utilizan instrucciones para cada condición dada, en Perl al igual que en otros lenguajes de alto rendimiento se dá la posibilidad de encadenar condiciones a través de elsif, finalizando con else si ninguna de la condiciones dadas es cierta.

#if elsif else

$numero1 = 1;
$numero2 = 2;

if ($numero1 == $numero2)
{
print "El $numero1 es igual que $numero2";
}
elsif ($numero1 > $numero2)
{
print "El $numero1 es mayor que $numero2";
}
elsif ($numero1 < $numero2)
{
print "El $numero1 es menor que $numero2";
}
else
{
print "Error";
}

while

while es una estructura de control cuyo misión es realizar un búcle determinado por la condición dada. Este tipo de búcles tienen que tener un delimitador y una variable incrementable o decrementable -> $variable++; o $variable--;, de lo contrario se convierte en un búcle infinito.

#while
my $x = 0; #autoincrementable
my $limite = 9; #delimitador

while ($x <= $limite)
{
print "$x \n";
$x++;
}

Para detener el búcle condicionado por una sentencia condicional se utiliza la palabra reservada last, es el equivalente a break en PHP.

Ejemplo:

#while last -> detener el bucle
my $x = 9;
my $limite = 0;

while ($x >= $limite)
{
print "$x \n";
if ($x == 5)
{
last;
}
$x--;
}

do while

do while es una estructura de control muy semejante a while, prácticamente su función y el resultado conseguido es el mismo, la estructura básica es la siguiente -> do{instrucciones} while(condición);

Ejemplo:

#do while

my $pasos = 0;
my @elementos = ("cero", "uno", "dos", "tres", "cuatro", "cinco", "seis", "siete", "ocho", "nueve");

do
{
print $elementos[$pasos]."\n";
$pasos++;
}
while
($pasos <= @elementos);

for

for permite ejecutar búcles, estructura -> for(inicio, condición, incremento ++ | decremento --){instrucciones}

Ejemplo:

#for
my @elementos = ("cero", "uno", "dos", "tres", "cuatro", "cinco", "seis", "siete", "ocho", "nueve");

for ($x = 0; $x < @elementos; $x++)
{
print $elementos[$x]."\n";
}

foreach

foreach permite recorrer los elementos de un array, estructura -> foreach $elemento (@elementos {instrucciones}

#foreach
my @elementos = ("cero", "uno", "dos", "tres", "cuatro", "cinco");
foreach $elemento (@elementos)
{
print $elemento."\n";
}

Funciones

Las funciones son partes de código reservadas para realizar una tarea en concreto, es decir, un función es un nombre con una serie de instrucciones que posteriormente pueden ser llamadas en una o varias partes del script, las funciones permiten simplificar, ordenar y contraer el número de líneas de código necesarias para determinadas acciones que pueden ser repetitivas.

Para construir funciones en Perl se utiliza la palabra reservada sub seguido del nombre de la función, ejemplo -> sub mi_funcion{#instrucciones};, en Perl los parámetros se declaran dentro de las llaves de la función, ejemplo -> local($parametro1, $parametro2) = @_;, @_ recibe los argumentos que posteriormente podrán ser utilizados al llamar la función -> mi_funcion("hola", "mundo");, en las funciones es de uso común la palabra reservada return;, esto retorna el valor de la acción realizada dentro de la función.

Ejemplo de función simple ...

#funcion simple
sub texto
{
return "Hola Mundo \n";
}
print texto();

Ejemplo de función con parámetro ...

#funcion con parametro
sub con_parametro
{
local($cadena) = @_;
return $cadena;
}
print con_parametro("Hola Mundo \n");

Ejemplo de función con parámetro opcional ...

#funcion con parametro opcional
sub con_parametro_opcional
{
local($cadena, $opcional) = @_;
if (!defined($opcional))
{
$opcional = "predeterminado \n";
}
return $cadena . " " . $opcional;
}
print con_parametro_opcional("Hola");
print con_parametro_opcional("Hola", "Mundo");

Ejemplo de función con opciones ...

#funcion con opciones
sub con_opciones
{
    $imprime = "";
    %args=@_;
    %defaults=("color" => "rojo", "altura" => 100);
    foreach (keys %defaults) {
        defined ($args{$_})  || {$args{$_}= $defaults{$_}} ;
        $imprime .= "\n".$_ ." - ".$args{$_};
    }
 return $imprime;
}
print con_opciones("color" => "verde");

Como se puede observar en los ejemplo, las funciones abren un abanico amplio de posibilidades y creo que cada uno de los ejemplos son una buena base para crear funciones más complejas.

Perl Orientado a Objetos

La Programación Orientada a Objetos también es posible en el Lenguaje Perl, para su construcción se hace a través de la extensión ".pm", generalmente llamados módulos o clases, cada nueva clase se crea a través de un nombre con la palabra reservada "package", toda clase u objeto necesita de un método constructor, generalmente llamado new aunque puede ser otro nombre, el cual contiene la referencia al objeto creado así como las variables de instancias que podrán o no ser manipuladas a través de los métodos de la clase.

En el siguiente ejemplo, puedes ver una demostración de la creación de una clase llamada "Coche", esta clase tiene 4 variables de instancia, aunque sólo 3 de ellas pueden ser modificadas, ya que todos los coches tienes 4 ruedas, sin embargo el color, velocidad y puertas si pueden ser cambiados a través de sus métodos, si no se decide cambiarlos se mantendrán los valores por defecto, que contienen el método constructor.

Para ello primero creamos el objeto que guardarás con extensión ".pm" -> "Coche.pm" ...

Coche.pm

package Coche;
#El modulo strict genera errores, es decir, asegura de que la escritura de codigo es llevada a cabo correctamente
use strict; 

#Se inicializa el constructor de referencia del objeto, generalmente se hace con la palabra 'new'
sub new{
    my $this=shift; #Cogemos la clase que somos o una referencia a la clase (si soy un objeto)
    my $class = ref($this) || $this; #Averiguo la clase a la que pertenezco

    my $self={}; #Inicializamos la tabla hash que contendrá las variables de instancia
    $self->{COLOR} = "rojo"; #color predeterminado  
    $self->{RUEDAS} = 4;   #numero de ruedas, valor fijo
 $self->{VELOCIDAD_MAXIMA} = 240; #velocidad predeterminada
 $self->{PUERTAS} = 5; #numero de puertas predeterminado

    bless $self, $class; #Se crea la clase
    return ($self); #Devolvemos la clase recién construida
}


#METODOS DE LA CLASE

#COLOR DEL COCHE
sub color
{
#Recibe el parametro por default de la clase
my $self=shift;
#Si se indica el color como parametro mostrarlo de lo contrario mantener el default
$self->{COLOR} = shift if (@_);
return $self->{COLOR};
}

#RUEDAS DEL COCHE, no acepta parametros ya que todos los coches tienes 4 ruedas
sub ruedas
{
#Recibe el parametro por default de la clase
my $self=shift;
return $self->{RUEDAS};
}

#VELOCIDAD MAXIMA
sub velocidad_maxima
{
#Recibe el parametro por default de la clase
my $self=shift;
#Si se indica la velocidad como parametro mostrarlo de lo contrario mantener el default
$self->{VELOCIDAD} = shift if (@_);
return $self->{VELOCIDAD};
}

#PUERTAS
sub puertas
{
#Recibe el parametro por default de la clase
my $self=shift;
$self->{PUERTAS} = shift if (@_);
return $self->{PUERTAS};
}

#Esto es imprescindible para indicar la finalizacion de la clase
#Fin
1;

A continuación creamos un archivo en la misma carpeta donde has guardado la clase, a este archivo lo puedes llamar "index.pl".

index.pl

#Importamos el modulo o clase
use Coche;

my $coche=Coche::new("Coche");
#para inicializar la clase tambien se puede hacer de la siguiente forma
#my $coche=Coche->new();

$color = $coche->color("Verde");
$ruedas = $coche->ruedas;
$velocidad_maxima = $coche->velocidad_maxima(280);
$puertas = $coche->puertas(3);

print "Caracteristicas del coche ... \n";
print "Color: $color \n";
print "Ruedas: $ruedas \n";
print "Velocidad maxima: $velocidad_maxima k/h \n";
print "Puertas: $puertas \n";

Si ejecutas el archivo index.pl podrás ver como hemos llamado a la clase e indicado nuevas características o propiedades, menos el número de ruedas como ya se comentó anteriormente ...

Como se puede ver, es cuestión de seguir unas pautas sencillas para la creación de nuevos módulos. Perl contiene muchos módulos integrados que simplemente con la palabra reservada "use" los podemos importar a los proyectos, hay módulos para cualquier tarea o acción que se deseé realizar, también existe la posibilidad de instalar nuevos módulos a través de "cpan", aunque esto lo veremos más adelante.

Herencia

La Herencia es en cierto modo una subclase que hereda las cualidades de una clase, por ejemplo, anteriormente creamos una clase llamada Coche, a partir de esta clase, podemos crear una subclase que herede las propiedades de la clase Coche y de paso añadirle nuevas propiedades y métodos.

Supongamos que queremos crear una clase para indicar el precio de un coche y que para ello necesitemos saber el color, velocidad y número de puertas del vehículo, en lugar de construir una nueva clase desde cero con todas estas propiedades, como ya tenemos una clase llamada Coche, únicamente la importamos a una nueva subclase.

Para realizar la herencia se utiliza un Array llamado "@ISA", que puede contener tantas herencias como se necesiten, si sólo hereda una clase se le llama herencia simple y si hay más de una herencia es llamado herencia múltiple.

En el siguiente ejemplo crearemos una nueva subclase llamada "PrecioCoche" que heredará la clase "Coche", el valor del coche será determinado según la velocidad máxima que pueda alcanzar ...

PrecioCoche.pm

package PrecioCoche;
#Agregamos la herencia a la nueva subclase PrecioCoche
use Coche;
@ISA = qw(Coche);

use strict;

#Creamos el constructor
sub new
{
my $this=shift; #Cogemos la clase que somos o una referencia a la clase (si soy un objeto)
my $class = ref($this) || $this; #Averiguo la clase a la que pertenezco
     my $self=$class->Coche::new("Coche"); #Inicializamos las propiedades con las usadas en Coche
     $self->{PRECIO} = undef; #No se indica ningun precio
     bless $self, $class; #Se crea la clase
     return ($self); #Devolvemos la clase recién construida
}

sub precio
{
    my $self=shift; #El primer parámetro de un metodo es la  clase

 #Determinamos el precio segun la velocidad del coche
    if ($self->{VELOCIDAD_MAXIMA} <= 160)
    {
    $self->{PRECIO} = 6000;
    }
    elsif ($self->{VELOCIDAD_MAXIMA} > 160 && $self->{VELOCIDAD_MAXIMA} <= 220)
    {
    $self->{PRECIO} = 12000;
    }
    elsif ($self->{VELOCIDAD_MAXIMA} > 220)
    {
    $self->{PRECIO} = 18000;
    }
    else
    {
    $self->{PRECIO} = "Ha ocurrido un error \n"; 
    }
    
       #Devolvemos el precio
       return $self->{PRECIO};
}
#Muy importante
#Fin del modulo
1;

Ahora hacemos uso de la nueva subclase, crea un archivo llamado "precio.pl" ...

precio.pl

use PrecioCoche;

my $coche=PrecioCoche::new("PrecioCoche");
#para inicializar la clase tambien se puede hacer de la siguiente forma
#my $coche=PrecioCoche->new();

$color = $coche->color("Verde");
$ruedas = $coche->ruedas;
$velocidad_maxima = $coche->velocidad_maxima(280);
$puertas = $coche->puertas(3);
$precio = $coche->precio;

print "Caracteristicas del coche ... \n";
print "Color: $color \n";
print "Ruedas: $ruedas \n";
print "Velocidad maxima: $velocidad_maxima k/h \n";
print "Puertas: $puertas \n";
print "Precio: $precio \n";

Creo que los ejemplos son sencillos de comprender y pueden servir de base para crear clases y subclases más avanzadas.

Funciones útiles de Perl

A continuación podrás ver una serie de funciones que vienen integradas en Perl, útiles para el tratamiento de strings, matemáticas y listas.

Funciones de Strings y Listas

chomp, chop, chr, crypt, index, lc, lcfirst, length, rindex, substr, uc, ucfirst

chomp: Elimina los saltos de línea -> \n.

my @cadena = ("Hola Mundo \n", "Hola Mundo \n", "Hola Mundo \n");
#devuelve un numero con el numero de saltos de linea eliminados
print "Numero de saltos de linea eliminados: " . chomp(@cadena); 
print "\n";
#Devuelve los elementos del array sin saltos de linea
print @cadena; 
#regresa: Numero de saltos de linea eliminados: 3
#regresa: Hola Mundo Hola Mundo Hola Mundo

chop: Elimina el último carácter de la cadena.

my $cadena = "Eliminar el ultimo caracter de la cadena";
#devuelve el caracter eliminado
print "Ultimo caracter eliminado: " . chop($cadena);
print "\n";
#muestra el string, ya sin el caracter eliminado
print $cadena;
#regresa: Ultimo caracter eliminado: a
#regresa: Eliminar el ultimo caracter de la caden

chr: Devuelve el carácter representado de la tabla ASCII, a través del número indicado.

$ascii = 49;
print chr($ascii);
#regresa 1

crypt: Encripta la cadena pasada por el primer parámetro, a través de los caracteres dados en el segundo.

$password = "password";
print "Password encriptado: " . crypt($password, "0123456789");

index: Devuelve la posición de la primera ocurrencia del substring, la posición inicial es 0, si el substring no es encontrado devuelve -1.

$cadena = "Buscando la posicion de la palabra perl";
print index($cadena, "perl", 0);
#regresa: 35

lc: Regresa el string seleccionado en minúsculas.

$cadena = "APRENDIENDO PERL";
print lc($cadena);
#regresa: aprendiendo perl

lcfirst: Regresa el primer carácter del string convertido en minúscula.

$cadena = "APRENDIENDO PERL";
print lcfirst($cadena);
#regresa: aPRENDIENDO PERL

length: Regresa la longitud total del string seleccionado.

$cadena = "Longitud de esta cadena de texto";
print length($cadena);
#regresa: 32

rindex: Devuelve la posición de la última ocurrencia del substring, la posición inicial si no se indica nada empieza al final de la cadena, si el substring no es encontrado devuelve -1.

$cadena = "perl perl perl perl";
print rindex($cadena, "perl");
#regresa: 15

substr: Regresa el substring a través de las coordenadas inicio, final, si es negativo la extracción se realiza de derecha a izquierda.

#substr($string, inicio, final);
$cadena = "Buscando un substring";
print substr($cadena, -9, 9);
#regresa: substring

uc: Devuelve el string convertido en mayúsculas.

$cadena = "aprendiendo perl";
print uc($cadena);
#regresa: APRENDIENDO PERL

ucfirst: Regresa la primera letra de la cadena en mayúsculas.

$cadena = "aprendiendo perl";
print ucfirst($cadena);
#regresa: Aprendiendo perl

Funciones de Arrays

grep, join, pop, push, reverse, scalar, shift, sort, split, unshift

grep: busca mediante una expresión regular posibles coincidencias entre los elementos de un array

@elementos = ("perro", "casa", "puerro", "puerta");
print grep(/rro/, @elementos);
#regresa: perropuerro

join: Útil para separar mediante un determinado carácter los elementos de un array.

@elementos = ("separados", "por", "comas", "a", "traves", "de", "join");
print join(", ", @elementos);
#regresa: separados, por, comas, a, traves, de, join

pop: Extrae el último elemento de un array, este elemento deja de formar parte del array.

@elementos = ("uno", "dos", "tres");
print pop(@elementos); #regresa tres
print "\n";
print @elementos; #regresa uno dos

push: Permite añadir nuevos elementos a final de un array, bien puede ser un escalar o un array.

@elementos1 = ("uno", "dos", "tres");
@elementos2 = ("cuatro", "cinco");
push(@elementos1, @elementos2);
print @elementos1;
#regresa: uno dos tres cuatro cinco

reverse: revierte la posición de los elementos del array seleccionado.

@elementos = (9, 8, 7, 6, 5, 4, 3, 2, 1);
print reverse(@elementos);
#regresa: 123456789

scalar: devuelve el número total de elementos de un array.

@elementos = ("uno", "dos", "tres");
print scalar(@elementos);
#regresa: 3

shift: Extrae el primer elemento de un array, este elemento deja de formar parte del array.

@elementos = ("uno", "dos", "tres");
print shift(@elementos); #regresa uno
print "\n";
print @elementos; #regresa: dos tres

sort: ordena los elementos de un array de menor a mayor alfabéticamente.

@elementos = ("zorro", "casa", "resto", "barca", "coche", "alto");
print sort(@elementos);
#regresa: alto barca casa coche resto zorro

split: Divide un string para convertirlo en un array, a partir del patrón indicado.

$cadena = "uno dos tres cuatro";
@nuevo_array = split(" ", $cadena);
print $nuevo_array[1];
#regresa: 2

unshift: Permite añadir nuevos elementos al principio de un array, bien puede ser un escalar o un array.

@elementos1 = ("tres", "cuatro", "cinco");
@elementos2 = ("uno", "dos");
unshift(@elementos1, @elementos2);
print @elementos1;
#regresa: uno dos tres cuatro cinco

Funciones Matemáticas

abs, atan2, cos, exp, int, log, rand, sin, sqrt, srand, time

abs: Devuelve el valor absoluto del argumento número, si seleccionas 1 devuelve 1, si es un numero negativo lo regresa positivo, es decir -1 = 1

$numero = -100;
print abs($numero);
#regresa 100

atan2:Esta función devuelve la tangente inversa de las coordenadas especificadas por los argumentos coord_x y coord_y. El valor devuelto por la función es un ángulo. El resultado viene dado en radianes.

$coord_x = 30;
$coord_y = 20;
print atan2($coord_y, $coord_x);
#regresa 0.982793723247329

cos: Esta función calcula el coseno del argumento número.

$numero = 20;
print cos($numero);
#regresa 0.408082061813392

exp: El resultado de esta función es el número e elevado a la potencia indicada en el argumento. e**2

$numero = 12;
print exp($numero);
#regresa 162754.791419004

int: Convierte el número dado, en un número entero. $numero = 13.3; print int($numero); #regresa 13

log: Calcula el logaritmo natural del valor. Esta es la inversa de la función exp. $numero = 12; print log($numero); #regresa 2.484906649788

rand: Devuelve un número real aleatorio entre 0 y la expresión pasada. Si no se pasa ningún valor, se asume 1 y un valor entre 0 y 1 se devuelve. $rand = rand(999999999999999); print $rand;

sin: Se devuelve el seno en radianes. $numero = 222; print sin($numero); #devuelve 0.868950838216349

sqrt: Devuelve la raíz cuadrada del valor. $numero = 4; print sqrt($numero); #devuelve 2

srand: Establece el valor de inicialización para el generador de números aleatorios a expr o a un valor aleatorio basado en el tiempo, ID de proceso, y otros valores si se omite expr. srand(12); print rand(); #devuelve 0.002349853515625 print "\n"; #mantenemos el mismo numero aleatorio, volviendo a llamar a srand() srand(12); print rand(); #devuelve 0.002349853515625

time: Devuelve el número de segundos desde el 1 de enero de 1970. print time() + 50; #devuelve el numero de segundos mas 50

Tratamiento de errores

En en Lenguaje Perl no existe por defecto el clásico try catch de otros lenguajes de programación, pero esto no significa que no se puedan capturar errores y evitar que la ejecución del programa se vea interrumpida, para ello su utiliza la sentencia eval{sentencias a evaluar}, En el tiempo de ejecución, si el motor Perl encuentra un error en una sentencia del bloque eval, omite el resto del bloque eval y establece con la variable especial de eval -> "$@" el texto de error correspondiente, sin detener la ejecución del programa.

En el siguiente ejemplo, puedes ver un modo de controlar la división por zero, en ningún momento la ejecución del programa se ve interrumpida, puedes probarlo introduciendo como primer número 12 y como segundo 0, es decir, 12/0

#TRATAMIENTOS DE ERRORES EN PERL - eval{}
#prueba a dividir por 0 para ver el resultado

#Función para establecer una división entre dos números
sub division{
local($a, $b) = @_;
return $a / $b;
}

#Función que inicia el programa
sub init{
print "\n \n Prueba de error, division por ZERO ... \n \n";
print "Introduce un numero ... ";
$num_1 = <STDIN>;
print "Introduce otro numero ... ";
$num_2 = <STDIN>;
#Preparamos la excepción mediante eval
$resultado = eval{division($num_1, $num_2)};
if($@)
{
print "\n \n Lo siento ha ocurrido un error, empezamos de nuevo ... ! \n \n";
init();
}
else
{
print "El resultado de la division es ... " . $resultado;
}
}
#inicia el programa
init();

Tratamiento de archivos

En esta ocasión veremos como tratar archivos con perl. Para abrir un archivo se utiliza la función open, en su primer parametro va un nombre o filehandle con el cual podremos acceder a la información del archivo, en el segundo parámetro se indica la ruta. Para el tratamiento de archivos existe una serie de comandos que permiten indicar el tipo de permisos con el que accederemos al archivo ...

Entidad	Definición
< or r	Sólo lectura
> or w	Crear, escritura y eliminar todo el contenido anterior
>> or a	Escritura al final de fichero y crear si no existe
+< or r+	Lectura y escritura
+> or w+	Lectura, escritura, Crear si no existe y eliminar todo el contenido anterior
+>> or a+	Lectura, escritura al final del fichero y eliminar todo el contenido anterior

En el siguiente ejemplo verás como crear un archivo, añadirle contenido y leerlo ...

#si utilizas '>>' abre el archivo o lo crea si no existe, si el archivo existe no elimina el contenido 
#que tenía anteriormente, añade el nuevo contenido al final del fichero.

#si utilizas '+>' abre el archivo o lo crea si no existe, si el archivo existe restaura el contenido con 
#el nuevo contenido añadido, eliminando el anterior, añade el nuevo contenido al final del fichero.

#puedes probar cambiando los permisos de >> a +> para ver los resultados.

#Si no existe crea un archivo llamado prueba.
open(ARCHIVO, ">> prueba.txt");

$escribe = "Estoy escribiendo en el archivo prueba \n";

print ARCHIVO $escribe;

$escribe = "estoy escribiendo otra vez \n";

#añade una nueva línea al final del fichero
print ARCHIVO $escribe;

#cierra el fichero
close(ARCHIVO);

#Lectura del archivo
#Para la lectura del archivo puedes utilizar tanto < como ningún argumento, es de sólo lectura.
open(ARCHIVO, "< prueba.txt");

$total_de_lineas=0;

print "::::::::::::::::::::CONTENIDO DEL ARCHIVO::::::::::::::::::::\n";
while(<ARCHIVO>)
{
#Imprime cada nueva línea
print $_;
$total_de_lineas++;
}
print "::::::::::::::::::::CONTENIDO DEL ARCHIVO::::::::::::::::::::\n";
#imprime el total de líneas del fichero
print "El total de lineas del archivo es: " . $total_de_lineas;

#cierra el archivo
close(ARCHIVO);

Instalación de módulos con CPAN

CPAN es un programa desarrollado exclusivamente para Perl, el cual se conecta a la web www.cpan.org, donde se encuentran almacenados miles de módulos creados por la Comunidad Perl, la instalación de nuevos módulos puede llevarse a cabo manualmente, pero ésto puede ser tedioso, ya que un módulo puede depender de otro y puede acabar complicando la correcta instalación, desde CPAN, sin embargo, la instalación de un módulo, lleva consigo la instalación de los otros módulos necesarios, facilitando la correcta instalación. Existen una infinidad de módulos tanto para bases de datos, matématicas avanzadas, gráficos, conexiones http avanzadas, ...

Para iniciar CPAN es suficiente con escribir en la consola el comando cpan, para instalar un módulo puedes entrar en la web de www.cpan.org y rastrear entre una gran cantidad de módulos, para su instalación simplemente inicias cpan y posteriormente añades install seguido del nombre del módulo a instalar, por ejemplo ...

cpan> install WWW::Mechanize

Para ver las distintas opciones de ayuda de cpan, incluyes el signo de interrogación "?" ...

cpan> ?

También existe la posibilidad de actualizar todos los módulos mediante el comando "-r" ...

cpan> -r

Otro aspecto importante es saber que módulos hay instalados en Perl, en Windows puedes abrir el fichero "DISTRIBUTIONS.txt", que se encuentra entre la carpeta base de perl(strawberry y activestate) ...

También se puede hacer a través del módulo ExtUtils::Installed, que proporciona los métodos necesarios para saber los módulos instalados en Perl, para ello crear un nuevo archivo perl y añade el siguiente código ...

use strict;
use ExtUtils::Installed;

my $instmod = ExtUtils::Installed->new();

foreach my $module ($instmod->modules()) 
{
   my $version = $instmod->version($module) || "???";
   print "$module $version\n";
 }

Al ejecutarlo te listará todos los módulos ...

Conexión http con el módulo LWP::Simple

En este ejemplo vamos a realizar una conexión simple http mediante una de las clases que vienen integradas en la librería LWP, concretamente la clase Simple, mediante esta clase y sus métodos get y head realizaremos una petición http para recibir tanto el cuerpo HTML, como las CABECERAS de la web solicitada. Para obtener más información sobre este módulo puedes ir a la siguiente url -> http://search.cpan.org/~gaas/libwww-perl-6.05/lib/LWP/Simple.pm, el siguiente programa necesitará de un parámetro que es la url para poder realizar la petición -> perl http-simple.pl http://www.google.com

http-simple.pl

#Conexión http simple
use LWP::Simple;
use strict;

#Entrada de la url
my $url = $ARGV[0];

if (!@ARGV)
{
print "Deber indicar una url ejemplo -> http-simple.pl http://www.google.com \n";
}
else
{
#Conecta con la url recorriendo todo el cuerpo html
my $html = get($url);

#Regresa el contenido html de la web
print $html;

print "\n \n";

#Conecta con la url regresando las cabeceras http
my ($content_type, $document_length, $modified_time, $expires, $server) = head($url);

#regresa las cabeceras de la web
print "content-type: $content_type\n";
print "document-length: $document_length\n";
print "modified-time: $modified_time\n";
print "expires: $expires\n";
print "server: $server\n";
}

Conexiones http avanzadas con el módulo Mechanize

Mechanize es el módulo más completo de Perl para interactuar vía http con websites, este módulo tiene múltiples funciones, desde enviar formularios vía get y post, a la posibilidad de establecer parámetros de búsqueda dentro del cuerpo html de la web solicitada y de este modo obtener información como cabeceras, links, imágenes, formularios, etc ..., el problema es que mechanize no viene instalado en Perl por defecto, por lo tanto hay que hacerlo a través de CPAN ...

cpan> install WWW::Mechanize

La instalación puede tardar unos cinco minutos, pero merece la pena, ya que como podrás ver en los siguientes ejemplos se le puede sacar mucho partido, también puedes investigar un poco más sobre este módulo en el siguiente link ...

http://search.cpan.org/~ether/WWW-Mechanize-1.73/lib/WWW/Mechanize.pm

En el primer ejemplo se muestra como enviar un formulario con sus respectivos campos y valores y mostrar por la consola la respuesta del servidor ...

mechanize-form.pl

#mechanize-form.pl
#Enviar formulario con Mechanize
use WWW::Mechanize;
use strict;

my $url = "http://www.web.com/index.php";

#Crear un nuevo objeto mechanize
my $mechanize = WWW::Mechanize->new();

#Url de destino
$mechanize -> get($url);

#Se preparan los datos a enviar en el formulario
$mechanize -> submit_form(
#Además de form_id, puedes utilizar form_number y form_name
form_id => "form_sesion", 
#Rellena cada uno de los campos del formulario con su respectivo valor ...
fields => {admin => "admin", password => "password"}
);

#Almacenamos en esta variable el contenido devuelto por la petición
my $contenido = $mechanize -> content();

#Se imprime el contenido
print $contenido;

Este otro ejemplo extrae la url tanto de imágenes como de links, simplemente hay que indicar la url, la opción que se desea images o links y opcionalmente si se quiere guardar el resultado en un fichero.

mechanize-find.pl

#mechanize-find.pl
#Buscar la url de imágenes y links con Mechanize
#opción de guardar los resultado en un fichero
use WWW::Mechanize;
use strict;

#parametros
my $url = $ARGV[0];
my $tipo = $ARGV[1];
my $fichero = $ARGV[2];

if (!@ARGV || $tipo != "images" || $tipo != "links")
{
print "\n\n Introduce correctamente los datos ... mechanize-find.pl http://www.web.com/ images|links opcional[fichero txt] \n\n";
}
else
{
#Crear un nuevo objeto mechanize
my $mechanize = WWW::Mechanize->new();

#Url de destino
$mechanize -> get($url);

#Se busca el tipo que puede ser imágenes o links
my @elementos = $mechanize -> $tipo;

my $elemento;
my $resultado;

for $elemento (@elementos)
{
#Se recorre cada uno de los elementos y se almacenan en una variable
$resultado .= $elemento->url . "\n";
}

#Si se indica un fichero se crea el fichero y se guarda el resultado
if ($fichero)
{
open(ARCHIVO, "+> $fichero");
print ARCHIVO $resultado;
close(ARCHIVO);
}

#Se imprime el resultado en la consola
print $resultado;
}

Conexión a base de datos Mysql con el Módulo DBI

DBI es el módulo de interfaz de base de datos estándar de Perl. Se define un conjunto de métodos, variables y convenciones que proporcionan una interfaz de base de datos consistente independiente de la base de datos real que se utiliza. Para este caso utilizaremos una base de datos Mysql, veremos como establecer una conexión a una base de datos y ejecutar consultas mediante los métodos que proporciona el Módulo DBI ...

Primeramente veremos como establecer la conexión y crear una tabla si no existe, esta tabla se llamará 'usuarios', la cual nos servirá para trabajar con el resto de ejemplos.

crear-tabla.pl

#crear-tabla.pl
#Crear tabla
use DBI;
use strict;

my $admin = "root";
my $password = "password";
my $base_de_datos = "base_de_datos";
my $servidor = "localhost";

#Se establece la conexión a la base de datos mysql
my $mysql = DBI -> connect("DBI:mysql:$base_de_datos;host=$servidor", $admin, $password) || die "Error al conectar con la base de datos: $DBI::errstr";

#Creamos una tabla llamada usuarios si no existe
my $consulta = $mysql->prepare("CREATE TABLE IF NOT EXISTS usuarios (id INT(11) PRIMARY KEY AUTO_INCREMENT, nombre VARCHAR(100), email VARCHAR(100))")
|| die "Error al crear la tabla: $DBI::errstr";
#Ejecuta la consulta
my $resultado = $consulta->execute();

if ($resultado)
{
print "\n\n Consulta llevada a cabo correctamente \n\n";
}
#Se cierra la conexión
$consulta->finish;
$mysql->disconnect;

Bien, ya tenemos una tabla en la que poder realizar consultas, el siguiente ejemplo muestra como insertar nuevos campos a través de la consola en la recien creada tabla 'usuarios'.

insertar-datos.pl

#insertar-datos.pl
#Insertar Datos
use DBI;
use strict;

print "\n\n****INSERTAR DATOS EN LA TABLA USUARIOS****\n\n";
#Para la entrada de datos
print "Introduce el nombre a guardar ... ";
my $nombre = <STDIN>;
print "Introduce el email a guardar ... ";
my $email = <STDIN>;

my $admin = "root";
my $password = "password";
my $base_de_datos = "base_de_datos";
my $servidor = "localhost";

#Se establece la conexión a la base de datos mysql
my $mysql = DBI -> connect("DBI:mysql:$base_de_datos;host=$servidor", $admin, $password) || die "Error al conectar con la base de datos: $DBI::errstr";

#Preparamos la consulta para insertar datos
my $consulta = $mysql->prepare("INSERT INTO usuarios(nombre, email) VALUES('$nombre', '$email')")
|| die "Error al insertar los datos: $DBI::errstr";
#Ejecuta la consulta
my $resultado = $consulta->execute();

if ($resultado)
{
print "\n\n Consulta llevada a cabo correctamente \n\n";
}
#Se cierra la conexión
$consulta->finish;
$mysql->disconnect;

Puedes insertar varios usuarios esto te servirá para el ejemplo siguiente, en el cual extraeremos todos los usuarios almacenados en la tabla ...

seleccionar-datos.pl

#seleccionar-datos.pl
#Seleccionar Datos
use DBI;
use strict;

print "\n\n****TODOS LOS USUARIOS DE LA TABLA****\n\n";

my $admin = "root";
my $password = "password";
my $base_de_datos = "base_de_datos";
my $servidor = "localhost";

#Se establece la conexión a la base de datos mysql
my $mysql = DBI -> connect("DBI:mysql:$base_de_datos;host=$servidor", $admin, $password) || die "Error al conectar con la base de datos: $DBI::errstr";

#Preparamos la consulta para seleccionar datos
my $consulta = $mysql->prepare("SELECT * FROM usuarios")
|| die "Error al seleccionar datos: $DBI::errstr";

#Se ejecuta la consulta
my $resultado = $consulta->execute();

#Se extraen los datos
my $fila;
while($fila = $consulta->fetchrow_hashref())
{

#Cada valor devuelto por el Array se almacena en una variable
my $nombre = $fila->{nombre};
my $email = $fila->{email};
my $id = $fila->{id};

#Esta parte es para eliminar posibles saltos de línea
$nombre =~ s/\n//g;
$email =~ s/\n//g;
$id =~ s/\n//g;

#Se imprime cada fila
print "Id:" . $id .  " --- " . "Nombre:". $nombre . " --- " . "Email:" . $email . "\n";
}

#Se cierra la conexión
$consulta->finish;
$mysql->disconnect;

Ahora veremos como actualizar una determinada fila a través de la consola de comandos ...

Actualizar Datos

#actualizar-datos.pl
#Actualizar Datos
use DBI;
use strict;

print "\n\n****PROGRAMA PARA ACTUALIZAR DATOS DE LA TABLA****\n\n";

my $admin = "root";
my $password = "password";
my $base_de_datos = "base_de_datos";
my $servidor = "localhost";

#Se establece la conexión a la base de datos mysql
my $mysql = DBI -> connect("DBI:mysql:$base_de_datos;host=$servidor", $admin, $password) || die "Error al conectar con la base de datos: $DBI::errstr";

#Preparamos la consulta para seleccionar datos y tener una vista previa
my $consulta = $mysql->prepare("SELECT * FROM usuarios")
|| die "Error al seleccionar datos: $DBI::errstr";

#Se ejecuta la consulta
my $resultado = $consulta->execute();

#Se extraen los datos
my $fila;
while($fila = $consulta->fetchrow_hashref())
{

#Cada valor devuelto por el Array se almacena en una variable
my $nombre = $fila->{nombre};
my $email = $fila->{email};
my $id = $fila->{id};

#Esta parte es para eliminar posibles saltos de línea
$nombre =~ s/\n//g;
$email =~ s/\n//g;
$id =~ s/\n//g;

#Se imprime cada fila
print "Id:" . $id .  " --- " . "Nombre:". $nombre . " --- " . "Email:" . $email . "\n";
}

# Ahora preparamos los datos de entrada
print "Indique el numero id de la fila que desea actualizar:";
my $id = <STDIN>;
print "Nuevo valor del campo nombre: ";
my $nombre = <STDIN>;
print "Nuevo valor del campo email: ";
my $email = <STDIN>;

#Preparamos la consulta para actualizar datos
my $consulta = $mysql->prepare("UPDATE usuarios SET nombre='$nombre', email='$email' WHERE id=$id")
|| die "Error al seleccionar datos: $DBI::errstr";
$resultado = $consulta -> execute();
if ($resultado)
{
print "\n\n Actualizacion correcta \n\n";
}

#Se cierra la conexión
$consulta->finish;
$mysql->disconnect;

Y finalmente veremos un ejemplo para eliminar filas de la tabla a través de la entrada de datos ...

eliminar-datos.pl

#eliminar-datos.pl
#Eliminar Datos
use DBI;
use strict;

print "\n\n****PROGRAMA PARA ELIMINAR DATOS DE LA TABLA****\n\n";

my $admin = "root";
my $password = "password";
my $base_de_datos = "base_de_datos";
my $servidor = "localhost";

#Se establece la conexión a la base de datos mysql
my $mysql = DBI -> connect("DBI:mysql:$base_de_datos;host=$servidor", $admin, $password) || die "Error al conectar con la base de datos: $DBI::errstr";

#Preparamos la consulta para seleccionar datos y tener una vista previa
my $consulta = $mysql->prepare("SELECT * FROM usuarios")
|| die "Error al seleccionar datos: $DBI::errstr";

#Se ejecuta la consulta
my $resultado = $consulta->execute();

#Se extraen los datos
my $fila;
while($fila = $consulta->fetchrow_hashref())
{

#Cada valor devuelto por el Array se almacena en una variable
my $nombre = $fila->{nombre};
my $email = $fila->{email};
my $id = $fila->{id};

#Esta parte es para eliminar posibles saltos de línea
$nombre =~ s/\n//g;
$email =~ s/\n//g;
$id =~ s/\n//g;

#Se imprime cada fila
print "Id:" . $id .  " --- " . "Nombre:". $nombre . " --- " . "Email:" . $email . "\n";
}

# Ahora preparamos los datos de entrada
print "Indique el numero id de la fila que desea eliminar:";
my $id = <STDIN>;

#Preparamos la consulta para eliminar la fila
my $consulta = $mysql->prepare("DELETE FROM usuarios WHERE id=$id")
|| die "Error al eliminar la fila: $DBI::errstr";
$resultado = $consulta -> execute();
if ($resultado)
{
print "\n\n Eliminacion correcta \n\n";
}

#Se cierra la conexión
$consulta->finish;
$mysql->disconnect;

jQuery Manual

lunes, 9 de septiembre de 2013