Estructura del lenguaje Perl

This article possibly contains original research. Please improve it by verifying the claims made and adding inline citations. Statements consisting only of original research should be removed. (July 2017) (Learn how and when to remove this message)

La estructura del lenguaje de programación Perl abarca tanto las reglas sintácticas del lenguaje como las formas generales en que se organizan los programas. La filosofía de diseño de Perl se expresa en el lema comúnmente citado " hay más de una manera de hacerlo ". Como lenguaje multiparadigma y de tipado dinámico , Perl permite un alto grado de flexibilidad en el diseño de programas. Perl también fomenta la modularización; esto se ha atribuido a la estructura de diseño basada en componentes de sus raíces Unix ^{[ ¿cuándo? ]} , ^[1] y es responsable del tamaño del archivo CPAN , un repositorio mantenido por la comunidad de más de 100.000 módulos. ^[2]

En Perl, el programa mínimo Hola Mundo se puede escribir de la siguiente manera:

Imprimir "¡Hola, mundo!\n" 

Esto imprime la cadena Hello, World! y una nueva línea , expresada simbólicamente por un ncarácter cuya interpretación se modifica por el carácter de escape precedente (una barra invertida). Desde la versión 5.10, la nueva función incorporada 'say' ^[3] produce el mismo efecto de forma aún más sencilla:

Di "Hola, mundo!" 

También se puede especificar un programa Perl completo como parámetro de línea de comandos de Perl, de modo que el mismo programa también se puede ejecutar desde la línea de comandos (ejemplo mostrado para Unix):

$ perl - e 'print "Hola, mundo!\n"'   

La forma canónica del programa es un poco más detallada:

#!/usr/bin/perl print "Hola, mundo!\n" ; 

El carácter de almohadilla introduce un comentario en Perl, que se extiende hasta el final de la línea de código y es ignorado por el compilador (excepto en Windows). El comentario utilizado aquí es de un tipo especial: se llama línea shebang . Esto le dice a los sistemas operativos tipo Unix que encuentren el intérprete de Perl, lo que hace posible invocar el programa sin mencionar explícitamente perl. (Tenga en cuenta que, en los sistemas Microsoft Windows , los programas Perl generalmente se invocan asociando la .pl extensión con el intérprete de Perl. Para lidiar con tales circunstancias, perldetecta la línea shebang y la analiza en busca de modificadores. ^[4] )

La segunda línea de la forma canónica incluye un punto y coma, que se utiliza para separar sentencias en Perl. Con una sola sentencia en un bloque o archivo, no es necesario un separador, por lo que se puede omitir en la forma mínima del programa (o, de manera más general, en la sentencia final de cualquier bloque o archivo). La forma canónica lo incluye porque es común terminar cada sentencia incluso cuando no es necesario hacerlo, ya que esto facilita la edición: se puede agregar código al final de un bloque o archivo o alejarlo de él sin tener que ajustar los puntos y comas.

La versión 5.10 de Perl introduce una sayfunción que añade implícitamente un carácter de nueva línea a su salida, haciendo que el programa minimalista "Hola Mundo" sea aún más corto:

use 5.010 ; # debe estar presente para importar las nuevas funciones 5.10, observe que es 5.010, no 5.10. Diga '¡Hola, mundo!'   

Perl tiene varios tipos de datos fundamentales . Los más utilizados y analizados son los escalares , las matrices , los hashes , los identificadores de archivos y las subrutinas :

Los valores de cadena (literales) deben estar entre comillas. Encerrar una cadena entre comillas dobles permite que los valores de las variables cuyos nombres aparecen en la cadena reemplacen automáticamente el nombre de la variable (o se interpolen ) en la cadena. Encerrar una cadena entre comillas simples evita la interpolación de variables.

Por ejemplo, si $namees "Jim":

• luego print("My name is $name")imprimirá "My name is Jim"(interpolación entre comillas dobles),
• pero print('My name is $name')se imprimirá "My name is $name"(sin interpolación entre comillas simples).

