¡Ya estamos en Twitter!

Perl en Español
  1. Home
  2. Tutoriales
  3. Foro
  4. Artículos
  5. Donativos
  6. Publicidad

Tecnicas para generar y manipular sitios dinámicos desde Perl

por Perl User

Las tecnologías para generar y manipular contenido dinámico via Web se presentan en diversos sabores, en este tutorial se abordarán algunas de las tendencias actuales para generar y visualizar contenido dinámico via Web utilizando el lenguaje de programación Perl.
Es recomendable que el lector tenga fundamentos sobre la programación en Perl, así como el manejo básico de HTML, XML/XSLT, y YAML. Para los módulos a revisar en Perl, se recomienda la documentación en línea desde CPAN.

La primera parte del tutorial comprende una breve introducción sobre las necesidades de trabajar con dicha forma de contenido. La siguiente parte refleja una introducción sobre la representación de datos en el lenguaje de programación Perl. En la parte 3 se abordan diferentes formas de visualizar y presentar dichos datos, desde el uso de sistemas de plantillas, hasta la transformación de datos serializados.

Contenido


Introducción

Representación del contenido


Contenido estático
Llamaremos contenido estático a la representación de datos en un sitio Web, en el cúal dichos datos no serán modificados o reemplazados en el transcurso de la presentación de los mismos. Generalmente dichos datos son presentados en HTML directamente, o generados mediante un XML y transformados como documento estático en HTML.

El concepto anterior puede o no aplicarse en diferentes circunstancias, sin embargo, es un acercamiento a lo que el contenido estático nos ofrece de acuerdo a su naturaleza. Dicho contenido, solamente nos puede representar la información contenida en ese momento, y el cambiarlo, implica quizas volver a generar dicho documento. Mantener sitios grandes de esta manera puede ser un poco problemático y/o tedioso.


Contenido dinámico
Desde el nacimiento de CGI, y algunas otras tecnologías para representación de datos, la tendencia del web cambió, ahora, las compañías prefieren un sitio el cual está en constante cambio, y que a su vez, dicha tecnología les permita una sencilla manera de modificar dichos datos.

Así pues, el contenido dinámico como concepto es aquel en el cual un sitio representa datos desde una o varias vistas de acuerdo al contenido, y dicho contenido puede cambiar o ser reemplazado en cualquier instante.

Este tipo de contenido, nos permite una enorme flexibilidad, puesto que lo que nos conviene es la separación de la estructura del sitio, con los datos a presentar. El mantenimiento de éste no es complejo, sin embargo requiere de conocimiento sobre la tecnología a utilizar.



Representación de los datos


Estructuras de datos
Las estructuras de datos en perl se basan prácticamente en referencias a sus tipos de datos simples, es decir, referencias sobre escalares, arreglos y hashes ( también se incluyen subrutinas y typeglobs, pero en este tutorial no es necesario el uso de typeglobs ). Se recomienda una lectura mas profunda sobre el tema, el perldoc perldsc y Programming Perl[pperl] Capítulo 12 contiene bastante información al respecto.

Breve recordatorio de referencias
Una referencia sobre un tipo de dato la vamos a conceptualizar como la dirección donde están guardados los datos de dicha variable ( declarada o anónima ). Las referencias nos van a permitir crear estructuras de datos complejas las cuales no son posible implementar en tipos de datos simples. Una referencia tiene un valor escalar, por lo tanto, vamos a poder utilizar dichas referencias como escalares ( de aquí que, es posible utilizarlas en conjunto con tipos de datos simples).

Existen 3 tipos de referencias, 2 de ellas las más utilizadas ( la tercera son ``softreferences'' las cuales quedan fuera del contexto de este tutorial ): referencias fuertes ( a alguna variable previamente declarada ) y referencias anónimas.

Para declarar una referencia fuerte a una variable existente tenemos la siguiente sintaxis:

$scalar = 4;
$scalar_ref = \$scalar;

@array = ( 1, 2, 3 );
$array_ref = \@array;

%hash = ( one => 1, dos => 2 );
$hash_ref = \%hash

