++ed by:
SALVA MISHIN

2 PAUSE users
4 non-PAUSE users.

Enrique Nell
and 1 contributors

NAME

perlintro -- Breve introducción y descripción general de Perl

DESCRIPCIÓN

Este documento proporciona una introducción rápida al lenguaje de programación Perl e incluye referencias a documentación adicional. Es una guía de iniciación para los nuevos usuarios del lenguaje que proporciona la información necesaria para poder leer el código Perl de otras personas y comprender a grandes rasgos su funcionamiento, o para escribir scripts sencillos.

Es un documento introductorio, no una guía completa. Tampoco explica el lenguaje en detalle. En algunos casos se ha sacrificado la precisión para transmitir la idea general. Es muy recomendable complementar esta introducción con información del manual de Perl completo, cuya tabla de contenido se encuentra en perltoc.

En este documento se incluyen referencias a otras partes de la documentación de Perl. Puede consultar la documentación mediante el comando perldoc o cualquier otro método que use para leer este documento.

En la documentación de Perl se incluyen muchos ejemplos que ilustran las características descritas. Tenga en cuenta que muchos de estos ejemplos son fragmentos de código, no programas completos.

Los ejemplos de las distintas partes de la documentación reflejan el estilo y las preferencias de sus autores, y pueden ser más escuetos que una línea de código equivalente en un programa real. Salvo si se indica lo contrario, debe suponer que al principio del "programa" se incluyen las instrucciones use strict y use warnings, y que todas las variables han sido declaradas, aunque se omitan las declaraciones para facilitar la lectura del ejemplo.

Tenga en cuenta que los ejemplos han sido escritos por muchos autores distintos a lo largo de varias décadas. Por esta razón, habrá diversos estilos y técnicas, pero se ha procurado que en una misma sección los estilos no varíen demasiado. Ningún estilo es mejor que otro. No olvide que uno de los lemas de Perl es "Se puede hacer de varias maneras". Al fin y al cabo, en su vida profesional como programador se va a encontrar distintos estilos.

¿Qué es Perl?

Perl es un lenguaje de programación de propósito general desarrollado originalmente para la manipulación de texto y que, en la actualidad, se usa para una amplia gama de tareas, como administración de sistemas, desarrollo web, programación de red, desarrollo de interfaces gráficas de usuario, etc.

El lenguaje se diseñó para ser práctico (fácil de usar, eficaz, completo), más que estético (reducido, elegante, minimalista). Se caracteriza principalmente por su facilidad de uso (permite programar tanto de manera procedural como orientada a objetos (OO)), su magnífica capacidad para procesamiento de texto y por tener una de las colecciones de módulos de terceros más impresionantes del mundo.

En perl, perlfaq1 y en muchos otros sitios se incluyen definiciones de Perl. Esto refleja el hecho de que, aunque Perl tiene muchos públicos distintos, muchas personas piensan que merece la pena escribir sobre este lenguaje.

Ejecución de programas Perl

Para ejecutar un programa Perl desde la línea de comandos de Unix, use el siguiente comando:

 perl nombre_programa.pl

Como alternativa, puede colocar al principio del script la siguiente línea:

 #!/usr/bin/env perl

... y ejecutar el script como /path/to/script.pl. Por supuesto, antes deberá marcarlo como ejecutable con el comando chmod 755 script.pl (en Unix).

