Perl

**Perl** es un lenguaje de programación diseñado por Larry Wall en 1987. Perl toma características del lenguaje C, del lenguaje interpretado bourne shell (sh), AWK, sed, Lisp y, en un grado inferior, de muchos otros lenguajes de programación.

Estructuralmente, Perl está basado en un estilo de bloques como los
del C o AWK, y fue ampliamente adoptado por su destreza en el procesado
de texto y no tener ninguna de las limitaciones de los otros lenguajes
de script.

## Índice

* 1 Historia
	+ 1.1 Nombre
	+ 1.2 El símbolo del camello
* 2 Descripción
	+ 2.1 Características
	+ 2.2 Diseño
	+ 2.3 Aplicaciones
	+ 2.4 Implementación
	+ 2.5 Disponibilidad
		- 2.5.1 GNU/Linux
		- 2.5.2 Windows
* 3 Estructura del lenguaje
	+ 3.1 Programa ejemplo
	+ 3.2 Tipos de datos
	+ 3.3 Estructuras de control
	+ 3.4 Subrutinas
	+ 3.5 Expresiones regulares
	+ 3.6 Interfaz con bases de datos
* 4 Comparativa de funcionamiento
	+ 4.1 Optimizando
* 5 Futuro
* 6 Diversión con Perl
	+ 6.1 Enlaces relacionados
* 7 Comunidad Perl
* 8 Véase también
* 9 Referencias
* 10 Enlaces externos

## Historia

Larry Wall comenzó a trabajar en Perl en 1987 mientras trabajaba como programador en Unisys3 y anunció la versión 1.0 en el grupo de noticias comp.sources.misc el 18 de diciembre de 1987. El lenguaje se expandió rápidamente en los siguientes años. Perl 2, publicado en 1988, aportó un mejor motor de expresiones regulares. Perl 3, publicado en 1989, añadió soporte para datos binarios.
Hasta 1991 la única documentación de Perl era una simple (y cada vez más larga) página de manual Unix. En 1991 se publicó *Programming Perl* (el libro del camello) y se convirtió en la referencia *de facto*
 del lenguaje. Al mismo tiempo, el número de versión de Perl saltó a 4,
no por marcar un gran cambio en el lenguaje, sino por identificar a la
versión que estaba documentada en el libro.

Perl 4 trajo consigo una serie de lanzamientos de mantenimiento,
culminando en Perl 4.036 en 1993. En este punto, Larry Wall abandonó
Perl 4 para comenzar a trabajar en Perl 5. Perl 4 se quedaría en esa
versión hasta hoy.

El desarrollo de Perl 5 continuó en 1994. La lista de correo *perl5-porters*
 se estableció en mayo de 1994 para coordinar el trabajo de adaptación
de Perl 5 a diferentes plataformas. Es el primer foro para desarrollo,
mantenimiento y adaptación de Perl 5.

Perl 5 fue publicado el 17 de octubre de 1994. Fue casi una completa reescritura del intérprete
 y añadió muchas nuevas características al lenguaje, incluyendo objetos,
 referencias, paquetes y módulos. A destacar, los módulos proveen de un
mecanismo para extender el lenguaje sin modificar el intérprete. Esto
permitió estabilizar su núcleo principal, además de permitir a los
programadores de Perl añadirle nuevas características.

El 26 de octubre de 1995, se creó el *Comprehensive Perl Archive Network* (CPAN). CPAN
 es una colección de sitios web que almacenan y distribuyen fuentes en
Perl, binarios, documentación, scripts y módulos. Originalmente, cada
sitio CPAN debía ser accedido a través de su propio URL; hoy en día, http://www.cpan.org redirecciona automáticamente a uno de los cientos de repositorios espejo de CPAN.

En 2008,
 Perl 5 continua siendo mantenido. Características importantes y algunas
 construcciones esenciales han sido añadidas, incluyendo soporte Unicode, Hilos (*threads*), un soporte importante para la programación orientada a objetos y otras mejoras.

### Nombre

Perl se
llamó originalmente "Pearl". Larry Wall quería darle al lenguaje un
nombre corto con connotaciones positivas; asegura que miró (y rechazó)
todas las combinaciones de tres y cuatro letras del diccionario. También
 consideró nombrarlo como su esposa Gloria. Wall descubrió antes del
lanzamiento oficial que ya existía un lenguaje de programación llamado PEARL y cambió la ortografía del nombre.
El nombre normalmente comienza con mayúscula (*Perl*) cuando se refiere al lenguaje y con minúscula (*perl*)
 cuando se refiere al propio programa intérprete debido a que los
sistemas de ficheros Unix distinguen mayúsculas y minúsculas. Antes del
lanzamiento de la primera edición de *Programming Perl* era común referirse al lenguaje como *perl*; Randal L. Schwartz,
 sin embargo, forzó el nombre en mayúscula en el libro para que
