Un módulo Perl es un componente discreto de software para el lenguaje de programación Perl . Técnicamente, es un conjunto particular de convenciones para usar el mecanismo de paquetes de Perl que se ha adoptado universalmente. [ discutir ]
Un módulo define su código fuente para estar en un paquete (muy parecido a un paquete Java ), el mecanismo 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 en Perl de la clase cuando se emplea programación orientada a objetos . [ discutir ]
Una colección de módulos, con documentación adjunta , scripts de compilación y, por lo general, un conjunto de pruebas , componen una distribución . La comunidad de Perl tiene una biblioteca considerable de distribuciones disponibles para buscar y descargar a través de CPAN .
Perl es un lenguaje que permite muchos estilos diferentes de programación. Es 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 el módulo necesita hacer. Los módulos también pueden ser utilizados para mixin 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 Perl generalmente se limita al ámbito actual en el que se cargó.
Es común que los módulos de Perl tengan documentación incrustada en el formato Plain Old Documentation de Perl . POD impone poca estructura al autor. Es lo suficientemente flexible como para ser utilizado para escribir artículos, páginas web e incluso libros completos como Programming Perl . Contraste con javadoc que se especializa en documentar clases de Java . Por convención, la documentación del módulo sigue típicamente la estructura de una página de manual de Unix .
El lenguaje de Perl se define mediante la implementación única (a la que se hace referencia como "perl") y se agrega (y en raras ocasiones se quita de) cada nueva versión. Por esta razón, es importante que el autor de un módulo sepa qué características están 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 ahora se considera bastante antiguo.
Ejemplos de
Lo que sigue son ejemplos de " Hello, World " implementados en diferentes estilos de módulos. Debe entenderse que un módulo no es necesario en Perl; las funciones y el código se pueden definir y utilizar en cualquier lugar. Esto es solo para fines de ejemplo. Contraste con Java donde una clase siempre es necesaria. Una función real "Hola, mundo" se escribiría así:
sub hello { "¡Hola, mundo! \ n" } print hello ();
o simplemente impreso en una línea:
imprimir "¡Hola, mundo! \ n" ;
Ejemplo de procedimiento
Aquí está "Hola, mundo" implementado como un módulo de procedimiento con un destino personalizable para el saludo, solo para hacer las cosas interesantes. También se incluye un breve script para ilustrar el uso del módulo.
hello_world.pl
#! / usr / bin / perl # Carga el módulo e importa cualquier función en nuestro espacio de nombres # (por defecto es "principal") exportado por el módulo. Hello :: World exporta # hello () por defecto. Las exportaciones generalmente pueden ser controladas por la persona que llama. use Hello :: World ;imprimir hola (); # imprime "¡Hola, mundo! \ n" print hola ( "Vía Láctea" ); # imprime "¡Hola, Vía Láctea! \ n"
Hola / World.pm
# "paquete" es el espacio de nombres donde residen la funcionalidad / los datos del módulo. # Dicta el nombre del archivo si desea que sea "use" d. # Si hay más de una palabra, restringe la ubicación del módulo.paquete Hola :: Mundo ;# Por defecto, Perl le permite usar variables sin # declararlas . Esto puede ser conveniente para guiones cortos y frases breves. # Pero en una unidad de código más larga, como un módulo, es prudente declarar # sus variables tanto para detectar errores tipográficos como para restringir su accesibilidad # adecuadamente desde fuera del módulo. El pragma estricto # te obliga a declarar tus variables. uso estricto ; # De manera similar, Perl no emite la mayoría de las advertencias de compilador o en tiempo de ejecución de forma predeterminada. # Los scripts más complicados, como la mayoría de los módulos, generalmente los encontrarán muy # útiles para la depuración. El pragma de advertencias activa las advertencias opcionales. use advertencias ; # El número de versión de un módulo se almacena en $ ModuleName :: VERSION; ciertas # formas del "uso" incorporado dependen de la definición de esta variable.nuestra $ VERSION = '1.00' ;# Heredar del módulo "Exportador" que maneja las funciones de exportación. # La mayoría de los módulos de procedimiento hacen uso de esto.use la base 'Exportador' ;# Cuando se invoca el módulo, exporte, por defecto, la función "hola" al # espacio de nombres del código de uso.nuestro @EXPORTAR = qw (hola) ;# Las líneas que comienzan con un signo igual indican la documentación de POD # incrustada . Las secciones de POD terminan con una directiva = cut y se pueden # entremezclar casi libremente con el código normal.= head1 NAMEHello :: World: una encapsulación de un mensaje de salida común= head1 SINOPSIS use Hello :: World; imprimir hola (); imprimir hola ("Vía Láctea");= head1 DESCRIPCIÓNEste es un módulo de procedimiento que le brinda el famoso "¡Hola, mundo!" mensaje, ¡e incluso es personalizable!= Funciones head2Las siguientes funciones se exportan de forma predeterminada= head3 hola imprimir hola (); imprimir hola ($ objetivo);Devuelve el famoso saludo. Si se proporciona un C <$ target>, se utilizará, de lo contrario , "world" es el objetivo de su saludo.= cortar# definir la función hola ().sub hola { mi $ objetivo = turno ; $ target = 'world' a menos que se defina $ target ; return "¡Hola, $ objetivo! \ n" ; }= cabeza1 AUTORJoe Hacker @joehacker.org>= 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 una falla, pero # esto se usa raramente y en su lugar moriría () (salir con un error). 1 ;
Dado que Hello / World.pm no está en su ruta @INC, debe especificar. en la línea de comando para ejecutar el ejemplo anterior:
perl -I. hello_world.pl
Ejemplo orientado a objetos
Aquí hay un ejemplo de lo mismo hecho en un estilo orientado a objetos. La ventaja de un módulo OO es que cada objeto se puede configurar independientemente de otros objetos.
hello_world.pl
#! / usr / bin / perluse Hello :: World ; my $ 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 ( destino => "Pittsburgh" ); $ saludo -> imprimir ; # imprime "¡Hola, Pittsburgh! \ n" $ hola -> imprimir ; # todavía imprime "¡Hola, Vía Láctea! \ n"
Hola / World.pm
# En Perl no hay una definición especial de 'clase'. Un espacio de nombres es una clase. paquete Hola :: Mundo ;uso estricto ; use advertencias ; nuestro $ VERSION = "1.00" ;= head1 NAME Hello :: World - Una encapsulación de un mensaje de salida común = head1 SINOPSIS use Hello :: World; my $ hola = Hola :: Mundo-> nuevo (); $ hola-> imprimir; = head1 DESCRIPCIÓN Esta es una biblioteca orientada a objetos que puede imprimir el famoso mensaje "HW" . = head2 Methods = head3 new my $ hola = Hola :: Mundo-> nuevo (); my $ hola = Hola :: Mundo-> nuevo (objetivo => $ objetivo); Crea una instancia de un objeto que contiene un mensaje de saludo. Si se proporciona un C <$ target> , se pasa a C << $ hello-> target >>. = cortar # 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 { mi ( $ clase , % argumentos ) = @_ ; mi $ yo = bendecir ({}, $ clase ); mi $ objetivo = existe $ args { objetivo } ? $ args { objetivo } : "mundo" ; $ self -> { target } = $ target ; return $ self ; } = head3 target my $ target = $ hola-> target; $ hola-> objetivo ($ objetivo); Obtiene y establece el objetivo actual de nuestro mensaje. = cortar objetivo secundario { my $ self = shift ; if ( @_ ) { my $ target = shift ; $ self -> { target } = $ target ; } return $ self -> { target }; } = head3 to_string mi $ saludo = $ hola-> to_string; Devuelve el $ saludo como una cadena = cortar sub to_string { my $ self = shift ; return "¡Hola, $ self -> {target}!" ; } = head3 print $ hola-> imprimir; Envía el saludo a STDOUT = cut sub print { my $ self = shift ; print $ self -> to_string (), "\ n" ; } = head1 AUTOR Joe Hacker @joehacker.org>= cut 1 ;
Paquetes de Perl y espacios de nombres
Un programa de Perl en ejecución tiene un espacio de nombres incorporado llamado " main
", que es el nombre predeterminado. Por ejemplo, una subrutina llamada Sub1
se puede llamar como Sub1()
o main::Sub1()
. Con una variable, el sigilo apropiado se coloca delante del espacio de nombres; por lo que una variable escalar llamada $var1
también puede denominarse $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 nuestro $ var2 = 2 ; # también creado en ese espacio de nombres; nuestro requerido si se aplica el uso estricto my $ var3 = 3 ; # mi-declarado con ámbito léxico - NO en ningún espacio de nombres, ni siquiera principal
$ Espacio de nombres2 :: var1 = 10 ; # creado en el espacio de nombres Namespace2, también creado si no es preexistente nuestro $ Namespace2 :: var2 = 20 ; # también creó en ese espacio de nombres my $ Namespace2 :: var3 = 30 ; # error de compilación: mis variables declaradas NO PUEDEN pertenecer a un paquete
Las declaraciones de paquete aplican el alcance del paquete hasta la siguiente declaración de paquete o el final del bloque en el que se realiza la declaración.
nuestra $ mainVar = 'a' ; paquete Sp1 ; nuestro $ sp1aVar = 'aa' ; imprimir "$ main :: mainVar \ t $ sp1aVar \ n" ; # note mainVar necesita paquete calificado Sp2 ; nuestro $ sp2aVar = 'aaa' ; print "$ main :: mainVar \ t $ Sp1 :: sp1aVar \ t $ sp2aVar \ n" ; # note mainVar y sp1aVar necesitan un paquete calificado main ; print "$ mainVar \ t $ Sp1 :: sp1aVar \ t $ Sp2 :: sp2aVar \ n" ; # note que sp1aVar y sp2aVar necesitan calificación$ mainVar = 'b' ; { # NOTA paquetes creados previamente y variables de paquete aún accesibles paquete Sp1 ; nuestro $ sp1bVar = 'bb' ; print "$ main :: mainVar \ t $ sp1aVar \ t $ sp1bVar \ n" ; # note mainVar necesita calificar { paquete Sp2 ; nuestro $ sp2bVar = 'bbb' ; print "$ main :: mainVar \ t $ Sp1 :: sp1aVar $ Sp1 :: sp1bVar \ t $ sp2aVar $ sp2bVar \ n" ; } # note mainVar y sp1 ... Var necesitan una impresión calificada "$ main :: mainVar \ t $ sp1bVar $ sp1aVar \ t $ Sp2 :: sp2bVar $ Sp2 :: sp2aVar \ n" ; } # note que el paquete Sp1 se aplica por defecto # main se aplica de nuevo por defecto; todas las variables del paquete siguen siendo accesibles siempre y cuando se califique print "$ mainVar \ t $ Sp1 :: sp1aVar $ Sp2 :: sp2bVar \ n" ;
Paquetes y módulos
Convencionalmente, 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 idioma 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, se invocarían comúnmente de la siguiente manera:
use CGI ( ': estándar' ); # importa muchas funciones, incluyendo b () ... print b ( 'Hola, mundo' ); # salidas Hola, mundo
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 ])); }
e invocado de la siguiente manera:
print CGI :: bi ( 'Hola, mundo' ); # salidas Hola, mundo
Sin embargo, aunque técnicamente factible, sería una práctica de programación dudosa. También puede definir el sub en el espacio de nombres de llamada y llamarlo desde ese espacio de nombres.