Tutorial de Perl para principiantes

Qué es Perl y para qué se usa

Perl es un lenguaje de alto nivel y de tipado dinámico creado por Larry Wall en 1987. Se diseñó para el procesamiento de texto y la generación de informes, y se hizo famoso como el lenguaje pegamento de la administración de sistemas Unix y del desarrollo web temprano. Las expresiones regulares de Perl fueron tan influyentes que muchos otros lenguajes adoptaron una sintaxis de regex «compatible con Perl».

Hoy Perl se usa en scripts de administración de sistemas, procesamiento de registros y de texto, bioinformática, aplicaciones web heredadas y filtros de una línea en la terminal. Viene preinstalado en la mayoría de los sistemas Linux y Unix. CPAN, la Comprehensive Perl Archive Network, aloja una enorme colección de módulos reutilizables. Este tutorial cubre Perl 5; el lenguaje que una vez se llamó Perl 6 es ahora un lenguaje distinto llamado Raku.

Ejecuta Hola, mundo

Comprueba que Perl está instalado con perl -v. En Windows, Strawberry Perl es una distribución habitual. Empieza todos los scripts con use strict; y use warnings;: detectan errores tipográficos y código inseguro.

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

print "Hello, world!\n";

perl hello.pl
# Hello, world!
perl -e 'print "Hello from a one-liner\n"'

Las instrucciones terminan con punto y coma. Los comentarios empiezan con #. Las cadenas entre comillas dobles interpolan variables y secuencias de escape como \n; las cadenas entre comillas simples son literales.

Variables: escalares, arreglos y hashes

Las variables de Perl empiezan con un sigilo que indica el tipo de valor. Declara cada variable con my, que la hace local al bloque que la contiene.

use strict;
use warnings;

my $name  = "Perl";             # scalar: one value
my $year  = 1987;
my @langs = ("Perl", "C", "sh"); # array: ordered list
my %port  = (http => 80, https => 443);  # hash: key-value pairs

print "$name since $year\n";    # Perl since 1987
print "First: $langs[0]\n";     # First: Perl (element is a scalar, so $)
print "Count: ", scalar(@langs), "\n";   # Count: 3
print "HTTPS: $port{https}\n";  # HTTPS: 443
print "Sum: ", "10" + 5, "\n";  # Sum: 15 (strings convert to numbers)
print "Join: " . "a" . "b" x 3, "\n";    # Join: abbb

Control de flujo

Perl tiene if, elsif, else, unless, while, until, for y foreach. Una instrucción corta puede ir seguida de una condición, lo que se lee casi como lenguaje natural. next salta a la siguiente iteración y last sale del bucle.

use strict;
use warnings;

my $score = 72;
if ($score >= 90) {
    print "A\n";
} elsif ($score >= 70) {
    print "B\n";                 # B
} else {
    print "C\n";
}
print "passed\n" if $score >= 50;          # statement modifier
print "not perfect\n" unless $score == 100;

for my $i (1 .. 3) {
    print "i = $i\n";
}

my @names = ("ann", "bo");
foreach my $n (@names) {
    next if $n eq "bo";          # skip to the next item
    print ucfirst($n), "\n";     # Ann
}

my $k = 3;
while ($k > 0) { $k--; }

Los valores falsos son 0, "0", la cadena vacía "", la lista vacía y undef. Todo lo demás es verdadero.

Subrutinas

Define una función con sub. Los argumentos llegan en el arreglo especial @_, y la primera línea habitual los copia en variables con nombre. Una subrutina puede devolver un escalar o una lista.

use strict;
use warnings;

sub add {
    my ($x, $y) = @_;            # arguments arrive in @_
    return $x + $y;
}

sub greet {
    my ($name, $greeting) = @_;
    $greeting //= "Hello";       # default if undefined
    return "$greeting, $name!";
}

sub stats {
    my @nums = @_;
    my $sum = 0;
    $sum += $_ for @nums;
    return ($sum, $sum / @nums); # return a list
}

print add(2, 3), "\n";           # 5
print greet("Ann"), "\n";        # Hello, Ann!
my ($total, $avg) = stats(4, 8, 6);
print "$total $avg\n";           # 18 6

El Perl moderno también admite firmas, como en sub add($x, $y) { ... }, que se activan con use v5.36; o posterior, lo que además habilita strict y warnings.

Arreglos, hashes y referencias

Los arreglos y los hashes incluyen potentes funciones integradas como push, pop, shift, sort, map, grep, keys y exists. Los datos anidados usan referencias: [ ... ] crea una referencia a un arreglo y { ... } una referencia a un hash, y -> las sigue.

