Estructura del lenguaje Perl

La estructura del lenguaje de programación Perl abarca tanto las reglas sintácticas como la organización general de los programas. La filosofía de diseño de Perl se expresa en el lema comúnmente citado: « Hay más de una forma de hacerlo ». Como lenguaje multiparadigma y de tipado dinámico , Perl permite una gran flexibilidad en el diseño de programas. Perl también fomenta la modularización; esto se atribuye a la estructura de diseño basada en componentes de sus raíces Unix [ ^{1 ] y} es responsable del tamaño del archivo CPAN , un repositorio comunitario con 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!"

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

¡Di "Hola, mundo!"

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

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

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

#!/usr/bin/env 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 denomina línea shebang . Esta indica a los sistemas operativos tipo Unix que busquen el intérprete de Perl, lo que permite invocar el programa sin mencionarlo explícitamente perl. (Cabe destacar que, en los sistemas Microsoft Windows , los programas de Perl se invocan normalmente asociando la .plextensión con el intérprete de Perl. Para gestionar estas 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 instrucciones en Perl. Cuando un bloque o archivo contiene una sola instrucción, el separador es innecesario, por lo que puede omitirse de la forma mínima del programa, o, en general, de la última instrucción de cualquier bloque o archivo. La forma canónica lo incluye porque es común finalizar cada instrucción incluso cuando no es necesario, ya que esto facilita la edición: se puede agregar o mover código al final de un bloque o archivo sin tener que modificar los puntos y comas.

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

use 5.010 ; # debe estar presente para importar las nuevas funciones 5.10, tenga en cuenta que es 5.010, no 5.10 diga '¡Hola, mundo!'

Perl tiene varios tipos de datos fundamentales . Los más utilizados y comentados son los escalares , los arrays , los hashes , los descriptores de archivo y las subrutinas :

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

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

$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

mi $real_resultado = $boolean_resultado ? 1 : 0 ;

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

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

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

%favorite = ( 'joe' , "red" , 'sam' , "blue" ); %favorite = ( joe => 'red' , sam => 'blue' );

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

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

# Cada llamada a each devuelve el siguiente par clave/valor. # Todos los valores se devolverán eventualmente, pero su orden # no se puede predecir. while (( $name , $address ) = each %addressbook ) { print "$name vive 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.

Posee estructuras de control orientadas a bloques, similares a las de los lenguajes de programación C, JavaScript y Java . Las condiciones se encierran entre paréntesis y los bloques controlados entre llaves.

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

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

instrucción if cond ; instrucción unless cond ; instrucción while cond ; instrucción until cond ; instrucción foreach list ;

Los operadores lógicos de cortocircuito se utilizan habitualmente para afectar al flujo de control a nivel de expresión:

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

(Los operadores "and" y "or" son similares a && y || pero tienen menor precedencia , lo que facilita su uso para controlar sentencias completas).

Las palabras clave de control de flujo next(que corresponden a C's continue), last(que corresponden a C's break) return, y 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 = map { ... } lista resultados = map expr , lista

grepDevuelve todos los elementos de la lista para los que el bloque o expresión controlada se evalúa como verdadero. mapEvalúa el bloque o expresión controlada para cada elemento de la lista y devuelve una lista con los valores resultantes. Estas construcciones permiten un estilo de programación funcional sencillo .

Hasta la versión 5.10.0, no existía la instrucción switch en Perl 5. A partir de la versión 5.10.0, está disponible una instrucción de bifurcación múltiple llamada given/ when, que tiene la siguiente forma:

usev5.10;# must be present to import the new 5.10 functions dado ( expr ) { cuando ( cond ) { ... } por defecto { ... } }

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

Para quienes no utilicen Perl 5.10, la documentación de Perl describe media docena de maneras de lograr el mismo efecto mediante otras estructuras de control. También existe un módulo Switch, que proporciona una funcionalidad basada en la del lenguaje hermano Raku . Está implementado mediante un filtro de origen , por lo que su uso no está recomendado oficialmente. ^{[ 6 ]}

Perl incluye una goto labelinstrucción, pero rara vez se usa. Las situaciones en las que gotose requiere una instrucción en otros lenguajes no ocurren con tanta frecuencia en Perl, debido a su amplia gama de opciones de control de flujo.