Para incluir comillas dobles en una cadena, antepóngalas con una barra invertida o encierre la cadena entre comillas simples. Para incluir comillas simples, antepóngalas con una barra invertida o encierre la cadena entre comillas dobles.

Las cadenas también se pueden citar con los operadores similares a comillas qy qq:

• 'this'y q(this)son idénticos,
• "$this"y qq($this)son idénticos.

Finalmente, se pueden definir cadenas multilínea utilizando estos documentos :

$multilined_string = << EOF ; Esta es mi cadena multilineal , tenga en cuenta que la termino con la palabra "EOF". EOF  

Los números (constantes numéricas) no requieren comillas. Perl convertirá números en cadenas y viceversa dependiendo del contexto en el que se utilicen. Cuando las cadenas se convierten en números, las partes no numéricas finales de las cadenas se descartan. Si ninguna parte inicial de una cadena es numérica, la cadena se convertirá al número 0. En el siguiente ejemplo, las cadenas $ny $mse tratan como números. Este código imprime el número '5'. Los valores de las variables permanecen iguales. Tenga en cuenta que en Perl, +es siempre el operador de suma numérica. El operador de concatenación de cadenas es el punto.

$n = '3 manzanas' ; $m = '2 naranjas' ; imprimir $n + $m ;       

Se proporcionan funciones para redondear valores fraccionarios a valores enteros: intelimina la parte fraccionaria y redondea hacia cero; POSIX::ceily POSIX::floorredondea siempre hacia arriba y siempre hacia abajo, respectivamente. La conversión de números a cadenas de printf "%f"o sprintf "%f"redondea a pares, utiliza el redondeo bancario .

Perl también tiene un contexto booleano que utiliza para evaluar declaraciones condicionales. Los siguientes valores se evalúan como falsos en Perl:

$false = 0 ; # el número cero $false = 0.0 ; # el número cero como un float $false = 0b0 ; # el número cero en binario $false = 0x0 ; # el número cero en hexadecimal $false = '0' ; # la cadena cero $false = "" ; # la cadena vacía $false = (); # la lista vacía $false = undef ; # el valor de retorno de undef $false = 2 - 3 + 1 # se calcula como 0 que se convierte a "0" por lo que es falso                           

Todos los demás valores (que no evalúan cero) se evalúan como verdaderos. Esto incluye la extraña cadena literal autodescriptiva de "0 pero verdadero", que de hecho es 0 como número, pero verdadera cuando se usa como booleano. Todas las cadenas no numéricas también tienen esta propiedad, pero Perl trunca esta cadena en particular sin una advertencia numérica. Una versión menos explícita pero más portátil conceptualmente de esta cadena es ' 0E0 ' o ' 0e0 ', que no depende de que los caracteres se evalúen como 0, porque '0E0' es literalmente cero por diez a la potencia cero. El hash vacío también es verdadero; en este contexto no es un bloque vacío, porque devuelve .{}{}perl -e 'print ref {}'HASH

Las expresiones booleanas evaluadas también son valores escalares. La documentación no promete qué valor particular de verdadero o falso se devuelve. Muchos operadores booleanos devuelven 1 para verdadero y la cadena vacía para falso. La defined()función determina si una variable tiene algún valor establecido. En los ejemplos anteriores, defined($false)es verdadero para cada valor excepto undef.

Si se necesitan específicamente 1 o 0, se puede realizar una conversión explícita utilizando el operador condicional :

mi $resultado_real = $resultado_booleano ? 1 : 0 ;       

Un valor de matriz (o lista) se especifica enumerando sus elementos, separados por comas y encerrados entre paréntesis (al menos cuando lo requiere la precedencia del operador).

@puntajes = ( 32 , 45 , 16 , 5 );     

El operador qw() similar a comillas permite definir una lista de cadenas sin necesidad de escribir comillas ni comas. Se puede utilizar casi cualquier delimitador en lugar de paréntesis. Las siguientes líneas son equivalentes:

@nombres = ( 'Billy' , 'Joe' , 'Jim-Bob' ); @nombres = qw(Billy Joe Jim-Bob) ;      

La función split devuelve una lista de cadenas, que se dividen de una expresión de cadena utilizando una cadena delimitadora o una expresión regular.

@scores = split ( ', ' , '32,45,16,5' );   

Se puede acceder a los elementos individuales de una lista proporcionando un índice numérico entre corchetes. Se debe utilizar el sigilo$month[3] escalar. También se pueden especificar sublistas (secciones de matriz), utilizando un rango o lista de índices numéricos entre corchetes. En este caso, se utiliza el sigilo de matriz. Por ejemplo, is "April"(el primer elemento de una matriz tiene un valor de índice de 0) y @month[4..6]is ("May", "June", "July").

Los programadores de Perl pueden inicializar un hash (o matriz asociativa ) a partir de una lista de pares clave/valor. Si las claves se separan de los valores con el =>operador (a veces llamado coma gruesa ), en lugar de una coma, pueden estar sin comillas (palabras simples ^[5] ). Las siguientes líneas son equivalentes:

%favorite = ( 'joe' , "rojo" , 'sam' , "azul" ); %favorite = ( joe => 'rojo' , sam => 'azul' );            

Se accede a los valores individuales de un hash proporcionando la clave correspondiente, entre llaves. El $sigilo identifica el elemento al que se accede como un escalar. Por ejemplo, $favorite{joe}equals 'red'. Un hash también se puede inicializar configurando sus valores individualmente:

$favorite { joe } = 'rojo' ; $favorite { sam } = 'azul' ; $favorite { oscar } = 'verde' ;      

Se puede acceder a varios elementos utilizando el @sigilo (identificando el resultado como una lista). Por ejemplo, @favorite{'joe', 'sam'}es igual a ('red', 'blue').

Los identificadores de archivos proporcionan acceso de lectura y escritura a los recursos. Suelen ser archivos en el disco, pero también pueden ser un dispositivo, una tubería o incluso un valor escalar.

Originalmente, los identificadores de archivo solo se podían crear con variables de paquete, utilizando la convención ALL_CAPS para distinguirlos de otras variables. Perl 5.6 y versiones posteriores también aceptan una variable escalar, que se establecerá ( autovivificará ) en una referencia a un identificador de archivo anónimo, en lugar de un identificador de archivo con nombre.

Un valor de typeglob es una entrada de la tabla de símbolos. El uso principal de los typeglobs es crear alias de tabla de símbolos. Por ejemplo:

* PI = \ 3.141592653 ; # creando una constante escalar $PI * this = * that ; # creando alias para todos los tipos de datos 'this' para todos los tipos de datos 'that'      

La cantidad de elementos de una matriz se puede determinar evaluando la matriz en un contexto escalar o con la ayuda del $#sigilo. Este último proporciona el índice del último elemento de la matriz, no la cantidad de elementos. Las expresiones scalar( @array) y ( $#array + 1) son equivalentes.

Hay algunas funciones que operan sobre hashes completos. La función keys toma un hash y devuelve la lista de sus claves. De manera similar, la función values ​​devuelve los valores de un hash. Tenga en cuenta que las claves y los valores se devuelven en un orden coherente pero arbitrario.

# Cada llamada a each devuelve el siguiente par clave/valor. # Todos los valores serán eventualmente devueltos, pero su orden # no puede predecirse. while (( $name , $address ) = each %addressbook ) { print "$name reside en $address\n" ; }        # Similar al anterior, pero ordenado alfabéticamente foreach my $next_name ( sort keys %addressbook ) { print "$next_name vive en $addressbook{$next_name}\n" ; }        

Perl tiene varios tipos de estructuras de control.

Tiene estructuras de control orientadas a bloques, similares a las de los lenguajes de programación C, JavaScript y Java . Las condiciones están entre paréntesis y los bloques controlados entre llaves:

etiqueta mientras ( cond ) { … } etiqueta mientras ( cond ) { … } continuar { … } etiqueta para ( expr-init  ; expr-cond  ; expr-incr ) { … } etiqueta para cada var ( lista ) { … } etiqueta para cada var ( lista ) { … } continuar { … }si ( cond ) { … }si ( cond ) { … } de lo contrario { … }si ( cond ) { … } elsif ( cond ) { … } de lo contrario { … }

Cuando solo se controla una única declaración, los modificadores de declaración proporcionan una sintaxis más concisa:

declaración if cond  ; declaración sometimes cond  ; declaración while cond  ; declaración Until cond  ; declaración foreach lista  ;

Los operadores lógicos de cortocircuito se utilizan comúnmente para afectar el flujo de control a nivel de expresión:

expr y expr expr && expr expr o expr expr || expr

(Los operadores "y" y "o" son similares a && y || pero tienen menor precedencia , lo que hace que sea más fácil usarlos para controlar declaraciones enteras).

Las palabras clave de control de flujo next(correspondientes a C continue), last(correspondientes a C break), returny redoson expresiones, por lo que se pueden utilizar con operadores de cortocircuito.

Perl también tiene dos construcciones de bucle implícitas, cada una de las cuales tiene dos formas:

resultados = grep { … } lista resultados = grep expr , lista resultados = map { … } lista resultados = map expr , lista

grepdevuelve todos los elementos de la lista para los que el bloque o la expresión controlados se evalúan como verdaderos. mapevalúa el bloque o la expresión controlados para cada elemento de la lista y devuelve una lista de los valores resultantes. Estas construcciones permiten un estilo de programación funcional simple .

Hasta la versión 5.10.0, no existía ninguna declaración switch en Perl 5. Desde la versión 5.10.0 en adelante, está disponible una declaración de bifurcación multidireccional llamada given/ when, que tiene el siguiente formato:

use v5.10; # debe estar presente para importar las nuevas funciones 5.10
dadas ( expr ) { when ( cond ) { … } default { … } }

Sintácticamente, esta estructura se comporta de manera similar a las sentencias switch que se encuentran en otros lenguajes, pero con algunas diferencias importantes. La más importante es que, a diferencia de las estructuras switch/case, las sentencias given/when interrumpen la ejecución después de la primera bifurcación exitosa, en lugar de esperar comandos break definidos explícitamente. Por el contrario, continuese necesitan s explícitas para emular el comportamiento switch.

Para aquellos que no utilicen Perl 5.10, la documentación de Perl describe media docena de formas de lograr el mismo efecto utilizando otras estructuras de control. También existe un módulo Switch, que proporciona una funcionalidad modelada en la del lenguaje hermano Raku . Se implementa utilizando un filtro de código fuente, por lo que su uso se desaconseja de manera extraoficial. ^[6]

Perl incluye una goto labeldeclaración, pero rara vez se utiliza. Las situaciones en las que gotose requiere una declaración en otros lenguajes no ocurren tan a menudo en Perl, debido a su amplitud de opciones de control de flujo.

También hay una goto &subinstrucción que realiza una llamada de cola . Termina la subrutina actual e inmediatamente llama a la especificada sub. Esto se utiliza en situaciones en las que un llamador puede realizar una gestión de pila más eficiente que el propio Perl (normalmente porque no se requiere ningún cambio en la pila actual) y en la recursión profunda, la llamada de cola puede tener un impacto positivo sustancial en el rendimiento, porque evita la sobrecarga de la gestión del alcance/pila al regresar.

Las subrutinas se definen con la subpalabra clave y se invocan simplemente nombrándolas. Si la subrutina en cuestión aún no se ha declarado, la invocación requiere paréntesis después del nombre de la función o un ampersand ( & ) antes de él. Pero usar & sin paréntesis también pasará implícitamente los argumentos de la subrutina actual a la llamada, y usar & con paréntesis omitirá los prototipos.