sub foo { #Esta rutina hace 'algo' }
$code_ref = \&foo;

Las referencias anónimas se crean apartir de arreglos, hashes y subrutinas, utilizando los símbolos [], {} y sub{} respectivamente.

$hash_ref = { uno => 1, dos => 2 };

$array _ref =[ 1, 2, 3 ];

$code_ref = sub { ... };

Caso contrario de la creación de una referencia, es el hecho de poder desreferenciarla para poder acceder a dichos datos, esto lo hacemos de la siguiente manera:

$array_ref = [ 1, 2, ``tres'', ``cuatro'', 5 ];

print $$array_ref[1]; # Imprime el 2

print $$array_ref[3]; # Imprime el ``cuatro''

$hash_ref = { uno => 1, dos => 2, tres => 3 };

print $$hash_ref{uno}; #imprime 1;

$code_ref = sub { ``hello world\n'' };

print &$code_ref(); #Imprime 'hello world'

Limpiando un poco la notación de referencias
Es sencillo ver como podría irse ``horrificando'' la notación entre mas referencias anidadas tengamos, por ejemplo:

$array_ref = [1, 2, [ ``tres'', ``cuatro'', [ 6, ``foo'' ] ], 5 ];

print $$array_ref[2][2][1]; # Imprime ``foo''

$hash_ref = { uno => 1, dos => { tres => 3, cuatro => { seis => 6 } }, cinco => 5 };

print $$hash_ref{dos}{cuatro}{seis}; # Imprime 6

Utilizando la notación -> podemos limpiar un poquito esto, de tal manera que podremos saber quien es la referencia y que es lo que exactamente queremos desreferenciar, intentemos reescribir el ejemplo anterior:

$array_ref = [1, 2, [ ``tres'', ``cuatro'', [ 6, ``foo'' ] ], 5 ];

print $array->[2][2][1]; #Imprime ``foo''

$hash_ref = { uno => 1, dos => { tres => 3, cuatro => { seis => 6, siete => 7 } }, cinco => 5 };

print $hash_ref->{dos}{cuatro}{seis}; # Imprime 6

$code_ref = sub{ ``hello world\n'' };

print $code_ref->(); #Imprime 'Hello world'

Creación de estructuras de datos complejas
Veamos un ejemplo, en el cual es necesario el uso de referencias anidadas para poder representar la información sobre un libro de manera organizada:

$datos = {
titulo => 'Effective Perl Programming',
autores => [ 'Joseph N. Hall', 'Randal L . Schwartz' ],
edicion => '1ed',
editorial => {
nombre => 'Addison Wesley',
web => 'http://www.aw.com',
},
pub => 2002
};

La necesidad de crear referencias como esta, es para representar generalmente asociación de información/datos, según la referencia puede ser un tipo de asociación, de esta manera podremos ``clasificar'' las estructuras de la siguiente forma:

  • - Arreglo de arreglos
  • - Arreglo de hashes
  • - Hash de arreglos
  • - Hash de hashes
  • - Estructuras Mixtas

El tipo adoptado es de acuerdo a la necesidad que se quiere cubrir y el algoritmo a utilizar para acceder a los datos contenidos.

Veamos ahora otro ejemplo, con 3 registros de la misma índole:

@datos = ( {
titulo => 'Effective Perl Programming',
autores => [ 'Joseph N. Hall', 'Randal L . Schwartz' ],
edicion => '1ed',
editorial => {
nombre => 'Addison Wesley',
web => 'http://www.aw.com'
},
pub => 2002
},
{
titulo => 'Programming Perl',
autores => [ 'Larry Wall', 'Tom Christiansen' ],
edicion => '3ed',
editorial => {
nombre => "O'Reilly",
web => 'http://www.oreilly.com'
},
pub => 2001
},
{
titulo => 'Perl Cookbook',
autores => [ 'Tom Christiansen', 'Nathan Torkington' ],
edicion => '2da',
editorial => {
nombre => "O'Reilly",
web => 'http://www.oreilly.com'
},
pub => 2003
}
);

Teniendo este tipo estructura, veamos ahora como acceder a esa información. Supongamos que queremos imprimir todos los nombres de los libros, tenemos éste código:

foreach my $hash_ref ( @datos ) {
print $hash_ref->{titulo};
}

o bien:

print $_->{titulo} foreach @datos;


Datos persistentes
Datos persistentes son toda aquella información guardada de manera ``permanente'' en algún medio físico, cuyo acceso a los datos se realiza mediante alguna interfaz ( ya sea una API o algún formato establecido ).

Los datos persistentes nos van a servir para poder almacenar gran cantidad de información en algún formato que luego nos permita extraerla de manera eficiente y hasta cierto punto organizada. Entre los formatos que tocaremos en el tutorial utilizaremos: RDBMS, XML, YAML como enfoques prácticos, y haremos mención sobre DBM y algunos otros formatos de archivos mas simples.

Estos formatos ya mencionados, se van a exportar de manera de una estructura de datos en Perl, con esto podremos manipular dicha información y para desplegar y trabajar con lo que nos interesa. Veamos un ejemplo utilizando una RDBMS, en nuestro caso PostgreSQL; tenemos la siguiente descripción de tabla: 

              Table "public.libro"
   Column    |         Type          | Modifiers 
-------------+-----------------------+-----------
 isbn        | integer               | not null
 titulo      | character varying(50) | not null
 editorial   | character varying(30) | not null
 publicacion | integer               | not null
 edicion     | character varying(10) | not null 
 autor       | character varying(40) | not null 
Indexes:
    "libro_pkey" primary key, btree (isbn)

Ahora bien, utilicemos dicha tabla ( con información insertada previamente ), y generemos una estructura con dicha información, el código queda de la siguiente manera.

#!/usr/bin/perl

use strict;
use warnings;
use DBI;

sub _init {
my $dbh = DBI->connect( 'dbi:Pg:dbname=amnesiac', 'amnesiac','', { RaiseError => 1 } )
or die "Error al conectarse a la BD: $!\n";
my $libros = fetch( $dbh );
$dbh->disconnect;
}

sub fetch {
my $dbh = shift;
return $dbh->selectall_hashref( 'select * from libro', 'isbn' );
}

_init();

Introducción a Data::Dumper
Ahora bien, ¿qué pasa con nuestros datos?, ¿cómo puedo verificar el tipo de estructura creada?, En nuestro ejemplo anterior, importamos unos datos de PostgreSQL para poder utilizarlos, pero para realizar esto, necesitamos conocer que tipo de estructura nos asoció la RDBMS. Perl cuenta con diversos módulos que nos permiten conocer ``internamente'' como está compuesta una estructura, el mas sencillo y utilizado de estos es Data::Dumper[CPAN]. Data::Dumper lo que nos permite realizar es una ``inspección'' hacia el contenido de alguna variable, permitiendonos depurar y conocer dichos datos. Veamos el ejemplo anterior, agregaremos las siguientes líneas:

use Data::Dumper; #Importamos las funciones estandares del módulo Data::Dumper

.........

my $libros = fetch( $dbh );

print Dumper( $libros ); # Utilizamos la función Dumper() importada desde Data::Dumper

$dbh->disconnect;

La salida que nos provee dicho código es la siguiente:

$VAR1 = {
'596001320' => {
'edicion' => '3ed',
'titulo' => 'Learning Perl',
'autor' => 'Randal L. Schwartz',
'editorial' => 'O\'Reilly',
'publicacion' => '2001',
'isbn' => '596001320'
},
'1565926994' => {
'edicion' => '1ed',
'titulo' => 'Programming The Perl DBI',
'autor' => 'Alligator Descartes',
'editorial' => 'O\'Reilly',
'publicacion' => '2000',
'isbn' => '1565926994'
},
.........
};

De esta manera es sencillo saber que el método selectall_hashref() de la clase DBI nos regresó una referencia a un hash, que contiene mas referencias a cada una de las tuplas devueltas por dicho query. Nótese que cada tupla esta asociada al ISBN del libro, puesto que así fué indicado en el segundo parámetro de selectall_hashref. Si quisieramos acceder a cada uno de los ISBN de cada tupla, lo mas sencillo sería iterar sobre cada llave de la referencia principal de la siguiente manera:

foreach my $isbn( keys %$libros ) {

print $isbn,''\n'';

}

o bien:

print $_,``\n'' for keys %$libros; # Sin saltos de línea podría ser facilmente print for keys %$libros


Serialización de Datos
Con la serialización de datos, se puede represantar estructuras ya vistas anteriormente utilizando un formato establecido, simple a la vista y fácil para poder mostrar dicha salida de acuerdo a nuestras necesidades. Nuestros casos de estudio: XML y YAML[yml].

XML
Veamos el ejemplo anterior de los libros, exportando dicha estructura a XML utilizando XML::Simple.

Agregamos a nuestro código lo siguiente:

use XML::Simple;

# Eliminamos la línea use Data::Dumper, ya no se necesita

....

my $libros = fetch( $dbh );

#eliminamos la linea de print Dumper( $data ) no es necesaria

my $xml = XMLout( $libros, NoAttr => 1, RootName => 'libros' );

$dbh->disconnect();

En la variable $xml se encuentra nuestra salida en XML en forma de cadena, el contenido queda de la siguiente manera:

<libros>
<1565926994>
<autor>Alligator Descartes</autor>
<edicion>1ed</edicion>
<editorial>O'Reilly</editorial>
<isbn>1565926994</isbn>
<publicacion>2000</publicacion>
<titulo>Programming The Perl DBI</titulo>
</1565926994>
<1861002971>
<autor>Neil Mathews</autor>
<edicion>3ed</edicion>
<editorial>Wrox Press</editorial>
<isbn>1861002971</isbn>
<publicacion>2003</publicacion>
<titulo>Beginning Linux Programming</titulo>
</1861002971>
...
...
</libros>

Si queremos guardar nuestra salida XML en un archivo, a XMLout le pasamos el parámetro OutputFile => 'nombre.xml' o en caso de contar con algún filehandler ya abierto, en vez del nombre le pasamos dicho FH.

YAML
Ahora veamos un ejemplo de la misma salida del RDBMS pero ahora serializado a YAML, Cambiemos las líneas de XML por las siguientes de YAML:

use YAML qw( :all );

...

my $libros = fetch( $dbh );

my $yaml = Dump( $libros );

$dbh->disconnect();

La salida es la siguiente en formato YAML:

--- #YAML:1.0
1565926994:
autor: Alligator Descartes
edicion: 1ed
editorial: O'Reilly
isbn: 1565926994
publicacion: 2000
titulo: Programming The Perl DBI
1861002971:
autor: Neil Mathews
edicion: 3ed
editorial: Wrox Press
isbn: 1861002971
publicacion: 2003
titulo: Beginning Linux Programming

...
...



Presentación de los Datos

HTML y los sistemas de plantillas

¿Por qué utilizar plantillas?


  • - Separación de la lógica de programación a la lógica del contenido

  • - Consistencia

  • - Sencillo mantenimiento y reutilización de código

  • - Mayor control sobre los aspectos de diseño

  • - Permite el trabajo activo y amigable entre desarrollador-diseñador


Algunos sistemas de plantillas y generación de contenido en Perl

HTML::Template
Este pequeño sistema de plantillas es quizás el mas sencillo, mediante una pequeña y limitada serie de tags, se pueden crear sitios dinámicos de manera rápida. Su ventaja es que puede ser utilizado para sitios con necesidades no muy específicas, y es muy fácil de utilizar para el diseñador en cuanto a la realización de sus plantillas.

Template Toolkit
Este sistema generador de contenido es demasiado poderoso y flexible, tanto para el programador como para el diseñador. Lo que nos ofrece este sistema de plantillas es no solo generar contenido Web, sino cualquier otro tipo de contenido tal como PDF, SVG, XML, entre otros. Su ventaja es que es muy rápido, esta muy optimizado, puede ser utilizado junto con mod_perl, y a su vez, nos permite incluso incrustar código tipo Mason, y aparte de todo esto, puede ser capaz de utilizar módulos dentro de las plantillas.

Mason
Mason es un sistema de generación de contenido el cual permite generar sitios mezclando código de Perl y HTML, creando componentes capaces de reutilizarse o compartirse a lo largo del sitio. Al igual que Template Toolkit, Mason puede ser utilizado desde mod_perl. Su desventaja es que en desarrollos grandes, puede comenzar a perderse un poco la lógica entre diseño y programación.

Embperl
Emperl es un sistema de generación de contenido, hasta siento punto arcaico, anterior a Mason, lo que hace Emperl es buscar código de Perl ( de una manera no muy eficiente quizas )dentro de una plantilla, similar a ASP/PHP. Su utilización es al igual que HTML::Template preferentemente en sistios de necesidades no muy grandes.

Axkit
Al igual que Template Toolkit, axkit es un sistema de generación de contenido muy poderoso y flexible, pero a diferencia del otro, Axkit utiliza XML como representación de los datos. La manera de trabajar de Axkit es realizando transformaciones de XML a HTML ( o el contenido a utilizar ) por medio de XSLT, aprovechándose de mod_perl como canal de transmisión hacia el servidor HTTP.


HTML mediante Template Toolkit


Retomemos el caso de los libros, ahora toca el turno de generar una salida amigable para la información almacenada en la Base de Datos. Escribiremos un pequeño CGI que se aproveche de Template Toolkit para mostrar dicho contenido, el código es el siguiente:

#!/usr/bin/perl

use strict;
use warnings;
use DBI;
use Template;

sub _init {
my ( $dbh, $libros );
$dbh = DBI->connect( 'dbi:Pg:dbname=amnesiac', 'amnesiac','', { RaiseError => 1 } )
or die "Error al conectarse a la BD: $!\n";
$libros = fetch( $dbh );
$dbh->disconnect;
$libros = [ map $libros->{$_}, keys %$libros ];
content( $libros );
}

sub fetch {
my $dbh = shift;
return $dbh->selectall_hashref( 'select * from libro', 'isbn' );
}

sub content {
my( $tt, $datos );
$datos = shift;
$tt = Template->new();
print "Content-type: text/html\n\n";
$tt->process( 'libros.tt', { libros => $datos } ) || die $tt->error;
}

_init();

Nuestra plantilla queda de la siguiente manera:

<body> [% FOREACH libro IN libros %] <table width="600" border="1" cellspacing="0" cellpadding="0"> <tr bgcolor="#f1f1f6"> <td colspan="2" class="titulo">[% libro.titulo %]</td> </tr> <tr> <td align="center"> <img src="img/[% libro.isbn %].jpg" alt="[% libro.titulo %]" width="100" /> </td> <td bgcolor="#f1f1f6"> <ul> <li><span class="field">ISBN:</span> [% libro.isbn %]</li> <li><span class="field">Autor:</span> [% libro.autor %]</li> <li><span class="field">Editorial:</span> [% libro.editorial %]</li> <li><span class="field">Edición:</span> [% libro.edicion %]</li> <li><span class="field"> Año de Publicación:</span> [% libro.publicacion %] </li> </ul> </td> </tr> </table><br /> [% END %] </body>

Es necesario poner nuestro CGI y nuestra plantilla en el servidor web, en algún directorio que tenga permisos de ejecución CGI para ver la salida.


HTML mediante XML/XSLT


Normalmente, nos vamos a encontrar soluciones basadas en XML cuando dicha información será para uso múltiple, es decir, cuando los datos serializados vayan a tener diversas salidas. Para nuestro ejemplo retomemos el caso de los libros, pero ahora, de acuerdo al parámetro enviado por GET a nuestro script, es la salida que va a proporcionar nuestro script. La primer forma de presentación será la estandar, ya mostrada en el caso de Template Toolkit, la segunda consistirá en presentar los datos en un archivo YAML equivalente al XML fuente.

Veamos el código:

#!/usr/bin/perl

use strict;
use warnings;
use XML::LibXML;
use XML::LibXSLT;
use CGI;

sub _init {
my ( %salida, $q );
$q = CGI->new;
error() && return unless( $q->param('formato') and
( $q->param('formato') eq 'html' || $q->param('formato' ) eq 'yaml' )
) ;

%salida = (
html => \&html_output,
yaml => \&yaml_output
);
$salida{ $q->param('formato') }->();
}

sub error {
print "Content-type: text/html\n\n",
"<h4>ERROR</h4>Parámetro enviado no válido";
}

sub html_output {
my ( $xml, $xml_parser, $xslt_parser, $rv, $xsl, $xslt );
$xml_parser = XML::LibXML->new;
$xslt_parser = XML::LibXSLT->new;

$xml = $xml_parser->parse_file( 'libros.xml' );
$xsl = $xml_parser->parse_file( 'libros.xsl' );

$xslt = $xslt_parser->parse_stylesheet( $xsl );
$rv = $xslt->transform( $xml );
print "Content-type: text/html\n\n", $xslt->output_string( $rv );
}

sub yaml_output {
my ( $xml, $output );
require XML::Simple;
require YAML;
$xml = XML::Simple::XMLin( 'libros.xml' );
print "Content-type: text/plain\n\n", YAML::Dump( $xml );
}

_init;

Nuestra hoja XSL para la transformación de XML->HTML se ve de la siguiente manera:

<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/libros">
<html>
<head><title>Lista de Libros</title>
<style type="text/css">
.titulo { font-family: Georgia, Verdana; color: #006600; text-align: center }
li { font-family: Verdana, helvetica; color: #24326f; font-size: 12px }
.field { font-family: Georgia; color: #006000; font-size: 14px }
</style>
</head>
<body>
<xsl:apply-templates select="libro" />
</body>
</html>
</xsl:template>

<xsl:template match="libro">
<xsl:for-each select=".">
<table width="600" border="1" cellspacing="0" cellpadding="0">
<tr bgcolor="#f1f1f6">
<td colspan="2" class="titulo"><xsl:value-of select="titulo"/></td>
</tr>
<tr>
<td align="center">
<img src="img/{isbn}.jpg" alt="{titulo}" width="100" />
</td>
<td bgcolor="#f1f1f6">
<ul>
<li><span class="field">ISBN:</span> <xsl:value-of select="isbn" /></li>
<li><span class="field">Autor:</span> <xsl:value-of select="autor" /></li>
<li><span class="field">Editorial:</span> <xsl:value-of select="editorial" /></li>
<li><span class="field">Edición:</span> <xsl:value-of select="edicion" /></li>
<li><span class="field">
Año de Publicación:</span> <xsl:value-of select="publicacion" />
</li>
</ul>
</td>
</tr>
</table><br />
</xsl:for-each>
</xsl:template>

</xsl:stylesheet>

El script tomará nuestro archivo XML ( previamente generado ), y de acuerdo al parámetro pasado en formato, será la salida generada. Cabe señalar que nuestro archivo XML y el XSL deben estar CORRECTAMENTE formados, ya que el módulo XML::LibXML[CPAN] valida estrictamente el documento y en caso de existir alguna malformación nos avisará.

Ejemplo de estudio: Generación de un News Viewer con XML::RSS

En nuestro último ejemplo haremos una mezcla de ambos métodos tratados en este capítulo, utilizaremos un archivo XML ( RSS para nuestro caso ) como fuente de datos de noticias, lo transformaremos a una correspondiente estructura de dato, para luego obtener los datos que nos interesan y por medio de Template Toolkit daremos la salida pertinente en HTML.

Nuestro CGI queda de la siguiente manera:

#!/usr/bin/perl

use strict;
use XML::RSS;
use LWP;
use Template;
use CGI;
use CGI::Carp qw( fatalsToBrowser );

sub _init {
my( $cgi, $url, $ua, $request, $response, $canal );
$cgi = CGI->new();
$url = $cgi->param('url') || 'http://www.cofradia.org/backend.php';
$ua = LWP::UserAgent->new;

$ua->agent('get_rdf/1.0 (' . $ua->agent . ')');
$request = HTTP::Request->new( GET => $url );
$response = $ua->request( $request );
croak "Error: No se pudo obtener la pagina pedida o el contenido es inválido"
unless $response->is_success;

$canal = build_data( $response->content );
show_content( $canal );
}


sub build_data {
my( $content, $rss, $canal );
$content = shift;
$rss = XML::RSS->new();
$rss->parse($content);

$canal->{'nombre'} = $rss->{'channel'}->{'title'};
foreach my $item ( @{ $rss->{'items'} } ) {
push @{ $canal->{'notas'} }, { titulo => $item->{'title'},
liga => $item->{'link'},
};
}
return $canal;
}


sub show_content {
my ( $canal, $dir, $tt, $datos );
$canal = shift;
$tt = Template->new({
PRE_PROCESS => 'config',
});
$datos = {
titulo => $canal->{'nombre'},
noticias => $canal->{'notas'},
};

print "Content-type: text/html\n\n";
$tt->process( 'rss.tt', $datos ) or die "Error: $tt->error";
}

_init();

La plantilla para generar nuestra salida es la siguiente:

[% INCLUDE header %]

<h4>[% titulo %] para hoy</h4>
<table border="0" cellpadding="2" cellspacing="5">
[% FOREACH noticias %]
<tr>
<td>
<a href="[% liga %]">[% titulo %]</a>
</td>
</tr>
[% END %]
</table>

[% INCLUDE footer %]

Pongamos nuestro script en algún directorio que pueda ejecutar CGI y veamos la salida mostrada. La manera de utilizarlo es enviando una URL con el archivo RDF/RSS del cual tomaremos los datos, en caso de no existir dicho parámetro por default el script tomará el RSS del sitio de www.cofradia.org.

Por ejemplo: http://localhost/~usuario/rss.pl?url=http://www.barrapunto.com/barrapunto.rdf


Conclusiones


Todos los sistemas existentes ( incluyendo aquellos no mencionados en el tutorial ) presentan cualidades únicas de acuerdo al tipo de contenido a manejar y de acuerdo a nuestras necesidades, pero todos estos tienen algo en común: El trabajar con Perl como lenguaje de soporte hace que nuestro tratamiento de información sea mas transparente y sencillo.


Bibliografía

CPAN - http://search.cpan.org

pperl
Wall, Christiansen, et_all, ``Programming Perl'', 3ed, O'Reilly & Associates.

tt
Template Toolkit Homepage - http://www.template-toolkit.org

yml
YAML WebSite - http://yaml.kwiki.org/index.cgi?HomePage


Cortesía de Marco Antonio Manzo Bañuelos
Marco A. Manzo es un "Maestro Honorario" de Perl en Español, y gentilmente ha ofrecido algunos de sus tutoriales para su publicación en este sitio.

Puedes visitar la página personal de Marco A. Manzo con el siguiente link:
http://www.unixmonkeys.com/amnesiac/blog/

O puedes ver su perfil de "Perl en Español".

¿Quiéres más tutoriales como este? Escribir tutoriales toma una gran cantidad de tiempo y esfuerzo. Si este tutorial te ayudó a aprender o a solucionar algo, por favor considera dejar alguna donación en apoyo a Perl en Español.

Cliquea en el botón de abajo para dejar tu donación por medio de PayPal.

Comparte:
Categorías de Tutoriales:
En Nuestros Foros:

    Software error:

    junk after document element at line 1, column 32, byte 32 at /usr/lib64/perl5/vendor_perl/XML/Parser.pm line 187.

    For help, please send mail to the webmaster ([email protected]), giving this error message and the time and date of the error.

  • Entra a los foros »
Socializa:
Síguenos por Twitter

Suscríbete GRATUITAMENTE al Boletín de Perl en Español

Perl en Español es mantenido con Movable Type
Todo el contenido de Perl en Español está bajo una licencia CC:
 Creative Commons License
 
 
Perl en Español fue creado y es mantenido por Uriel Lizama