use strict;
use warnings;

my @nums = (5, 3, 8, 1);
push @nums, 9;                           # add to the end
my $last = pop @nums;                    # remove from the end: 9
my @sorted  = sort { $a <=> $b } @nums;  # numeric sort
my @doubled = map  { $_ * 2 } @sorted;
my @big     = grep { $_ > 4 } @sorted;
print "@sorted | @doubled | @big\n";     # 1 3 5 8 | 2 6 10 16 | 5 8

my %age = (ann => 31, bo => 25);
$age{cy} = 40;
delete $age{bo};
for my $who (sort keys %age) {
    print "$who is $age{$who}\n";        # ann is 31 / cy is 40
}
print "has ann\n" if exists $age{ann};

# references build nested data structures
my $user = { name => "Ann", langs => ["Perl", "SQL"] };
print "$user->{name} knows $user->{langs}[1]\n";  # Ann knows SQL
print scalar @{ $user->{langs} }, "\n";           # 2

Dentro de un bloque sort, $a y $b son los dos elementos que se comparan. <=> compara numéricamente y cmp compara como cadenas; un simple sort @list ordena como cadenas, así que 10 va antes que 9.

Expresiones regulares

Las expresiones regulares forman parte de la sintaxis de Perl, que es su característica distintiva. =~ aplica una coincidencia m/.../ o una sustitución s/.../.../. Los grupos capturados están disponibles como $1, $2, etc., y los modificadores como g (global) e i (sin distinguir mayúsculas) van después de la barra final.

use strict;
use warnings;

my $line = "2026-10-31 ERROR disk full on /dev/sda1";

if ($line =~ /^(\d{4})-(\d\d)-(\d\d)\s+(\w+)/) {
    print "year=$1 level=$4\n";          # year=2026 level=ERROR
}

(my $masked = $line) =~ s/\d/#/g;        # copy, then replace digits
print "$masked\n";                       # ####-##-## ERROR disk full on /dev/sda#

my @words = split /\s+/, $line;
print scalar(@words), " words\n";        # 6 words

my %h = ("a=1, b=2, c=3" =~ /(\w)=(\d)/g); # pairs into a hash
print join(",", map { "$_$h{$_}" } sort keys %h), "\n";  # a1,b2,c3

Usa qr/.../ para guardar un patrón compilado en una variable, y el modificador x para escribir patrones largos en varias líneas con comentarios.

Manejo de errores

die lanza una excepción y warn muestra una advertencia en la salida de error estándar. eval { ... } captura una excepción y guarda el mensaje de error en $@. Las llamadas al sistema como open devuelven falso si fallan y asignan a $! el error del sistema operativo, así que compruébalas con or die.

use strict;
use warnings;

sub divide {
    my ($x, $y) = @_;
    die "division by zero\n" if $y == 0;
    return $x / $y;
}

my $result = eval { divide(1, 0) };
if ($@) {
    print "Caught: $@";                  # Caught: division by zero
}

open(my $fh, "<", "missing.txt")
    or print "Cannot open: $!\n";        # Cannot open: No such file or directory

Un mensaje de die que termina en \n se imprime tal cual; sin el salto de línea, Perl añade el nombre del archivo y el número de línea. Desde Perl 5.34 existe también una función experimental try/catch, y módulos como Try::Tiny se usan mucho.

Un programa pequeño y completo: contador de niveles de registro

Este script lee un registro de los archivos indicados en la línea de comandos o de la entrada estándar, cuenta las líneas por nivel e imprime un resumen ordenado. Muestra el operador diamante <>, las expresiones regulares, los hashes y printf.

#!/usr/bin/env perl
# logstat.pl: count log levels in a file or standard input
use strict;
use warnings;

my %count;
my $lines = 0;

while (my $line = <>) {                  # reads files named on the command line, or STDIN
    chomp $line;
    $lines++;
    next unless $line =~ /\b(INFO|WARN|ERROR)\b/;
    $count{$1}++;
}

printf "%d lines read\n", $lines;
for my $level (sort { $count{$b} <=> $count{$a} || $a cmp $b } keys %count) {
    printf "%-5s %3d\n", $level, $count{$level};
}

perl logstat.pl app.log
# 120 lines read
# INFO   97
# WARN   18
# ERROR   5

Siguientes pasos

• perlintro y los demás tutoriales en perldoc.perl.org, también disponibles sin conexión con perldoc perlintro.
• Learning Perl y Modern Perl, dos libros muy conocidos para principiantes.
• MetaCPAN, la interfaz de búsqueda de los módulos de CPAN.
• perlre y perlretut, para la referencia completa de expresiones regulares.