destacara mejor cuando fuera impreso. La distinción fue
subsiguientemente adoptada por la comunidad.

El nombre es descrito ocasionalmente como "PERL" (por **P**ractical **E**xtraction and **R**eport **L**anguage - *Lenguaje Práctico para la Extracción e Informe*). Aunque esta expansión ha prevalecido en muchos manuales actuales, incluyendo la página de manual de Perl, es un retroacrónimo y oficialmente el nombre no quiere decir nada. La ortografía de PERL en mayúsculas es por eso usada como jerga para detectar a individuos ajenos a la comunidad. Sin embargo, se han sugerido varios retroacrónimos, incluyendo el cómico *Pathologically Eclectic Rubbish Lister* (Contabilizador de Basura Patológicamente Ecléctico).

### El símbolo del camello

Perl se simboliza generalmente por un camello de una sola joroba (camello arábigo o dromedario), que fue la imagen elegida por el editor O'Reilly para la cubierta de *Programming Perl*, que por consiguiente adquirió el nombre de *El Libro del Camello*.3 O'Reilly es propietario de este símbolo como marca registrada, pero dice que usa sus derechos legales sólo para proteger la *"integridad e impacto de este símbolo"*.4 O'Reilly permite el uso no comercial del símbolo, y ofrece logos Programming Republic of Perl y botones Powered by Perl.
Desde hace unos años, y para evitar este tipo de problemas con la
licencia comercial, la Fundación Perl elaboró nuevos logotipos basados
en una cebolla, a raíz de las conferencias anuales que Larry Wall ofrece
 con el título: *State of the Onion* ("Estado de la Cebolla") *Onion* se pronuncia muy parecido a *Union*, por lo que suena parecido a *State of the Union* ("Estado de la Unión"), evento en el cual el Presidente de los Estados Unidos informa a los ciudadanos del estado en que se encuentra su país.

## Descripción

La página de manual Unix perlintro(1) dice:

### Características

La estructura completa de Perl deriva ampliamente del lenguaje C. Perl es un lenguaje imperativo, con variables, expresiones, asignaciones, bloques de código delimitados por llaves, estructuras de control y subrutinas.
Perl también toma características de la programación shell. Todas las variables son marcadas con un Sigilo precedente (*Sigil*,
 en inglés). Los sigilos identifican inequívocamente los nombres de las
variables, permitiendo a Perl tener una rica sintaxis. Notablemente, los
 sigilos permiten interpolar variables directamente dentro de las cadenas de caracteres (*string*). Como en los shell, Perl tiene muchas funciones integradas para tareas comunes y para acceder a los recursos del sistema.

Perl toma las listas del Lisp, *hash* (memoria asociativa) del AWK y expresiones regulares del sed. Todo esto simplifica y facilita todas las formas del análisis sintáctico, manejo de texto y tareas de gestión de datos.

En Perl 5, se añadieron características para soportar estructuras de datos complejas, funciones de primer orden (p. e. clausuras como valores) y un modelo de programación orientada a objetos. Éstos incluyen referencias, paquetes y una ejecución de métodos basada en clases y la introducción de variables de ámbito léxico, que hizo más fácil escribir código robusto (junto con el pragma strict). Una característica principal introducida en Perl 5 fue la habilidad de empaquetar código reutilizable como módulos.
 Larry Wall indicó más adelante que "la intención del sistema de módulos
 de Perl 5 era apoyar el crecimiento de la cultura Perl en vez del
núcleo de Perl".5

Todas las versiones de Perl hacen el tipificado automático de datos y la gestión de memoria.
 El intérprete conoce el tipo y requerimientos de almacenamiento de cada
 objeto en el programa; reserva y libera espacio para ellos según sea
necesario. Las conversiones legales de tipo se hacen de forma automática
 en tiempo de ejecución; las conversiones ilegales son consideradas
errores fatales.

### Diseño

El
diseño de Perl puede ser entendido como una respuesta a tres amplias
tendencias de la industria informática: rebaja de los costes en el
hardware, aumento de los costes laborales y las mejoras en la tecnología
 de compiladores. Anteriormente, muchos lenguajes de ordenador como el Fortran
 y C, fueron diseñados para hacer un uso eficiente de un hardware caro.
En contraste, Perl es diseñado para hacer un uso eficiente de los
costosos programadores de ordenador.
Perl tiene muchas características que facilitan la tarea del
programador a costa de unos requerimientos de CPU y memoria mayores.
Éstas incluyen gestión de memoria automática; tipo de dato dinámico; *strings*, listas y *hashes*; expresiones regulares; introspección y una función `eval()`.

Larry Wall fue adiestrado como lingüista y el diseño de Perl ha sido
muy aleccionado con principios lingüísticos. Ejemplos incluyen la Codificación Huffman
 (las construcciones más comunes deben ser las más cortas), buena