# Llamar a una subrutina# Los paréntesis son necesarios aquí si la subrutina se define más adelante en el código foo (); & foo ; # (esto también funciona, pero tiene otras consecuencias con respecto a los argumentos pasados ​​a la subrutina) # Definición de una subrutina sub foo { … }    foo ; # Aquí no se requieren paréntesis 

Se puede proporcionar una lista de argumentos después del nombre de la subrutina. Los argumentos pueden ser escalares, listas o hashes.

foo $x , @y , %z ;   

Los parámetros de una subrutina no necesitan declararse en cuanto a número o tipo; de hecho, pueden variar de una llamada a otra. Cualquier validación de parámetros debe realizarse explícitamente dentro de la subrutina.

Las matrices se expanden a sus elementos; los hashes se expanden a una lista de pares clave/valor; y todo se pasa a la subrutina como una lista plana de escalares.

Los argumentos que se pasan están disponibles para la subrutina en la matriz especial @_. Los elementos de @_son referencias a los argumentos reales; al cambiar un elemento de @_se cambia el argumento correspondiente.

Se puede acceder a los elementos de @_subscribiéndolos de la forma habitual.

$_ [ 0 ], $_ [ 1 ] 

Sin embargo, el código resultante puede ser difícil de leer y los parámetros tienen una semántica de paso por referencia , lo que puede ser indeseable.

Un modismo común es asignar @_a una lista de variables con nombre.

mi ( $x , $y , $z ) = @_ ;     

Esto proporciona nombres de parámetros mnemotécnicos e implementa semántica de paso por valor . La mypalabra clave indica que las siguientes variables tienen un alcance léxico en el bloque contenedor.

Otro modismo es cambiar los parámetros de @_. Esto es especialmente común cuando la subrutina solo toma un argumento o para manejar el $selfargumento en módulos orientados a objetos.

mi $x = turno ;   

Las subrutinas pueden asignarse @_a un hash para simular argumentos nombrados; esto se recomienda en las mejores prácticas de Perl para subrutinas que probablemente tengan más de tres parámetros. ^[7]

sub función1 { mis %args = @_ ; print "el argumento 'x' era '$args{x}'\n" ; } función1 ( x => 23 );            

Las subrutinas pueden devolver valores.

devuelve 42 , $x , @y , %z ;    

Si la subrutina no sale a través de una returninstrucción, devuelve la última expresión evaluada dentro del cuerpo de la subrutina. Las matrices y los hashes en el valor de retorno se expanden a listas de escalares, tal como sucede con los argumentos.

La expresión devuelta se evalúa en el contexto de llamada de la subrutina; esto puede sorprender a los incautos.

sublista { ( 4 , 5 , 6 ) } submatriz { @x = ( 4 , 5 , 6 ) ; @x }​               $x = lista ; # devuelve 6 - último elemento de la lista $x = matriz ; # devuelve 3 - número de elementos en la lista @x = lista ; # devuelve (4, 5, 6) @x = matriz ; # devuelve (4, 5, 6)            

Una subrutina puede descubrir su contexto de llamada con la wantarrayfunción.

sub either { return wantarray ? ( 1 , 2 ) : 'Naranjas' ; }         $x = either ; # devuelve "Naranjas" @x = either ; # devuelve (1, 2)      

( sub { print "Me llamaron\n" }) -> (); # 1. completamente anónimo, llamado tal como fue creado     mi $squarer = sub { mi $x = shift ; $x * $x }; # 2. asignado a una variable             sub curry { my ( $sub , @args ) = @_ ; return sub { $sub -> ( @args , @_ ) }; # 3. como valor de retorno de otra función }              # ejemplo de currying en programación Perl sub sum { my $tot = 0 ; $tot += $_ for @_ ; $tot } # devuelve la suma de sus argumentos my $curried = curry \& sum , 5 , 7 , 9 ; print $curried -> ( 1 , 2 , 3 ), "\n" ; # imprime 27 ( = 5 + 7 + 9 + 1 + 2 + 3 )                        

