Estructura del lenguaje Perl

Este artículo posiblemente contenga una investigación original . Por favor, mejorarlo mediante la verificación de las afirmaciones hechas y la adición de citas en línea . Deben eliminarse las declaraciones que solo contengan investigaciones originales. ( Julio de 2017 ) ( Obtenga información sobre cómo y cuándo eliminar este mensaje de plantilla )

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 tipado dinámicamente , 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 CPAN.archive, un repositorio mantenido por la comunidad de más de 100.000 módulos. ^[2]

Sintaxis básica

En Perl, el programa mínimo de Hello World 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 es alterada por el carácter de escape anterior (una barra invertida). Desde la versión 5.10, el nuevo 'say' incorporado ^[3] produce el mismo efecto aún más simple:

di  "¡Hola, mundo!"

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

$  perl  - e  'imprime "¡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 la marca de almohadilla introduce un comentario en Perl, que se ejecuta hasta el final de la línea de código y es ignorado por el compilador (excepto en Windows). El comentario que se usa aquí es de un tipo especial: se llama la línea shebang . Esto le dice a los sistemas operativos similares a Unix que encuentren el intérprete de Perl, lo que hace posible 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 Perl. Para hacer frente a tales circunstancias, perldetecta la línea shebang y la analiza en busca de conmutadores. ^[4] )

La segunda línea de 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 puede omitirse 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 agrega 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 y no 5.10 dice  '¡Hola, mundo!'

Tipos de datos

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

Escribe	Sigilo	Ejemplo	Descripción
Escalar	PS	$ foo	Un solo valor; puede ser un número, una cadena , un identificador de archivo o una referencia .
Formación	@	@foo	Una colección ordenada de escalares.
Picadillo	%	% foo	Un mapa de cadenas a escalares; las cadenas se denominan claves y los escalares se denominan valores . También conocido como matriz asociativa .
Filehandle	ninguno	$ foo o FOO	Una representación opaca de un archivo abierto u otro destino para leer, escribir o ambos.
Subrutina	Y	& foo	Un fragmento de código al que se le pueden pasar argumentos, ejecutar y devolver datos.
Typeglob	*	* foo	La entrada de la tabla de símbolos para todos los tipos con el nombre 'foo'.

Valores escalares

Los valores de cadena (literales) deben ir entre comillas. Incluir 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. Incluir 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, preceda con una barra invertida o encierre la cadena entre comillas simples. Para incluir una comilla simple, preceda con una barra invertida o encierre la cadena entre comillas dobles.

Cuerdas también puede ser citado con el qy qqcita como operadores:

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

Finalmente, las cadenas de varias líneas se pueden definir utilizando aquí documentos :

$ multilined_string  =  << EOF ; Esta es mi nota de cadena de varias líneas que la termino con la palabra "EOF". EOF

Los números (constantes numéricas) no requieren cotización. 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 finales no numéricas 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, +es siempre el operador de suma numérico. El operador de concatenación de cadenas es el punto.

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

Se proporcionan funciones para el redondeo de valores fraccionarios a valores enteros: intcorta la parte fraccionaria, redondeando hacia cero; POSIX::ceily POSIX::floorredondear siempre hacia arriba y siempre hacia abajo, respectivamente. La conversión de número a cadena de printf "%f"o sprintf "%f"redondear par, utilice el redondeo bancario .

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

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

Todos los demás valores (de evaluación distintos 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 conceptualmente portátil 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 elevado a cero. El hash vacío {}también es cierto; en este contexto {}no es un bloque vacío, porque perl -e 'print ref {}'devuelve 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 función definida () determina si una variable tiene algún valor establecido. En los ejemplos anteriores, definido ($ false) es verdadero para todos los valores excepto undef .

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

my  $ real_result  =  $ boolean_result  ?  1  :  0 ;

Valores de matriz

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

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

El operador de tipo comillas qw () 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 separan de una expresión de cadena mediante una cadena delimitadora o una expresión regular.

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

Se accede a los elementos individuales de una lista proporcionando un índice numérico entre corchetes. Debe usarse 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 la 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").

Valores hash

Los programadores de Perl pueden inicializar un hash (o matriz asociativa ) 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, 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 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} es igual a 'rojo'. Un hash también se puede inicializar configurando sus valores individualmente:

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

En su lugar, se puede acceder a múltiples elementos usando el @sigilo (identificando el resultado como una lista). Por ejemplo, @favorite {'joe', 'sam'} es igual a ('rojo', 'azul').

Manijas de archivos

Los identificadores de archivos brindan acceso de lectura y escritura a los recursos. Por lo general, estos son archivos en disco, pero también pueden ser un dispositivo, una tubería o incluso un valor escalar.

Originalmente, los identificadores de archivos solo se podían crear con variables de paquete, usando 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á (se autovivificará ) como una referencia a un identificador de archivo anónimo, en lugar de un identificador de archivo con nombre.