(En esta línea se supone que dispone del programa env. También puede especificar directamente la ruta de acceso a su ejecutable perl: #!/usr/bin/perl).

Para obtener más información e instrucciones para otras plataformas, como Windows y Mac OS, lea perlrun.

Red de seguridad

Por su diseño, Perl es un lenguaje muy indulgente. Sin embargo, para trabajar de manera más segura se recomienda iniciar cada programa con las líneas siguientes:

 #!/usr/bin/perl
 use strict;
 use warnings;

Estas dos líneas adicionales ordenan a perl que detecte diversos problemas comunes en el código. Comprueban cosas distintas, por lo que ambas deben ser incluidas. Un posible problema detectado por use strict; hará que el código se detenga inmediatamente, mientras que use warnings; (al igual que el modificador de línea de comandos -w) sólo mostrará una advertencia y dejará que el código se ejecute. Para obtener más información, consulte las páginas de manual correspondientes a strict y warnings.

Descripción general de la sintaxis básica

Un script o programa Perl consta de una o varias instrucciones. Estas instrucciones se escriben directamente en el script. Es decir, no es necesario utilizar una función main() ni nada similar.

Las instrucciones de Perl deben terminar con un signo de punto y coma:

 print "Hola a todos";

Los comentarios comienzan con un símbolo # y van hasta el final de la línea:

 # Esto es un comentario

El espacio en blanco no es significativo:

 print
     "Hola a todos"
     ;

... salvo cuando está entre comillas:

 # esto imprimirá un salto de línea en la mitad de la frase
 print "Hola
 a todos";

Las cadenas literales se pueden escribir entre comillas dobles o simples:

 print "Hola a todos";
 print 'Hola a todos';

Sin embargo las variables y los caracteres especiales, como los caracteres de nueva línea (\n), solo se "interpolan" con comillas dobles:

 print "Hola, $nombre\n";  # funciona correctamente
 print 'Hola, $nombre\n';  # imprime $nombre\n literalmente

No es necesario escribir los números entre comillas:

 print 42;

Puede escribir los argumentos de las funciones entre paréntesis u omitir los paréntesis, si lo prefiere. Solo son necesarios en algunos casos para aclarar la precedencia.

 print("Hola a todos\n");
 print "Hola a todos\n";

Encontrará información más detallada sobre la sintaxis de Perl en perlsyn.

Tipos de variables de Perl

En Perl hay tres tipos de variables principales: escalares, arrays y hashes.

Escalares

Un escalar representa un solo valor:

 my $animal = "camello";
 my $respuesta = 42;

Los valores escalares pueden ser cadenas, enteros o números de punto flotante, y Perl los convertirá de un tipo a otro cuando sea necesario. No es necesario predeclarar los tipos de las variables, pero éstas deben declararse con la palabra clave my la primera vez que se usan. (Éste es uno de los requisitos de use strict;).

Los valores escalares se pueden usar de varias maneras:

 print $animal;
 print "El animal es $animal\n";
 print "El cuadrado de $respuesta es ", $respuesta * $respuesta, "\n";

Hay varios escalares "mágicos" con nombres que recuerdan conjuntos de signos de puntuación (o "ruido de señal"). Estas variables especiales se usan para diversos fines y se describen en perlvar. La única que tiene que conocer por ahora es $_, la "variable predeterminada". Se usa como argumento predeterminado de varias funciones de Perl y su valor se establece implícitamente en determinadas estructuras de bucle.

 print;          # imprime el contenido de $_ de manera predeterminada
Arrays

Un array representa una lista de valores:

 my @animales = ("camello", "llama", "búho");
 my @numeros  = (23, 42, 69);
 my @mezcla   = ("camello", 42, 1.23);

El índice de un array empieza en cero. Para obtener los elementos de un array:

 print $animales[0];  # imprime "camello"
 print $animales[1];  # imprime "llama"

La variable especial $#array indica el índice del último elemento de un array:

 print $mezcla[$#mezcla];  # último elemento, imprime 1.23

Podría sentirse tentado de usar $#array + 1 para determinar el número de elementos de un array. No es necesario. Si utiliza @array donde Perl espera encontrar un valor escalar ("en contexto de escalar"), obtendrá el número de elementos del array:

 if (@animales < 5) { ... }

Los nombres de los elementos que obtenemos del array empiezan por $ porque reciben valores individuales del array; si se pide un escalar, se obtiene un escalar.

Para obtener varios elementos de un array:

 @animales[0,1];                 # devuelve ("camello", "llama");
 @animales[0..2];                # devuelve ("camello", "llama", "búho");
 @animales[1..$#animales];        # devuelve todos los elementos menos el primero

Esto se denomina una "porción de array".

Puede hacer varias cosas útiles con las listas:

 my @ordenados     = sort @animales;
 my @orden_inverso = reverse @numeros;

También hay dos arrays especiales: @ARGV (los argumentos de línea de comandos pasados al script) y @_ (los argumentos pasados a una subrutina). Se describen en perlvar.

Hashes

Un hash representa un conjunto de pares clave-valor:

 my %color_fruta = ("manzana", "rojo", "plátano", "amarillo");

Puede usar espacio en blanco y el operador => para expresarlos de manera más clara:

 my %color_fruta = (
     manzana => "rojo",
     plátano => "amarillo",
 );

Para obtener los elementos de un hash:

 $color_fruta{"manzana"};           # devuelve "rojo"

Puede obtener una lista de las claves y los valores con keys() y values() respectivamente.

 my @frutas  = keys %color_fruta;
 my @colores = values %color_fruta;

En los hashes no hay un orden interno específico, aunque puede ordenar las claves antes de recorrerlas en un bucle.

De la misma manera que hay escalares y arrays especiales, también hay hashes especiales. El más conocido es %ENV, que contiene variables de entorno. Encontrará información sobre este hash (y sobre otras variables especiales) en perlvar.

Encontrará información detallada sobre los escalares, arrays y hashes en perldata.

Se pueden crear tipos de datos más complejos mediante referencias, que permiten generar listas y hashes dentro de listas y hashes.

Una referencia es un valor escalar que puede apuntar a cualquier tipo de datos de Perl. Así, almacenando una referencia como el valor de un elemento de array o hash, puede crear fácilmente listas y hashes dentro de listas y hashes. En el ejemplo siguiente se muestra una estructura de hash de hashes de 2 niveles en la que se usan referencias de hash anónimas.

 my $variables = {
     escalar  =>  {
                  descripcion => "elemento individual",
                  sigilo => '$',
                 },
     array   =>  {
                  descripcion => "lista ordenada de elementos",
                  sigilo => '@',
                 },
     hash    =>  {
                  descripcion => "pares clave-valor",
                  sigilo => '%',
                 },
 };

 print "Los escalares empiezan por $variables->{'escalar'}->{'sigilo'}\n";

Encontrará información detallada sobre las referencias en perlreftut, perllol, perlref y perldsc.

Ámbito de las variables

En todos los ejemplos de la sección anterior se utilizó esta sintaxis:

 my $var = "valor";

En realidad no es obligatorio usar my; se puede usar simplemente:

 $var = "valor";

Sin embargo, el uso anterior creará variables globales en todo el programa, algo que no se recomienda en programación. En cambio, my crea variables dentro de un ámbito léxico. El ámbito de las variables es el bloque (conjunto de instrucciones entre llaves) en el que se definen.

 my $x = "foo";
 my $una_condicion = 1;
 if ($una_condicion) {
     my $y = "bar";
     print $x;           # imprime "foo"
     print $y;           # imprime "bar"
 }
 print $x;               # imprime "foo"
 print $y;               # no imprime nada; $y está fuera del ámbito

Si escribe use strict; al principio de los scripts de Perl y usa my, el intérprete detectará determinados errores frecuentes de programación. Así, en el ejemplo anterior, la última instrucción print $y provocará un error en tiempo de compilación que impedirá la ejecución del programa. Es muy recomendable usar strict.

Estructuras condicionales y de bucle

Perl ofrece las estructuras condiciones y de bucle habituales. En Perl 5.10, incluso ofrece una instrucción case/switch (llamada given/when). Consulte "Instrucciones switch" en perlsyn para obtener información detallada.

Una condición puede ser cualquier expresión Perl. Consulte la lista de operadores de la siguiente sección para obtener información sobre los operadores lógicos booleanos y de comparación que se suelen usar en instrucciones condicionales.

if
 if ( condición ) {
     ...
 } elsif ( otra condición ) {
     ...
 } else {
     ...
 }

También existe la versión negada:

 unless ( condición ) {
     ...
 }

Esto se proporciona como una versión más legible de if (!condición).

Tenga en cuenta que en Perl es obligatorio usar las llaves, aunque sólo haya una línea en el bloque. Sin embargo, puede escribir los bloques condicionales de una sola línea de manera que recuerden a una frase en inglés:

 # la manera tradicional
 if ($zippy) {
     print "¡Caramba!";
 }

 # ahora con una condición posterior, al estilo Perl
 print "¡Caramba!" if $zippy;
 print "No quedan plátanos" unless $platanos;
while
 while ( condición ) {
     ...
 }

Existe también una versión negada, por la misma razón que existe unless:

 until ( condición ) {
     ...
 }

También puede usar while en una condición posterior:

 print "LA LA LA\n" while 1;          # bucle sin fin
for

Exactamente igual que en C:

 for ($i = 0; $i <= $max; $i++) {
     ...
 }

El bucle for de C no se suele usar, ya que Perl proporciona una alternativa más sencilla para recorrer listas, el bucle foreach.

foreach
 foreach (@array) {
     print "Este elemento es $_\n";
 }

 print $lista[$_] foreach 0 .. $max;

 # tampoco tiene que usar la variable $_ predeterminada...
 foreach my $clave (keys %hash) {
     print "El valor de $clave es $hash{$clave}\n";
 }

En realidad, la palabra clave foreach es un sinónimo de la palabra clave for. Vea la sección sobre bucles foreach en perlsyn.

Para obtener más información sobre las estructuras de bucle (y otras estructuras que no se han mencionado en esta introducción ), consulte perlsyn.

Funciones y operadores predefinidos

Perl incluye una amplia selección de funciones y operadores predefinidos. Ya hemos visto algunas funciones, como print, sort y reverse. Al principio de perlfunc se incluye una lista completa de funciones. También puede obtener fácilmente información sobre cualquier función mediante el comando perldoc -f nombre_función.

Encontrará información detallada sobre los operadores de Perl en perlop; algunos de los más comunes son:

Aritmética
 +   suma
 -   resta
 *   multiplicación
 /   división
Comparación numérica
 ==  igual que
 !=  distinto que
 <   menor que
 >   mayor que
 <=  menor o igual que
 >=  mayor o igual que
Comparación de cadenas
 eq  igual que
 ne  distinto que
 lt  menor que
 gt  mayor que
 le  menor o igual que
 ge  mayor o igual que

¿Por qué se usa un operador de comparación para números y otro para cadenas? Porque Perl no distingue el tipo del contenido de las variables y tiene que determinar si debe ordenar numéricamente (99 menor que 100) o alfabéticamente (100 es anterior a 99).

Lógica Booleana
 &&  and
 ||  or
 !   not

(En la tabla anterior and, or y not no son solo descripciones de los operadores. Son también operadores. Ofrecen más legibilidad que los operadores tipo C correspondientes, como &&, pero su precedencia es distinta. Consulte perlop para obtener más información).

Otros operadores
 =   asignación
 .   concatenación de cadenas
 x   multiplicación de cadenas
 ..  operador de intervalo (crea una lista de números o cadenas)

Muchos operadores se pueden combinar con un signo = de la manera siguiente:

 $a += 1;        # igual que $a = $a + 1
 $a -= 1;        # igual que $a = $a - 1
 $a .= "\n";     # igual que $a = $a . "\n";

Archivos y E/S

La función open() abre un archivo para entrada o salida. Esta función se describe de forma muy detallada en perlfunc y perlopentut. A continuación se muestra un resumen de cómo se usa:

 open(my $entrada,  "<",  "entrada.txt") or die "No se puede abrir entrada.txt: $!";
 open(my $salida,   ">",  "salida.txt" ) or die "No se puede abrir salida.txt: $!";
 open(my $registro, ">>", "mi.registro") or die "No se puede abrir mi.registro: $!";

Puede utilizar el operador <> para leer de un identificador de archivo abierto. En contexto de escalar, este operador lee una sola línea del identificador de archivo, mientras que en contexto de lista lee todo el archivo y asigna cada línea a un elemento de la lista:

 my $linea  = <$entrada>;
 my @lineas = <$entrada>;

La lectura de un archivo completo se suele llamar "slurping" (succión). Puede resultar útil, pero esta operación consume mucha memoria. Gran parte de las tareas de procesamiento de archivos de texto se puede hacer de línea en línea con las estructuras de bucle de Perl.

El operador <> se suele utilizar en un bucle while:

 while (<$entrada>) {     # asigna una línea cada vez a $_
     print "Acabo de leer esta línea: $_";
 }

Ya hemos visto la manera de imprimir en la salida estándar mediante print(). Sin embargo, print() también puede consumir un primer argumento opcional que especifique el identificador de archivo en el que se debe imprimir:

 print STDERR "Ésta es la última advertencia.\n";
 print $salida $registro;
 print $registro $mensaje_registro;

Cuando termine de trabajar con los identificadores de archivo, debe cerrarlos con close() (de todos modos, Perl se encargará de ello si se le olvida):

 close $entrada or die "$entrada: $!";

Expresiones regulares

El soporte de Perl para las expresiones regulares es amplio y profundo, y se describe en gran detalle en los documentos perlrequick y perlretut, entre otros. Se incluye a continuación un resumen:

Detección de coincidencias sencilla
 if (/foo/)       { ... }  # verdadero si $_ contiene "foo"
 if ($a =~ /foo/) { ... }  # verdadero si $a contiene "foo"

El operador de detección de coincidencias // se describe en perlop. Opera en $_ de manera predeterminada, o se puede enlazar a otra variable con el operador de enlace =~ (que también se describe en perlop).

Sustitución simple
 s/foo/bar/;        # reemplaza foo por bar en $_
 $a =~ s/foo/bar/;  # reemplaza foo por bar en $a
 $a =~ s/foo/bar/g;        # reemplaza TODAS LAS INSTANCIAS de foo por bar
                           # en $a

El operador de sustitución, s///, se describe en perlop.

Expresiones regulares más complejas

No tiene que limitarse a detectar coincidencias en cadenas fijas. De hecho, puede detectar coincidencias donde quiera con expresiones regulares más complejas. Estas se describen de forma detallada en perlre. A continuación se incluye una guía rápida:

 .                   un solo carácter
 \s                  un espacio en blanco (espacio, tabulación, nueva línea,
                     ...)
 \S                  un carácter que no sea un espacio en blanco
 \d                  un dígito (0-9)
 \D                  un carácter que no sea un dígito
 \w                  un carácter de palabra (a-z, A-Z, 0-9, _)
 \W                  un carácter que no sea de palabra
 [aeiou]             un solo carácter del conjunto especificado
 [^aeiou]            un solo carácter no perteneciente al conjunto
                     especificado
 (foo|bar|baz)       cualquiera de las alternativas especificadas

 ^                   principio de una cadena
 $                   final de una cadena

Los cuantificadores se utilizan para especificar cuántas coincidencias de lo anterior (un carácter literal, uno de los metacaracteres antes especificados o un grupo de caracteres o metacaracteres entre paréntesis) se desea detectar.

 *                   cero o más coincidencias de lo anterior
 +                   una o más coincidencias de lo anterior
 ?                   cero o una coincidencias de lo anterior
 {3}                 detecta exactamente 3 coincidencias de lo anterior
 {3,6}               detecta entre 3 y 6 coincidencias de lo anterior
 {3,}                detecta 3 o más coincidencias de lo anterior

Algunos ejemplos breves:

 /^\d+/              cadena que empieza por uno o varios dígitos
 /^$/                cadena vacía (principio y final
                     contiguos)
 /(\d\s){3}/         tres dígitos, cada uno seguido de un espacio
                     (p. ej., "3 4 5 ")
 /(a.)+/             cadena en la que cada letra impar
                     es una a (p. ej., "abacadaf")

 # Este bucle lee de STDIN e imprime las líneas que no estén vacías:
 while (<>) {
     next if /^$/;
     print;
 }
Paréntesis de captura

Además de para agrupar, los paréntesis también se pueden usar para capturar los resultados de partes de una expresión regular a fin de usarlos posteriormente. Los resultados se almacenan en $1, $2, etc.

 # manera rápida de descomponer una dirección de correo electrónico

 if ($email =~ /([^@]+)@(.+)/) {
     print "El nombre de usuario es $1\n";
     print "El nombre de host es $2\n";
 }
Otras características de las expresiones regulares

Las expresiones regulares de Perl también ofrecen referencias a capturas previas, inspección hacia adelante, y muchas otras funcionalidades complejas. Encontrará más información en perlrequick, perlretut y perlre.

Programación de subrutinas

Es fácil escribir subrutinas:

 sub registrador {
    my $mensaje_registro = shift;
    open my $registro, ">>", "mi.registro" or die "No se pudo abrir mi.registro: $!";
    print $registro $mensaje_registro;
 }

Ahora podemos usar la subrutina como cualquier función predefinida:

 registrador("Tenemos una subrutina para registrar.");

¿Qué hace shift? Los argumentos pasados a una subrutina están disponibles en un array especial denominado @_ (consulte perlvar para obtener más información). El argumento predeterminado de la función shift es @_. Así, my $mensaje_registro = shift; quita el primer elemento de la lista de argumentos y se lo asigna a $mensaje_registro.

También podemos manipular @_ de otras maneras:

 my ($mensaje_registro, $prioridad) = @_; # común
 my $mensaje_registro = $_[0];            # poco común (y poco estético)

Las subrutinas también pueden devolver valores:

 sub cuadrado {
     my $num = shift;
     my $resultado = $num * $num;
     return $resultado;
 }

Puede asignar el valor devuelto así:

 $sq = cuadrado(8);

Para obtener más información sobre cómo escribir subrutinas, consulte perlsub.

Perl orientado a objetos

La programación orientada a objetos en Perl es relativamente sencilla y se implementa con referencias que "conocen" qué tipo de objeto son, basándose en el concepto de paquetes de Perl. Sin embargo, este tema queda fuera del ámbito de este documento. Vea perlootut y perlobj.

La aplicación que suelen hacer los programadores principiantes de la programación orientada a objetos en Perl es la utilización de módulos de terceros, que se describe a continuación.

Utilización de módulos de Perl

No pierda tiempo reinventando la rueda. Los módulos de Perl disponibles en CPAN ( http://www.cpan.org/) proporcionan funcionalidad que puede utilizar en sus programas. La distribución de Perl incluye muchos módulos populares.

Las categorías de módulos abarcan desde la manipulación de texto hasta protocolos de red, integración de bases de datos o gráficos. En CPAN también está disponible una lista de módulos clasificados por categorías.

Para aprender a instalar los módulos que descargue de CPAN, lea perlmodinstall.

Para aprender a usar un módulo específico, ejecute perldoc Nombre::Módulo. Normalmente agregará a su programa la línea use Nombre::Módulo, que le proporcionará acceso a las funciones exportadas o a una interfaz orientada a objetos del módulo.

perlfaq contiene preguntas y respuestas relacionadas con muchas tareas comunes, y en muchos casos sugiere los módulos de CPAN adecuados para cada tarea.

En perlmod se describen los módulos de Perl en general. perlmodlib enumera los módulos incluidos en la instalación de Perl.

Si desea escribir módulos de Perl, perlnewmod le ayudará a empezar.

AUTOR

Kirrily "Skud" Robert <skud@cpan.org>

TRADUCTORES

  • Joaquín Ferrero (Tech Lead)

  • Enrique Nell (Language Lead)