distribución (la información importante debe ir primero) y una larga
colección de primitivas del lenguaje. Perl favorece las construcciones
del lenguaje, tan naturales, como para los humanos son la lectura y la
escritura, incluso si eso hace más complicado al intérprete Perl.

La sintaxis de Perl refleja la idea de que "cosas que son diferentes deben parecer diferentes". Por ejemplo, escalares, *arrays* y *hashes* tienen diferente sigilo. Índices de *array* y claves *hash* usan diferentes clases de paréntesis. *Strings* y expresiones regulares tienen diferentes delimitadores estándar. Esta aproximación puede contrastarse con lenguajes como Lisp, donde la misma construcción *S-expresión* y sintaxis básica se usa para muchos y variados propósitos.

Perl tiene características que soportan una variedad de paradigmas de programación, como la imperativa, funcional y la orientada a objetos. Al mismo tiempo, Perl no obliga a seguir ningún paradigma en particular, ni obliga al programador a elegir alguna de ellas.

Hay un amplio sentido de lo práctico, tanto en el lenguaje Perl como en la comunidad y la cultura que lo rodean. El prefacio de *Programming Perl*
 comienza con, "Perl es un lenguaje para tener tu trabajo terminado".
Una consecuencia de esto es que Perl no es un lenguaje ordenado. Incluye
 características si la gente las usa, tolera excepciones a las reglas y
emplea la heurística
 para resolver ambigüedades sintácticas. Debido a la naturaleza
indulgente del compilador, a veces los errores pueden ser difíciles de
encontrar. Hablando del variado comportamiento de las funciones internas
 en los contextos de lista y escalar, la página de manual de `perlfunc(1)` dice "En general, hacen lo que tu quieras, siempre que quieras la coherencia."

Perl tiene varios lemas que transmiten aspectos de su diseño y uso. Uno es *There's more than one way to do it* (Hay más de una forma de hacerlo) (TMTOWTDI, usualmente pronunciado 'Tim Toady'). Otros son *"Perl: la motosierra del ejército Suizo de los lenguajes de programación"* y *"Límites imprecisos"*.
 Una meta prefijada de Perl es hacer las cosas fáciles de forma fácil y
las tareas difíciles, posibles. A Perl también se le ha llamado *"El esparadrapo de Internet"*.

### Aplicaciones

La LAMP comprende Perl (aquí con Squid)

Perl tiene muchas y variadas aplicaciones, gracias a la disponibilidad de muchos módulos estándares y de terceras partes.

Se ha usado desde los primeros días del Web para escribir guiones (*scripts*) CGI.
 Es una de las "tres Pes" (Perl, Python y PHP), que son los lenguajes
más populares para la creación de aplicaciones Web, y es un componente
integral de la popular solución LAMP para el desarrollo web. Grandes proyectos escritos en Perl son Slash, IMDb6 y UseModWiki, un motor de Wiki. Muchos sitios web con alto tráfico, como Amazon.com y Ticketmaster.com usan Perl extensamente.

Perl se usa a menudo como un "lenguaje pegamento", ligando sistemas e interfaces
 que no fueron diseñados específicamente para interoperar; y para el
"escarbado de datos", convirtiendo o procesando grandes cantidades de
datos para tareas como por ejemplo crear informes. De hecho, estas
fortalezas están íntimamente unidas. Su combinación hace a Perl una
popular herramienta de propósito general para los administradores de sistemas, especialmente en programas pequeños que pueden ser escritos y ejecutados en una sola línea de comandos.

Perl es también ampliamente usado en finanzas y bioinformática, donde es apreciado por su desarrollo rápido, tanto de aplicaciones como de despliegue, así como la habilidad de manejar grandes volúmenes de datos.

### Implementación

Perl está implementado como un intérprete, escrito en C, junto con una gran colección de módulos, escritos en Perl y C. La distribución fuente tiene, en 2005, 12 MB cuando se empaqueta y comprime en un fichero tar. El intérprete tiene 150.000 líneas de código C y se compila en un ejecutable de 1 MB en las arquitecturas de hardware más típicas. De forma alternativa, el intérprete puede ser compilado como una biblioteca y ser embebida
 en otros programas. Hay cerca de 500 módulos en la distribución,
sumando 200.000 líneas de Perl y unas 350.000 líneas adicionales de
código C. Mucho del código C en los módulos consiste en tablas de codificación de caracteres.
El intérprete tiene una arquitectura orientada a objetos. Todos los elementos del lenguaje Perl —escalares, listas, *hashes*,
 referencias a código, manejadores de archivo— están representados en el
 intérprete como estructuras C. Las operaciones sobre estas estructuras
están definidas como una numerosa colección de macros, typedef y funciones; esto constituye la API
 C de Perl. La API Perl puede ser desconcertante para el no iniciado,
pero sus puntos de entrada siguen un esquema de nombres coherente, que
ayuda a los que quieran utilizarla.

