Un módulo de Perl es un componente discreto del software para el lenguaje de programación Perl . Técnicamente, es un conjunto particular de convenciones para utilizar el mecanismo de paquetes de Perl que se ha adoptado universalmente. [ discutir ]
Un módulo define su código fuente como un paquete (de forma muy similar a un paquete Java ), el mecanismo de Perl para definir espacios de nombres , por ejemplo, CGI o Net::FTP o XML::Parser ; la estructura del archivo refleja la estructura del espacio de nombres (por ejemplo, el código fuente de Net::FTP está en Net/FTP.pm ). Además, un módulo es el equivalente de Perl de la clase cuando se emplea programación orientada a objetos . [ discutir ]
Una distribución está compuesta por una colección de módulos, con la documentación que los acompaña , scripts de compilación y, por lo general, un conjunto de pruebas . La comunidad Perl tiene una biblioteca considerable de distribuciones disponibles para búsqueda y descarga a través de CPAN .
Perl es un lenguaje que permite muchos estilos diferentes de programación. Es igual de probable que un desarrollador encuentre un módulo escrito en un estilo procedimental (por ejemplo, Test::Simple) como orientado a objetos (por ejemplo, XML::Parser); ambos se consideran igualmente válidos según lo que necesite hacer el módulo. Los módulos también se pueden utilizar para mezclar métodos (DBIx::Class) o ser un pragma (strict.pm) que tiene un efecto inmediatamente después de ser cargado. Los módulos incluso se pueden utilizar para alterar la sintaxis del lenguaje. El efecto de los módulos de Perl suele limitarse al ámbito actual en el que se cargaron.
Es habitual que los módulos de Perl tengan documentación incorporada en el formato Plain Old Documentation de Perl . POD impone poca estructura al autor. Es lo suficientemente flexible como para usarse para escribir artículos, páginas web e incluso libros completos como Programming Perl. Contrasta con javadoc , que está especializado en documentar clases Java . Por convención, la documentación de módulos normalmente sigue la estructura de una página de manual de Unix .
El lenguaje Perl se define por una única implementación (a la que se denomina "perl") y se añade (y en raras ocasiones se quita) a cada nueva versión. Por este motivo, es importante que el autor de un módulo sepa qué características está utilizando y cuál es la versión mínima requerida de Perl. El código de esta página requiere Perl 5.6.0, que a estas alturas se considera bastante antiguo.
A continuación se presentan ejemplos de " Hola, mundo " implementados en diferentes estilos de módulos. Debe entenderse que en Perl no es necesario un módulo; las funciones y el código se pueden definir y utilizar en cualquier lugar. Esto es sólo a modo de ejemplo. En contraste con Java , donde siempre es necesaria una clase. Una función "Hola, mundo" real se escribiría de la siguiente manera:
sub hola { "Hola, mundo!\n" } print hola (); o simplemente impreso en una línea:
imprimir "Hola, mundo!\n" ; Aquí se implementa "Hola, mundo" como un módulo procedimental con un objetivo personalizable para el saludo, solo para hacer las cosas más interesantes. También se incluye un breve script para ilustrar el uso del módulo.
#!/usr/bin/perl # Carga el módulo e importa cualquier función en nuestro espacio de nombres # (por defecto "main") exportada por el módulo. Hello::World exporta # hello() por defecto. Las exportaciones pueden ser controladas por el llamador. use Hello::World ; print hola (); # imprime "¡Hola, mundo!\n" print hola ( "Vía Láctea" ); # imprime "¡Hola, Vía Láctea!\n" # "paquete" es el espacio de nombres donde reside la funcionalidad/datos del módulo. # Dicta el nombre del archivo si desea que se "use". # Si hay más de una palabra, restringe la ubicación del módulo.paquete Hola::Mundo ; # Por defecto, Perl permite usar variables sin declararlas . Esto puede ser conveniente para scripts cortos y de una sola línea. # Pero en una unidad de código más larga, como un módulo, es aconsejable declarar # las variables tanto para detectar errores tipográficos como para restringir su # accesibilidad de forma adecuada desde fuera del módulo. El pragma strict # obliga a declarar las variables. use strict ; # De forma similar, Perl no emite la mayoría de las advertencias del compilador o de tiempo de ejecución por defecto. # Los scripts más complicados, como la mayoría de los módulos, normalmente las encontrarán muy # útiles para la depuración. El pragma Warnings activa las advertencias opcionales. use Warnings ; # El número de versión de un módulo se almacena en $ModuleName::VERSION; ciertas # formas del "use" incorporado dependen de que se defina esta variable. nuestra $VERSION = '1.00' ; # Hereda del módulo "Exportador" que maneja las funciones de exportación. # La mayoría de los módulos de procedimiento hacen uso de esto.utilizar base 'Exportador' ; # Cuando se invoca el módulo, se exporta, por defecto, la función "hola" al # espacio de nombres del código que lo utiliza.nuestro @EXPORT = qw(hola) ; # Las líneas que comienzan con un signo igual indican documentación POD incorporada. # Las secciones POD terminan con una directiva =cut y pueden # mezclarse casi libremente con el código normal.=cabeza1 NOMBREHello::World - Una encapsulación de un mensaje de salida común=cabeza1 SINOPSIS usar Hola::Mundo; imprimir hola(); imprimir hola("Vía Láctea");=cabeza1 DESCRIPCIONEste es un módulo de procedimiento que te brinda el famoso mensaje "¡Hola, mundo!" ¡Y además es personalizable!Funciones =head2Las siguientes funciones se exportan de forma predeterminada=cabeza3 hola imprimir hola(); imprimir hola($objetivo);Devuelve el saludo famoso. Si se proporciona un C<$target>, se utilizará; de lo contrario, "world" será el destino del saludo.=cortar# define la función hello().sub hola { mi $target = shift ; $target = 'mundo' a menos que se defina $target ; return "Hola, $target!\n" ; } =cabeza1 AUTORJoe Hacker <[email protected]>=cortar# Un módulo Perl debe terminar con un valor verdadero o de lo contrario se considera que no se ha cargado. Por convención, este valor suele ser 1, aunque puede ser cualquier valor verdadero. Un módulo puede terminar con falso para indicar un fallo, pero esto rara vez se utiliza y, en su lugar, se ejecutaría die() (saldría con un error). 1 ;Dado que Hello/World.pm no está en tu ruta @INC, debes especificar . en la línea de comando para ejecutar el ejemplo anterior:
perl -I.hola_mundo.pl
A continuación se muestra un ejemplo de lo mismo realizado en un estilo orientado a objetos. La ventaja de un módulo orientado a objetos es que cada objeto se puede configurar independientemente de los demás objetos.
#!/usr/bin/perlusar Hola::Mundo ; mi $hola = Hola::Mundo -> nuevo ; $hola -> imprimir ; # imprime "Hola, mundo!\n" $hola -> objetivo ( "Vía Láctea" ); $hola -> imprimir ; # imprime "Hola, Vía Láctea!\n" mi $saludo = Hola::Mundo -> nuevo ( objetivo => "Pittsburgh" ); $saludo -> imprimir ; # imprime "¡Hola, Pittsburgh!\n" $hola -> imprimir ; # sigue imprimiendo "¡Hola, Vía Láctea!\n" # En Perl no existe una definición especial de "clase". Un espacio de nombres es una clase. paquete Hello::World ; utilizar estricto ; utilizar advertencias ; nuestra $VERSION = "1.00" ; =head1 NOMBRE Hello::World - Una encapsulación de un mensaje de salida común =head1 SINOPSIS use Hello::World; my $hello = Hello::World->new(); $hello->print; =head1 DESCRIPCIÓN Esta es una biblioteca orientada a objetos que puede imprimir el famoso mensaje "HW". =head2 Métodos =head3 new my $hello = Hello::World->new(); my $hello = Hello::World->new( target => $target ); Crea una instancia de un objeto que contiene un mensaje de saludo. Si se proporciona un C<$target>, se pasa a C<< $hello->target >>. =cut # El constructor de un objeto se llama new() por convención. Cualquier # método puede construir un objeto y puedes tener tantos como quieras. sub new { my ( $class , %args ) = @_ ; my $self = bless ({}, $class ); my $target = exist $args { target } ? $args { target } : "world" ; $self -> { target } = $target ; return $self ; } =head3 target my $target = $hello->target; $hello->target($target); Obtiene y establece el objetivo actual de nuestro mensaje. =cut sub target { my $self = shift ; if ( @_ ) { my $target = shift ; $self -> { target } = $target ; } return $self -> { target }; } =head3 to_string my $greeting = $hello->to_string; Devuelve el $greeting como una cadena =cut sub to_string { my $self = shift ; return "Hola, $self->{target}!" ; } =head3 print $hello->print; Envía el saludo a STDOUT =cut sub print { my $self = shift ; print $self -> to_string (), "\n" ; } =head1 AUTOR Joe Hacker <[email protected]> =cut 1 ; Un programa Perl en ejecución tiene un espacio de nombres incorporado llamado " main", que es el nombre predeterminado. Por ejemplo, una subrutina llamada Sub1puede llamarse como Sub1()o main::Sub1(). Con una variable, el sigilo apropiado se coloca delante del espacio de nombres; por lo tanto, una variable escalar llamada $var1también puede denominarse como $main::var1, o incluso $::var1. Se pueden crear otros espacios de nombres en cualquier momento.
paquete Namespace1 ; $var1 = 1 ; # creado en el espacio de nombres Namespace1, que también se crea si no existe previamente our $var2 = 2 ; # también se crea en ese espacio de nombres; our requerido si se aplica el uso estricto my $var3 = 3 ; # de alcance léxico my-declared - NO en ningún espacio de nombres, ni siquiera en el principal $ Namespace2:: var1 = 10 ; # creado en el espacio de nombres Namespace2, también creado si no existía previamente nuestro $ Namespace2:: var2 = 20 ; # también creado en ese espacio de nombres my $ Namespace2:: var3 = 30 ; #error de compilación: las variables declaradas my NO PUEDEN pertenecer a un paquete Las declaraciones de paquete se aplican al ámbito del paquete hasta la siguiente declaración de paquete o hasta el final del bloque en el que se realiza la declaración.
nuestra $mainVar = 'a' ; paquete Sp1 ; nuestra $sp1aVar = 'aa' ; print "$main::mainVar\t$sp1aVar\n" ; # nota mainVar necesita el paquete calificado Sp2 ; nuestra $sp2aVar = 'aaa' ; print "$main::mainVar\t$Sp1::sp1aVar\t$sp2aVar\n" ; # nota mainVar y sp1aVar necesitan el paquete calificado main ; print "$mainVar\t$Sp1::sp1aVar\t$Sp2::sp2aVar\n" ; # nota sp1aVar y sp2aVar necesitan el paquete calificado $mainVar = 'b' ; { # NOTA los paquetes creados previamente y las variables de paquete aún son accesibles paquete Sp1 ; nuestro $sp1bVar = 'bb' ; print "$main::mainVar\t$sp1aVar\t$sp1bVar\n" ; # nota mainVar necesita calificación { paquete Sp2 ; nuestro $sp2bVar = 'bbb' ; print "$main::mainVar\t$Sp1::sp1aVar$Sp1::sp1bVar\t$sp2aVar$sp2bVar\n" ; } # nota mainVar y sp1...Var necesitan calificación print "$main::mainVar\t$sp1bVar$sp1aVar\t$Sp2::sp2bVar$Sp2::sp2aVar\n" ; } # nota el paquete Sp1 se aplica por defecto # main se aplica nuevamente por defecto; todas las variables del paquete siguen siendo accesibles siempre que estén calificadas print "$mainVar\t$Sp1::sp1aVar$Sp2::sp2bVar\n" ; Tradicionalmente, los espacios de nombres se asocian con módulos; en la práctica, suele haber un espacio de nombres por módulo y viceversa, pero el lenguaje no lo exige. Por ejemplo, el módulo "estándar" CGI.pm tiene la siguiente declaración en la parte superior:
paquete CGI ; Este módulo y su funcionalidad normalmente se invocarían de la siguiente manera:
usa CGI ( ':standard' ); # importa muchas funciones, incluyendo b() ... print b ( 'Hola, mundo' ); # genera <b>Hola, mundo</b> Se podría agregar una subrutina 'faltante' desde el espacio de nombres del programa en uso.
sub CGI ::bi { # define el espacio de nombres de destino (CGI) y el subnombre (bi) return b ( i ( $_ [ 0 ])); } y se invoca de la siguiente manera:
imprimir CGI:: bi ( 'Hola, mundo' ); # salidas <b><i>Hola, mundo</i></b> Sin embargo, aunque técnicamente sea factible, sería una práctica de programación dudosa. También podría definir el sub en el espacio de nombres que lo llama y llamarlo desde ese espacio de nombres.