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 de tipado dinámico , Perl permite un gran 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 ¡Hola, mundo! y una nueva línea , expresada simbólicamente por un ncarácter cuya interpretación se ve alterada por el carácter de escape anterior (una barra invertida). Desde la versión 5.10, el nuevo incorporado '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 comando para Perl, por lo que el mismo programa también se puede ejecutar desde la línea de comando (se muestra un ejemplo para Unix):
$ perl - e 'imprimir "¡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 ejecuta hasta el final de la línea de código y el compilador lo ignora (excepto en Windows). El comentario utilizado aquí es de un tipo especial: se llama línea shebang . Esto le indica a los sistemas operativos tipo Unix que encuentren el intérprete de Perl, lo que permite invocar el programa sin mencionarlo 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 hacer frente a tales circunstancias, perldetecta la línea shebang y la analiza en busca de modificadores. [4] )
La segunda línea en la forma canónica incluye un punto y coma, que se utiliza para separar declaraciones en Perl. Con una sola declaración en un bloque o archivo, un separador es innecesario, por lo que se puede omitir de la forma mínima del programa o, más generalmente, de la declaración final en cualquier bloque o archivo. La forma canónica lo incluye, porque es común terminar cada declaración incluso cuando no es necesario hacerlo, ya que esto facilita la edición: el código se puede agregar o alejar del final de un bloque o archivo sin tener que hacerlo. ajustar el punto y coma.
La versión 5.10 de Perl introduce una sayfunción que implícitamente añade un carácter de nueva línea a su salida, haciendo que el programa mínimo "Hello World" sea aún más corto:
utilizar 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 comúnmente utilizados y discutidos son escalares , matrices , hashes , identificadores de archivos y 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":
print("My name is $name")imprimirá "My name is Jim"(interpolación entre comillas dobles),print('My name is $name')se imprimirá "My name is $name"(sin interpolación entre comillas simples).Para incluir una comilla doble en una cadena, preceda por una barra invertida o encierre la cadena entre comillas simples. Para incluir una comilla simple, preceda por una barra invertida o incluya la cadena entre comillas dobles.
Las cadenas también se pueden citar con los operadores tipo comillas qy :qq
'this'y q(this)son idénticos,"$this"y qq($this)son identicos.Finalmente, las cadenas multilínea se pueden definir usando estos documentos :
$cadena_multilínea = << EOF ; Esta es mi nota de cadena de varias líneas y la terminaré con la palabra "EOF". EOF Los números (constantes numéricas) no requieren comillas. Perl convertirá números en cadenas y viceversa según el 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 siguen siendo los mismos. Tenga en cuenta que en Perl, +siempre es 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: intcorta la parte fraccionaria y redondea hacia cero; POSIX::ceily POSIX::floorredondear siempre hacia arriba y siempre hacia abajo, respectivamente. La conversión de número a cadena printf "%f"o sprintf "%f"redondeo par utiliza el redondeo bancario .
Perl también tiene un contexto booleano que utiliza para evaluar declaraciones condicionales. Todos los siguientes valores se evalúan como falsos en Perl:
$falso = 0 ; # el número cero $false = 0.0 ; # el número cero como flotante $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 a 0 y se convierte a "0", por lo que es falso Todos los demás valores (de evaluación distinta de 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 verdadero 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 multiplicado por diez elevado a 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 cierto para todos los valores 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 requiera la precedencia de operadores).
@puntuaciones = ( 32 , 45 , 16 , 5 ); El operador qw() tipo comillas permite la definición de una lista de cadenas sin 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 de división devuelve una lista de cadenas, que se dividen a partir de una expresión de cadena mediante una cadena delimitadora o una expresión regular.
@puntuaciones = dividir ( ',' , '32,45,16,5' ); Se accede a los elementos individuales de una lista proporcionando un índice numérico entre corchetes. Se debe utilizar el sigilo escalar . También se pueden especificar sublistas (porciones de matriz), utilizando un rango o lista de índices numéricos entre paréntesis. En este caso se utiliza el sigilo de matriz. Por ejemplo, $month[3]es "April"(el primer elemento de una matriz tiene un valor de índice de 0) y @month[4..6]es ("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 están separadas de los valores con el =>operador (a veces llamado coma gruesa ), en lugar de una coma, es posible que no estén entre comillas (palabras simples [5] ). Las siguientes líneas son equivalentes:
%favorito = ( 'joe' , "rojo" , 'sam' , "azul" ); % favorito = ( joe => 'rojo' , sam => 'azul' ); Se accede a los valores individuales en un hash proporcionando la clave correspondiente, entre llaves. El $sigilo identifica el elemento al que se accede como un escalar. Por ejemplo, $favorite{joe}es igual a 'red'. Un hash también se puede inicializar estableciendo sus valores individualmente:
$favorito { joe } = 'rojo' ; $favorito { sam } = 'azul' ; $favorito { oscar } = 'verde' ; En su lugar , 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. Generalmente son archivos en el disco, pero también pueden ser un dispositivo, una tubería o incluso un valor escalar.
Originalmente, los identificadores de archivos solo podían crearse 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á ( autovivificada ) como 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 typeglobs es la creación de alias de tablas de símbolos. Por ejemplo:
* PI = \ 3.141592653 ; # creando un escalar constante $PI * this = * that ; # crear alias para todos los tipos de datos 'esto' para todos los tipos de datos 'aquello' El número de elementos en 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 el número de elementos. Las expresiones escalar( @array) y ( $#array + 1) son equivalentes.
Hay algunas funciones que operan en hashes completos. La función de claves toma un hash y devuelve la lista de sus claves. De manera similar, la función de valores 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 cada uno devuelve el siguiente par clave/valor. # Todos los valores eventualmente se devolverán, pero su orden # no se puede predecir. while (( $nombre , $dirección ) = cada %libreta de direcciones ) { print "$nombre vive en $dirección\n" ; } # Similar al anterior, pero ordenado alfabéticamente para cada mi $next_name ( ordenar claves %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 están 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 ) {… } más {… }si ( cond ) {...} elsif ( cond ) {...} más {...}Cuando solo se controla una declaración, los modificadores de declaración proporcionan una sintaxis más concisa:
declaración si cond ; declaración a menos que cond ; declaración mientras cond ; declaración hasta cond ; declaración para cada lista ;
Los operadores lógicos de cortocircuito se utilizan comúnmente para afectar el flujo de control en el nivel de expresión:
expr y expr expr && expr expr o expr expr || exprés
(Los operadores "y" y "o" son similares a && y || pero tienen menor precedencia , lo que facilita su uso para controlar declaraciones completas).
Las palabras clave de control de flujo next(correspondientes a C continue), last(correspondientes a C break), returny redoson expresiones, por lo que pueden usarse 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 = mapa {...} lista resultados = mapa expr , listagrepdevuelve todos los elementos de la lista para los cuales el bloque o expresión controlado se evalúa como verdadero. mapevalúa el bloque o expresión controlado 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 había ninguna declaración de cambio en Perl 5. Desde 5.10.0 en adelante, está disponible una declaración de rama multidireccional llamada given/ when, que toma la siguiente forma:
utilizar 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 declaraciones de cambio que se encuentran en otros idiomas, pero con algunas diferencias importantes. La más importante es que, a diferencia de las estructuras switch/case, las declaraciones dadas/cuando interrumpen la ejecución después de la primera rama exitosa, en lugar de esperar comandos de interrupción definidos explícitamente. Por el contrario, los s explícitos continueson necesarios para emular el comportamiento del interruptor.
Para aquellos que no usan Perl 5.10, la documentación de Perl describe media docena de formas de lograr el mismo efecto mediante el uso de otras estructuras de control. También hay un módulo Switch, que proporciona una funcionalidad inspirada en la del idioma hermano Raku . Se implementa mediante un filtro de fuente, por lo que se desaconseja extraoficialmente su uso. [6]
Perl incluye una goto labeldeclaración, pero rara vez se utiliza. Las situaciones en las que gotose requiere a en otros lenguajes no ocurren con tanta frecuencia en Perl, debido a su amplitud de opciones de control de flujo.
También hay una goto &subdeclaración que realiza una llamada de cola . Termina la subrutina actual e inmediatamente llama al especificado sub. Esto se utiliza en situaciones en las que una persona que llama 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 recursividad 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 ha sido declarada, la invocación requiere paréntesis después del nombre de la función o un signo ( & ) antes. Pero usar & sin paréntesis también pasará implícitamente los argumentos de la subrutina actual a la subrutina llamada, y usar & con paréntesis omitirá los prototipos.
# Llamar a una subrutina# Se requieren paréntesis 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) # Definiendo 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 ; No es necesario declarar los parámetros de una subrutina ni en número ni en 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.
Cualquier argumento que se pase está disponible para la subrutina en la matriz especial @_. Los elementos de @_son referencias a los argumentos reales; cambiar un elemento de @_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 resultar indeseable.
Un modismo común es asignar @_a una lista de variables nombradas.
mi ( $x , $y , $z ) = @_ ; Esto proporciona nombres de parámetros mnemotécnicos e implementa una 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 toma sólo un argumento o para manejar el $selfargumento en módulos orientados a objetos.
mi $x = turno ; Las subrutinas pueden asignar @_un hash para simular argumentos con nombre; esto se recomienda en las Mejores prácticas de Perl para subrutinas que probablemente alguna vez tendrán más de tres parámetros. [7]
sub función1 { mi %args = @_ ; print "el argumento 'x' era '$args{x}'\n" ; } función1 ( x => 23 ); Las subrutinas pueden devolver valores.
devolver 42 , $x , @y , %z ; Si la subrutina no sale mediante una returndeclaració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 lo hacen con los argumentos.
La expresión devuelta se evalúa en el contexto de llamada de la subrutina; Esto puede sorprender a los incautos.
sub lista { ( 4 , 5 , 6 ) } sub matriz { @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 cualquiera { return wantarray ? ( 1 , 2 ) : 'Naranjas' ; } $x = cualquiera ; # devuelve "Naranjas" @x = cualquiera ; # devuelve (1, 2) Perl 5 admite funciones anónimas, [8] de la siguiente manera:
( sub { print "Me llamaron\n" }) -> (); # 1. totalmente anónimo, llamado tal como se creó mi $cuadrado = sub { mi $x = cambio ; $x * $x }; # 2. asignado a una variable sub curry { mi ( $sub , @args ) = @_ ; devolver sub { $sub -> ( @args , @_ ) }; # 3. como valor de retorno de otra función } # ejemplo de curry en programación Perl sub sum { my $tot = 0 ; $tot += $_ para @_ ; $tot } # devuelve la suma de sus argumentos my $curried = curry \& sum , 5 , 7 , 9 ; imprimir $curry -> ( 1 , 2 , 3 ), "\n" ; # imprime 27 ( = 5 + 7 + 9 + 1 + 2 + 3 ) Otras construcciones toman bloques desnudos como argumentos, que cumplen una función similar a las funciones lambda de un parámetro, pero no tienen la misma convención de paso de parámetros que las funciones: @_ no está configurado.
mis @cuadrados = mapa { $_ * $_ } 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 = mapa { imprimir para @_ } 1 .. 10 ; # valores no pasados como la función Perl normal El lenguaje Perl incluye una sintaxis especializada para escribir expresiones regulares (RE o expresiones regulares) y el intérprete contiene un motor para hacer coincidir cadenas con expresiones regulares. El motor de expresiones regulares utiliza un algoritmo de retroceso , ampliando sus capacidades desde la simple coincidencia de patrones hasta la captura y sustitución de cadenas. El motor de expresiones regulares se deriva de expresiones regulares escritas por Henry Spencer .
La sintaxis de las expresiones regulares de Perl se tomó originalmente de las expresiones regulares de la versión 8 de Unix. Sin embargo, divergió antes del primer lanzamiento de Perl y desde entonces ha crecido hasta incluir muchas más funciones. Muchos otros lenguajes y aplicaciones están adoptando ahora expresiones regulares compatibles con Perl sobre 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 la historia. Los primeros dialectos de expresiones regulares eran sólo un poco más expresivos que los globs y la sintaxis se diseñó para que una expresión se pareciera al texto con el que coincide. [ cita necesaria ] Esto significó usar no más de un único 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 fue revisado y continúa dependiendo de la puntuación. Como resultado, las expresiones regulares pueden ser crípticas y extremadamente densas.
El m//operador (coincidencia) introduce una coincidencia de expresión regular. (Si está delimitado por barras, como en todos los ejemplos aquí, mse puede omitir el interlineado por motivos de brevedad. Si mestá presente, como en todos los ejemplos siguientes, se pueden usar otros delimitadores en lugar de barras). caso más simple, una expresión como
$x =~ /abc/ ; se evalúa como verdadero si y sólo 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/ ; # mayúsculas la b Otro uso de las expresiones regulares es especificar delimitadores para la splitfunción:
@palabras = dividir /,/ , $línea ; 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 tener modificadores . Son sufijos de una sola letra que modifican el significado de la expresión:
$x =~ /abc/i ; # coincidencia de patrón que no distingue entre mayúsculas y minúsculas $x =~ s/abc/aBc/g ; # búsqueda global y reemplazo Debido a que la sintaxis compacta de las expresiones regulares puede hacerlas 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 expresiones regulares:
$x =~ / a # coincide con 'a' . # seguido de cualquier carácter c # seguido del carácter 'c' /x ; Partes de una expresión regular pueden estar entre paréntesis; Se capturan las porciones correspondientes de una cadena coincidente . 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/ ; # capturar 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 funciones integradas o definidas por el usuario se apliquen a la coincidencia capturada, mediante el uso del /emodificador:
$x = "Naranjas" ; $x =~ s/(ge)/uc($1)/e ; # Naranjas $x .= $1 ; # agregar $x con el contenido de la coincidencia en la declaración anterior: OranGEsge Hay muchas formas de escribir código orientado a objetos en Perl. Lo más básico es utilizar referencias “benditas” . Esto funciona identificando una referencia de cualquier tipo como perteneciente a un paquete determinado, y el paquete proporciona los métodos para la bendita referencia. Por ejemplo, un punto bidimensional podría definirse de esta manera:
sub Punto ::nuevo { # Aquí, Punto->nuevo(4, 5) dará como resultado que $clase sea 'Punto'. # Es una variable que admite subclases (consulte la página de manual de perloop). mi ( $clase , $x , $y ) = @_ ; bendecir [ $x , $y ], $clase ; # Retorno implícito } sub punto :: distancia { mi ( $ yo , $ desde ) = @_ ; mi ( $dx , $dy ) = ( $$self [ 0 ] - $$from [ 0 ], $$self [ 1 ] - $$from [ 1 ]); raíz cuadrada ( $dx * $dx + $dy * $dy ); } Esta clase se puede utilizar invocando new()para construir instancias e invocando distanceen esas instancias.
mi $p1 = Punto -> nuevo ( 3 , 4 ); mi $p2 = Punto -> nuevo ( 0 , 0 ); imprimir $p1 -> distancia ( $p2 ); # Impresiones 5 Muchas aplicaciones Perl modernas utilizan el sistema de objetos Moose . [ cita necesaria ] Moose está construido sobre Class::MOP, un protocolo de metaobjetos, que proporciona una introspección completa para todas las clases que utilizan Moose. Por lo tanto, puede preguntar a las clases sobre sus atributos, padres, hijos, métodos, etc. utilizando una API simple.
Clases de alces:
Roles de los alces:
Un ejemplo de una clase escrita usando la extensión MooseX::Declare [10] para Moose:
utilizar MooseX::Declarar ; clase Point3D extiende Punto { tiene 'z' => ( isa => 'Num' , es => 'rw' ); después de borrar { $self -> z ( 0 ); } método set_to ( Núm $x , Núm $y , Núm $z ) { $self -> x ( $x ); $yo -> y ( $y ); $yo -> 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 lo extiende clear.
[…] una cadena sin comillas, conocida como cadena de palabra simple […]