La ejecución de un programa Perl se puede dividir, generosamente, en dos fases: tiempo de compilación y tiempo de ejecución.7 En tiempo de compilación el intérprete *parsea* el texto del programa en un árbol sintáctico. En tiempo de ejecución, ejecuta el programa siguiendo el árbol. El texto es parseado sólo una vez y el árbol sintáctico es optimizado antes de ser ejecutado, para que la fase de ejecución sea relativamente eficiente. Las optimizaciones del árbol sintáctico en tiempo de compilación incluyen simplificación de expresiones constantes, propagación del contexto y optimización en trozos sueltos de código. Sin embargo, las fases de compilación y ejecución pueden anidarse: un bloque `BEGIN` se ejecuta en tiempo de compilación, mientras que una función `eval` inicia una compilación durante una ejecución. Ambas operaciones están implícitas en otras -de forma notable, la cláusula `use` que carga bibliotecas, conocidas en Perl como módulos, implica un bloque `BEGIN`.

Perl es un lenguaje dinámico y tiene una gramática sensible al contexto que puede quedar afectada por el código ejecutado durante una fase de ejecución intermedia (Ver ejemplos.8 ). Por eso Perl no puede ser parseado mediante una aplicación directa de analizadores sintácticos/parseadores Lex/Yacc. En cambio, el intérprete implementa su propio analizador léxico, que coordinado con un parseador modificado GNU bison resuelve las ambigüedades del lenguaje. Se ha dicho que "sólo perl puede parsear Perl", queriendo decir que sólo el intérprete Perl (*perl*) puede parsear el lenguaje Perl (*Perl*).
 La razón de esto se atestigua por las persistentes imperfecciones de
otros programas que emprenden la tarea de parsear Perl, como los
analizadores de código y los auto-indentadores, que tienen que vérselas
no sólo con las muchas formas de expresar inequívocamente construcciones
 sintácticas, sino también con el hecho de que también Perl no puede, en
 general, ser parseado sin antes ser ejecutado.

El mantenimiento
 del intérprete Perl, a lo largo de los años, se ha vuelto cada vez más
difícil. El núcleo ha estado en continuo desarrollo desde 1994. El código ha sido optimizado en rendimiento
 a expensas de la simplicidad, claridad y unas interfaces internas más
fuertes. Nuevas características han sido añadidas, manteniendo todavía,
compatibilidad virtualmente completa hacia atrás con las primeras
versiones. El tamaño y la complejidad del intérprete son una barrera
para los desarrolladores que desean trabajar en él.

Perl es distribuido con unos 120.000 test funcionales. Éstos se
ejecutan como parte del proceso normal de construcción y comprueban
extensamente al intérprete y a sus módulos principales. Los
desarrolladores Perl confían en los test funcionales para asegurarse que
 los cambios en el intérprete no introducen errores; recíprocamente, los
 usuarios Perl que vean al intérprete pasar los test funcionales en su
sistema pueden tener un alto grado de confianza de que está funcionando
adecuadamente.

No hay una especificación o estándar escrito para el lenguaje Perl y
no hay planes de crear uno para la versión actual de Perl. Siempre ha
existido sólo una implementación del intérprete. Este intérprete, junto
con los test funcionales, forman la especificación *de facto* del lenguaje.

### Disponibilidad

Perl es software libre y está licenciado bajo la Licencia Artística y la GNU General Public License. Existen distribuciones disponibles para la mayoría de sistemas operativos. Está especialmente extendido en Unix y en sistemas similares,
 pero ha sido portado a las plataformas más modernas (y otras más
obsoletas). Con sólo seis excepciones confirmadas, puede ser compilado
desde el código fuente en todos los Unix, compatibles POSIX
 o cualquier otra plataforma Unix compatible. Sin embargo, esto no es
normalmente necesario, porque Perl está incluido por defecto en la
instalación de los sistemas operativos más populares.9
Debido a los cambios especiales necesarios para soportar al Mac OS Classic, existe una adaptación especial llamada MacPerl.10

#### GNU/Linux

Perl está preinstalado en las distribuciones más populares de GNU/Linux incluyendo Gentoo, Slackware, Mandriva, Debian, RedHat y SUSE.

#### Windows

Los usuarios de Microsoft Windows normalmente instalan una distribución binaria de Perl.11
 Compilar Perl desde el código fuente bajo Windows es posible, pero la
mayoría de las instalaciones no disponen del necesario compilador de C.
La capa de emulación Cygwin proporciona otra forma de correr Perl bajo Windows. Cygwin proporciona en entorno parecido al Unix en Windows que incluye gcc, por lo que compilar Perl desde el código es una opción accesible para los usuarios que prefieren esta opción.

En junio de 2006, win32.perl.org fue lanzado por Adam Kennedy en nombre de la Fundación Perl. Es una comunidad web "para todo lo relacionado con Windows y Perl".12

## Estructura del lenguaje

### Programa ejemplo

En Perl, el programa canónico "Hola mundo" es:

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

