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 el que se ha adoptado universalmente. [ conversar ]
Un módulo define su código fuente como 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 . [ conversar ]
Una colección de módulos, con la documentación adjunta , scripts de compilación y generalmente un conjunto de pruebas , compone una distribución . La comunidad 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 tan 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 se pueden usar para mezclar métodos (DBIx::Class) o ser un pragma (strict.pm) que tiene un efecto inmediatamente después de cargarse. Los módulos incluso se pueden utilizar para alterar la sintaxis del idioma. El efecto de los módulos Perl generalmente se limita al ámbito actual en el que se cargaron.
Es común 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 usarlo para escribir artículos, páginas web e incluso libros completos como Programación Perl. Contraste con javadoc , que está especializado en documentar clases de Java . Por convención, la documentación del módulo suele seguir la estructura de una página de manual de Unix .
El lenguaje de Perl se define mediante una implementación única (denominada "perl") y se agrega (y en raras ocasiones se elimina) en cada nueva versión. Por esta razón, es importante que el autor de un módulo sepa qué funciones 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 ya se considera bastante antiguo.
Lo que sigue son ejemplos de " Hola, mundo " 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 sólo a modo de ejemplo. En contraste con Java, donde siempre es necesaria una clase. Una función real "Hola mundo" se escribiría así:
sub hola { "¡Hola mundo!\n" } print hola (); o simplemente impreso en una línea:
imprimir "¡Hola mundo!\n" ; Aquí está "Hola mundo" implementado como un módulo de procedimiento con un objetivo personalizable para el saludo, sólo para hacer las cosas interesantes. También se incluye un breve guión para ilustrar el uso del módulo.
#!/usr/bin/perl # Carga el módulo e importa cualquier función a nuestro espacio de nombres # (por defecto "main") exportada por el módulo. Hola::Exportaciones mundiales # hola() de forma predeterminada. Por lo general, la persona que llama puede controlar las exportaciones. utilizar Hola::Mundo ; imprimir hola (); # imprime "¡Hola mundo!\n" imprime 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 le permite usar variables sin # declararlas. Esto puede ser conveniente para guiones cortos y frases ingeniosas. # Pero en una unidad de código más larga, como un módulo, es aconsejable declarar # sus variables tanto para detectar errores tipográficos como para restringir su # accesibilidad apropiadamente desde fuera del módulo. El pragma estricto # te obliga a declarar tus variables. utilizar estricto ; # De manera similar, Perl no emite la mayoría de las advertencias del compilador o del tiempo de ejecución de forma predeterminada. # Los scripts más complicados, como la mayoría de los módulos, normalmente los encontrarán muy # útiles para la depuración. La pragma de advertencias activa advertencias opcionales. utilizar advertencias ; # El número de versión de un módulo se almacena en $ModuleName::VERSION; ciertas # formas del "uso" incorporado dependen de que se defina esta variable. nuestra $VERSIÓN = '1.00' ; # Hereda del módulo "Exportador" que maneja las funciones de exportación. # La mayoría de los módulos de procedimientos hacen uso de esto.utilizar la base 'Exportador' ; # Cuando se invoca el módulo, exporta, de forma predeterminada, la función "hola" al # espacio de nombres del código de uso.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 código normal.=cabeza1 NOMBREHola::Mundo: una encapsulación de un mensaje de salida común=cabeza1 SINOPSIS utilizar Hola::Mundo; imprimir hola(); print hola("Vía Láctea");=cabeza1 DESCRIPCIÓNEste es un módulo de procedimiento que le brinda el famoso "¡Hola, mundo!" mensaje, ¡e incluso es personalizable!=cabeza2 FuncionesLas siguientes funciones se exportan de forma predeterminada=cabeza3 hola imprimir hola(); imprimir hola ($objetivo);Devuelve el famoso saludo. Si se proporciona un C<$target>, se utilizará; de lo contrario, "mundo" es el destino de su saludo.= cortar# definir la función hola().sub hola { mi $objetivo = cambio ; $objetivo = 'mundo' a menos que esté definido $objetivo ; return "¡Hola, $objetivo!\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 falla, pero # esto rara vez se usa y en su lugar moriría() (saldría 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-yo. hola_mundo.pl
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.
#!/usr/bin/perlutilizar Hola::Mundo ; mi $hola = Hola::Mundo -> nuevo ; $hola -> imprimir ; # imprime "¡Hola mundo!\n" $hola -> destino ( "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" # En Perl no existe una definición especial de "clase". Un espacio de nombres es una clase. paquete Hola::Mundo ; utilizar estricto ; utilizar advertencias ; nuestra $VERSIÓN = "1.00" ; =head1 NOMBRE Hola::Mundo - Una encapsulación de un mensaje de salida común =head1 SINOPSIS uso Hola::Mundo; mi $hola = Hola::Mundo->nuevo(); $hola->imprimir; =head1 DESCRIPCIÓN Esta es una biblioteca orientada a objetos que puede imprimir el famoso mensaje "HW". =head2 Métodos =head3 nuevo mi $hola = Hola::Mundo->nuevo(); mi $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 nuevo() por convención. Cualquier # método puede construir un objeto y puedes tener tantos como quieras. sub nuevo { mi ( $clase , %args ) = @_ ; mi $self = bendecir ({}, $clase ); mi $objetivo = existe $args { objetivo } ? $args { objetivo } : "mundo" ; $self -> { objetivo } = $objetivo ; devolver $ uno mismo ; } =head3 objetivo mi $objetivo = $hola->objetivo; $hola->objetivo($objetivo); Obtiene y establece el destino actual de nuestro mensaje. = cortar subobjetivo { mi $self = cambio ; if ( @_ ) { mi $objetivo = cambio ; $self -> { objetivo } = $objetivo ; } devolver $self -> { objetivo }; } =head3 to_string mi $saludo = $hola->to_string; Devuelve el $saludo como una cadena =cut sub to_string { my $self = shift ; devolver "¡Hola, $self->{target}!" ; } =cabeza3 imprimir $hola->imprimir; Envía el saludo a STDOUT =cut sub print { my $self = shift ; imprimir $self -> to_string (), "\n" ; } =cabeza1 AUTOR Joe Hacker <[email protected]> =corte 1 ; Un programa Perl en ejecución tiene un espacio de nombres integrado 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 que una variable escalar llamada $var1también puede denominarse $main::var1, o incluso $::var1. Se pueden crear otros espacios de nombres en cualquier momento.
paquete Espacio de nombres1 ; $var1 = 1 ; # creado en el espacio de nombres Namespace1, que también se crea si no es preexistente 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 en el 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 creado 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 hasta el final del bloque en el que se realiza la declaración.
nuestro $mainVar = 'a' ; paquete Sp1 ; nuestro $sp1aVar = 'aa' ; imprimir "$main::mainVar\t$sp1aVar\n" ; # nota mainVar necesita el paquete calificado Sp2 ; nuestro $sp2aVar = 'aaa' ; print "$main::mainVar\t$Sp1::sp1aVar\t$sp2aVar\n" ; # tenga en cuenta que mainVar y sp1aVar necesitan el paquete calificado main ; print "$Varprincipal\t$Sp1::sp1aVar\t$Sp2::sp2aVar\n" ; # nota sp1aVar y sp2aVar necesitan calificación $Varprincipal = '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" ; } # note mainVar y sp1...Var necesitan calificar print "$main::mainVar\t$sp1bVar$sp1aVar\t$Sp2::sp2bVar$Sp2::sp2aVar\n" ; } # el paquete de notas Sp1 se aplica de forma predeterminada # main se aplica nuevamente de forma predeterminada; todas las variables del paquete aún son accesibles siempre que se califique print "$mainVar\t$Sp1::sp1aVar$Sp2::sp2bVar\n" ; Convencionalmente, los espacios de nombres están asociados con módulos; en la práctica, suele haber un espacio de nombres por módulo y viceversa, pero eso no es obligatorio en el lenguaje. Por ejemplo, el módulo 'estándar' CGI.pm tiene la siguiente declaración en su parte superior:
paquete CGI ; Este módulo y su funcionalidad normalmente se invocarían de la siguiente manera:
utilizar CGI ( ':estándar' ); # importa muchas funciones, incluida b() ... print b ( 'Hola, mundo' ); # salidas <b>Hola mundo</b> Se podría agregar una subrutina "faltante" desde el espacio de nombres del programa que lo utiliza.
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:
imprimir CGI:: bi ( 'Hola, mundo' ); # salidas <b><i>Hola mundo</i></b> Sin embargo, aunque técnicamente factible, sería una práctica de programación dudosa. También podrías definir el sub en el espacio de nombres de llamada y llamarlo desde ese espacio de nombres.