my @squares = map { $_ * $_ } 1 .. 10 ; # map y grep no usan la palabra clave 'sub' my @square2 = map $_ * $_ , 1 .. 10 ; # llaves innecesarias para una expresión                  mi @bad_example = map { print for @_ } 1 .. 10 ; # valores no pasados ​​como una función Perl normal          

El lenguaje Perl incluye una sintaxis especializada para escribir expresiones regulares (RE, o regexes), y el intérprete contiene un motor para hacer coincidir cadenas con expresiones regulares. El motor de expresiones regulares utiliza un algoritmo de retroceso , que extiende sus capacidades desde la simple coincidencia de patrones hasta la captura y sustitución de cadenas. El motor de expresiones regulares se deriva de regex escrito por Henry Spencer .

La sintaxis de expresiones regulares de Perl se tomó originalmente de las expresiones regulares de Unix versión 8. Sin embargo, divergió antes del primer lanzamiento de Perl y desde entonces ha crecido para incluir muchas más funciones. Muchos otros lenguajes y aplicaciones están adoptando ahora las expresiones regulares compatibles con Perl en lugar de las expresiones regulares POSIX , como PHP , Ruby , Java , .NET Framework de Microsoft ^[9] y el servidor HTTP Apache .

La sintaxis de las expresiones regulares es extremadamente compacta debido a su historia. Los primeros dialectos de expresiones regulares eran apenas un poco más expresivos que los globs , y la sintaxis estaba diseñada de modo que una expresión se asemejara al texto con el que coincide. ^{[ cita requerida ]} Esto significaba no usar más que un solo carácter de puntuación o un par de caracteres delimitadores para expresar las pocas afirmaciones admitidas. Con el tiempo, la expresividad de las expresiones regulares creció enormemente, pero el diseño de la sintaxis nunca se revisó y continúa dependiendo de la puntuación. Como resultado, las expresiones regulares pueden ser crípticas y extremadamente densas.

El m//operador (match) introduce una coincidencia de expresión regular. (Si está delimitada por barras, como en todos los ejemplos aquí, mse puede omitir el inicial para abreviar. Si mestá presente, como en todos los ejemplos siguientes, se pueden usar otros delimitadores en lugar de barras). En el caso más simple, una expresión como

$x =~ /abc/ ; 

se evalúa como verdadero si y solo si la cadena $xcoincide con la expresión regular abc.

El s///operador (sustituto), por otro lado, especifica una operación de búsqueda y reemplazo:

$x =~ s/abc/aBc/ ; # convierte b en mayúsculas   

Otro uso de las expresiones regulares es especificar delimitadores para la splitfunción:

@words = split /,/ , $linea ;    

La splitfunción crea una lista de las partes de la cadena que están separadas por lo que coincide con la expresión regular. En este ejemplo, una línea se divide en una lista de sus propias partes separadas por comas y, luego, esta lista se asigna a la @wordsmatriz.

Las expresiones regulares de Perl pueden aceptar modificadores . Se trata de sufijos de una sola letra que modifican el significado de la expresión:

$x =~ /abc/i ; # coincidencia de patrones sin distinción entre mayúsculas y minúsculas $x =~ s/abc/aBc/g ; # búsqueda y reemplazo global     

Debido a que la sintaxis compacta de las expresiones regulares puede hacer que sean densas y crípticas, el /xmodificador se agregó en Perl para ayudar a los programadores a escribir expresiones regulares más legibles. Permite a los programadores colocar espacios en blanco y comentarios dentro de las expresiones regulares:

$x =~ / a # coincide con 'a' . # seguido de cualquier carácter c # luego seguido por el carácter 'c' /x ; 

Las partes de una expresión regular pueden estar entre paréntesis; las partes correspondientes de una cadena coincidente se capturan . Las cadenas capturadas se asignan a las variables integradas secuenciales $1, $2, $3, …y se devuelve una lista de cadenas capturadas como valor de la coincidencia.

$x =~ /a(.)c/ ; # captura el carácter entre 'a' y 'c'  