```

La primera línea contiene el *shebang*
 (par de caracteres que identifica el texto que sigue), que le indica al
 sistema operativo dónde encontrar el intérprete de Perl. La segunda
imprime el *string* *¡Hola mundo!* y un carácter de nueva línea.
El *shebang* es la forma normal para invocar al intérprete en
los sistemas Unix. Los sistemas Windows pueden seguir utilizándolo o
pueden asociar la extensión de archivo .pl con el intérprete Perl. Algunos editores de texto también usan la línea *shebang*
 como una pista sobre el modo de trabajo en que deben operar. Si el
programa es ejecutado por perl y no invocado por el shell, la línea que
empieza por el *shebang* es parseada para interpretar las opciones. En otro caso, es ignorada. Para ver los detalles de esto, consultar la página de manual perlrun.

### Tipos de datos

Perl tiene tres tipos de datos: escalares, listas y hashes:

* Un escalar es un solo valor; puede ser un número, un *string* (cadena de caracteres) o una referencia
* Una lista es una colección ordenada de escalares (una variable que almacena una lista se llama *array*)
* Un *hash*, o memoria asociativa, es un mapeo de *strings* a escalares; los *strings* se llaman *claves* y los escalares *valores*.

Todas las variables están precedidas por un sigilo, que identifica el
 tipo de dato que es accedido (no el tipo de dato de la misma variable).
 Se puede usar el mismo nombre para variables de diferentes tipos, sin
que tengan conflictos.

```
$var   # un escalar
@var   # un array
%var   # un hash

```

Los números se escriben de la forma usual; los *strings* están rodeados entre comillas de varias clases.

```
$n      = 42;
$nombre = "juan";
$color  = 'rojo';

```

Perl convertirá los *strings* en números y viceversa dependiendo del contexto en que sean usados. En el siguiente ejemplo los *strings* `$n` y `$m`
 son tratados como números cuando son argumentos del operador suma. Este
 código imprime el número '5', desechando cualquier información no
numérica de la operación y dejando los valores de las variables
intactos. (El operador de concatenación no es `+`, sino `.`.)

```
$n     = "3 manzanas";
$m     = "2 naranjas";
print $n + $m;

```

Perl también tiene un contexto booleano que utiliza en la evaluación de declaraciones condicionales. Los siguientes valores en Perl evalúan todos como falso:

```
$falso = 0;     # el número cero
$falso = 0.0;   # el número cero como flotante
$falso = '0';   # el string cero
$falso = "";    # el string vacío
$falso = undef; # el valor devuelto por undef

```

Todos los demás valores se evalúan a verdadero. Esto incluye el curioso *string* auto-descriptivo `"0 pero verdadero"`, que de hecho es 0 como número, pero verdadero como booleano. (Cualquier *string* no numérico también tendrá esta propiedad, pero este *string*
 en particular es ignorado por Perl en contextos numéricos). Las
expresiones booleanas evaluadas también devuelven valores escalares.
Aunque la documentación no indica qué valor *particular* se devuelve como verdadero o falso (y por lo tanto no fiable), muchos operadores booleanos devuelven 1 por verdadero y el *string* vacío para falso (que evalúa a cero en contexto numérico). La función *defined()* le dice si la variable tiene algún valor. En el ejemplo anterior *defined($falso)* será verdadero con cada uno de los valores anteriores, excepto *undef*. Si, específicamente, quiere asegurarse de tener un resultado 1/0 (como en C), necesita realizar el cálculo siguiente:

```
my $resultado_real = $resultado_booleano ? 1 : 0;

```

Una lista se define listando sus elementos, separados por comas y
rodeados por paréntesis donde así sea requerido por la precedencia de
los operadores.

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

```

Un *hash* puede ser inicializado desde una lista de pares clave/valor.

```
%favorito = (
      joe => 'rojo',
      sam => 'azul',
);

```

Los elementos individuales de una lista son accedidos utilizando un
índice numérico, dentro de corchetes. Valores individuales en un hash
son accedidos utilizando la correspondiente clave, dentro de llaves. El
sigilo $ identifica que el elemento accedido es un escalar.

```
$puntuaciones[2]  # un elemento de @puntuaciones
$favorito{joe}    # un valor de %favorito

```

Múltiples elementos pueden ser accedidos usando en su lugar el sigilo @ (identificando el resultado como una lista).

```
@puntuaciones[2, 3, 1]   # tres elementos de @puntuaciones
@favorito{'joe', 'sam'}  # dos valores de %favorito

```

El número de elementos en un array puede ser obtenido evaluando el *array* en contexto escalar o con la ayuda del sigilo $#. Éste último da el índice del último elemento dentro del *array*, no el número de elementos.

```
$numero = @amigos;
$#amigos;      # el índice del último elemento en @amigos
$#amigos+1;    # normalmente el número de elementos en @amigos,
               # que es uno más que $#amigos porque el primer elemento tiene el índice 0, no 1

```