Valores de Typeglob

Un valor de typeglob es una entrada de tabla de símbolos. El uso principal de typeglobs es crear 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 'eso'

Funciones de matriz

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

Funciones hash

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 devuelve el siguiente par clave / valor. # Todos los valores serán devueltos eventualmente, pero su orden # no se puede predecir. while  (( $ nombre ,  $ dirección )  =  cada  % libreta de direcciones )  {  print  "$ nombre vive en $ dirección \ n" ; }# Al igual que el anterior, pero organizados alfabéticamente foreach  mi  $ next_name  ( ordenar  teclas  % libreta de direcciones )  {  print  "$ vidas next_name en la libreta de direcciones $ {} $ next_name \ n" ; }

Estructuras de Control

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 rodeadas por paréntesis y los bloques controlados están rodeados por llaves:

etiqueta while ( cond ) {…} etiqueta while ( cond ) {…} continuar {…} etiqueta para ( init-expr  ; cond-expr  ; incr-expr ) {…} etiqueta foreach var ( lista ) {…} etiqueta foreach var ( lista ) {…} continuar {…}
if ( cond ) {…}
if ( cond ) {…} else {…}
if ( cond ) {…} elsif ( cond ) {…} else {…}

Cuando solo se controla una sola 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 while cond  ;declaración hasta 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 facilita su uso para controlar declaraciones completas).

Las palabras clave de control de flujo next(correspondientes a las C continue), last(correspondientes a las C break) return, y 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 = mapa {…} lista resultados = mapa 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 controlado o la expresión 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 instrucción switch en Perl 5. Desde la 5.10.0 en adelante, está disponible una instrucción de rama multidireccional llamada given/ when, que tiene la siguiente forma:

utilizar v5.10; # debe estar presente para importar las nuevas funciones 5.10
dado ( expr ) {cuando ( cond ) {…} predeterminado {…}}

Sintácticamente, esta estructura se comporta de manera similar a las declaraciones de cambio que se encuentran en otros lenguajes, pero con algunas diferencias importantes. El más grande es que, a diferencia de las estructuras switch / case, las declaraciones / when rompen 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 continues explícitos son necesarios para emular el comportamiento del conmutador.

Para aquellos que no usan Perl 5.10, la documentación de Perl describe media docena de formas de lograr el mismo efecto usando 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 su uso extraoficialmente. ^[6]

Perl incluye una goto labeldeclaración, pero rara vez se usa. Las situaciones en las que gotose solicita 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 usa en situaciones en las que una persona que llama puede realizar una administración de pila más eficiente que el propio Perl (generalmente porque no se requiere ningún cambio en la pila actual), y en la recursividad profunda, la llamada de cola puede tener un impacto positivo sustancial en el rendimiento, ya que evita la gastos generales de gestión de alcance / pila a la devolución.

Subrutinas

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 ampersand ( & ) antes. Pero el uso de & sin paréntesis también pasará implícitamente los argumentos de la subrutina actual a la llamada, y el uso de & entre paréntesis evitará los prototipos.

# Llamar a una subrutina# Aquí se requieren paréntesis 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 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 hash se expanden a una lista de pares clave / valor; y todo el lote se pasa a la subrutina como una lista plana de escalares.

Los argumentos que se pasen están disponibles 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 subíndolos de la forma habitual.

$ _ [ 0 ],  $ _ [ 1 ]

Sin embargo, el código resultante puede ser difícil de leer y los parámetros tienen 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 la semántica de paso por valor . La mypalabra clave indica que las siguientes variables tienen un ámbito léxico en el bloque contenedor.

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

my  $ x  =  turno ;

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