También existe una instrucción que realiza una llamada recursiva . Esta finaliza la subrutina actual e inmediatamente llama a la instrucción especificada . Esto se utiliza en situaciones donde quien realiza la llamada puede gestionar la pila de forma más eficiente que Perl (normalmente porque no se requiere ningún cambio en la pila actual), y en la recursión profunda, la llamada recursiva puede tener un impacto positivo sustancial en el rendimiento, ya que evita la sobrecarga de la gestión del ámbito/pila al regresar.goto &subsub

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 signo de ampersand ( & ) antes del mismo. Sin embargo, usar & sin paréntesis también pasa implícitamente los argumentos de la subrutina actual a la llamada, y usar & con paréntesis omite los prototipos.

# Llamando 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)# Definición de una subrutina sub foo { … }foo ; # Aquí no se requieren paréntesis

Tras el nombre de la subrutina, se puede proporcionar una lista de argumentos. Estos pueden ser escalares, listas o hashes.

foo $x , @y , %z ;

Los parámetros de una subrutina no necesitan declararse 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.

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

Los argumentos que se le pasan están disponibles para la subrutina en el array 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 @_indexá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 cual puede resultar indeseable.

Una forma común de hacerlo es asignar un valor @_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 alcance léxico limitado al bloque que las contiene.

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

mi $x = desplazamiento ;

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

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

Las subrutinas pueden devolver valores.

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

Si la subrutina no finaliza mediante una returninstrucción, devuelve la última expresión evaluada dentro de su cuerpo. Los arrays y hashes del valor de retorno se expanden a listas de escalares, al igual que los argumentos.

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

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 como se creómi $squarer = sub { mi $x = shift ; $x * $x }; # 2. asignado a una variablesub curry { my ( $sub , @args ) = @_ ; return sub { $sub -> ( @args , @_ ) }; # 3. como valor de retorno de otra función }# Ejemplo de currificación 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 )

mi @cuadrados = map { $_ * $_ } 1 .. 10 ; # map y grep no usan la palabra clave 'sub' mi @cuadrado2 = map $_ * $_ , 1 .. 10 ; # llaves innecesarias para una expresiónmi @bad_example = map { print para @_ } 1 .. 10 ; # los valores no se pasan como en una función Perl normal

El lenguaje Perl incluye una sintaxis especializada para escribir expresiones regulares (RE o regex), y el intérprete contiene un motor para comparar cadenas con expresiones regulares. El motor de expresiones regulares utiliza un algoritmo de retroceso , lo que amplía sus capacidades desde la simple coincidencia de patrones hasta la captura y sustitución de cadenas. El motor de expresiones regulares 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 características. Muchos otros lenguajes y aplicaciones están adoptando ahora expresiones regulares compatibles con Perl en lugar de expresiones regulares POSIX , como PHP , Ruby , Java , el .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 solo ligeramente más expresivos que los comodines , y su sintaxis se diseñó para que una expresión se asemejara al texto con el que coincidía. Esto implicaba usar un solo signo de puntuación o un par de caracteres delimitadores para expresar las pocas aserciones admitidas. Con el tiempo, la expresividad de las expresiones regulares aumentó enormemente, pero el diseño sintáctico nunca se revisó y sigue dependiendo de la puntuación. Como resultado, las expresiones regulares pueden ser crípticas y extremadamente densas.

$x =~ /abc/ ;

$x =~ s/abc/aBc/ ; # convertir la b a mayúscula

@words = split /,/ , $line ;

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

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

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

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

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

sub Point ::new { # Aquí, Point->new(4, 5) hará que $class sea 'Point'. # Es una variable para admitir la herencia (ver la página man 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 usar invocándola new()para construir instancias y luego invocándolas 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 . Moose se basa en Class::MOP, un protocolo de metaobjetos que proporciona introspección completa para todas las clases que lo utilizan. De este modo, se puede consultar información sobre los atributos, clases padre, clases hija, métodos, etc., de las clases mediante una API sencilla.

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 llamadas clases padre). Una clase hereda de su(s) superclase(s).
• Una clase realiza cero o más funciones, lo que permite añadir funcionalidades predefinidas a las clases sin necesidad de crear 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, a los métodos heredados de sus clases ancestras o a los métodos proporcionados por los roles.

Funciones de los alces:

• Un rol es una función que desempeña una clase, similar a los mixins o las 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.

usar 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 ); } } 

• Tutoriales de Perl
• Aprende Perl en aproximadamente 2 horas y 30 minutos.
• PerlMonks: Una comunidad dedicada a compartir conocimientos sobre Perl y consejos de programación.