Hay unas pocas funciones que operan sobre *hashes* enteros.

```
@nombres_de_clientes  = keys   %direcciones;   # guarda en @nombres_de_clientes  todas las claves  de %direcciones
@direcciones_de_email = values %direcciones;   # guarda en @direcciones_de_email todos los valores de %direcciones

```

### Estructuras de control

Artículo principal: *Estructuras de control, en inglés*

Perl tiene varias clases de estructuras de control.
Tiene estructuras de control orientado al bloque, similar a los de
los lenguajes de programación C y Java. Las condiciones están rodeadas
por paréntesis y los bloques subordinados por llaves:

```
 ''etiqueta'' while ( ''condición'' ) {... }
  ''etiqueta'' while ( ''condición'' ) {... } continue {... }
  ''etiqueta'' for ( ''expresión inicial''; ''expresión condicional''; ''expresión incremental'' ) {... }
  ''etiqueta'' foreach ''var'' ( ''lista'' ) {... }
  ''etiqueta'' foreach ''var'' ( ''lista'' ) {... } continue {... }
  if ( ''condición'' ) {... }
  if ( ''condición'' ) {... } else {... }
  if ( ''condición'' ) {... } elsif ( ''condición'' ) {... } else {... }

```

Cuando se controla a una sola declaración, los modificadores de declaración proporcionan una sintaxis más ligera:

```
 ''declaración'' if      ''condición'';
  ''declaración'' unless  ''condición'';
  ''declaración'' while   ''condición'';
  ''declaración'' until   ''condición'';
  ''declaración'' foreach ''lista'';

```

Los operadores lógicos *cortocircuito* son normalmente usados para controlar el flujo del programa a nivel de expresión:

```
 ''expr'' and ''expr''
  ''expr'' or  ''expr''

```

Las palabras clave de control de flujo `next`, `last`, `return` y `redo` son expresiones, por lo que pueden ser usadas con los operadores cortocircuito.
Perl también tiene dos construcciones implícitas para bucles:

```
 ''resultados'' = grep {... } ''lista''
  ''resultados'' = map  {... } ''lista''

```

`grep` devuelve todos los elementos de *lista* en que el bloque subordinado evalúa a verdadero. `map` evalúa el bloque subordinado por cada elemento de *lista* y devuelve una lista de los valores resultantes. Estas construcciones permiten un estilo simple de programación funcional.
La declaración switch (llamada "given"/"when") existe desde la versión 5.10:

```
  use 5.10.1; # o posterior
   given ($variable) {
     when (''condición'') { ... }
     when (''condición'') { ... }
     default { ... }
   }

```

Perl incluye una declaración `goto *etiqueta*`, pero es usada raramente. Las situaciones donde en otros lenguajes se utiliza `goto` no ocurren tan a menudo en Perl debido a sus amplias opciones de control de flujo.
Existe también una declaración `goto &*sub*` que realiza una llamada 'final'. Termina la subrutina actual e inmediatamente llama a la `*sub*` especificada. Esto se usa en situaciones donde una nueva subrutina puede realizar una gestión de la pila
 más eficiente que el propio Perl (porque típicamente no se requiere
ningún cambio en la pila actual), y en una recursión muy profunda este
tipo de llamadas puede tener un sustancial impacto positivo en el
funcionamiento porque evita la sobrecarga de la gestión contexto/pila en
 el momento de retornar.

### Subrutinas

Las subrutinas se definen con la palabra clave `sub`
 e invocadas simplemente nombrándolas. Si la subrutina en cuestión no ha
 sido todavía declarada, es necesario, para el proceso de análisis
sintáctico, poner los paréntesis.

```
foo();           # paréntesis necesarios aquí...
sub foo {... }
foo;             #... pero no aquí

```

Una lista de argumentos pueden ser indicados 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 ser declarados, ni en
número ni en tipo; de hecho, pueden variar en cada llamada. Los *arrays* son expandidos a sus elementos, los *hashes* a una lista de pares clave/valor y todo el conjunto es pasado a la subrutina como una indiferenciada lista de escalares.
Cualesquiera de los argumentos pasados están disponibles para la subrutina en el *array* especial `@_`. Los elementos de `@_` son asociados a los argumentos actuales; cambiando un elemento de `@_` cambia el argumento correspondiente.

Los elementos de `@_` pueden ser accedidos con los subíndices de la forma normal.

```
$_[0], $_[1]

```

Sin embargo, el código resultante puede ser difícil de leer y los
parámetros tener una semántica de pase por referencia, que puede
resultar algo no deseable.
Un modismo común es asignar `@_` a una lista de variables con nombres.

```
my($x, $y, $z) = @_;

```

Esto afecta tanto a la mnemónica de los nombres de los parámetros
como a la semántica de los valores pasados por valor. La palabra clave `my` indica que las siguientes variables están léxicamente embebidas en el bloque que las contienen.
Otro modismo es sacar los parámetros de `@_`. Esto es muy común cuando la subrutina toma un sólo argumento.