Las cadenas capturadas $1, $2, $3, …se pueden utilizar más adelante en el código.

Las expresiones regulares de Perl también permiten que las funciones integradas o definidas por el usuario se apliquen a la coincidencia capturada, utilizando el /emodificador:

$x = "Naranjas" ; $x =~ s/(ge)/uc($1)/e ; # OranGEs $x .= $1 ; # anexa $x con el contenido de la coincidencia en la declaración anterior: OranGEsge        

This section needs expansion. You can help by adding to it. (March 2010)

Existen muchas formas de escribir código orientado a objetos en Perl. La más básica es usar referencias "bendecidas" . Esto funciona identificando una referencia de cualquier tipo como perteneciente a un paquete determinado, y el paquete proporciona los métodos para la referencia bendecida. Por ejemplo, un punto bidimensional podría definirse de esta manera:

sub Point ::new { # Aquí, Point->new(4, 5) dará como resultado que $class sea 'Point'. # Es una variable para soportar subclasificaciones (vea la página de manual de perloop). my ( $class , $x , $y ) = @_ ; bless [ $x , $y ], $class ; # Retorno implícito }              sub Punto ::distancia { mi ( $self , $from ) = @_ ; mi ( $dx , $dy ) = ( $$self [ 0 ] - $$from [ 0 ], $$self [ 1 ] - $$from [ 1 ]); sqrt ( $dx * $dx + $dy * $dy ); }                       

Esta clase se puede utilizar invocándola new()para construir instancias e invocándola distanceen esas instancias.

mi $p1 = Punto -> nuevo ( 3 , 4 ); mi $p2 = Punto -> nuevo ( 0 , 0 ); imprimir $p1 -> distancia ( $p2 ); # Imprime 5          

Muchas aplicaciones modernas de Perl utilizan el sistema de objetos Moose . ^{[ cita requerida ]} Moose está construido sobre Class::MOP, un protocolo de meta-objetos, que proporciona una introspección completa para todas las clases que utilizan Moose. De esta manera, puede preguntar a las clases sobre sus atributos, padres, hijos, métodos, etc. utilizando una API simple.

Clases de alces:

• Una clase tiene cero o más atributos.
• Una clase tiene cero o más métodos.
• Una clase tiene cero o más superclases (también conocidas como clases padre). Una clase hereda de sus superclases.
• Una clase realiza cero o más roles, lo que agrega la capacidad de agregar funcionalidad predefinida a las clases sin subclasificar.
• Una clase tiene un constructor y un destructor.
• Una clase tiene una metaclase.
• Una clase tiene cero o más modificadores de método. Estos modificadores pueden aplicarse a sus propios métodos, a métodos heredados de sus antecesores o a métodos proporcionados por roles.

Roles del alce:

• Un rol es algo que hace una clase, algo así como los mixins o interfaces en otros lenguajes de programación orientados a objetos. A diferencia de los mixins y las interfaces, los roles se pueden aplicar a instancias de objetos individuales.
• Un rol tiene cero o más atributos.
• Un rol tiene cero o más métodos.
• Un rol tiene cero o más modificadores de método.
• Un rol tiene cero o más métodos obligatorios.

Un ejemplo de una clase escrita usando la extensión MooseX::Declare ^[10] de Moose:

utilizar MooseX::Declare ; clase Point3D extiende Point { tiene 'z' => ( isa => 'Num' , es => 'rw' );              después de borrar { $self -> z ( 0 ); } método set_to ( Num $x , Num $y , Num $z ) { $self -> x ( $x ); $self -> y ( $y ); $self -> z ( $z ); } }                 

Esta es una clase llamada Point3Dque extiende otra clase llamada Pointexplicada en los ejemplos de Moose . Agrega a su clase base un nuevo atributo z, redefine el método set_toy extiende el método clear.

• Tutoriales de Perl
• Aprenda Perl en aproximadamente 2 horas y 30 minutos
• PerlMonks Una comunidad comprometida a compartir conocimientos sobre Perl y consejos de codificación.