sub  function1  {  my  % 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 returndeclaración, devuelve la última expresión evaluada dentro del cuerpo de la subrutina. Las matrices y hashes en el valor de retorno se expanden a listas de escalares, al igual que lo son para 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  array  {  @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  o bien  {  return  wantarray  ?  ( 1 ,  2 )  :  'Naranjas' ; }$ x  =  cualquiera ;  # devuelve "Naranjas" @x  =  ya sea ;  # devuelve (1, 2)

Expresiones regulares

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 amplía 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 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 para incluir muchas más funciones. Muchos otros lenguajes y aplicaciones están adoptando expresiones regulares compatibles con Perl sobre expresiones regulares POSIX , como PHP , Ruby , Java , .NET Framework de Microsoft , ^[8] y el servidor HTTP Apache .

La sintaxis de las expresiones regulares es extremadamente compacta debido a la historia. Los primeros dialectos de expresión regular eran solo un poco más expresivos que los globs , y la sintaxis se diseñó para que una expresión se pareciera al texto que coincide. ^{[ cita requerida ]} Esto significaba no usar más de un 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 sintaxis nunca se revisó y sigue dependiendo de la puntuación. Como resultado, las expresiones regulares pueden ser crípticas y extremadamente densas.

Usos

El m//operador (coincidencia) introduce una coincidencia de expresión regular. (Si está delimitado por barras, como en todos los ejemplos aquí, el interlineado mpuede omitirse por 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 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 / ;  # upcase 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.

Sintaxis

Modificadores

Las expresiones regulares de Perl pueden tomar modificadores . Estos 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 y reemplazo global

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 ;

Capturando

Las partes de una expresión regular se pueden incluir entre paréntesis; se capturan las porciones correspondientes de una cadena coincidente . Las cadenas capturadas se asignan a las variables incorporadas 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 usar 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, mediante el uso del /emodificador:

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

Objetos

Esta sección necesita expansión . Puede ayudar añadiéndole . ( Marzo de 2010 )

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

sub  Point :: new {  # Aquí, Point-> new (4, 5) resultará en que $ class sea 'Point'.  # Es una variable para admitir subclases (consulte la página de manual de perloop).  mi  ( $ clase ,  $ x ,  $ y )  =  @_ ;  bendiga  [ $ x ,  $ y ],  $ clase ;  # Retorno implícito }sub  Point :: distancia {  my  ( $ self ,  $ from )  =  @_ ;  my  ( $ dx ,  $ dy )  =  ( $$ self [ 0 ]  -  $$ de [ 0 ],  $$ self [ 1 ]  -  $$ de [ 1 ]);  sqrt ( $ dx  *  $ dx  +  $ dy  *  $ dy ); }

Esta clase se puede utilizar invocando new()para construir instancias e invocando distanceen esas instancias.

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

Muchas aplicaciones modernas de Perl utilizan el sistema de objetos de Moose . ^{[ cita requerida ]} Moose está construido sobre Class :: MOP, un protocolo de meta-objeto, que proporciona una introspección completa para todas las clases que usan Moose. Por lo tanto, 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 principales). Una clase hereda de su (s) superclase (s).
Una clase tiene cero o más roles, lo que agrega la capacidad de agregar funcionalidad predefinida a las clases sin subclases.
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, métodos heredados de sus antepasados o métodos proporcionados por roles.

Roles de los alces:

Un rol es algo que hace una clase, algo así como 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 requeridos.

Ejemplos de

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

use  MooseX :: Declare ;class  Point3D  extiende  Point  {  has  'z'  =>  ( isa  =>  'Num' ,  is  =>  'rw' ); después de  borrar  {  $ self -> z ( 0 );  }  método  set_to  ( Num  $ x ,  Num  $ y ,  Num  $ z )  {  $ self -> x ( $ x );  $ self -> y ( $ y );  $ uno mismo -> z ( $ z );  } }

Esta es una clase nombrada Point3Dque amplía otra clase nombrada 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.

Referencias

^ Orwant, Jon (2003). Juegos, diversiones y cultura Perl: lo mejor de la revista Perl . ISBN 978-0-596-00312-8.
^ "Portada de CPAN" . Consultado el 9 de diciembre de 2011 .
^ "Características" . Perldoc . Perl.org . Consultado el 24 de julio de 2017 .
^ "perlrun" . perldoc.perl.org - Documentación oficial para el lenguaje de programación Perl . Consultado el 8 de enero de 2011 .
^ Wainwright, Peter (2005). Pro Perl . Pro a Expert Series. Presione. pag. 64. ISBN 978-1-59059-438-4. Consultado el 3 de agosto de 2010 . […] Una cadena sin comillas, conocida como cadena de palabras desnudas […]
^ usando el interruptor
^ Damian Conway, Perl Best Practices Archivado el 18 de septiembre de 2011 en Wayback Machine , p.182
^ Microsoft Corp., "Expresiones regulares de .NET Framework", Guía del desarrollador de .NET Framework , [1]
^ MooseX :: Declarar documentación

enlaces externos

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

[1] Orwant, Jon (2003). Juegos, diversiones y cultura Perl: lo mejor de la revista Perl . ISBN 978-0-596-00312-8.

[home-2] "Portada de CPAN" . Consultado el 9 de diciembre de 2011 .

[3] "Características" . Perldoc . Perl.org . Consultado el 24 de julio de 2017 .

[4] "perlrun" . perldoc.perl.org - Documentación oficial para el lenguaje de programación Perl . Consultado el 8 de enero de 2011 .

[5] Wainwright, Peter (2005). Pro Perl . Pro a Expert Series. Presione. pag. 64. ISBN 978-1-59059-438-4. Consultado el 3 de agosto de 2010 . […] Una cadena sin comillas, conocida como cadena de palabras desnudas […]

[6] usando el interruptor

[7] Damian Conway, Perl Best Practices Archivado el 18 de septiembre de 2011 en Wayback Machine , p.182

[8] Microsoft Corp., "Expresiones regulares de .NET Framework", Guía del desarrollador de .NET Framework , [1]

[9] MooseX :: Declarar documentación

[1]