```
my $x = shift;  # Si no se dice nada, nos referimos a @_

```

Las subrutinas pueden devolver valores.

```
return 42, $x, @y, %z;

```

Si la subrutina no sale vía declaración `return`, entonces devuelve la última expresión evaluada en el cuerpo de la subrutina. *Arrays* y *hashes* en el valor de retorno son expandidos a una lista de escalares, igual que si fueran argumentos de una función.
La expresión devuelta es evaluada en el contexto de la llamada de la subrutina; esto puede sorprender al desprevenido.

```
sub lista {      (4, 5, 6)     }
sub array { @x = (4, 5, 6); @x }

$x = lista;  # devuelve 6 - último elemento de la lista
$x = array;  # devuelve 3 - número de elementos de la lista
@x = lista;  # devuelve (4, 5, 6)
@x = array;  # devuelve (4, 5, 6)

```

Una subrutina puede descubrir su contexto de llamada con la función `wantarray`.

```
sub cualquiera { wantarray ? (1, 2) : "Naranjas" }

$x = cualquiera;    # devuelve "Naranjas"
@x = cualquiera;    # devuelve (1, 2)

```

### Expresiones regulares

Artículo principal: *Expresiones regulares con Perl, en inglés*

El lenguaje Perl incluye una sintaxis especializada para escribir expresiones regulares y el intérprete contiene un motor para emparejar *strings* con expresiones regulares. El motor de expresiones regulares usa un algoritmo de Vuelta Atrás (backtracking), extendiendo sus capacidades desde el simple emparejamiento de patrones simples con la captura y sustitución de *strings*. El motor de expresiones regulares se deriva de *regex*, escrito por Henry Spencer.
La sintaxis de expresiones regulares fue originalmente tomada de las
expresiones regulares de Unix Versión 8. Sin embargo, se diferenció ya
antes del primer lanzamiento de Perl y desde entonces ha ido
incorporando muchas más características. Otros lenguajes y aplicaciones
están adoptando las expresiones regulares de Perl (PCRE) en vez de las expresiones regulares POSIX, incluyendo PHP, Ruby, Java y el Servidor HTTP Apache.

El operador `m//` (empareja) permite comprobar un emparejamiento por medio de una expresión regular. (Para abreviar, el precedente `m` puede ser omitido.) En el caso más simple, una expresión como:

```
$x =~ m/abc/

```

evalúa a verdadero si y sólo si el *string* `$x` empareja con la expresión regular `abc`.
Partes de la expresión regular pueden ser incluidas entre paréntesis: las partes correspondientes de un string emparejado son *capturadas*. Los *strings* capturados son asignados de forma secuencial a las variables internas `$1, $2, $3,...` y una lista de *strings* capturados se devuelve como valor del emparejamiento.

```
$x =~ m/a(.)c/;     # captura el carácter entre 'a' y 'c' y lo guarda en $1

```

El operador `s///` (sustitución) especifica una operación de búsqueda y reemplazo:

```
$x =~ s/abc/aBc/;   # Convierte la b en mayúscula

```

Las expresiones regulares en Perl pueden tomar unos *modificadores*. Son sufijos de una sola letra que modifican el significado de la expresión:

```
$x =~ m/abc/i;      # emparejamiento independientemente de si están en mayúscula o minúscula
 $x =~ s/abc/aBc/g;  # búsqueda y reemplazo global (a lo largo de todo el ''string'')

```

Las expresiones regulares pueden ser densas y crípticas. Esto es
porque la sintaxis de las expresiones regulares es extremadamente
compacta, generalmente usando caracteres sueltos o pares de caracteres
que representan sus operaciones. Perl alivia un poco este problema con
el modificador `/x` que permite a los programadores poner espacio en blanco y comentarios *dentro* de las expresiones regulares:

```
$x =~ m/a           # empareja una 'a'
        .           # empareja cualquier carácter
        c           # empareja una 'c'
      /x;

```

Un uso común de las expresiones regulares es el de especificar delimitadores de campos al operador `split`:

```
@palabras = split m/,/, $línea;   # divide la $línea de valores separados por comas

```

El operador `split` complementa la captura de string. La
captura de string devuelve las partes de un string que emparejan con una
 expresión regular; `split` devuelve las partes que no emparejan.

### Interfaz con bases de datos

Perl está ampliamente favorecido para las aplicaciones de bases de datos. Sus facilidades de manejo de texto son buenas para generar consultas SQL; *arrays*, *hashes* y la gestión de memoria automática hace fácil recoger y procesar los datos devueltos.
En las primeras versiones de Perl, las interfaces de bases de datos
fueron creadas enlazando el intérprete con una biblioteca de base de
datos desde el lado del cliente. Esto era algo torpe; un problema en
particular fue que el ejecutable `perl` resultante estaba
restringido a usar sólo una interfaz de base de datos, la que había sido
 enlazada. También, reenlazar el intérprete era lo suficientemente
dificultoso que sólo fue realizado para algunas de las más famosas e
importantes bases de datos.

En Perl 5, las interfaces de bases de datos están implementadas por el módulo Perl DBI. El módulo `DBI` presenta una única interfaz a las aplicaciones Perl, independiente de las bases de datos, mientras que los módulos `DBD::` (Controlador de base de datos) manejan los detalles de acceso a unas 50 bases de datos diferentes. Existen controladores `DBD::` para la mayor parte de las bases de datos ANSI SQL.

## Comparativa de funcionamiento

El "Computer Language Shootout Benchmarks"
 compara el funcionamiento de implementaciones de problemas de
programación típicos, en diversos lenguajes. Sus implementaciones Perl
normalmente toman más memoria que las implementaciones en otros
lenguajes, y esto varía los resultados de velocidad. Las prestaciones de
 Perl son similares a las de otros lenguajes como Python, PHP o Ruby,
pero más lento que la mayor parte de lenguajes compilados.
Perl puede ser más lento que otros lenguajes haciendo lo mismo porque
 tiene que compilar el código fuente cada vez que corre el programa. En "A Timely Start",
 Jean-Louis Leroy encontró que sus scripts en Perl tardaban mucho más
tiempo en correr que lo que él esperaba porque el intérprete perl perdía
 la mayor parte del tiempo buscando y compilando los módulos. Como Perl
no puede salvar su compilación intermedia como lo hacen Java, Python y
Ruby, los scripts Perl conllevan esta sobrecarga en cada ejecución. La
sobrecarga no es un problema cuando la fase de ejecución es muy larga,
pero puede sesgar significativamente en tiempos de ejecución muy cortos,
 como se encuentra a menudo en los benchmarks. Una vez que perl inicia
la fase de ejecución, sin embargo, puede ser muy rápido y típicamente
supera a otros lenguajes dinámicos. Tecnologías como mod perl superan esto guardando el programa compilado en memoria entre ejecuciones, o Class::Autouse que retrasa la compilación de partes del programa hasta que son necesarias.

### Optimizando

Nicholas Clark, un desarrollador principal de Perl, diserta sobre algunas mejoras en el diseño con Perl y otras soluciones en "When perl is not quite fast enough". Las rutinas más críticas de un programa Perl pueden escribirse en C o incluso en lenguaje ensamblador con XS o Inline.
Optimizar Perl puede requerir un conocimiento íntimo de su
funcionamiento en lugar de la destreza con el lenguaje y su sintaxis,
significando que el problema está con la implementación de Perl en lugar
 de con el lenguaje mismo. Perl 6, la siguiente versión, tomará algunas
de estas ideas como lecciones, que otros lenguajes ya han aprendido.

## Futuro

Artículo principal: *Perl 6*

En el año 2000, en la conferencia Perl, Jon Orwant hizo una petición para una nueva versión del lenguaje.13
 Esto condujo a una decisión para comenzar el trabajo del rediseño del
lenguaje, que se llamaría Perl 6. Se pidieron propuestas a la comunidad
Perl para las nuevas características del lenguaje, y se recibieron más
de 300 RFC (del inglés *Request For Comments*, petición de comentarios).
Larry Wall estuvo los siguientes años digiriendo los RFC y
sintetizándolos en un entorno de trabajo coherente para Perl 6. Presentó

```
su diseño de Perl 6 en una serie de documentos llamados Apocalipsis, que se numeran para corresponderse con los capítulos de *Programming Perl*.

```

 La actual, inacabada especificación de Perl 6, está resumida en unos
documentos de diseño llamados Sinopsis, que están numerados para
corresponder a los Apocalipsis.

Perl 6 no tiene la intención de ser compatible para atrás, aunque existirá un modo de compatibilidad.

En 2001 se decidió que Perl 6 corriese en una máquina virtual llamada Parrot.
 Esto quiere decir que otros lenguajes que usen Parrot podrán ganar
acceso nativo a CPAN y permitirá algún cierto nivel de desarrollo
cruzado.

En 2005 Audrey Tang creó el proyecto pugs, una implementación de Perl 6 en Haskell.
 Fue y es una plataforma de testeo del lenguaje Perl 6 (separado del
desarrollo actual de la implementación) permitiendo a los diseñadores
explorar. El proyecto pugs engendró una activa comunidad Perl/Haskell
centrada alrededor del canal irc #perl6 en Freenode.

Un cierto número de características en el lenguaje Perl 6 muestran
una similaridad con las de Haskell y Perl 6 ha sido acogido por la
comunidad Haskell como un potencial lenguaje de scripting.

En el 2006, Perl 6, Parrot y pugs siguen estando bajo desarrollo y un nuevo módulo para Perl 5 llamado v6 permite a una parte del código Perl 6 correr directamente sobre Perl 5.