Perl Language

#perl
Tabla de contenido
Acerca de 1

Capítulo 1: Empezando con Perl Language 2

Observaciones 2

Versiones 2

Examples 3

Empezando con Perl 3

Capítulo 2: Aleatoriedad 5

Observaciones 5

Examples 5

Generar un número aleatorio entre 0 y 100. 5

Generar un entero aleatorio entre 0 y 9 5

Accediendo a un elemento del array al azar 5

Capítulo 3: Análisis XML 7

Examples 7

Analizando con XML :: Twig 7

Consumiendo XML con XML :: Rabbit 8

Analizando con XML :: LibXML 10

Capítulo 4: Aplicaciones GUI en Perl 12

Observaciones 12

Examples 12

Solicitud de GTK 12

Capítulo 5: Archivo I / O (lectura y escritura de archivos) 13

Parámetros 13

Observaciones 13

Examples 13

Leyendo de un archivo 13

Escribir en un archivo 14

Abriendo una manija de archivo para leer 15

Apertura de archivos de texto ASCII genéricos 15

Apertura de archivos binarios 15

 Apertura de archivos de texto UTF8 15

Leer y escribir en un archivo. 16

"use autodie" y no necesitará verificar los errores de apertura / cierre de archivos 17

autodie permite trabajar con archivos sin tener que verificar explícitamente las fallas de 17

Rebobinar un identificador de archivo 18

Lectura y escritura de archivos comprimidos gzip 18

Escribiendo un archivo comprimido 18

Leyendo de un archivo comprimido 18

Configuración de la codificación predeterminada para IO 19

Capítulo 6: Bailarín 20

Introducción 20

Examples 20

Ejemplo mas facil 20

Capítulo 7: Clasificación 21

Introducción 21

Sintaxis 21

Examples 21

Ordenación léxica básica 21

Orden numérico 22

Orden inverso 22

La transformada de Schwartzian 22

Case Insensitive Sort 23

Capítulo 8: Comandos Perl para Windows Excel con Win32 :: módulo OLE 24

Introducción 24

Sintaxis 24

Parámetros 24

Observaciones 24

Examples 25

1. Abrir y guardar Excel / Workbooks 25

2. Manipulación de hojas de trabajo. 26

3. Manipulación de células. 26

4. Manipulación de Filas / Columnas. 27

Capítulo 9: Comentarios 29

Examples 29

Comentarios de una sola línea 29

Comentarios multilínea 29

Capítulo 10: Compilar el módulo sapnwrfc de Perl cpan a partir del código fuente 30

Introducción 30

Observaciones 30

Examples 31

Ejemplo simple para probar la conexión RFC. 31

Capítulo 11: Cuerdas y métodos de citar. 33

Observaciones 33

Examples 33

Cotizaciones literales de cuerdas 33

Doble cita 33

Heredocs 35

Eliminando nuevas líneas finales 35

Capítulo 12: Declaraciones de control 37

Examples 37

Condicionales 37

Declaraciones If-else 37

Bucles 37

Capítulo 13: Depuración de scripts Perl 39

Examples 39

Ejecutar script en modo de depuración 39

Utilice un depurador no estándar 39

Capítulo 14: Dividir una cadena en separadores sin comillas 40

Examples 40

parse_line () 40

Texto :: CSV o Texto :: CSV_XS 40

NOTAS 40

Capítulo 15: Empacar y desempacar 42

 Examples 42

Conversión manual de estructuras C para empaquetar sintaxis 42

Construyendo un encabezado IPv4 43

Capítulo 16: Expresiones regulares 45

Examples 45

Cuerdas a juego 45

Uso de \ Q y \ E en la coincidencia de patrones 45

Lo que está entre \ Q y \ E se trata como caracteres normales 45

Analizar una cadena con una expresión regular 46

Reemplace una cadena usando expresiones regulares 46

Capítulo 17: Fechas y hora 48

Examples 48

Crear un nuevo DateTime 48

Trabajando con elementos de fecha y hora. 48

Calcular el tiempo de ejecución del código. 49

Capítulo 18: Fechas y hora 50

Examples 50

Formato de fecha 50

Capítulo 19: Instalacion de perl 51

Introducción 51

Examples 51

Linux 51

OS X 51

Windows 52

Capítulo 20: Instalar módulos Perl a través de CPAN 53

Examples 53

Ejecute Perl CPAN en su terminal (Mac y Linux) o en el símbolo del sistema (Windows) 53

Línea de comando 53

Shell interactivo 53

Instalando módulos manualmente 53

cpanminus, el reemplazo ligero y sin configuración para cpan 54

Capítulo 21: Interacción simple con la base de datos a través del módulo DBI. 56

Parámetros 56

Examples 56

Módulo DBI 56

Capítulo 22: Interpolación en Perl 58

Examples 58

Interpolación básica 58

Lo que se interpola 58

Capítulo 23: Leyendo el contenido de un archivo en una variable 61

Examples 61

La forma manual 61

Camino :: Diminuto 61

Archivo :: Slurper 62

Archivo :: Slurp 62

Slurping un archivo en una variable de matriz 62

Archivo de slurp en una sola línea 62

Capítulo 24: Liza 64

Examples 64

Array como lista 64

Asignando una lista a un hash 64

Las listas se pueden pasar a subrutinas 65

Lista de retorno de subrutina 66

Usando arrayref para pasar array a sub 66

Hash como lista 67

Capítulo 25: Manejo de excepciones 68

Examples 68

eval y muere 68

Capítulo 26: Mejores prácticas 70

Examples 70

Utilizando Perl :: Crítico 70

Instalación 70

Uso básico 70
 Políticas de visualización 71

Ignorando el código 72

Creando excepciones permanentes 73

Conclusión 73

Capítulo 27: Optimización del uso de la memoria. 75

Examples 75

Lectura de archivos: foreach vs. while 75

Procesando listas largas 75

Capítulo 28: Orientado a objetos Perl 77

Examples 77

Creando objetos 77

Definiendo clases 77

Herencia y resolución de métodos. 78

Métodos de clase y objeto 81

Definiendo clases en Perl moderno. 82

Roles 83

Capítulo 29: Paquetes y módulos 85

Sintaxis 85

Examples 85

Ejecutando los contenidos de otro archivo. 85

Cargando un módulo en tiempo de ejecución 85

Usando un modulo 86

Usando un módulo dentro de un directorio 86

CPAN.pm 87

Listar todos los módulos instalados 88

Capítulo 30: Perl one-liners 89

Examples 89

Ejecutar algún código de Perl desde la línea de comandos 89

Uso de cadenas entre comillas dobles en las líneas de Windows 89

Líneas de impresión que coinciden con un patrón (PCRE grep) 89

Reemplazar una subcadena con otra (PCRE sed) 90

Imprimir solo ciertos campos 90

 Imprimir líneas 5 a 10 90

Editar archivo en el lugar 90

Leyendo todo el archivo como una cadena 90

Subir archivo a mojolicious 91

Capítulo 31: Perl Testing 92

Examples 92

Ejemplo de prueba de unidad Perl 92

Capítulo 32: Perlbrew 94

Introducción 94

Observaciones 94

Examples 94

Configurar perlbrew por primera vez 94

Crear script de configuración ~/.perlbrew.sh : 94

Crear script de instalación install_perlbrew.sh : 94

Ejecutar script de instalación: 94

Agrega al final de tu ~/.bashrc 95

Fuente ~/.bashrc : 95

Capítulo 33: Salida de depuración 96

Examples 96

Dumping estructuras de datos 96

Dumping con estilo 96

Dumping lista de matriz 97

Muestra de datos 98

Capítulo 34: Subrutinas 100

Observaciones 100

Examples 100

Creando subrutinas 100

Los argumentos de subrutina se pasan por referencia (excepto los de las firmas) 101

Subrutinas 102

Capítulo 35: Texto atribuido 104

Examples 104

Imprimiendo texto en color 104

Capítulo 36: Una forma sencilla de comprobar los módulos instalados en Mac y Ubuntu 105

Examples 105

Compruebe los módulos perl instalados a través de la terminal 105

Use perldoc para verificar la ruta de instalación del paquete Perl 105

Cómo comprobar los módulos de la lista de Perl. 105

¿Cómo comprobar la versión de un módulo instalado? 105

Capítulo 37: Unicode 106

Observaciones 106

Una advertencia sobre la codificación de nombre de archivo 106

: encoding (utf8) vs: utf8 106

UTF-8 vs utf8 vs UTF8 107

Más lectura 107

Examples 108

Crear nombres de archivos 108

Leer nombres de archivos 108

Interruptores de línea de comando para one-liners 110

Habilitar pragma utf8 110

Manejo de Unicode con interruptor -C 110

E / S estándar 110

Argumentos del guión 110

Capa PerlIO predeterminada 110

E / S estándar 111

Manijas de archivo 111

Configuración de la codificación con Open () 111

Configuración de la codificación con binmode () 111

pragma abierto 112

Configuración de la codificación con la línea de comando -C bandera 112

El pragma utf8: usando Unicode en tus fuentes 112

Manejo de UTF-8 inválido 113

Lectura inválida de UTF-8 113

Capítulo 38: Variables 115

 Sintaxis 115

Examples 115

Escalares 115

Arrays 116

Hashes 117

Referencias escalares 119

Es posible que desee una referencia escalar si: 120

Referencias de Array 120

Hash Referencias 121

Typeglobs, typeglob refs, manejadores de archivos y constantes 123

Sigilos 124

Capítulo 39: Variables especiales 127

Observaciones 127

Examples 127

Variables especiales en perl: 127

Capítulo 40: Verdadero y falso 128

Sintaxis 128

Observaciones 128

Los siguientes valores se consideran falsos: 128

Todos los demás valores son verdaderos: 128

Los siguientes operadores se tratan normalmente para devolver un valor booleano en context 128

Examples 129

Lista de valores verdaderos y falsos 129

Creditos 130
Acerca de
You can share this PDF with anyone you feel could benefit from it, downloaded the latest version
from: perl-language

It is an unofficial and free Perl Language ebook created for educational purposes. All the content
is extracted from Stack Overflow Documentation, which is written by many hardworking individuals
at Stack Overflow. It is neither affiliated with Stack Overflow nor official Perl Language.

The content is released under Creative Commons BY-SA, and the list of contributors to each
chapter are provided in the credits section at the end of this book. Images may be copyright of
their respective owners unless otherwise specified. All trademarks and registered trademarks are
the property of their respective company owners.

Use the content presented in this book at your own risk; it is not guaranteed to be correct nor
accurate, please send your feedback and corrections to [email protected]

https://riptutorial.com/es/home 1
Capítulo 1: Empezando con Perl Language
Observaciones
Perl es el camello de las lenguas: útil, pero no siempre bello. Tiene una buena documentación
propia a la que se puede acceder usando el comando perldoc desde su shell / comando. También
está disponible en línea en perldoc.perl.org .

Versiones

Versión Notas de lanzamiento Fecha de lanzamiento

1.000 1987-12-18

2.000 1988-06-05

3.000 1989-10-18

4.000 1991-03-21

5.000 1994-10-17

5.001 1995-05-13

5.002 1996-02-29

5.003 1996-06-25

5.004 perl5004delta 1997-05-15

5.005 perl5005delta 1998-07-22

5.6.0 Perl56delta 2000-03-22

5.8.0 perl58delta 2002-07-18

perl581delta ,
perl582delta ,
perl583delta ,
perl584delta ,
5.8.8 2006-02-01
perl585delta ,
perl586delta ,
perl587delta ,
Perl588delta

5.10.0 perl5100delta 2007-12-18

https://riptutorial.com/es/home 2
 Versión Notas de lanzamiento Fecha de lanzamiento

5.12.0 Perl5120delta 2010-04-12

5.14.0 perl5140delta 2011-05-14

5.16.0 perl5160delta 2012-05-20

5.18.0 Perl5180delta 2013-05-18

5.20.0 Perl5200delta 2014-05-27

5.22.0 perl5220delta 2015-06-01

5.24.0 perl5240delta 2016-05-09

5.26.0 perl5260delta 2017-05-30

Examples
Empezando con Perl

Perl intenta hacer lo que quieres decir:

print "Hello World\n";

Los dos bits difíciles son el punto y coma al final de la línea y el \n , que agrega una nueva línea
(avance de línea). Si tiene una versión relativamente nueva de perl, puede usar say lugar de print
para que el retorno de carro se agregue automáticamente:

5.10.0

use feature 'say';

say "Hello World";

La función say también se habilita automáticamente con una use v5.10 (o superior):

use v5.10;
say "Hello World";

Es bastante común simplemente usar perl en la línea de comandos usando la opción -e :

$ perl -e 'print "Hello World\n"'

Hello World

Agregar la opción -l es una forma de imprimir nuevas líneas automáticamente:

$ perl -le 'print "Hello World"'

Hello World

https://riptutorial.com/es/home 3
5.10.0

Si desea habilitar nuevas funciones , use la opción -E lugar:

$ perl -E 'say "Hello World"'

Hello World

Por supuesto, también puede guardar el script en un archivo. Simplemente elimine la opción de
línea de comando -e y use el nombre de archivo del script: perl script.pl . Para programas más
largos que una línea, es aconsejable activar un par de opciones:

use strict;
use warnings;

print "Hello World\n";

No hay una desventaja real más que hacer el código un poco más largo. A cambio, el estricto
pragma le impide usar código potencialmente inseguro y las advertencias le notifican muchos
errores comunes.

Observe que el punto y coma de fin de línea es opcional para la última línea, pero es una buena
idea en caso de que luego agregue al final de su código.

Para obtener más opciones sobre cómo ejecutar Perl, vea perlrun o escriba perldoc perlrun en un
símbolo del sistema. Para obtener una introducción más detallada de Perl, vea perlintro o escriba
perldoc perlintro en el símbolo del sistema. Para un tutorial interactivo peculiar, prueba Perl .

Lea Empezando con Perl Language en línea: https://riptutorial.com/es/perl/topic/341/empezando-

con-perl-language

https://riptutorial.com/es/home 4
Capítulo 2: Aleatoriedad
Observaciones
Documentación para la función rand () de perl: http://perldoc.perl.org/functions/rand.html

Examples
Generar un número aleatorio entre 0 y 100.

Pase un límite superior como argumento a la función rand ().

Entrada:

my $upper_limit = 100;
my $random = rand($upper_limit);

print $random . "\n";

Salida:

Un número aleatorio de punto flotante, como ...

45.8733038119139

Generar un entero aleatorio entre 0 y 9

Emitir su número de punto flotante aleatorio como un int.

Entrada:

my $range = 10;

# create random integer as low as 0 and as high as 9

my $random = int(rand($range)); # max value is up to but not equal to $range

print $random . "\n";

Salida:

Un entero aleatorio, como ...

Véase también el perldoc para rand .

Accediendo a un elemento del array al azar

https://riptutorial.com/es/home 5
 my @letters = ( 'a' .. 'z' ); # English ascii-bet

print $letters[ rand @letters ] for 1 .. 5; # prints 5 letters at random

Cómo funciona

• rand EXPR espera un valor escalar, por lo que @letters se evalúa en un contexto escalar
• Una matriz en contexto escalar devuelve el número de elementos que contiene (26 en este
caso)
• rand 26 devuelve un número fraccionario aleatorio en el intervalo 0 ≤ VALUE < 26 . (Nunca
puede ser 26 )
• Los índices de matriz son siempre enteros, por lo que $letters[rand @letters] ≡ $letters[int
rand @letters]
• Las matrices de Perl están indexadas en cero, por lo que $array[rand @array] devuelve
$array[0] , $array[$#array] o un elemento intermedio

(El mismo principio se aplica a los hashes)

my %colors = ( red => 0xFF0000,

green => 0x00FF00,
blue => 0x0000FF,
);

print ( values %colors )[rand keys %colors];

Lea Aleatoriedad en línea: https://riptutorial.com/es/perl/topic/6905/aleatoriedad

https://riptutorial.com/es/home 6
Capítulo 3: Análisis XML
Examples
Analizando con XML :: Twig

#!/usr/bin/env perl

use strict;
use warnings 'all';

use XML::Twig;

my $twig = XML::Twig->parse( \*DATA );

#we can use the 'root' method to find the root of the XML.
my $root = $twig->root;

#first_child finds the first child element matching a value.

my $title = $root->first_child('title');

#text reads the text of the element.

my $title_text = $title->text;

print "Title is: ", $title_text, "\n";

#The above could be combined:

print $twig ->root->first_child_text('title'), "\n";

## You can use the 'children' method to iterate multiple items:

my $list = $twig->root->first_child('list');

#children can optionally take an element 'tag' - otherwise it just returns all of them.
foreach my $element ( $list->children ) {

#the 'att' method reads an attribute

print "Element with ID: ", $element->att('id') // 'none here', " is ", $element->text,
"\n";
}

#And if we need to do something more complicated, we an use 'xpath'.

#get_xpath or findnodes do the same thing:
#return a list of matches, or if you specify a second numeric argument, just that numbered
match.

#xpath syntax is fairly extensive, but in this one - we search:

# anywhere in the tree: //
#nodes called 'item'
#with an id attribute [@id]
#and with that id attribute equal to "1000".
#by specifying '0' we say 'return just the first match'.

print "Item 1000 is: ", $twig->get_xpath( '//item[@id="1000"]', 0 )->text, "\n";

#this combines quite well with `map` to e.g. do the same thing on multiple items
print "All IDs:\n", join ( "\n", map { $_ -> att('id') } $twig -> get_xpath('//item'));
#note how this also finds the item under 'summary', because of //

https://riptutorial.com/es/home 7
 __DATA__
<?xml version="1.0" encoding="utf-8"?>
<root>
<title>some sample xml</title>
<first key="value" key2="value2">
<second>Some text</second>
</first>
<third>
<fourth key3="value">Text here too</fourth>
</third>
<list>
<item id="1">Item1</item>
<item id="2">Item2</item>
<item id="3">Item3</item>
<item id="66">Item66</item>
<item id="88">Item88</item>
<item id="100">Item100</item>
<item id="1000">Item1000</item>
<notanitem>Not an item at all really.</notanitem>
</list>
<summary>
<item id="no_id">Test</item>
</summary>
</root>

Consumiendo XML con XML :: Rabbit

Con XML::Rabbit es posible consumir archivos XML fácilmente. Usted define de forma declarativa
y con una sintaxis de XPath lo que está buscando en XML y XML::Rabbit devolverá los objetos de
acuerdo con la definición dada.

Definición:

package Bookstore;
use XML::Rabbit::Root;
has_xpath_object_list books => './book' => 'Bookstore::Book';
finalize_class();

package Bookstore::Book;
use XML::Rabbit;
has_xpath_value bookid => './@id';
has_xpath_value author => './author';
has_xpath_value title => './title';
has_xpath_value genre => './genre';
has_xpath_value price => './price';
has_xpath_value publish_date => './publish_date';
has_xpath_value description => './description';
has_xpath_object purchase_data => './purchase_data' => 'Bookstore::Purchase';
finalize_class();

package Bookstore::Purchase;
use XML::Rabbit;
has_xpath_value price => './price';
has_xpath_value date => './date';
finalize_class();

https://riptutorial.com/es/home 8
Consumo de XML:

use strict;
use warnings;
use utf8;

package Library;
use feature qw(say);
use Carp;
use autodie;

say "Showing data information";

my $bookstore = Bookstore->new( file => './sample.xml' );

foreach my $book( @{$bookstore->books} ) {

say "ID: " . $book->bookid;
say "Title: " . $book->title;
say "Author: " . $book->author, "\n";
}

Notas:

Por favor tenga cuidado con lo siguiente:

1. La primera clase debe ser XML::Rabbit::Root . Te colocará dentro de la etiqueta principal del
documento XML. En nuestro caso nos colocará dentro de <catalog>

2. Clases anidadas que son opcionales. Es necesario acceder a esas clases a través de un
bloque try / catch (o eval / $@ check). Los campos opcionales simplemente devolverán null
. Por ejemplo, para purchase_data el bucle sería:

foreach my $book( @{$bookstore->books} ) {

say "ID: " . $book->bookid;
say "Title: " . $book->title;
say "Author: " . $book->author;
try {
say "Purchase price: ". $book->purchase_data->price, "\n";
} catch {
say "No purchase price available\n";
}
}

sample.xml

<?xml version="1.0"?>
<catalog>
<book id="bk101">
<author>Gambardella, Matthew</author>
<title>XML Developer's Guide</title>
<genre>Computer</genre>
<price>44.95</price>
<publish_date>2000-10-01</publish_date>
<description>An in-depth look at creating applications
with XML.</description>
</book>
<book id="bk102">

https://riptutorial.com/es/home 9
 <author>Ralls, Kim</author>
<title>Midnight Rain</title>
<genre>Fantasy</genre>
<price>5.95</price>
<publish_date>2000-12-16</publish_date>
<description>A former architect battles corporate zombies,
an evil sorceress, and her own childhood to become queen
of the world.</description>
</book>
<book id="bk103">
<author>Corets, Eva</author>
<title>Maeve Ascendant</title>
<genre>Fantasy</genre>
<price>5.95</price>
<publish_date>2000-11-17</publish_date>
<description>After the collapse of a nanotechnology
society in England, the young survivors lay the
foundation for a new society.</description>
</book>
<book id="bk104">
<author>Corets, Eva</author>
<title>Oberon's Legacy</title>
<genre>Fantasy</genre>
<price>5.95</price>
<publish_date>2001-03-10</publish_date>
<description>In post-apocalypse England, the mysterious
agent known only as Oberon helps to create a new life
for the inhabitants of London. Sequel to Maeve
Ascendant.</description>
<purchase_data>
<date>2001-12-21</date>
<price>20</price>
</purchase_data>
</book>
</catalog>

Analizando con XML :: LibXML

# This uses the 'sample.xml' given in the XML::Twig example.

# Module requirements (1.70 and above for use of load_xml)

use XML::LibXML '1.70';

# let's be a good perl dev

use strict;
use warnings 'all';

# Create the LibXML Document Object

my $xml = XML::LibXML->new();

# Where we are retrieving the XML from

my $file = 'sample.xml';

# Load the XML from the file

my $dom = XML::LibXML->load_xml(
location => $file
);

# get the docroot

https://riptutorial.com/es/home 10
 my $root = $dom->getDocumentElement;

# if the document has children

if($root->hasChildNodes) {

# getElementsByLocalName returns a node list of all elements who's

# localname matches 'title', and we want the first occurrence
# (via get_node(1))
my $title = $root->getElementsByLocalName('title');

if(defined $title) {
# Get the first matched node out of the nodeList
my $node = $title->get_node(1);

# Get the text of the target node

my $title_text = $node->textContent;

print "The first node with name 'title' contains: $title_text\n";

}

# The above calls can be combined, but is possibly prone to errors

# (if the getElementsByLocalName() failed to match a node).
#
# my $title_text = $root->getElementsByLocalName('title')->get_node(1)->textContent;
}

# Using Xpath, get the price of the book with id 'bk104'

#

# Set our xpath

my $xpath = q!/catalog/book[@id='bk104']/price!;

# Does that xpath exist?

if($root->exists($xpath)) {

# Pull in the twig

my $match = $root->find($xpath);

if(defined $match) {
# Get the first matched node out of the nodeList
my $node = $match->get_node(1);

# pull in the text of that node

my $match_text = $node->textContent;

print "The price of the book with id bk104 is: $match_text\n";

}
}

Lea Análisis XML en línea: https://riptutorial.com/es/perl/topic/3590/analisis-xml

https://riptutorial.com/es/home 11
Capítulo 4: Aplicaciones GUI en Perl
Observaciones
Tk es uno de los kits de herramientas GUI más utilizados para Perl. Otros kits de herramientas
comunes son GTK + 2 y 3, WxWidgets y widgets Win32. Menos comúnmente utilizados son Qt4,
XUL, Prima y FLTK.

Tk, GTK + 3, Wx, Win32, Prima, FLTK y XUL se actualizan activamente. Qt4 y GTK + 2 ya no se
desarrollan activamente, pero pueden tener versiones de mantenimiento.

Examples
Solicitud de GTK

use strict;
use warnings;

use Gtk2 -init;

my $window = Gtk2::Window->new();
$window->show();

Gtk2->main();

0;

Lea Aplicaciones GUI en Perl en línea: https://riptutorial.com/es/perl/topic/5924/aplicaciones-gui-

en-perl

https://riptutorial.com/es/home 12
Capítulo 5: Archivo I / O (lectura y escritura
de archivos)
Parámetros

Modo Explicacion

Escribir (trunc) . Sobrescribirá los archivos existentes. Crea un nuevo archivo si no

>
se encontró ningún archivo

Escribir (adjuntar) . No sobrescribirá los archivos, sino que agregará contenido

>> nuevo al final. También creará un archivo si se utiliza para abrir un archivo no
existente.

< Leer Abre el archivo en modo de solo lectura.

+< Leer / Escribir . No creará ni truncará el archivo.

+> Lectura / Escritura (trunc) . Creará y truncará el archivo.

+>> Leer / Escribir (añadir) . Creará pero no truncará el archivo.

Observaciones
chomp se utiliza a menudo cuando se lee de un archivo. Por defecto, recorta el carácter de nueva
línea, aunque para su funcionalidad completa, refiérase a los perldocs .

Tenga cuidado con la diferencia entre caracteres y bytes: no todas las codificaciones,
especialmente UTF-8, utilizan caracteres de 1 byte. Si bien esto se maneja de manera casi
perfecta por PerlIO, hay un posible escollo:

• read usa caracteres para sus parámetros de longitud y desplazamiento

• seek y tell usar siempre bytes para posicionamiento

Así que no uses aritmética basada en estos valores mixtos. En su lugar, use, por ejemplo,
Encode::encode('utf8',$value_by_read) para obtener los octetos (bytes) de un resultado de read ,
cuya cuenta puede usar con tell y seek .

Examples
Leyendo de un archivo

my $filename = '/path/to/file';

https://riptutorial.com/es/home 13
 open my $fh, '<', $filename or die "Failed to open file: $filename";

# You can then either read the file one line at a time...
while(chomp(my $line = <$fh>)) {
print $line . "\n";
}

# ...or read whole file into an array in one go

chomp(my @fileArray = <$fh>);

Si sabe que su archivo de entrada es UTF-8, puede especificar la codificación:

open my $fh, '<:encoding(utf8)', $filename or die "Failed to open file: $filename";

Después de terminar de leer el archivo, se debe cerrar el identificador de archivo:

close $fh or warn "close failed: $!";

Ver también: Leer un archivo en una variable.

Otra forma más rápida de leer un archivo es usar File :: Slurper Module. Esto es útil si trabajas
con muchos archivos.

use File::Slurper;
my $file = read_text("path/to/file"); # utf8 without CRLF transforms by default
print $file; #Contains the file body

Ver también: [Leyendo un archivo con sorbete]

Escribir en un archivo

Este código abre un archivo para escribir. Devuelve un error si no se pudo abrir el archivo.
También cierra el archivo al final.

#!/usr/bin/perl
use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding

# Open "output.txt" for writing (">") and from now on, refer to it as the variable $fh.
open(my $fh, ">", "output.txt")
# In case the action failed, print error message and quit.
or die "Can't open > output.txt: $!";

Ahora tenemos un archivo abierto listo para la escritura que se accede a través de $fh (esta
variable se denomina gestor de archivo). A continuación podemos dirigir la salida a ese archivo
usando el operador de print :

# Print "Hello" to $fh ("output.txt").

print $fh "Hello";
# Don't forget to close the file once we're done!
close $fh or warn "Close failed: $!";

https://riptutorial.com/es/home 14
El operador open tiene una variable escalar ( $fh en este caso) como su primer parámetro. Como
se define en el operador open , se trata como un identificador de archivo . El segundo parámetro
">" (mayor que) define que el archivo está abierto para escritura. El último parámetro es la ruta
del archivo para escribir los datos.

Para escribir los datos en el archivo, el operador de print se utiliza junto con el identificador de
archivo. Observe que en el operador de print no hay una coma entre el identificador de archivo y
la declaración en sí, solo el espacio en blanco.

Abriendo una manija de archivo para leer

Apertura de archivos de texto ASCII genéricos

5.6.0

open my $filehandle, '<', $name_of_file or die "Can't open $name_of_file, $!";

Este es el lenguaje básico para el archivo IO "predeterminado" y hace que $filehandle archivo sea
un flujo de entrada legible de bytes , filtrado por un decodificador predeterminado específico del
sistema, que puede configurarse localmente con el pragma open

Perl en sí no maneja los errores en la apertura del archivo, por lo que debe manejarlos usted
mismo al verificar la condición de salida de open . $! se rellena con el mensaje de error que hizo
que la apertura falle.

En Windows, el decodificador predeterminado es un filtro "CRLF", que asigna cualquier secuencia

"\ r \ n" en la entrada a "\ n"

Apertura de archivos binarios

5.8.0

open my $filehandle, '<:raw', 'path/to/file' or die "Can't open $name_of_file, $!";

Esto especifica que Perl no debe realizar una traducción de CRLF en Windows.

Apertura de archivos de texto UTF8

5.8.0

open my $filehandle, '<:raw:encoding(utf-8)', 'path/to/file'

or die "Can't open $name_of_file, $!";

Esto especifica que Perl debe evitar la traducción de CRLF y luego decodificar los bytes resultantes
en cadenas de caracteres (implementados internamente como matrices de enteros que pueden
exceder de 255), en lugar de cadenas de bytes

https://riptutorial.com/es/home 15
Leer y escribir en un archivo.

Antes de leer y escribir archivos de texto, debe saber qué codificación utilizar. Consulte la
documentación de Perl Unicode para obtener más detalles sobre la codificación . Aquí mostramos
la configuración de UTF-8 como la codificación y decodificación predeterminadas para la función
open . Esto se hace usando el pragma open cerca de la parte superior de su código (justo después
de su use strict; y use warnings; sería apropiado):

use strict;
use warnings;
use open qw( :encoding(UTF-8) :std );

La función open crea un identificador de archivo que se utiliza para leer y / o escribir en un archivo.
La función open tiene la firma.

open(FILEHANDLE, MODE, FILEPATH) y devuelve un valor falso si la operación falla. La descripción del
error se almacena en $! .

Leyendo

#!/usr/bin/perl
use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding

my $file_path = "/path/to/file";
open(my $file_handle, '<', $file_path) or die "Could not open file! $!";

while(my $row = <$file_handle>) {

print chomp($row), "\n";
}

close $file_handle
or warn "Close failed!";

Escritura

#!/usr/bin/perl
use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding

my $file_path = "/path/to/file";
open(my $file_handle, '>', $file_path) or die "Could not open file! $!";

print $file_handle "Writing to a file";

close $file_handle
or warn "Close failed!";

Lectura de trozos

Abrir y leer archivos grandes puede llevar tiempo y recursos. Si solo se requiere una pequeña

https://riptutorial.com/es/home 16
parte del contenido, puede ser una buena idea leer el contenido en fragmentos utilizando la
función de read que tiene la firma

read(FILEHANDLE, SCALAR, LENGTH, OFFSET)

FILEHANDLE debe ser un identificador de archivo abierto, SCALAR mantendrá los datos de lectura
después de la operación. LENGTH especifica el número de caracteres que se leerán a partir de la
OFFSET . La función devuelve el número de caracteres leídos, 0 si se alcanzó el final del archivo y
undef en caso de error.

read($file_handle, $data, 16, 0);

Lee 16 caracteres desde el principio del archivo en $data .

"use autodie" y no necesitará verificar los errores de apertura / cierre de

archivos

permite trabajar con archivos sin tener que verificar

autodie

explícitamente las fallas de apertura / cierre.

Desde Perl 5.10.1, autodie ha estado disponible en Core Perl. Cuando se utiliza, Perl buscará
automáticamente errores al abrir y cerrar archivos.

Aquí hay un ejemplo en el que todas las líneas de un archivo se leen y luego se escriben al final
de un archivo de registro.

use 5.010; # 5.010 and later enable "say", which prints arguments, then a newline
use strict; # require declaring variables (avoid silent errors due to typos)
use warnings; # enable helpful syntax-related warnings
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding
use autodie; # Automatically handle errors in opening and closing files

open(my $fh_in, '<', "input.txt"); # check for failure is automatic

# open a file for appending (i.e. using ">>")

open( my $fh_log, '>>', "output.log"); # check for failure is automatic

while (my $line = readline $fh_in) # also works: while (my $line = <$fh_in>)
{
# remove newline
chomp $line;

# write to log file

say $fh_log $line or die "failed to print '$line'"; # autodie doesn't check print
}

# Close the file handles (check for failure is automatic)

close $fh_in;
close $fh_log;

Por cierto, técnicamente siempre debe verificar print declaraciones de print . Muchas personas
no lo hacen, pero perl (el intérprete de Perl) no lo hace automáticamente y tampoco lo hace el

https://riptutorial.com/es/home 17
autodie .

Rebobinar un identificador de archivo

A veces es necesario dar marcha atrás después de leer.

# identify current position in file, in case the first line isn't a comment
my $current_pos = tell;

while (my $line = readline $fh)

{
if ($line =~ /$START_OF_COMMENT_LINE/)
{
push @names, get_name_from_comment($line);
}
else {
last; # break out of the while loop
}
$current_pos = tell; # keep track of current position, in case we need to rewind the next
line read
}

# Step back a line so that it can be processed later as the first data line
seek $fh, $current_pos, 0;

Lectura y escritura de archivos comprimidos gzip

Escribiendo un archivo comprimido

Para escribir un archivo comprimido, use el módulo IO::Compress::Gzip y cree un identificador de
archivo creando una nueva instancia de IO::Compress::Gzip para el archivo de salida deseado:

use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding

use IO::Compress::Gzip;

my $fh_out = IO::Compress::Gzip->new("hello.txt.gz");

print $fh_out "Hello World!\n";

close $fh_out;

use IO::Compress::Gzip;

Leyendo de un archivo comprimido

Para leer un archivo comprimido, use el módulo IO::Uncompress::Gunzip y luego cree un
identificador de archivo creando una nueva instancia de IO::Uncompress::Gunzip para el archivo de
entrada:

https://riptutorial.com/es/home 18
 #!/bin/env perl
use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding

use IO::Uncompress::Gunzip;

my $fh_in = IO::Uncompress::Gunzip->new("hello.txt.gz");

my $line = readline $fh_in;

print $line;

Configuración de la codificación predeterminada para IO

# encode/decode UTF-8 for files and standard input/output

use open qw( :encoding(UTF-8) :std );

Este pragma cambia el modo predeterminado de lectura y escritura de texto (archivos, entrada
estándar, salida estándar y error estándar) a UTF-8, que suele ser lo que desea al escribir nuevas
aplicaciones.

ASCII es un subconjunto de UTF-8, por lo que no se espera que cause ningún problema con los
archivos ASCII heredados y le ayudará a protegerse contra la corrupción accidental de archivos
que puede ocurrir cuando se tratan archivos UTF-8 como ASCII.

Sin embargo, es importante que sepa cuál es la codificación de sus archivos con los que está
tratando y los maneje en consecuencia. ( Razones por las que no debemos ignorar Unicode ) .
Para un tratamiento más profundo de Unicode, consulte el tema Perl Unicode .

Lea Archivo I / O (lectura y escritura de archivos) en línea:

https://riptutorial.com/es/perl/topic/1604/archivo-i---o--lectura-y-escritura-de-archivos-

https://riptutorial.com/es/home 19
Capítulo 6: Bailarín
Introducción
Acerca de:

Dancer2 (el sucesor de Dancer) es un marco de aplicación web simple pero potente para Perl.

Está inspirado en Sinatra y escrito por Alexis Sukrieh.

Características principales: ••• Dead Simple: sintaxis intuitiva, minimalista y muy expresiva. •••
Flexible: la compatibilidad con PSGI, los complementos y el diseño modular permiten una gran
escalabilidad. ••• Pocas dependencias: Dancer depende de la menor cantidad posible de módulos
CPAN, lo que facilita su instalación.

Examples
Ejemplo mas facil

#!/usr/bin/env perl
use Dancer2;

get '/' => sub {

"Hello World!"
};

dance;

Lea Bailarín en línea: https://riptutorial.com/es/perl/topic/5921/bailarin

https://riptutorial.com/es/home 20
Capítulo 7: Clasificación
Introducción
Para ordenar las listas de cosas, Perl tiene una sola función, como es lógico que se llame sort .
Es lo suficientemente flexible como para ordenar todo tipo de elementos: números, cadenas en
cualquier número de codificaciones, estructuras de datos anidadas u objetos. Sin embargo,
debido a su flexibilidad, hay bastantes trucos e idiomas que aprender para su uso.

Sintaxis
• ordenar la LISTA DE NOMBRES
• ordenar la lista de bloqueo
• Lista Ordenada

Examples
Ordenación léxica básica

@sorted = sort @list;

@sorted = sort { $a cmp $b } @list;

sub compare { $a cmp $b }

@sorted = sort compare @list;

Los tres ejemplos anteriores hacen exactamente lo mismo. Si no proporciona ninguna función o
bloque de comparador, la sort asume que desea que la lista esté ordenada de forma léxica. Esta
suele ser la forma que desea si solo necesita sus datos en un orden predecible y no le importa la
corrección lingüística.

sort pasa pares de elementos en @list a la función de comparación, que le dice a sort qué
elemento es más grande. El operador cmp hace esto para cadenas mientras que <=> hace lo
mismo para los números. El comparador se llama con bastante frecuencia, en promedio n * log ( n
) veces, siendo n el número de elementos a clasificar, por lo que es importante que sea rápido.
Esta es la razón por la que la sort usa variables globales predefinidas del paquete ( $a $b ) para
pasar los elementos que se compararán con el bloque o función, en lugar de los parámetros de
función adecuados.

Si use locale , cmp tiene en cuenta el orden de intercalación específico de la configuración

regional, por ejemplo, clasificará Å como A en una configuración regional danesa, pero después de
Z en una configuración inglesa o alemana. Sin embargo, no tiene en cuenta las reglas de
clasificación de Unicode más complejas ni ofrece ningún control sobre el pedido; por ejemplo, las
guías telefónicas a menudo se clasifican de forma diferente a los diccionarios. Para esos casos,
se recomiendan los módulos Unicode::Collate y particularmente Unicode::Collate::Locale .

https://riptutorial.com/es/home 21
Orden numérico

@sorted = sort { $a <=> $b } @list;

La comparación de $a y $b con el operador <=> garantiza que se comparen numéricamente y no

textualmente como por defecto.

Orden inverso

@sorted = sort { $b <=> $a } @list;

@sorted = reverse sort { $a <=> $b } @list;

Clasificación de elementos en orden descendente, simplemente se puede lograr mediante el

canje $a y $b en el bloque comparador. Sin embargo, algunas personas prefieren la claridad de un
reverse separado aunque sea un poco más lento.

La transformada de Schwartzian

Este es probablemente el ejemplo más famoso de una optimización de ordenación que utiliza las
funciones de programación funcional de Perl, para usarse donde el orden de los elementos
depende de una función costosa.

# What you would usually do

@sorted = sort { slow($a) <=> slow($b) } @list;

# What you do to make it faster

@sorted =
map { $_->[0] }
sort { $a->[1] <=> $b->[1] }
map { [ $_, slow($_) ] }
@list;

El problema con el primer ejemplo es que el comparador se llama muy a menudo y sigue
recalculando los valores usando una función lenta una y otra vez. Un ejemplo típico sería ordenar
los nombres de los archivos por su tamaño de archivo:

use File::stat;
@sorted = sort { stat($a)->size <=> stat($b)->size } glob "*";

Esto funciona, pero en el mejor de los casos incurre en la sobrecarga de dos llamadas al sistema
por comparación, en el peor, tiene que ir al disco dos veces para cada comparación y ese disco
puede estar en un servidor de archivos sobrecargado en el otro lado del planeta.

Entra en el truco de Randall Schwartz.

La Transformación de Schwartz, básicamente, empuja @list través de tres funciones, de abajo

hacia arriba. El primer map convierte cada entrada en una lista de dos elementos del elemento
original y el resultado de la función lenta como una clave de ordenación, por lo que al final de esto
llamamos slow() exactamente una vez para cada elemento. La siguiente sort puede simplemente

https://riptutorial.com/es/home 22
acceder a la clave de clasificación mirando en la lista. Como no nos importan las claves de
clasificación, sino que solo necesitamos los elementos originales en orden, el map final elimina las
listas de dos elementos de la lista ya ordenada que recibe de @sort y devuelve una lista de solo
sus primeros miembros .

Case Insensitive Sort

La técnica tradicional para hacer sort ignorar caso es pasar cadenas a lc o uc para la
comparación:

@sorted = sort { lc($a) cmp lc($b) } @list;

Esto funciona en todas las versiones de Perl 5 y es completamente suficiente para el inglés; No
importa si usas uc o lc . Sin embargo, presenta un problema para idiomas como el griego o el
turco, donde no hay correspondencia 1: 1 entre las letras mayúsculas y minúsculas, por lo que
obtiene diferentes resultados dependiendo de si usa uc o lc . Por lo tanto, Perl 5.16 y superior
tienen una función de plegado de caja llamada fc que evita este problema, por lo que la
clasificación multilingüe moderna debería usar esto:

@sorted = sort { fc($a) cmp fc($b) } @list;

Lea Clasificación en línea: https://riptutorial.com/es/perl/topic/8958/clasificacion

https://riptutorial.com/es/home 23
Capítulo 8: Comandos Perl para Windows
Excel con Win32 :: módulo OLE
Introducción
Estos ejemplos presentan los comandos más utilizados de Perl para manipular Excel a través del
módulo Win32 :: OLE.

Sintaxis
• $ Hoja-> Rango ( Celda1 , [ Celda2 ]) #Seleccione una celda o un rango de celdas
• $ Del tipo de hoja> Celdas (rowIndex, columnIndex) #Seleccione una célula por índice de
fila y columna

Parámetros

Parámetros Detalles

El nombre del rango. Esta debe ser una referencia de estilo A1 en el idioma
Celda 1
de la macro. Puede incluir el operador de rango (dos puntos), el operador
(requerido)
de intersección (un espacio) o el operador de unión (una coma).

Cell2 Si se especifica, Cell1 corresponde a la esquina superior izquierda del

(opcional) rango y Cell2 corresponde a la esquina inferior derecha del rango

Observaciones
Enlace para obtener información sobre Colors en Excel:
http://dmcritchie.mvps.org/excel/colors.htm

https://riptutorial.com/es/home 24
Enlace para obtener información sobre las constantes de Excel: http://msdn.microsoft.com/en-
us/library/aa221100%28office.11%29.aspx

Enlaces desde Win32 :: módulo OLE: http://search.cpan.org/~jdb/Win32-OLE-

0.1712/lib/Win32/OLE.pm#EXAMPLES

Puede encontrar información útil sobre el uso de Excel en esta dirección

Examples
1. Abrir y guardar Excel / Workbooks

#Modules to use
use Cwd 'abs_path';
use Win32::OLE;
use Win32::OLE qw(in with);
use Win32::OLE::Const "Microsoft Excel";
$Win32::OLE::Warn = 3;

#Need to use absolute path for Excel files

my $excel_file = abs_path("$Excel_path") or die "Error: the file $Excel_path has not been
found\n";

# Open Excel application

my $Excel = Win32::OLE->GetActiveObject('Excel.Application')

https://riptutorial.com/es/home 25
 || Win32::OLE->new('Excel.Application', 'Quit');

# Open Excel file

my $Book = $Excel->Workbooks->Open($excel_file);

#Make Excel visible

$Excel->{Visible} = 1;

#___ ADD NEW WORKBOOK

my $Book = $Excel->Workbooks->Add;
my $Sheet = $Book->Worksheets("Sheet1");
$Sheet->Activate;

#Save Excel file

$Excel->{DisplayAlerts}=0; # This turns off the "This file already exists" message.
$Book->Save; #Or $Book->SaveAs("C:\\file_name.xls");
$Book->Close; #or $Excel->Quit;

2. Manipulación de hojas de trabajo.

#Get the active Worksheet

my $Book = $Excel->Activewindow;
my $Sheet = $Book->Activesheet;

#List of Worksheet names

my @list_Sheet = map { $_->{'Name'} } (in $Book->{Worksheets});

#Access a given Worksheet

my $Sheet = $Book->Worksheets($list_Sheet[0]);

#Add new Worksheet

$Book->Worksheets->Add({After => $workbook->Worksheets($workbook->Worksheets->{Count})});

#Change Worksheet Name

$Sheet->{Name} = "Name of Worksheet";

#Freeze Pane
$Excel -> ActiveWindow -> {FreezePanes} = "True";

#Delete Sheet
$Sheet -> Delete;

3. Manipulación de células.

#Edit the value of a cell (2 methods)

$Sheet->Range("A1")->{Value} = 1234;
$Sheet->Cells(1,1)->{Value} = 1234;

#Edit the values in a range of cells

$Sheet->Range("A8:C9")->{Value} = [[ undef, 'Xyzzy', 'Plugh' ],
[ 42, 'Perl', 3.1415 ]];

#Edit the formula in a cell (2 types)

$Sheet->Range("A1")->{Formula} = "=A1*9.81";
$Sheet->Range("A3")->{FormulaR1C1} = "=SUM(R[-2]C:R[-1]C)"; # Sum of rows
$Sheet->Range("C1")->{FormulaR1C1} = "=SUM(RC[-2]:RC[-1])"; # Sum of columns

https://riptutorial.com/es/home 26
 #Edit the format of the text (font)
$Sheet->Range("G7:H7")->Font->{Bold} = "True";
$Sheet->Range("G7:H7")->Font->{Italic} = "True";
$Sheet->Range("G7:H7")->Font->{Underline} = xlUnderlineStyleSingle;
$Sheet->Range("G7:H7")->Font->{Size} = 8;
$Sheet->Range("G7:H7")->Font->{Name} = "Arial";
$Sheet->Range("G7:H7")->Font->{ColorIndex} = 4;

#Edit the number format

$Sheet -> Range("G7:H7") -> {NumberFormat} = "\@"; # Text
$Sheet -> Range("A1:H7") -> {NumberFormat} = "\$#,##0.00"; # Currency
$Sheet -> Range("G7:H7") -> {NumberFormat} = "\$#,##0.00_);[Red](\$#,##0.00)"; # Currency
- red negatives
$Sheet -> Range("G7:H7") -> {NumberFormat} = "0.00_);[Red](0.00)"; # Numbers
with decimals
$Sheet -> Range("G7:H7") -> {NumberFormat} = "#,##0"; # Numbers
with commas
$Sheet -> Range("G7:H7") -> {NumberFormat} = "#,##0_);[Red](#,##0)"; # Numbers
with commas - red negatives
$Sheet -> Range("G7:H7") -> {NumberFormat} = "0.00%"; # Percents
$Sheet -> Range("G7:H7") -> {NumberFormat} = "m/d/yyyy" # Dates

#Align text
$Sheet -> Range("G7:H7") -> {HorizontalAlignment} = xlHAlignCenter; # Center
text;
$Sheet -> Range("A1:A2") -> {Orientation} = 90; # Rotate
text

#Activate Cell
$Sheet -> Range("A2") -> Activate;

$Sheet->Hyperlinks->Add({
Anchor => $range, #Range of cells with the hyperlink; e.g. $Sheet->Range("A1")
Address => $adr, #File path, http address, etc.
TextToDisplay => $txt, #Text in the cell
ScreenTip => $tip, #Tip while hovering the mouse over the hyperlink
});

NB: para recuperar la lista de hipervínculos, eche un vistazo a la siguiente publicación Obtención
de la lista de hipervínculos de una hoja de cálculo de Excel con Perl Win32 :: OLE

4. Manipulación de Filas / Columnas.

#Insert a row before/after line 22

$Sheet->Rows("22:22")->Insert(xlUp, xlFormatFromRightOrBelow);
$Sheet->Rows("23:23")->Insert(-4121,0); #xlDown is -4121 and that xlFormatFromLeftOrAbove
is 0

#Delete a row
$Sheet->Rows("22:22")->Delete();

#Set column width and row height

$Sheet -> Range('A:A') -> {ColumnWidth} = 9.14;
$Sheet -> Range("8:8") -> {RowHeight} = 30;
$Sheet -> Range("G:H") -> {Columns} -> Autofit;

# Get the last row/column

my $last_row = $Sheet -> UsedRange -> Find({What => "*", SearchDirection => xlPrevious,
SearchOrder => xlByRows}) -> {Row};

https://riptutorial.com/es/home 27
 my $last_col = $Sheet -> UsedRange -> Find({What => "*", SearchDirection => xlPrevious,
SearchOrder => xlByColumns}) -> {Column};

#Add borders (method 1)

$Sheet -> Range("A3:H3") -> Borders(xlEdgeBottom) -> {LineStyle} = xlDouble;
$Sheet -> Range("A3:H3") -> Borders(xlEdgeBottom) -> {Weight} = xlThick;
$Sheet -> Range("A3:H3") -> Borders(xlEdgeBottom) -> {ColorIndex} = 1;
$Sheet -> Range("A3:H3") -> Borders(xlEdgeLeft) -> {LineStyle} = xlContinuous;
$Sheet -> Range("A3:H3") -> Borders(xlEdgeLeft) -> {Weight} = xlThin;
$Sheet -> Range("A3:H3") -> Borders(xlEdgeTop) -> {LineStyle} = xlContinuous;
$Sheet -> Range("A3:H3") -> Borders(xlEdgeTop) -> {Weight} = xlThin;
$Sheet -> Range("A3:H3") -> Borders(xlEdgeBottom) -> {LineStyle} = xlContinuous;
$Sheet -> Range("A3:H3") -> Borders(xlEdgeBottom) -> {Weight} = xlThin;
$Sheet -> Range("A3:H3") -> Borders(xlEdgeRight) -> {LineStyle} = xlContinuous;
$Sheet -> Range("A3:H3") -> Borders(xlEdgeRight) -> {Weight} = xlThin;
$Sheet -> Range("A3:H3") -> Borders(xlInsideVertical) -> {LineStyle} = xlDashDot
$Sheet -> Range("A3:H3") -> Borders(xlInsideVertical) -> {Weight} = xlMedium;
$Sheet -> Range("A3:I3") -> Borders(xlInsideHorizontal) -> {LineStyle} = xlContinuous;
$Sheet -> Range("A3:I3") -> Borders(xlInsideHorizontal) -> {Weight} = xlThin;

#Add borders (method 2)

my @edges = qw (xlInsideHorizontal xlInsideVertical xlEdgeBottom xlEdgeTop xlEdgeRight);
foreach my $edge (@edges)

Lea Comandos Perl para Windows Excel con Win32 :: módulo OLE en línea:
https://riptutorial.com/es/perl/topic/3420/comandos-perl-para-windows-excel-con-win32----modulo-
ole

https://riptutorial.com/es/home 28
Capítulo 9: Comentarios
Examples
Comentarios de una sola línea

Los comentarios de una sola línea comienzan con un signo de # y van al final de la línea:

# This is a comment

my $foo = "bar"; # This is also a comment

Comentarios multilínea

Los comentarios de varias líneas comienzan con = y con la instrucción =cut . Estos son
comentarios especiales llamados POD (Documentación antigua simple).

Cualquier texto entre los marcadores será comentado:

=begin comment

This is another comment.

And it spans multiple lines!

=end comment

=cut

Lea Comentarios en línea: https://riptutorial.com/es/perl/topic/6815/comentarios

https://riptutorial.com/es/home 29
Capítulo 10: Compilar el módulo sapnwrfc de
Perl cpan a partir del código fuente
Introducción
Me gustaría describir los requisitos previos y los pasos de cómo construir el módulo Perl CPAN
sapnwrfc con el entorno de Strawberry Perl en Windows 7 x64. Debería funcionar también para
todas las versiones posteriores de Windows como 8, 8.1 y 10.

Uso Strawberry Perl 5.24.1.1 de 64 bits, pero también debería funcionar con versiones anteriores.

Me tomó algo de tiempo para tener éxito con varios intentos (instalación de Perl, SAP NW RFC
SDK de 32 vs. 64 bits, compilador de MinGW vs. Microsoft C). Así que espero que algunos se
beneficien de mis hallazgos.

Observaciones
Instale un paquete actual de Strawberry Perl de 64 bits desde http://strawberryperl.com . En mi
caso fue 5.24.1.1.

Descargue la versión actual de SAP NW RFC SDK x64 bit desde

https://launchpad.support.sap.com/#/softwarecenter

Puede encontrarlo con la siguiente traza: Paquetes de soporte y parches => Por categoría =>
Componentes adicionales => SDK SAP NW RFC => SDK 7.20 SAP NW RFC

En mi caso la versión actual era 7.20 PL42 x64.

Extraiga el archivo descargado con sapcar -xvf NWRFC_42-20004568.SAR

C:\nwrfcsdk_x64 el nombre de la carpeta a C:\nwrfcsdk_x64

Cree archivos .def y .a para el compilador / enlazador MinGW con los siguientes comandos en el
directorio C: \ nwrfcsdk_x64:

gendef *.dll
dlltool --dllname icuin34.dll --def icuin34.def --output-lib icuin34.a
dlltool --dllname icudt34.dll --def icudt34.def --output-lib icudt34.a
dlltool --dllname icuuc34.dll --def icuuc34.def --output-lib icuuc34.a
dlltool --dllname libsapucum.dll --def libsapucum.def --output-lib libsapucum.a
dlltool --dllname libicudecnumber.dll --def libicudecnumber.def --output-lib libicudecnumber.a
dlltool --dllname sapnwrfc.dll --def sapnwrfc.def --output-lib sapnwrfc.a

En el directorio de direcciones C: \ nwrfcsdk_x64 \ lib deben existir los siguientes archivos:

icudt34.a
icudt34.def

https://riptutorial.com/es/home 30
 icudt34.dll
icuin34.a
icuin34.def
icuin34.dll
icuuc34.a
icuuc34.def
icuuc34.dll
libicudecnumber.a
libicudecnumber.def
libicudecnumber.dll
libsapucum.a
libsapucum.def
libsapucum.dll
libsapucum.lib
sapdecfICUlib.lib
sapnwrfc.a
sapnwrfc.def
sapnwrfc.dll
sapnwrfc.lib

Inicie el símbolo del sistema con cmd.exe e inicie el programa cpan .

Inicie el comando get sapnwrfc para descargar el módulo Perl sapnwrfc desde CPAN.

Salga del entorno cpan con el comando exit . Cambie el directorio a

C:\Strawberry\cpan\build\sapnwrfc-0.37-0 .

Construye los Makefile (s) con el siguiente comando. Adapte los nombres de las carpetas de
acuerdo a su configuración.

perl Makefile.PL --source=C:\nwrfcsdk_x64 --addlibs "C:\nwrfcsdk_x64\lib\sapnwrfc.a

C:\nwrfcsdk_x64\lib\libsapucum.a"

Ejecute los comandos dmake y dmake install para compilar e instalar el módulo.

Copie los archivos de C:\nwrfcsdk_x64\lib en C:\Strawberry\perl\site\lib\auto\SAPNW\Connection .

Examples
Ejemplo simple para probar la conexión RFC.

Ejemplo simple de http://search.cpan.org/dist/sapnwrfc/sapnwrfc-cookbook.pod

use strict;
use warnings;
use utf8;
use sapnwrfc;

SAPNW::Rfc->load_config('sap.yml');
my $conn = SAPNW::Rfc->rfc_connect;

my $rd = $conn->function_lookup("RPY_PROGRAM_READ");
my $rc = $rd->create_function_call;
$rc->PROGRAM_NAME("SAPLGRFC");

https://riptutorial.com/es/home 31
 eval {
$rc->invoke;
};
if ($@) {
die "RFC Error: $@\n";
}

print "Program name: ".$rc->PROG_INF->{'PROGNAME'}."\n";

my $cnt_lines_with_text = scalar grep(/LGRFCUXX/, map { $_->{LINE} } @{$rc->SOURCE_EXTENDED});
$conn->disconnect;

Lea Compilar el módulo sapnwrfc de Perl cpan a partir del código fuente en línea:
https://riptutorial.com/es/perl/topic/9775/compilar-el-modulo-sapnwrfc-de-perl-cpan-a-partir-del-
codigo-fuente

https://riptutorial.com/es/home 32
Capítulo 11: Cuerdas y métodos de citar.
Observaciones
La sintaxis de la versión no nos permite proteger las versiones que aún no existen, por lo que este
es un recordatorio para que alguien pueda volver atrás y editarlas una vez que llegue (RE: Perl
5.26). Los guardias de la versión necesitan tener una clasificación "futura" para las características
tentativas que podrían estar disponibles para las personas lo suficientemente valientes como para
realizar una comprobación de la fuente.

Examples
Cotizaciones literales de cuerdas

Los literales de cadena no implican escape o interpolación (con la excepción de citar

terminadores de cadena)

print 'This is a string literal\n'; # emits a literal \ and n to terminal

print 'This literal contains a \'postraphe '; # emits the ' but not its preceding \

Puedes usar mecanismos de cotización alternativos para evitar choques:

print q/This is is a literal \' <-- 2 characters /; # prints both \ and '
print q^This is is a literal \' <-- 2 characters ^; # also

Ciertos caracteres de comillas elegidos son "equilibrados"

print q{ This is a literal and I contain { parens! } }; # prints inner { }

Doble cita

Las cadenas de comillas dobles utilizan la interpolación y el escape , a diferencia de las

cadenas de comillas simples. Para citar una cadena, use comillas dobles " o el operador qq .

my $greeting = "Hello!\n";
print $greeting;
# => Hello! (followed by a linefeed)

my $bush = "They misunderestimated me."

print qq/As Bush once said: "$bush"\n/;
# => As Bush once said: "They misunderestimated me." (with linefeed)

El qq es útil aquí, para evitar tener que escapar de las comillas. Sin él, tendríamos que escribir ...

print "As Bush once said: \"$bush\"\n";

https://riptutorial.com/es/home 33
... lo que no es tan bonito.

Perl no lo limita a la utilización de una barra / con qq ; Puedes usar cualquier caracter (visible).

use feature 'say';

say qq/You can use slashes.../;

say qq{...or braces...};
say qq^...or hats...^;
say qq|...or pipes...|;
# say qq ...but not whitespace. ;

También puede interpolar arrays en cadenas.

use feature 'say';

my @letters = ('a', 'b', 'c');

say "I like these letters: @letters.";
# => I like these letters: a b c.

Por defecto, los valores están separados por espacios, porque la variable especial $"
predeterminada en un solo espacio. Esto, por supuesto, se puede cambiar.

use feature 'say';

my @letters = ('a', 'b', 'c');

{local $" = ", "; say "@letters"; } # a, b, c

Si lo prefiere, tiene la opción de use English y cambiar $LIST_SEPARATOR en $LIST_SEPARATOR lugar:

use v5.18; # English should be avoided on older Perls

use English;

my @letters = ('a', 'b', 'c');

{ local $LIST_SEPARATOR = "\n"; say "My favourite letters:\n\n@letters" }

Para algo más complejo que esto, debes usar un bucle en su lugar.

say "My favourite letters:";

say;
for my $letter (@letters) {
say " - $letter";
}

La interpolación no funciona con hashes.

use feature 'say';

my %hash = ('a', 'b', 'c', 'd');

say "This doesn't work: %hash" # This doesn't work: %hash

Algunos códigos abusan de la interpolación de referencias - evítalo .

https://riptutorial.com/es/home 34
 use feature 'say';

say "2 + 2 == @{[ 2 + 2 ]}"; # 2 + 2 = 4 (avoid this)

say "2 + 2 == ${\( 2 + 2 )}"; # 2 + 2 = 4 (avoid this)

El llamado "operador de carro" hace que perl se elimine la referencia @{ ... } la referencia de la
matriz que contiene la [ ... ] expresión que desea interpolar, 2 + 2 . Cuando usas este truco,
Perl construye una matriz anónima, luego la desactualiza y la descarta.

La versión ${\( ... )} es algo menos desperdiciadora, pero aún requiere asignar memoria y es
aún más difícil de leer.

En su lugar, considere escribir:

• say "2 + 2 == " . 2 + 2;

• my $result = 2 + 2; say "2 + 2 == $result"

Heredocs

Las cadenas grandes de líneas múltiples son gravosas para escribir.

my $variable = <<'EOF';
this block of text is interpreted literally,
no \'quotes matter, they're just text
only the trailing left-aligned EOF matters.
EOF

NB: asegúrese de ignorar el resaltador de sintaxis de la pila de desbordamientos: está muy mal.

Y los Heredocs Interpolados funcionan de la misma manera.

my $variable = <<"I Want it to End";

this block of text is interpreted.
quotes\nare interpreted, and $interpolations
get interpolated...
but still, left-aligned "I Want it to End" matters.
I Want it to End

Pendiente en 5.26.0 * es una sintaxis "Heredoc con sangría" que recorta el relleno izquierdo para
usted

5.26.0

my $variable = <<~"MuchNicer";
this block of text is interpreted.
quotes\nare interpreted, and $interpolations
get interpolated...
but still, left-aligned "I Want it to End" matters.
MuchNicer

Eliminando nuevas líneas finales

https://riptutorial.com/es/home 35
La función chomp eliminará un carácter de nueva línea, si está presente, de cada escalar que se le
pasa. chomp mutará la cadena original y devolverá el número de caracteres eliminados

my $str = "Hello World\n\n";

my $removed = chomp($str);
print $str; # "Hello World\n"
print $removed; # 1

# chomp again, removing another newline

$removed = chomp $str;
print $str; # "Hello World"
print $removed; # 1

# chomp again, but no newline to remove

$removed = chomp $str;
print $str; # "Hello World"
print $removed; # 0

También puedes chomp más de una cadena a la vez:

my @strs = ("Hello\n", "World!\n\n"); # one newline in first string, two in second

my $removed = chomp(@strs); # @strs is now ("Hello", "World!\n")

print $removed; # 2

$removed = chomp(@strs); # @strs is now ("Hello", "World!")

print $removed; # 1

$removed = chomp(@strs); # @strs is still ("Hello", "World!")

print $removed; # 0

Pero por lo general, a nadie le preocupa la cantidad de nuevas líneas que se eliminaron, por lo
que chomp generalmente se ve en un contexto vacío, y generalmente debido a que se leyeron las
líneas de un archivo:

while (my $line = readline $fh)

{
chomp $line;

# now do something with $line

}

my @lines = readline $fh2;

chomp (@lines); # remove newline from end of each line

Lea Cuerdas y métodos de citar. en línea: https://riptutorial.com/es/perl/topic/1984/cuerdas-y-

metodos-de-citar-

https://riptutorial.com/es/home 36
Capítulo 12: Declaraciones de control
Examples
Condicionales

Perl admite muchos tipos de sentencias condicionales (sentencias que se basan en resultados
booleanos). Las declaraciones condicionales más comunes son if-else, menos, y declaraciones
ternarias. given declaraciones given se introducen como una construcción similar a un interruptor
de lenguajes derivados de C y están disponibles en las versiones Perl 5.10 y superiores.

Declaraciones If-else

La estructura básica de una sentencia if es así:

if (EXPR) BLOCK
if (EXPR) BLOCK else BLOCK
if (EXPR) BLOCK elsif (EXPR) BLOCK ...
if (EXPR) BLOCK elsif (EXPR) BLOCK ... else BLOCK

Para las sentencias if simples, el if puede preceder o suceder al código que se ejecutará.

$number = 7;
if ($number > 4) { print "$number is greater than four!"; }

# Can also be written this way

print "$number is greater than four!" if $number > 4;

Bucles

Perl admite muchos tipos de construcciones de bucle: for / foreach, while / do-while y hasta.

@numbers = 1..42;
for (my $i=0; $i <= $#numbers; $i++) {
print "$numbers[$i]\n";
}

#Can also be written as

foreach my $num (@numbers) {
print "$num\n";
}

El bucle while evalúa el condicional antes de ejecutar el bloque asociado. Entonces, a veces el
bloque nunca se ejecuta. Por ejemplo, el siguiente código nunca se ejecutaría si el $fh fuera el
identificador de archivo para un archivo vacío, o si ya estaba agotado antes del condicional.

while (my $line = readline $fh) {

say $line;
}

https://riptutorial.com/es/home 37
Los bucles do / while y do / until , por otro lado, evalúan el condicional después de cada vez que
se ejecuta el bloqueo. Por lo tanto, un bucle do / while o do / until siempre se ejecuta al menos
una vez.

my $greeting_count = 0;
do {
say "Hello";
$greeting_count++;
} until ( $greeting_count > 1)

# Hello
# Hello

Lea Declaraciones de control en línea: https://riptutorial.com/es/perl/topic/4896/declaraciones-de-

control

https://riptutorial.com/es/home 38
Capítulo 13: Depuración de scripts Perl
Examples
Ejecutar script en modo de depuración

Para ejecutar el script en modo de depuración, debe agregar la opción -d en la línea de comando:

$perl -d script.pl

Si se especifica t , le indica al depurador que se utilizarán hilos en el código que se está

depurando:

$perl -dt script.pl

Información adicional en perldoc perlrun

Utilice un depurador no estándar

$perl -d:MOD script.pl ejecuta el programa bajo el control de un módulo de depuración, creación
de perfiles o seguimiento instalado como Devel::MOD .

Por ejemplo, -d:NYTProf ejecuta el programa utilizando el perfilador Devel::NYTProf .

Ver todos los módulos de Devel disponibles aquí

Módulos recomendados:

• - Potente y rápido generador de perfiles de código fuente Perl

Devel::NYTProf
• Devel::Trepan - Un depurador Perl modular tipo gdb
• Devel::MAT - Herramienta de análisis de memoria Perl
• Devel::hdb - Depurador Perl como página web y servicio REST
• Devel::DebugHooks::KillPrint - Permite olvidarse de la depuración mediante print
declaración print
• Devel::REPL - Un shell interactivo moderno de Perl
• Devel::Cover - Métricas de cobertura de código para Perl

Lea Depuración de scripts Perl en línea: https://riptutorial.com/es/perl/topic/6769/depuracion-de-

scripts-perl

https://riptutorial.com/es/home 39
Capítulo 14: Dividir una cadena en
separadores sin comillas
Examples
parse_line ()

Usando parse_line() de Text :: ParseWords :

use 5.010;
use Text::ParseWords;

my $line = q{"a quoted, comma", word1, word2};

my @parsed = parse_line(',', 1, $line);
say for @parsed;

Salida:

"a quoted, comma"

word1
word2

Texto :: CSV o Texto :: CSV_XS

use Text::CSV; # Can use Text::CSV which will switch to _XS if installed
$sep_char = ",";
my $csv = Text::CSV->new({sep_char => $sep_char});
my $line = q{"a quoted, comma", word1, word2};
$csv->parse($line);
my @fields = $csv->fields();
print join("\n", @fields)."\n";

Salida:

a quoted, comma
word1
word2

NOTAS
• De forma predeterminada, Text :: CSV no elimina los espacios en blanco alrededor del
carácter separador, como lo hace Text::ParseWords . Sin embargo, al agregar
allow_whitespace=>1 a los atributos del constructor se logra ese efecto.

my $csv = Text::CSV_XS->new({sep_char => $sep_char, allow_whitespace=>1});

https://riptutorial.com/es/home 40
 Salida:

a quoted, comma
word1
word2

• La biblioteca admite el escape de caracteres especiales (comillas, separadores)

• La biblioteca admite caracteres de separación, caracteres de comillas y caracteres de

escape configurables

Documentación en: http://search.cpan.org/perldoc/Text::CSV

Lea Dividir una cadena en separadores sin comillas en línea:

https://riptutorial.com/es/perl/topic/2115/dividir-una-cadena-en-separadores-sin-comillas

https://riptutorial.com/es/home 41
Capítulo 15: Empacar y desempacar
Examples
Conversión manual de estructuras C para empaquetar sintaxis

Si alguna vez está tratando con API Binary B desde Perl Code, a través de las syscall , ioctl o
fcntl , necesita saber cómo construir memoria de una manera compatible con C.

Por ejemplo, si alguna vez estuvo tratando con alguna función que esperaba una timespec ,
buscaría en /usr/include/time.h y encontraría:

struct timespec
{
__time_t tv_sec; /* Seconds. */
__syscall_slong_t tv_nsec; /* Nanoseconds. */
};

cpp un baile con cpp para encontrar lo que realmente significa:

cpp -E /usr/include/time.h -o /dev/stdout | grep __time_t

# typedef long int __time_t;
cpp -E /usr/include/time.h -o /dev/stdout | grep __syscall_slong_t
# typedef long int __syscall_slong_t

Así que es un int (firmado)

echo 'void main(){ printf("%#lx\n", sizeof(__syscall_slong_t)); }' |

gcc -x c -include stdio.h -include time.h - -o /tmp/a.out && /tmp/a.out
# 0x8

Y toma 8 bytes. Así que 64bit firmó int. Y estoy en un procesador de 64 bits. =)

Perldoc pack dice

q A signed quad (64-bit) value.

Así que para empacar un timespec:

sub packtime {
my ( $config ) = @_;
return pack 'qq', @{$config}{qw( tv_sec tv_nsec )};
}

Y para descomprimir un timepec:

sub unpacktime {
my ( $buf ) = @_;

https://riptutorial.com/es/home 42
 my $out = {};
@{$out}{qw( tv_sec tv_nsec )} = unpack 'qq', $buf;
return $out;
}

Ahora puedes usar esas funciones en su lugar.

my $timespec = packtime({ tv_sec => 0, tv_nsec => 0 });

syscall( ..., $timespec ); # some syscall that reads timespec

later ...
syscall( ..., $timespec ); # some syscall that writes timespec
print Dumper( unpacktime( $timespec ));

Construyendo un encabezado IPv4

A veces hay que tratar con estructuras definidas en términos de tipos de datos C de Perl. Una de
esas aplicaciones es la creación de paquetes de red sin procesar, en caso de que quiera hacer
algo más sofisticado que lo que ofrece la API de socket normal. Esto es justo para lo que está
disponible pack() (y unpack() por supuesto).

La parte obligatoria de un encabezado IP es de 20 octetos (AKA "bytes") de largo. Como puede

ver detrás de este enlace, la dirección IP de origen y destino constituyen los dos últimos valores
de 32 bits en el encabezado. Entre los otros campos hay algunos con 16 bits, algunos con 8 bits y
algunos fragmentos más pequeños entre 2 y 13 bits.

Suponiendo que tenemos las siguientes variables para incluir en nuestro encabezado:

my ($dscp, $ecn, $length,

$id, $flags, $frag_off,
$ttl, $proto,
$src_ip,
$dst_ip);

Tenga en cuenta que faltan tres campos del encabezado:

• La versión es siempre 4 (es IPv4 después de todo)

• IHL es 5 en nuestro ejemplo ya que no tenemos un campo de opciones ; La longitud se
especifica en unidades de 4 octetos, por lo que 20 octetos dan una longitud de 5.
• La suma de control se puede dejar en 0. En realidad, tendríamos que calcularlo, pero el
código para hacer esto no nos concierne aquí.

Podríamos probar y usar operaciones de bits para construir, por ejemplo, los primeros 32 bits:

my $hdr = 4 << 28 | 5 << 24 | $dscp << 18 | $ecn << 16 | $length;

Este enfoque sólo funciona hasta el tamaño de un entero sin embargo, que suele ser de 64 bits,
pero puede ser tan bajo como 32. Peor aún, depende de la CPU endianness por lo que funciona
en algunas CPUs y dejar a los demás. Probemos pack() :

https://riptutorial.com/es/home 43
 my $hdr = pack('H2B8n', '45', sprintf("%06b%02b", $dscp, $ecn), $length);

La plantilla primero especifica H2 , una cadena hexadecimal de 2 caracteres, primero nybble alto .
El argumento correspondiente al paquete es "45": versión 4, longitud 5. La siguiente plantilla es B8
, una cadena de bits de 8 bits, orden de bits descendente dentro de cada byte . Necesitamos usar
cadenas de bits para controlar el diseño a trozos más pequeños que un nybble (4 bits), por lo que
el sprintf() se utiliza para construir una cadena de bits de 6 bits desde $dscp y 2 desde $ecn . El
último es n , un valor sin signo de 16 bits en Orden de bytes de red , es decir, siempre big-endian
sin importar cuál sea el formato de entero nativo de su CPU, y se llena desde $length .

Esos son los primeros 32 bits del encabezado. El resto se puede construir de manera similar:

Modelo Argumento Observaciones

n $id

sprintf("%03b%013b",
B16
$flags, $frag_off) Igual que DSCP / ECN

C2 $ttl, $proto Dos octetos sin firmar consecutivos

xpodría utilizarse para insertar un byte nulo, pero n

n 0 / $checksum nos permite especificar un argumento en el caso de
que decidamos calcular una suma de comprobación

¡use a4a4 para empaquetar el resultado de dos

N2 $src_ip, $dst_ip llamadas gethostbyname() como ya está en Orden de
bytes de red!

Entonces, la llamada completa para empaquetar un encabezado IPv4 sería:

my $hdr = pack('H2B8n2B16C2nN2',
'45', sprintf("%06b%02b", $dscp, $ecn), $length,
$id, sprintf("%03b%013b", $flags, $frag_off),
$ttl, $proto, 0,
$src_ip, $dst_ip
);

Lea Empacar y desempacar en línea: https://riptutorial.com/es/perl/topic/1983/empacar-y-

desempacar

https://riptutorial.com/es/home 44
Capítulo 16: Expresiones regulares
Examples
Cuerdas a juego

El operador =~ intenta hacer coincidir una expresión regular (separada por / ) con una cadena:

my $str = "hello world";

print "Hi, yourself!\n" if $str =~ /^hello/;

/^hello/ es la expresión regular real. ^ Es un carácter especial que le dice a la expresión regular
que comience con el principio de la cadena y que no coincida en el medio en algún lugar. Luego,
la expresión regular trata de encontrar las siguientes letras en orden h , e , l , l y o .

Las expresiones regulares intentan coincidir con la variable predeterminada ( $_ ) si están vacías:

$_ = "hello world";

print "Ahoy!\n" if /^hello/;

También puede usar diferentes delimitadores si precede la expresión regular con el operador m :

m~^hello~;
m{^hello};
m|^hello|;

Esto es útil cuando se combinan cadenas que incluyen el carácter / :

print "user directory" if m|^/usr|;

Uso de \ Q y \ E en la coincidencia de patrones

Lo que está entre \ Q y \ E se trata como caracteres normales

#!/usr/bin/perl

my $str = "hello.it's.me";

my @test = (
"hello.it's.me",
"hello/it's!me",
);

sub ismatched($) { $_[0] ? "MATCHED!" : "DID NOT MATCH!" }

my @match = (
[ general_match=> sub { ismatched /$str/ } ],

https://riptutorial.com/es/home 45
 [ qe_match => sub { ismatched /\Q$str\E/ } ],
);

for (@test) {
print "\String = '$_':\n";

foreach my $method (@match) {

my($name,$match) = @$method;
print " - $name: ", $match->(), "\n";
}

Salida

String = 'hello.it's.me':
- general_match: MATCHED!
- qe_match: MATCHED!
String = 'hello/it's!me':
- general_match: MATCHED!
- qe_match: DID NOT MATCH!

Analizar una cadena con una expresión regular

En general, no es una buena idea usar una expresión regular para analizar una estructura
compleja . Pero puede hacerse. Por ejemplo, es posible que desee cargar datos en la tabla de la
sección y los campos estén separados por comas, pero los tipos complejos como la matriz están
separados por una "|". Los archivos contienen registros con todos los campos separados por
comas y los tipos complejos están dentro de corchetes. En ese caso, este bit de Perl desechable
podría ser suficiente:

echo "1,2,[3,4,5],5,6,[7,8],[1,2,34],5" | \
perl -ne \
'while( /\[[^,\]]+\,.*\]/ ){
if( /\[([^\]\|]+)\]/){
$text = $1;
$text_to_replace = $text;
$text =~ s/\,/\|/g;
s/$text_to_replace/$text/;
}
} print'

Querrás ver el resultado:

1,2, [3 | 4 | 5], 5,6, [7 | 8], [1 | 2 | 34], 5

Reemplace una cadena usando expresiones regulares

s/foo/bar/; # replace "foo" with "bar" in $_

my $foo = "foo";
$foo =~ s/foo/bar/; # do the above on a different variable using the binding operator =~
s~ foo ~ bar ~; # using ~ as a delimiter
$foo = s/foo/bar/r; # non-destructive r flag: returns the replacement string without modifying

https://riptutorial.com/es/home 46
 the variable it's bound to
s/foo/bar/g; # replace all instances

Lea Expresiones regulares en línea: https://riptutorial.com/es/perl/topic/3108/expresiones-

regulares

https://riptutorial.com/es/home 47
Capítulo 17: Fechas y hora
Examples
Crear un nuevo DateTime

Instale DateTime en su PC y luego utilícelo en el script perl:

use DateTime;

Crear nueva fecha y hora actual

$dt = DateTime->now( time_zone => 'Asia/Ho_Chi_Minh');

Luego puedes acceder a los valores de fecha y hora de los elementos:

$year = $dt->year;
$month = $dt->month;
$day = $dt->day;
$hour = $dt->hour;
$minute = $dt->minute;
$second = $dt->second;

Para obtener solo el tiempo:

my $time = $dt->hms; #tiempo de vuelta con formato hh:mm:ss

Para obtener solo la fecha:

my $date = $dt->ymd; # fecha de regreso con el formato yyyy-mm-dd

Trabajando con elementos de fecha y hora.

Establecer elemento único:

$dt->set( year => 2016 );

Establecer muchos elementos:

$dt->set( year => 2016, 'month' => 8);

Añadir duración a datetime

$dt->add( hour => 1, month => 2)

Resta de fecha y hora:

my $dt1 = DateTime->new(
year => 2016,
month => 8,
day => 20,

https://riptutorial.com/es/home 48
 );

my $dt2 = DateTime->new(
year => 2016,
month => 8,
day => 24,
);

my $duration = $dt2->subtract_datetime($dt1);
print $duration->days

Obtendrá el resultado es de 4 días.

Calcular el tiempo de ejecución del código.

use Time::HiRes qw( time );

my $start = time();

#Code for which execution time is calculated

sleep(1.2);

my $end = time();

printf("Execution Time: %0.02f s\n", $end - $start);

Esto imprimirá el tiempo de ejecución del Código en segundos.

Lea Fechas y hora en línea: https://riptutorial.com/es/perl/topic/5920/fechas-y-hora

https://riptutorial.com/es/home 49
Capítulo 18: Fechas y hora
Examples
Formato de fecha

Time :: Piece está disponible en Perl 5 después de la versión 10

use Time::Piece;

my $date = localtime->strftime('%m/%d/%Y');
print $date;

Output
07/26/2016

Lea Fechas y hora en línea: https://riptutorial.com/es/perl/topic/5923/fechas-y-hora

https://riptutorial.com/es/home 50
Capítulo 19: Instalacion de perl
Introducción
Voy a comenzar esto con el proceso en Ubuntu, luego en OS X y finalmente en Windows. No lo
he probado en todas las versiones de Perl, pero debería ser un proceso similar.

Utilice Perlbrew si desea cambiar fácilmente entre diferentes versiones de Perl.

Quiero decir que este tutorial es sobre Perl en su versión de código abierto. Existen otras
versiones como activeperl que tienen ventajas y desventajas, que no forman parte de este
tutorial.

Examples
Linux

Hay más de una forma de hacerlo:

• Usando el gestor de paquetes:

sudo apt install perl

• Instalación desde la fuente:

wget http://www.cpan.org/src/5.0/perl-version.tar.gz
tar -xzf perl-version.tar.gz
cd perl-version
./Configure -de
make
make test
make install

• Instalar en su directorio de inicio $ (no es necesario sudo) con Perlbrew :

wget -O - https://install.perlbrew.pl | bash

Ver también Perlbrew.

OS X

Hay varias opciones:

• Perlbrew

# You need to install Command Line Tools for Xcode

curl -L https://install.perlbrew.pl | bash

https://riptutorial.com/es/home 51
 • Perlbrew con soporte de hilo:

# You need to install Command Line Tools for Xcode

curl -L https://install.perlbrew.pl | bash

Después de la instalación de Perlbrew, si desea instalar Perl con soporte para subprocesos,
simplemente ejecute:

perlbrew install -v perl-5.26.0 -Dusethreads

• Desde la fuente:

tar -xzf perl-version.tar.gz

cd perl-version
./Configure -de
make
make test
make install

Windows

• Como dijimos antes, vamos con la versión de código abierto. Para Windows puedes elegir
strawberry o DWIM . Aquí cubrimos la versión de strawberry , ya que DWIM se basa en ella. La
manera fácil aquí es instalar desde el ejecutable oficial .

Véase también berrybrew - perlbrew para Windows Strawberry Perl

Lea Instalacion de perl en línea: https://riptutorial.com/es/perl/topic/9317/instalacion-de-perl

https://riptutorial.com/es/home 52
Capítulo 20: Instalar módulos Perl a través de
CPAN
Examples
Ejecute Perl CPAN en su terminal (Mac y Linux) o en el símbolo del sistema
(Windows)

Línea de comando
Puede usar cpan para instalar módulos directamente desde la línea de comando:

cpan install DBI

A esto le seguirán posiblemente muchas páginas de resultados que describan exactamente lo

que está haciendo para instalar el módulo. Dependiendo de los módulos que se estén instalando,
puede hacer una pausa y hacerle preguntas.

Shell interactivo
También puedes ingresar un "shell" así:

perl -MCPAN -e "shell"

Producirá salida como abajo:

Terminal does not support AddHistory.

cpan shell -- CPAN exploration and modules installation (v2.00)

Enter 'h' for help.

cpan[1]>

Luego, puede instalar los módulos que desee con el comando easy install <module> .

Ejemplo: cpan[1]> install DBI

Después de instalar con éxito, escriba exit para salir.

Instalando módulos manualmente

Si no tiene permisos para instalar módulos perl, aún puede instalarlos manualmente, indicando
una ruta personalizada donde tenga permisos de escritura.

https://riptutorial.com/es/home 53
Publica, descarga y descomprime el archivo del módulo:

wget module.tar.gz
tar -xzf module.tar.gz
cd module

Luego, si la distribución del módulo contiene un archivo Makefile.PL , ejecute:

perl Makefile.PL INSTALL_BASE=$HOME/perl

make
make test
make install

o si tiene un archivo Build.PL lugar de un Makefile.PL :

perl Build.PL --install_base $HOME/perl

perl Build
perl Build test
perl Build install

También debe incluir la ruta del módulo en la variable de entorno PERL5LIB para usarla en su
código:

export PERL5LIB=$HOME/perl

cpanminus, el reemplazo ligero y sin configuración para cpan

Uso

Para instalar un módulo (asumiendo que cpanm ya está instalado):

cpanm Data::Section

cpanm ("cpanminus") se esfuerza por ser menos detallado que cpan pero aún captura toda la
información de instalación en un archivo de registro en caso de que sea necesario. También
maneja muchas "preguntas interactivas" para usted, mientras que cpan no lo hace.

cpanm también es popular para instalar dependencias de un proyecto desde, por ejemplo, GitHub.
El uso típico es primero cd en la raíz del proyecto, luego ejecutar

cpanm --installdeps .

Con --installdeps lo hará:

1. Escanear e instalar las dependencias configure_requires desde

• META.json
• META.yml (si falta META.json)
2. Genere el proyecto (equivalente a perl Build.PL ), generando archivos MYMETA
3. Escanear e instalar requiere dependencias de cualquiera

https://riptutorial.com/es/home 54
 • MYMETA.json
• MYMETA.yml (si MYMETA.json falta)

Para especificar el archivo 'some.cpanfile', que contiene las dependencias, ejecute:

cpanm --installdeps --cpanfile some.cpanfile .

instalacion cpanm

Hay varias formas de instalarlo . Aquí está la instalación a través de cpan :

cpan App::cpanminus

Configuración de cpanm

No hay ningún archivo de configuración para cpanm . Más bien, se basa en las siguientes
variables de entorno para su configuración:

• PERL_CPANM_OPT( PERL_CPANM_OPT generales de línea de comando cpanm)

○export PERL_CPANM_OPT="--prompt" # en .bashrc, para habilitar las export
PERL_CPANM_OPT="--prompt" , por ejemplo
○setenv PERL_CPANM_OPT "--prompt" # en .tcshrc
• PERL_MM_OPT (ExtUtils :: Opciones de línea de comando de MakeMaker, afecta el objetivo de
instalación del módulo)
• PERL_MB_OPT (Módulo :: Crear opciones de línea de comando, afecta el destino de instalación
del módulo)

Lea Instalar módulos Perl a través de CPAN en línea:

https://riptutorial.com/es/perl/topic/3542/instalar-modulos-perl-a-traves-de-cpan

https://riptutorial.com/es/home 55
Capítulo 21: Interacción simple con la base
de datos a través del módulo DBI.
Parámetros

Columna Columna

$driver Controlador para DB, "Pg" para Postgresql y "mysql" para MySQL

$database el nombre de su base de datos

$userid su ID de base de datos

$password su contraseña de base de datos

$query ponga su consulta aquí, por ejemplo: "select * from $ your_table"

Examples
Módulo DBI

Debe asegurarse de que el módulo DBI se haya instalado en su PC, luego siga los siguientes
pasos:

1. Usa el módulo DBI en tu script perl

use DBI;

2. Declarar algunos parámetros primarios.

my $driver = "MyDriver";

my $database = "DB_name";

my $dsn = "DBI:$driver:dbname=$database";

my $userid = "your_user_ID";

my $password = "your_password";

my $tablename = "your_table";

3. Conéctate a tu base de datos

my $dbh = DBI->connect($dsn, $userid, $password);

4. Prepara tu consulta

my $query = $dbh->prepare("Your DB query");

https://riptutorial.com/es/home 56
Ex:

$my_query = qq/SELECT * FROM table WHERE column1 = 2/;

my $query = $dbh->prepare($my_query);

También podemos usar variable en la consulta, como a continuación:

my $table_name = "table";

my $filter_value = 2;

$my_query = qq/SELECT * FROM $table_name WHERE column1 = $filter_value/;

5. Ejecuta tu consulta

$query->execute();

* Nota: Para evitar un ataque por inyección, debes usar marcadores de posición ? En lugar de
poner tu variable en la consulta.

Ejemplo: desea mostrar todos los datos de la "tabla" donde column1 = $ value1 y column2 = $
value2:

my $query = $dbh->prepare("SELECT * FROM table WHERE column1 = ? AND column2 = ?;");

$query->execute($value1, $value2);

6. Fletch sus datos

my @row = $query->fetchrow_array(); almacenar datos como matriz

my $ref = $sth->fetchrow_hashref(); almacenar datos como referencia hash

7. Terminar y desconectar DB

$sth->finish;

$dbh->disconnect();

Lea Interacción simple con la base de datos a través del módulo DBI. en línea:
https://riptutorial.com/es/perl/topic/5917/interaccion-simple-con-la-base-de-datos-a-traves-del-
modulo-dbi-

https://riptutorial.com/es/home 57
Capítulo 22: Interpolación en Perl
Examples
Interpolación básica

Interpolación significa que el intérprete de Perl sustituirá los valores de las variables por su
nombre y algunos símbolos (que son imposibles o difíciles de escribir directamente) por
secuencias especiales de caracteres (también se conoce como escape). La distinción más
importante es entre comillas simples y dobles: las comillas dobles interpolan la cadena encerrada,
pero las comillas simples no.

my $name = 'Paul';
my $age = 64;
print "My name is $name.\nI am $age.\n"; # My name is Paul.
# I am 64.

Pero:

print 'My name is $name.\nI am $age.\n'; # My name is $name.\nI am $age.\n

Puede usar q{} (con cualquier delimitador) en lugar de comillas simples y qq{} lugar de comillas
dobles. Por ejemplo, q{I'm 64} permite usar un apóstrofe dentro de una cadena no interpolada (de
lo contrario terminaría la cadena).

Declaraciones:

print qq{$name said: "I'm $age".}; # Paul said: "I'm 64".

print "$name said: \"I'm $age\"." # Paul said: "I'm 64".

haga lo mismo, pero en el primero no necesita escaparse de comillas dobles dentro de la cadena.

Si el nombre de su variable coincide con el texto que lo rodea, puede usar la sintaxis ${var} para
desambiguar:

my $decade = 80;
print "I like ${decade}s music!" # I like 80s music!

Lo que se interpola

Perl interpola nombres de variables:

my $name = 'Paul';
print "Hello, $name!\n"; # Hello, Paul!

my @char = ('a', 'b', 'c');

print "$char[1]\n"; # b

https://riptutorial.com/es/home 58
 my %map = (a => 125, b => 1080, c => 11);
print "$map{a}\n"; # 125

Las matrices pueden interpolarse como un todo, sus elementos están separados por espacios:

my @char = ('a', 'b', 'c');

print "My chars are @char\n"; # My chars are a b c

Perl no interpola hashes como un todo:

my %map = (a => 125, b => 1080, c => 11);

print "My map is %map\n"; # My map is %map

y llamadas a funciones (incluidas las constantes):

use constant {
PI => '3.1415926'
};
print "I like PI\n"; # I like PI
print "I like " . PI . "\n"; # I like 3.1415926

Perl interpola secuencias de escape que comienzan con \ :

\t horizontal tab
\n newline
\r return
\f form feed
\b backspace
\a alarm (bell)
\e escape

La interpolación de \n depende del sistema en el que funciona el programa: producirá uno o más
caracteres de nueva línea de acuerdo con las convenciones actuales del sistema.

Perl no interpola \v , lo que significa una pestaña vertical en C y otros idiomas.

El personaje puede ser dirigido utilizando sus códigos:

\x{1d11e} by hexadecimal code

\o{350436} by octal code
\N{U+1d11e} by Unicode code point

o nombres de Unicode:

\N{MUSICAL SYMBOL G CLEF}

Los caracteres con códigos de 0x00 a 0xFF en la codificación nativa se pueden abordar de una
forma más corta:

\x0a hexadecimal

https://riptutorial.com/es/home 59
 \012 octal

El carácter de control puede dirigirse utilizando secuencias de escape especiales:

\c@ chr(0)
\ca chr(1)
\cb chr(2)
...
\cz chr(26)
\c[ chr(27)
\c\ chr(28) # Cannot be used at the end of a string
# since backslash will interpolate the terminating quote
\c] chr(29)
\c^ chr(30)
\c_ chr(31)
\c? chr(127)

Las letras mayúsculas tienen el mismo significado: "\cA" == "\ca" .

La interpretación de todas las secuencias de escape excepto para \N{...} puede depender de la
plataforma, ya que utilizan códigos dependientes de la plataforma y la codificación.

Lea Interpolación en Perl en línea: https://riptutorial.com/es/perl/topic/5284/interpolacion-en-perl

https://riptutorial.com/es/home 60
Capítulo 23: Leyendo el contenido de un
archivo en una variable
Examples
La forma manual

open my $fh, '<', $filename

or die "Could not open $filename for reading: $!";
my $contents = do { local $/; <$fh> };

Después de abrir el archivo (lea man perlio si desea leer codificaciones de archivo específicas en
lugar de bytes sin procesar), el truco está en el bloque do : <$fh> , el identificador de archivo en un
operador de diamante, devuelve un solo registro del archivo . La variable "separador de registro
de entrada" $/ especifica qué es un "registro"; de forma predeterminada, se establece en un
carácter de nueva línea, por lo que "un registro" significa "una sola línea". Como $/ es una
variable global, local hace dos cosas: crea una copia local temporal de $/ que desaparecerá al
final del bloque y le otorga el valor (no-) undef (el "valor" que Perl da a variables sin inicializar).
Cuando el separador de registro de entrada tiene ese (no) valor, el operador de diamante
devolverá el archivo completo. (Considera que todo el archivo es una sola línea).

Usando do , incluso puede moverse manualmente abriendo un archivo. Para la lectura repetida de
archivos,

sub readfile { do { local(@ARGV,$/) = $_[0]; <> } }

my $content = readfile($filename);

puede ser usado. Aquí, otra variable global ( @ARGV ) se localiza para simular el mismo proceso
utilizado al iniciar un script perl con parámetros. $/ sigue siendo undef , ya que la matriz que está
frente a él "come" todos los argumentos entrantes. A continuación, el operador Diamond <>
nuevamente entrega un registro definido por $/ (el archivo completo) y regresa del bloque do , que
a su vez regresa del sub.

El sub no tiene un manejo explícito de errores, lo cual es una mala práctica. Si se produce un
error al leer el archivo, recibirá undef como valor de retorno, en lugar de una cadena vacía de un
archivo vacío.

Otra desventaja del último código es el hecho de que no puede usar PerlIO para diferentes
codificaciones de archivos: siempre obtiene bytes sin procesar.

Camino :: Diminuto

Usar el idioma de The Manual Way varias veces en una secuencia de comandos pronto se vuelve
tedioso, por lo que es posible que desee probar un módulo.

https://riptutorial.com/es/home 61
 use Path::Tiny;
my $contents = path($filename)->slurp;

Puede pasar una opción binmode si necesita control sobre las codificaciones de archivos, finales
de línea, etc. - vea man perlio :

my $contents = path($filename)->slurp( {binmode => ":encoding(UTF-8)"} );

también tiene muchas otras funciones para tratar con archivos, por lo que puede ser
Path::Tiny
una buena opción.

Archivo :: Slurper

Este es un módulo minimalista que solo absorbe archivos en variables, nada más.

use File::Slurper 'read_text';

my $contents = read_text($filename);

read_text() toma dos parámetros opcionales para especificar la codificación del archivo y si los
finales de línea deben traducirse entre los estándares LF de Unixish o CRLF de DOSish:

my $contents = read_text($filename, 'UTF-8', 1);

Archivo :: Slurp

No lo uses Aunque ha existido durante mucho tiempo y sigue siendo el módulo que la mayoría de
los programadores sugerirán, está roto y no es probable que se solucione .

Slurping un archivo en una variable de matriz

open(my $fh, '<', "/some/path") or die $!;

my @ary = <$fh>;

Cuando se evalúa en el contexto de la lista, el operador de diamante devuelve una lista que
consta de todas las líneas del archivo (en este caso, asignando el resultado a un contexto de lista
de suministros de matriz). El terminador de línea se conserva, y se puede eliminar mediante la
masticación:

chomp(@ary); #removes line terminators from all the array elements.

Archivo de slurp en una sola línea

El separador de registro de entrada se puede especificar con el interruptor -0 ( cero , no

mayúscula ). Toma un número octal o hexadecimal como valor. Cualquier valor de 0400 o superior
hará que Perl absorba los archivos, pero por convención, el valor utilizado para este propósito es
0777 .

https://riptutorial.com/es/home 62
 perl -0777 -e 'my $file = <>; print length($file)' input.txt

Yendo más allá con el minimalismo, al especificar -n modificador hace que Perl lea
automáticamente cada línea (en nuestro caso, el archivo completo) en la variable $_ .

perl -0777 -ne 'print length($_)' input.txt

Lea Leyendo el contenido de un archivo en una variable en línea:

https://riptutorial.com/es/perl/topic/1779/leyendo-el-contenido-de-un-archivo-en-una-variable

https://riptutorial.com/es/home 63
Capítulo 24: Liza
Examples
Array como lista

La matriz es uno de los tipos de variables básicas de Perl. Contiene una lista, que es una
secuencia ordenada de cero o más escalares. La matriz es la variable que contiene (y
proporciona acceso a) los datos de la lista, como se documenta en perldata .

Puede asignar una lista a una matriz:

my @foo = ( 4, 5, 6 );

Puede usar una matriz donde se espera una lista:

join '-', ( 4, 5, 6 );
join '-', @foo;

Algunos operadores solo trabajan con matrices, ya que mutan la lista que contiene:

shift @array;
unshift @array, ( 1, 2, 3 );
pop @array;
push @array, ( 7, 8, 9 );

Asignando una lista a un hash

Las listas también se pueden asignar a las variables hash. Al crear una lista que se asignará a
una variable hash, se recomienda usar la coma grande => entre las claves y los valores para
mostrar su relación:

my %hash = ( foo => 42, bar => 43, baz => 44 );

El => es realmente solo una coma especial que cita automáticamente el operando a su izquierda.
Entonces, podrías usar comas normales, pero la relación no es tan clara:

my %hash = ( 'foo', 42, 'bar', 43, 'baz', 44 );

También puede usar cadenas entre comillas para el operando de la mano izquierda de la coma
grasa => , que es especialmente útil para las claves que contienen espacios.

my %hash = ( 'foo bar' => 42, 'baz qux' => 43 );

Para obtener más información, consulte Operador de coma en perldoc perlop .

https://riptutorial.com/es/home 64
Las listas se pueden pasar a subrutinas

Para pasar la lista a una subrutina, debe especificar el nombre de la subrutina y luego
proporcionarle la lista:

test_subroutine( 'item1', 'item2' );

test_subroutine 'item1', 'item2'; # same

Internamente, Perl @_ alias para esos argumentos y los coloca en la matriz @_ que está disponible
dentro de la subrutina:

@_ = ( 'item1', 'item2' ); # Done internally by perl

Se accede a argumentos de subrutina como este:

sub test_subroutine {
print $_[0]; # item1
print $_[1]; # item2
}

El alias le permite cambiar el valor original del argumento pasado a la subrutina:

sub test_subroutine {
$_[0] += 2;
}

my $x = 7;
test_subroutine( $x );
print $x; # 9

Para evitar cambios inadvertidos de valores originales pasados a su subrutina, debe copiarlos:

sub test_subroutine {
my( $copy_arg1, $copy_arg2 ) = @_;
$copy_arg1 += 2;
}

my $x = 7;
test_subroutine $x; # in this case $copy_arg2 will have `undef` value
print $x; # 7

Para probar cuántos argumentos se pasaron a la subrutina, verifique el tamaño de @_

sub test_subroutine {
print scalar @_, ' argument(s) passed into subroutine';
}

Si pasas los argumentos de matriz a una subrutina, todos serán aplanados :

my @x = ( 1, 2, 3 );
my @y = qw/ a b c /; # ( 'a', 'b', 'c' )

https://riptutorial.com/es/home 65
 test_some_subroutine @x, 'hi', @y; # 7 argument(s) passed into subroutine
# @_ = ( 1, 2, 3, 'hi', 'a', 'b', 'c' ) # Done internally for this call

Si su test_some_subroutine contiene la instrucción $_[4] = 'd' , para la llamada anterior causará

que $y[0] tenga un valor d después:

print "@y"; # d b c

Lista de retorno de subrutina

Por supuesto, puede devolver listas de subs:

sub foo {
my @list1 = ( 1, 2, 3 );
my @list2 = ( 4, 5 );

return ( @list1, @list2 );

}

my @list = foo();
print @list; # 12345

Pero no es la forma recomendada de hacerlo a menos que sepa lo que está haciendo.

Si bien esto está bien cuando el resultado está en el contexto LISTA , en el contexto SCALAR las
cosas no están claras. Echemos un vistazo a la siguiente línea:

print scalar foo(); # 2

¿Por qué 2 ? Que esta pasando?

1. Debido a que foo() evaluó en el contexto SCALAR , esta lista ( @list1, @list2 ) también se
evaluó en el contexto SCALAR
2. En contexto SCALAR , LIST devuelve su último elemento. Aquí está @list2
3. De nuevo en el contexto SCALAR , array @list2 devuelve el número de sus elementos. Aquí
está el 2 .

En la mayoría de los casos, la estrategia correcta devolverá las referencias a las estructuras
de datos .
Así que en nuestro caso deberíamos hacer lo siguiente:

return ( \@list1, \@list2 );

Luego, la persona que llama hace algo como esto para recibir los dos arrayrefs devueltos:

my ($list1, $list2) = foo(...);

Usando arrayref para pasar array a sub

https://riptutorial.com/es/home 66
El arrayref para @foo es \@foo . Esto es útil si necesita pasar una matriz y otras cosas a una
subrutina. Pasar a @foo es como pasar múltiples escalares. Pero pasar \@foo es un solo escalar.
Dentro de la subrutina:

xyz(\@foo, 123);
...
sub xyz {
my ($arr, $etc) = @_;
print $arr->[0]; # using the first item in $arr. It is like $foo[0]

Hash como lista

En la lista el hash de contexto se aplana.

my @bar = ( %hash, %hash );

La matriz @bar se inicializa con una lista de dos hashes de %hash

• ambos %hash son aplanados

• nueva lista se crea a partir de elementos aplanados
• @bar array se inicializa con esa lista

Se garantiza que los pares clave-valor van juntos. Las claves siempre están indexadas, los
valores son impares. No se garantiza que los pares clave-valor siempre se aplanen en el mismo
orden:

my %hash = ( a => 1, b => 2 );

print %hash; # Maybe 'a1b2' or 'b2a1'

Lea Liza en línea: https://riptutorial.com/es/perl/topic/4553/liza

https://riptutorial.com/es/home 67
Capítulo 25: Manejo de excepciones
Examples
eval y muere

Esta es la forma integrada de lidiar con las "excepciones" sin depender de bibliotecas de terceros
como Try :: Tiny .

my $ret;

eval {
$ret = some_function_that_might_die();
1;
} or do {
my $eval_error = $@ || "Zombie error!";
handle_error($eval_error);
};

# use $ret

"Abusamos" del hecho de que die tiene un valor de retorno falso, y el valor de retorno del bloque
de código global es el valor de la última expresión en el bloque de código:

• si $ret se asigna con éxito, entonces el 1; expresión es lo último que sucede en el bloque de
código eval . El bloque de código eval tiene un valor verdadero, por lo que el bloque or do no
se ejecuta.
• si some_function_that_might_die() die , entonces lo último que sucede en el bloque de código
eval es el die . El bloque de código eval tiene un valor falso y el bloque or do se ejecuta.
• Lo primero que debes hacer en el bloque or do es leer $@ . Esta variable global mantendrá
cualquier argumento que se haya pasado para die . El || "Zombie Error" es popular, pero
innecesario en el caso general.

Esto es importante de entender porque algunos no todos los códigos fallan al llamar a die, pero la
misma estructura puede usarse independientemente. Considere una función de base de datos
que devuelve:

• el número de filas afectadas en el éxito

• '0 but true' si la consulta es exitosa pero no hay filas afectadas
• 0 si la consulta no tuvo éxito.

En ese caso, puede seguir utilizando el mismo idioma, pero hay que saltar a la final 1; , y esta
función tiene que ser lo último en la evaluación. Algo como esto:

eval {
my $value = My::Database::retrieve($my_thing); # dies on fail
$value->set_status("Completed");
$value->set_completed_timestamp(time());

https://riptutorial.com/es/home 68
 $value->update(); # returns false value on fail
} or do { # handles both the die and the 0 return value
my $eval_error = $@ || "Zombie error!";
handle_error($eval_error);
};

Lea Manejo de excepciones en línea: https://riptutorial.com/es/perl/topic/1894/manejo-de-

excepciones

https://riptutorial.com/es/home 69
Capítulo 26: Mejores prácticas
Examples
Utilizando Perl :: Crítico

Si desea comenzar a implementar las mejores prácticas, para usted o su equipo, entonces Perl ::
Critic es el mejor lugar para comenzar. El módulo se basa en el libro Perl Best Practices de
Damien Conway y realiza un trabajo bastante bueno implementando las sugerencias que se
hacen en él.

Nota: Debo mencionar (y el mismo Conway dice en el libro) que estas son
sugerencias. He encontrado que el libro proporciona un razonamiento sólido en la
mayoría de los casos, aunque ciertamente no estoy de acuerdo con todos ellos. Lo
importante a recordar es que, independientemente de las prácticas que decida
adoptar, usted permanece consistente. Cuanto más predecible sea su código, más
fácil será mantenerlo.

También puede probar Perl :: Critic a través de su navegador en perlcritic.com .

Instalación

cpan Perl::Critic

Esto instalará el conjunto de reglas básicas y un script perlcritic al que se puede llamar desde la
línea de comandos.

Uso básico
El documento de CPAN para perlcritic contiene documentación completa, por lo que solo revisaré
los casos de uso más comunes para comenzar. El uso básico es simplemente llamar perlcritic en
el archivo:

perlcritic -1 /path/to/script.pl

Perlcritic funciona tanto en scripts como en módulos. El -1 se refiere al nivel de gravedad de las
reglas que desea ejecutar en el script. Hay cinco niveles que corresponden a la cantidad que Perl
:: Critic separará tu código.

-5 es el más suave y solo advertirá sobre problemas potencialmente peligrosos que podrían
causar resultados inesperados. -1 es el más brutal y se quejará de cosas tan pequeñas como que
su código esté ordenado o no. En mi experiencia, mantener el código compatible con el nivel 3 es
lo suficientemente bueno como para mantenerse fuera de peligro sin ponerse demasiado inquieto.

https://riptutorial.com/es/home 70
De manera predeterminada, cualquier falla incluirá la razón y la severidad que la regla activa en:

perlcritic -3 --verbose 8 /path/to/script.pl

Debugging module loaded at line 16, column 1. You've loaded Data::Dumper, which probably
shouln't be loaded in production. (Severity: 4)
Private subroutine/method '_sub_name' declared but not used at line 58, column 1. Eliminate
dead code. (Severity: 3)
Backtick operator used at line 230, column 37. Use IPC::Open3 instead. (Severity: 3)
Backtick operator used at line 327, column 22. Use IPC::Open3 instead. (Severity: 3)

Políticas de visualización
Puede ver rápidamente qué reglas se están activando y por qué utilizando la opción --verbose de
perlcritic:

Establecer el nivel en 8 le mostrará la regla que activó una advertencia:

perlcritic -3 --verbose 8 /path/to/script.pl

[Bangs::ProhibitDebuggingModules] Debugging module loaded at line 16, column 1. (Severity: 4)

[Subroutines::ProhibitUnusedPrivateSubroutines] Private subroutine/method '_sub_name' declared
but not used at line 58, column 1. (Severity: 3)
[InputOutput::ProhibitBacktickOperators] Backtick operator used at line 230, column 37.
(Severity: 3)
[InputOutput::ProhibitBacktickOperators] Backtick operator used at line 327, column 22.
(Severity: 3)

Mientras que un nivel de 11 mostrará las razones específicas por las que existe la regla:

perlcritic -3 --verbose 11 /path/to/script.pl

Debugging module loaded at line 16, near 'use Data::Dumper;'.

Bangs::ProhibitDebuggingModules (Severity: 4)
This policy prohibits loading common debugging modules like the
Data::Dumper manpage.

While such modules are incredibly useful during development and

debugging, they should probably not be loaded in production use. If this
policy is violated, it probably means you forgot to remove a `use
Data::Dumper;' line that you had added when you were debugging.
Private subroutine/method '_svn_revisions_differ' declared but not used at line 58, near 'sub
_sub_name {'.
Subroutines::ProhibitUnusedPrivateSubroutines (Severity: 3)
By convention Perl authors (like authors in many other languages)
indicate private methods and variables by inserting a leading underscore
before the identifier. This policy catches such subroutines which are
not used in the file which declares them.

This module defines a 'use' of a subroutine as a subroutine or method

call to it (other than from inside the subroutine itself), a reference
to it (i.e. `my $foo = \&_foo'), a `goto' to it outside the subroutine
itself (i.e. `goto &_foo'), or the use of the subroutine's name as an
even-numbered argument to `use overload'.
Backtick operator used at line 230, near 'my $filesystem_diff = join q{}, `diff

https://riptutorial.com/es/home 71
 $trunk_checkout $staging_checkout`;'.
InputOutput::ProhibitBacktickOperators (Severity: 3)
Backticks are super-convenient, especially for CGI programs, but I find
that they make a lot of noise by filling up STDERR with messages when
they fail. I think its better to use IPC::Open3 to trap all the output
and let the application decide what to do with it.

use IPC::Open3 'open3';

$SIG{CHLD} = 'IGNORE';

@output = `some_command`; #not ok

my ($writer, $reader, $err);

open3($writer, $reader, $err, 'some_command'); #ok;
@output = <$reader>; #Output here
@errors = <$err>; #Errors here, instead of the console
Backtick operator used at line 327, near 'my $output = `$cmd`;'.
InputOutput::ProhibitBacktickOperators (Severity: 3)
Backticks are super-convenient, especially for CGI programs, but I find
that they make a lot of noise by filling up STDERR with messages when
they fail. I think its better to use IPC::Open3 to trap all the output
and let the application decide what to do with it.

use IPC::Open3 'open3';

$SIG{CHLD} = 'IGNORE';

@output = `some_command`; #not ok

my ($writer, $reader, $err);

open3($writer, $reader, $err, 'some_command'); #ok;
@output = <$reader>; #Output here
@errors = <$err>; #Errors here, instead of the console

Ignorando el código
Habrá ocasiones en que no pueda cumplir con una política de Perl :: Critic. En esos casos,
puedes envolver comentarios especiales, " ## use critic () " y " ## no critic ", alrededor de tu
código para hacer que Perl :: Critic los ignore. Simplemente agregue las reglas que desea ignorar
entre paréntesis (los múltiplos se pueden separar con una coma).

##no critic qw(InputOutput::ProhibitBacktickOperator)

my $filesystem_diff = join q{}, `diff $trunk_checkout $staging_checkout`;
## use critic

Asegúrese de envolver el bloque de código completo o el crítico puede no reconocer la

instrucción de ignorar.

## no critic (Subroutines::ProhibitExcessComplexity)
sub no_time_to_refactor_this {
...
}
## use critic

Tenga en cuenta que hay ciertas políticas que se ejecutan en el nivel del documento y no pueden

https://riptutorial.com/es/home 72
ser exentas de esta manera. Sin embargo, se pueden desactivar ...

Creando excepciones permanentes

Usar ## no critic () es bueno, pero cuando comience a adoptar estándares de codificación, es
probable que desee hacer excepciones permanentes a ciertas reglas. Puede hacer esto creando
un archivo de configuración .perlcriticrc .

Este archivo le permitirá personalizar no solo las políticas que se ejecutan, sino también cómo se
ejecutan. Su uso es tan simple como colocar el archivo en su directorio de inicio (en Linux, sin
saber si es el mismo lugar en Windows). O bien, puede especificar el archivo de configuración
cuando ejecute el comando usando la opción --profile :

perlcritic -1 --profile=/path/to/.perlcriticrc /path/to/script.pl

Una vez más, la página CPAN perlcritic tiene una lista completa de estas opciones. Enumeraré
algunos ejemplos de mi propio archivo de configuración:

Aplicar la configuración básica:

#very very harsh

severity = 1
color-severity-medium = bold yellow
color-severity-low = yellow
color-severity-lowest = bold blue

Deshabilite una regla (observe el guión delante del nombre de la política):

# do not require version control numbers

[-Miscellanea::RequireRcsKeywords]

# pod spelling is too over-zealous, disabling

[-Documentation::PodSpelling]

Modificar una regla:

# do not require checking for print failure ( false positives for printing to stdout, not
filehandle )
[InputOutput::RequireCheckedSyscalls]
functions = open close

# Allow specific unused subroutines for moose builders

[Subroutines::ProhibitUnusedPrivateSubroutines]
private_name_regex = _(?!build_)\w+

Conclusión
Utilizado correctamente, Perl :: Critic puede ser una herramienta invaluable para ayudar a los

https://riptutorial.com/es/home 73
equipos a mantener su codificación constante y fácil de mantener, sin importar las políticas de
mejores prácticas que emplee.

Lea Mejores prácticas en línea: https://riptutorial.com/es/perl/topic/5919/mejores-practicas

https://riptutorial.com/es/home 74
Capítulo 27: Optimización del uso de la
memoria.
Examples
Lectura de archivos: foreach vs. while

Cuando se lee un archivo potencialmente grande, un while de bucle tiene una ventaja significativa
sobre la memoria foreach . Lo siguiente leerá el registro del archivo por registro (de manera
predeterminada, "registro" significa "una línea", según lo especificado en $/ ), asignando cada uno
a $_ medida que se lee:

while(<$fh>) {
print;
}

El operador Diamond hace algo de magia aquí para asegurarse de que el bucle solo finalice al
final del archivo y no, por ejemplo, en líneas que contengan solo un carácter "0".

El siguiente bucle parece funcionar igual, sin embargo, evalúa el operador Diamond en el
contexto de la lista, lo que hace que todo el archivo se lea de una sola vez:

foreach(<$fh>) {
print;
}

De todos modos, si está operando en un registro a la vez, esto puede resultar en una gran
pérdida de memoria y, por lo tanto, debe evitarse.

Procesando listas largas

Si ya tiene una lista en la memoria, la forma sencilla y generalmente suficiente de procesarla es

mediante un simple bucle foreach :

foreach my $item (@items) {

...
}

Esto está bien, por ejemplo, para el caso común de realizar un procesamiento en $item y luego
escribirlo en un archivo sin mantener la información. Sin embargo, si usted acumula alguna otra
estructura de datos de los artículos, un while de bucle es más eficiente de la memoria:

my @result;
while(@items) {
my $item = shift @items;
push @result, process_item($item);

https://riptutorial.com/es/home 75
 }

A menos que una referencia a $item termine directamente en su lista de resultados, los elementos
que eliminó de la matriz @items se pueden liberar y el intérprete puede reutilizar la memoria
cuando ingresa a la siguiente iteración de bucle.

Lea Optimización del uso de la memoria. en línea:

https://riptutorial.com/es/perl/topic/6327/optimizacion-del-uso-de-la-memoria-

https://riptutorial.com/es/home 76
Capítulo 28: Orientado a objetos Perl
Examples
Creando objetos

A diferencia de muchos otros idiomas, Perl no tiene constructores que asignen memoria para sus
objetos. En su lugar, uno debería escribir un método de clase que cree una estructura de datos y
lo rellene con datos (puede que lo conozca como el patrón de diseño del Método de fábrica).

package Point;
use strict;

sub new {
my ($class, $x, $y) = @_;
my $self = { x => $x, y => $y }; # store object data in a hash
bless $self, $class; # bind the hash to the class
return $self;
}

Este método se puede utilizar de la siguiente manera:

my $point = Point->new(1, 2.5);

Siempre que el operador de flecha -> se usa con métodos, su operando izquierdo se antepone a
la lista de argumentos dada. Entonces, @_ en new contendrá valores ('Point', 1, 2.5) .

No hay nada especial en el nombre new . Puede llamar a los métodos de fábrica como prefiera.

No hay nada especial en los hashes. Podrías hacer lo mismo de la siguiente manera:

package Point;
use strict;

sub new {
my ($class, @coord) = @_;
my $self = \@coord;
bless $self, $class;
return $self;
}

En general, cualquier referencia puede ser un objeto, incluso una referencia escalar. Pero la
mayoría de las veces, los hashes son la forma más conveniente de representar datos de objetos.

Definiendo clases

En general, las clases en Perl son solo paquetes. Pueden contener datos y métodos, como los
paquetes habituales.

https://riptutorial.com/es/home 77
 package Point;
use strict;

my $CANVAS_SIZE = [1000, 1000];

sub new {
...
}

sub polar_coordinates {
...
}

1;

Es importante tener en cuenta que las variables declaradas en un paquete son variables de clase,
no variables de objeto (instancia). El cambio de una variable a nivel de paquete afecta a todos los
objetos de la clase. Cómo almacenar datos específicos de objetos, consulte "Crear objetos".

Lo que hace que los paquetes de clase sean específicos, es el operador de flecha -> . Puede ser
usado después de una sola palabra:

Point->new(...);

o después de una variable escalar (generalmente con una referencia):

my @polar = $point->polar_coordinates;

Lo que está a la izquierda de la flecha se añade a la lista de argumentos dada del método. Por
ejemplo, después de la llamada

Point->new(1, 2);

array @_ en new contendrá tres argumentos: ('Point', 1, 2) .

Los paquetes que representan clases deben tener en cuenta esta convención y esperar que todos
sus métodos tengan un argumento adicional.

Herencia y resolución de métodos.

Para hacer que una clase sea una subclase de otra clase, use pragma parent :

package Point;
use strict;
...
1;

package Point2D;
use strict;
use parent qw(Point);
...
1;

https://riptutorial.com/es/home 78
 package Point3D;
use strict;
use parent qw(Point);
...
1;

Perl permite la herencia múltiple:

package Point2D;
use strict;
use parent qw(Point PlanarObject);
...
1;

La herencia tiene que ver con la resolución de qué método debe llamarse en una situación
particular. Dado que Perl puro no prescribe ninguna regla sobre la estructura de datos utilizada
para almacenar datos de objetos, la herencia no tiene nada que ver con eso.

Considere la siguiente jerarquía de clases:

package GeometryObject;
use strict;

sub transpose { ...}

1;

package Point;
use strict;
use parent qw(GeometryObject);

sub new { ... };

1;

package PlanarObject;
use strict;
use parent qw(GeometryObject);

sub transpose { ... }

1;

package Point2D;
use strict;
use parent qw(Point PlanarObject);

sub new { ... }

sub polar_coordinates { ... }

1;

La resolución del método funciona de la siguiente manera:

1. El punto de partida está definido por el operando izquierdo del operador de flecha.

https://riptutorial.com/es/home 79
 • Si es una palabra simple:

Point2D->new(...);

... o una variable escalar sosteniendo una cadena:

my $class = 'Point2D';
$class->new(...);

... entonces el punto de partida es el paquete con el nombre correspondiente ( Point2D

en ambos ejemplos).

• Si el operando izquierdo es una variable escalar que contiene una referencia bendita :

my $point = {...};
bless $point, 'Point2D'; # typically, it is encapsulated into class methods
my @coord = $point->polar_coordinates;

entonces el punto de partida es la clase de la referencia (nuevamente, Point2D ). El

operador de flecha no se puede utilizar para llamar a métodos para referencias no
bendecidas .

2. Si el punto de partida contiene el método requerido, simplemente se llama.

Así, puesto que Point2D::new existe,

Point2D->new(...);

simplemente lo llamará.

3. Si el punto de partida no contiene el método requerido, se realiza una búsqueda en

profundidad en las clases parent . En el ejemplo anterior, el orden de búsqueda será el
siguiente:

• Point2D
• Point (primer padre de Point2D )
• GeometryObject (padre de Point )
• PlanarObject (segundo padre de Point2D )

Por ejemplo, en el siguiente código:

my $point = Point2D->new(...);
$point->transpose(...);

el método que se llamará es GeometryObject::transpose , aunque se anularía en

PlanarObject::transpose .

4. Puede establecer el punto de partida explícitamente.

https://riptutorial.com/es/home 80
 En el ejemplo anterior, puede llamar explícitamente a PlanarObject::transpose así:

my $point = Point2D->new(...);
$point->PlanarObject::transpose(...);

5. De manera similar, SUPER:: realiza la búsqueda de métodos en las clases primarias de la

clase actual.

Por ejemplo,

package Point2D;
use strict;
use parent qw(Point PlanarObject);

sub new {
(my $class, $x, $y) = @_;
my $self = $class->SUPER::new;
...
}

1;

Point2D::new Point::new en el curso de la Point2D::new ejecución de Point2D::new .

Métodos de clase y objeto

En Perl, la diferencia entre los métodos de clase (estática) y objeto (instancia) no es tan fuerte
como en otros lenguajes, pero aún existe.

El operando izquierdo del operador de flecha -> convierte en el primer argumento del método a
llamar. Puede ser una cadena:

# the first argument of new is string 'Point' in both cases

Point->new(...);

my $class = 'Point';
$class->new(...);

o una referencia de objeto:

# reference contained in $point is the first argument of polar_coordinates

my $point = Point->new(...);
my @coord = $point->polar_coordinates;

Los métodos de clase son solo los que esperan que su primer argumento sea una cadena, y los
métodos de objeto son los que esperan que su primer argumento sea una referencia de objeto.

Los métodos de clase normalmente no hacen nada con su primer argumento, que es solo un
nombre de la clase. En general, Perl solo lo utiliza para la resolución de métodos. Por lo tanto,
también se puede llamar a un método de clase típico para un objeto:

https://riptutorial.com/es/home 81
 my $width = Point->canvas_width;

my $point = Point->new(...);
my $width = $point->canvas_width;

Aunque esta sintaxis está permitida, a menudo es engañosa, por lo que es mejor evitarla.

Los métodos de objeto reciben una referencia de objeto como primer argumento, por lo que
pueden abordar los datos del objeto (a diferencia de los métodos de clase):

package Point;
use strict;

sub polar_coordinates {
my ($point) = @_;
my $x = $point->{x};
my $y = $point->{y};
return (sqrt($x * $x + $y * $y), atan2($y, $x));
}

1;

El mismo método puede rastrear ambos casos: cuando se llama como una clase o un método de
objeto:

sub universal_method {
my $self = shift;
if (ref $self) {
# object logic
...
}
else {
# class logic
...
}
}

Definiendo clases en Perl moderno.

Aunque está disponible, la definición de una clase desde cero no se recomienda en Perl moderno.
Utilice uno de los sistemas OO auxiliares que proporcionan más características y conveniencia.
Entre estos sistemas se encuentran:

• Moose - inspirado en el diseño Perl 6 OO

• Class::Accessor - una alternativa ligera a Moose

• Class::Tiny - constructor de clase verdaderamente minimalista

Alce

package Foo;
use Moose;

https://riptutorial.com/es/home 82
 has bar => (is => 'ro'); # a read-only property
has baz => (is => 'rw', isa => 'Bool'); # a read-write boolean property

sub qux {
my $self = shift;
my $barIsBaz = $self->bar eq 'baz'; # property getter
$self->baz($barIsBaz); # property setter
}

Clase :: Accessor (sintaxis de alces)

package Foo;
use Class::Accessor 'antlers';

has bar => (is => 'ro'); # a read-only property

has baz => (is => 'rw', isa => 'Bool'); # a read-write property (only 'is' supported, the
type is ignored)

Clase :: Accessor (sintaxis nativa)

package Foo;
use base qw(Class::Accessor);

Foo->mk_accessors(qw(bar baz)); # some read-write properties

Foo->mk_accessors(qw(qux)); # a read-only property

Clase :: Tiny

package Foo;
use Class::Tiny qw(bar baz); # just props

Roles

Un papel en Perl es esencialmente

• un conjunto de métodos y atributos que

• inyectado en una clase directamente.

Un rol proporciona una pieza de funcionalidad que se puede componer (o aplicar ) a cualquier
clase (que se dice que consume el rol). Un rol no puede ser heredado, pero puede ser consumido
por otro rol.

Un rol también puede requerir clases de consumo para implementar algunos métodos en lugar de
implementar los métodos en sí (como las interfaces en Java o C #).

Perl no tiene soporte incorporado para roles, pero hay clases de CPAN que proporcionan dicho
soporte.

Moose :: Role

package Chatty;

https://riptutorial.com/es/home 83
 use Moose::Role;

requires 'introduce'; # a method consuming classes must implement

sub greet { # a method already implemented in the role

print "Hi!\n";
}

package Parrot;
use Moose;

with 'Chatty';

sub introduce {
print "I'm Buddy.\n";
}

Rol :: Diminuto

Utilícelo si su sistema OO no proporciona soporte para roles (por ejemplo, Class::Accessor o

Class::Tiny ) No soporta atributos.

package Chatty;
use Role::Tiny;

requires 'introduce'; # a method consuming classes must implement

sub greet { # a method already implemented in the role

print "Hi!\n";
}

package Parrot;
use Class::Tiny;
use Role::Tiny::With;

with 'Chatty';

sub introduce {
print "I'm Buddy.\n";
}

Lea Orientado a objetos Perl en línea: https://riptutorial.com/es/perl/topic/2920/orientado-a-

objetos-perl

https://riptutorial.com/es/home 84
Capítulo 29: Paquetes y módulos
Sintaxis
• requiere Módulo :: Nombre; # Requerir por nombre de @INC
• requiere "ruta / a / archivo.pm"; # Requerir por ruta relativa de @INC
• use Module :: Name; # requiere y la importación por defecto en BEGIN
• use Module :: Name (); # requiere y no importa en BEGIN
• use Module :: Name (@ARGS); # requiere e importa con args en BEGIN
• use Module :: Name VERSION; # requiere, verificación de versión e importación
predeterminada en BEGIN
• use Module :: Name VERSION (); # requiere, verifica versión, y no importa en BEGIN
• use Module :: Name VERSION (@ARGS); # require, version check, import con args en
BEGIN
• hacer "ruta / a / archivo.pl"; # cargar y evaluar el archivo dado

Examples
Ejecutando los contenidos de otro archivo.

do './config.pl';

Esto leerá el contenido del archivo config.pl y lo ejecutará. (Ver también: perldoc -f do .)

NB: Evite do menos que juegue al golf o algo así, ya que no hay comprobación de errores. Para
incluir módulos de biblioteca, use require o use .

Cargando un módulo en tiempo de ejecución

require Exporter;

Esto asegurará que el módulo Exporter se cargue en tiempo de ejecución si aún no se ha

importado. (Ver también: perldoc -f require .)

NB: La mayoría de los usuarios deberían use módulos en lugar de require . A diferencia del use ,
require no llama al método de importación del módulo y se ejecuta en tiempo de ejecución, no
durante la compilación.

Esta forma de cargar módulos es útil si no puede decidir qué módulos necesita antes del tiempo
de ejecución, como con un sistema de complementos:

package My::Module;
my @plugins = qw( One Two );
foreach my $plugin (@plugins) {
my $module = __PACKAGE__ . "::Plugins::$plugin";

https://riptutorial.com/es/home 85
 $module =~ s!::!/!g;
require "$module.pm";
}

Esto intentaría cargar My::Package::Plugins::One y My::Package::Plugins::Two . @plugins supuesto,

@plugins debería provenir de alguna entrada del usuario o un archivo de configuración para que
esto tenga sentido. Tenga en cuenta el operador de sustitución s!::!/!g que reemplaza cada par
de dos puntos con una barra. Esto se debe a que puede cargar módulos utilizando la sintaxis de
nombre de módulo familiar de use solo si el nombre del módulo es una simple palabra. Si pasa
una cadena o una variable, debe contener un nombre de archivo.

Usando un modulo

use Cwd;

Esto importará el módulo Cwd en el momento de la compilación e importará sus símbolos

predeterminados, es decir, hará que algunas de las variables y funciones del módulo estén
disponibles para el código que lo usa. (Ver también: perldoc -f use .)

Generalmente esto es lo que hará lo correcto. A veces, sin embargo, deseará controlar qué
símbolos se importan. Agregue una lista de símbolos después del nombre del módulo para
exportar:

use Cwd 'abs_path';

Si lo hace, solo se importarán los símbolos que especifique (es decir, el conjunto predeterminado
no se importará).

Cuando se importan varios símbolos, es idiomático utilizar la qw() list-building:

use Cwd qw(abs_path realpath);

Algunos módulos exportan un subconjunto de sus símbolos, pero se les puede decir que exporten
todo con :all :

use Benchmark ':all';

(Tenga en cuenta que no todos los módulos reconocen o utilizan la etiqueta :all ).

Usando un módulo dentro de un directorio

use lib 'includes';

use MySuperCoolModule;

use lib 'includes'; agrega el directorio relativo includes/ como otra ruta de búsqueda de módulo
en @INC . Así que suponga que tiene un archivo de módulo MySyperCoolModule.pm en
MySyperCoolModule.pm interior includes/ , que contiene:

https://riptutorial.com/es/home 86
 package MySuperCoolModule;

Si lo desea, puede agrupar tantos módulos como desee dentro de un solo directorio y hacer que
se puedan encontrar con un solo use lib .

En este punto, el uso de las subrutinas en el módulo requerirá el prefijo del nombre de la
subrutina con el nombre del paquete:

MySuperCoolModule::SuperCoolSub_1("Super Cool String");

Para poder usar las subrutinas sin el prefijo, debe exportar los nombres de las subrutinas para
que el programa las reconozca. La exportación se puede configurar para que sea automática, por
lo que:

package MySuperCoolModule;
use base 'Exporter';
our @EXPORT = ('SuperCoolSub_1', 'SuperCoolSub_2');

Luego, en el archivo que use el módulo, esas subrutinas estarán disponibles automáticamente:

use MySuperCoolModule;
SuperCoolSub_1("Super Cool String");

O puede configurar el módulo para exportar subrutinas condicionalmente, de esta manera:

package MySuperCoolModule;
use base 'Exporter';
our @EXPORT_OK = ('SuperCoolSub_1', 'SuperCoolSub_2');

En cuyo caso, debe solicitar explícitamente las subrutinas que desea exportar en el script que use
el módulo:

use MySuperCoolModule 'SuperCoolSub_1';

SuperCoolSub_1("Super Cool String");

CPAN.pm

CPAN.pm es un módulo de Perl que permite consultar e instalar módulos desde los sitios de CPAN.

Es compatible con el modo interactivo invocado con

cpan

perl -MCPAN -e shell

Módulos de consulta

https://riptutorial.com/es/home 87
Por nombre:

cpan> m MooseX::YAML

Por una expresión regular contra el nombre del módulo:

cpan> m /^XML::/

Nota: para habilitar un buscapersonas o redirigir a un uso de archivos | o > redirección de shell
(los espacios son obligatorios alrededor de | y > ), por ejemplo: m /^XML::/ | less

Por distribución:

cpan> d LMC/Net-Squid-Auth-Engine-0.04.tar.gz

Instalacion de modulos

Por nombre:

cpan> install MooseX::YAML

Por distribución:

cpan> install LMC/Net-Squid-Auth-Engine-0.04.tar.gz

Listar todos los módulos instalados

Desde la línea de comando:

cpan -l

De un script de Perl:

use ExtUtils::Installed;
my $inst = ExtUtils::Installed->new();
my @modules = $inst->modules();

Lea Paquetes y módulos en línea: https://riptutorial.com/es/perl/topic/451/paquetes-y-modulos

https://riptutorial.com/es/home 88
Capítulo 30: Perl one-liners
Examples
Ejecutar algún código de Perl desde la línea de comandos

Los sencillos de una línea se pueden especificar como argumentos de línea de comando para
perl usando el -e (piense "ejecuta"):

perl -e'print "Hello, World!\n"'

Debido a las reglas de cotización de Windows, no puede usar cadenas entre comillas simples,
pero tiene que usar una de estas variantes:

perl -e"print qq(Hello, World!\n)"

perl -e"print \"Hello, World!\n\""

Tenga en cuenta que para evitar romper el código antiguo, solo se puede usar la sintaxis
disponible hasta Perl 5.8.x con -e . Para usar algo más nuevo que pueda admitir su versión de
Perl, use -E lugar. Por ejemplo, para usar say disponible desde 5.10.0 en más Unicode 6.0 desde>
= v5.14.0 (también usa -CO para asegurarse de que STDOUT imprima en UTF-8):

5.14.0

perl -CO -E'say "\N{PILE OF POO}"'

Uso de cadenas entre comillas dobles en las líneas de Windows

Windows usa solo comillas dobles para ajustar los parámetros de la línea de comandos. Para
usar comillas dobles en perl one-liner (es decir, para imprimir una cadena con una variable
interpolada), tiene que escapar de ellas con barras invertidas:

perl -e "my $greeting = 'Hello'; print \"$greeting, world!\n\""

Para mejorar la legibilidad, puede usar un operador qq() :

perl -e "my $greeting = 'Hello'; print qq($greeting, world!\n)"

Líneas de impresión que coinciden con un patrón (PCRE grep)

perl -ne'print if /foo/' file.txt

Mayúsculas y minúsculas:

https://riptutorial.com/es/home 89
 perl -ne'print if /foo/i' file.txt

Reemplazar una subcadena con otra (PCRE sed)

perl -pe"s/foo/bar/g" file.txt

O en el lugar:

perl -i -pe's/foo/bar/g' file.txt

En Windows:

perl -i.bak -pe"s/foo/bar/g" file.txt

Imprimir solo ciertos campos

perl -lane'print "$F[0] $F[-1]"' data.txt

# prints the first and the last fields of a space delimited record

Ejemplo de CSV:

perl -F, -lane'print "$F[0] $F[-1]"' data.csv

Imprimir líneas 5 a 10

perl -ne'print if 5..10' file.txt

Editar archivo en el lugar

Sin una copia de seguridad ( no es compatible con Windows )

perl -i -pe's/foo/bar/g' file.txt

Con un file.txt.bak copia de seguridad.txt.bak

perl -i.bak -pe's/foo/bar/g' file.txt

Con una copia de seguridad old_file.txt.orig en el subdirectorio de backup (siempre que exista
este último):

perl -i'backup/old_*.orig' -pe's/foo/bar/g' file.txt

Leyendo todo el archivo como una cadena

https://riptutorial.com/es/home 90
 perl -0777 -ne'print "The whole file as a string: --->$_<---\n"'

Nota: El -0777 es solo una convención. Cualquier -0400 y superior sería el mismo.

Subir archivo a mojolicious

perl -Mojo -E 'p("http://localhost:3000" => form => {Input_Type => "XML", Input_File => {file
=> "d:/xml/test.xml"}})'

El archivo d:/xml/test.xml se cargará al servidor que escuche las conexiones en localhost:3000 (

Fuente )

En este ejemplo:

-Mmodule ejecuta use module; antes de ejecutar tu programa

-E commandline se usa para ingresar una línea de programa
Si no tiene un módulo ojo , puede usar el comando cpanm ojo para instalarlo

Para leer más sobre cómo ejecutar perl, use el comando perldoc perlrun o lea aquí

Lea Perl one-liners en línea: https://riptutorial.com/es/perl/topic/3696/perl-one-liners

https://riptutorial.com/es/home 91
Capítulo 31: Perl Testing
Examples
Ejemplo de prueba de unidad Perl

El siguiente es un ejemplo simple de la secuencia de comandos de prueba de Perl, que

proporciona cierta estructura para permitir la prueba de otros métodos en la clase / paquete bajo
prueba. El script produce una salida estándar con un simple texto "ok" / "not ok", que se llama
TAP (Test Anything Protocol).

Normalmente, el comando de prueba ejecuta los scripts y resume los resultados de la prueba.

#!/bin/env perl
# CPAN
use Modern::Perl;
use Carp;
use Test::More;
use Test::Exception;
use Const::Fast;

# Custom
BEGIN { use_ok('Local::MyPackage'); }

const my $PACKAGE_UNDER_TEST => 'Local::MyPackage';

# Example test of method 'file_type_build'

sub test_file_type_build {
my %arg = @_;
my $label = 'file_type_build';
my $got_file_type;
my $filename = '/etc/passwd';

# Check the method call lives

lives_ok(
sub {
$got_file_type = $PACKAGE_UNDER_TEST->file_type_build(
filename => $filename
);
},
"$label - lives"
);

# Check the result of the method call matches our expected result.
like( $got_file_type, qr{ASCII[ ]text}ix, "$label - result" );
return;
} ## end sub test_file_type_build

# More tests can be added here for method 'file_type_build', or other methods.

MAIN: {

subtest 'file_type_build' => sub {

test_file_type_build();

https://riptutorial.com/es/home 92
 # More tests of the method can be added here.
done_testing();
};

# Tests of other methods can be added here, just like above.

done_testing();
} ## end MAIN:

Mejores prácticas

Un script de prueba solo debe probar un paquete / clase, pero se pueden usar muchos scripts
para probar un paquete / clase.

Otras lecturas

• Prueba :: Más - Las operaciones de prueba básicas.

• Prueba :: Excepción - Probar excepciones lanzadas.
• Prueba :: Diferencias - Comparación de resultados de prueba que tienen estructuras de
datos complejas.
• Prueba :: Clase - Pruebas basadas en clase en lugar de script. Similitudes con JUnit.
• Perl Testing Tutorials - Lecturas adicionales.

Lea Perl Testing en línea: https://riptutorial.com/es/perl/topic/5918/perl-testing

https://riptutorial.com/es/home 93
Capítulo 32: Perlbrew
Introducción
Perlbrew es una herramienta para administrar múltiples instalaciones de Perl en su directorio
$HOME .

Observaciones
Ver también

• Página oficial de perlbrew

• Documentación CPAN para perlbrew

Examples
Configurar perlbrew por primera vez

Crear script de configuración ~/.perlbrew.sh :

# Reset any environment variables that could confuse `perlbrew`:

export PERL_LOCAL_LIB_ROOT=
export PERL_MB_OPT=
export PERL_MM_OPT=

# decide where you want to install perlbrew:

export PERLBREW_ROOT=~/perlbrew
[[ -f "$PERLBREW_ROOT/etc/bashrc" ]] && source "$PERLBREW_ROOT/etc/bashrc"

Crear script de instalación install_perlbrew.sh :

source ~/.perlbrew.sh
curl -L https://install.perlbrew.pl | bash
source "$PERLBREW_ROOT/etc/bashrc"

# Decide which version you would like to install:

version=perl-5.24.1
perlbrew install "$version"
perlbrew install-cpanm
perlbrew switch "$version"

Ejecutar script de instalación:

./install_perlbrew.sh

https://riptutorial.com/es/home 94
Agrega al final de tu ~/.bashrc

[[ -f ~/.perlbrew.sh ]] && source ~/.perlbrew.sh

Fuente ~/.bashrc :

source ~/.bashrc

Lea Perlbrew en línea: https://riptutorial.com/es/perl/topic/9144/perlbrew

https://riptutorial.com/es/home 95
Capítulo 33: Salida de depuración
Examples
Dumping estructuras de datos

use Data::Dumper;

my $data_structure = { foo => 'bar' };

print Dumper $data_structure;

Usar Data :: Dumper es una forma fácil de ver las estructuras de datos o el contenido variable en
tiempo de ejecución. Se envía con Perl y puedes cargarlo fácilmente. La función Dumper devuelve
la estructura de datos serializada de forma que se parece al código Perl.

$VAR1 = {
'foo' => 'bar',
}

Eso lo hace muy útil para observar rápidamente algunos valores en su código. Es una de las
herramientas más útiles que tienes en tu arsenal. Lea la documentación completa en metacpan .

Dumping con estilo

A veces, Data :: Dumper no es suficiente. ¿Tienes un objeto Moose que quieres inspeccionar?
¿Grandes números de la misma estructura? ¿Quieres cosas ordenadas? ¿De colores? Datos ::
La impresora es tu amiga.

use Data::Printer;

p $data_structure;

Datos :: Impresora escribe a STDERR, como warn . Eso hace que sea más fácil encontrar la
salida. Por defecto, ordena las claves hash y mira los objetos.

use Data::Printer;
use LWP::UserAgent;

my $ua = LWP::UserAgent->new;
p $ua;

Observará todos los métodos del objeto y también enumerará los aspectos internos.

LWP::UserAgent {

https://riptutorial.com/es/home 96
 Parents LWP::MemberMixin
public methods (45) : add_handler, agent, clone, conn_cache, cookie_jar, credentials,
default_header, default_headers, delete, env_proxy, from, get, get_basic_credentials,
get_my_handler, handlers, head, is_online, is_protocol_supported, local_address, max_redirect,
max_size, mirror, new, no_proxy, parse_head, post, prepare_request, progress,
protocols_allowed, protocols_forbidden, proxy, put, redirect_ok, remove_handler, request,
requests_redirectable, run_handlers, send_request, set_my_handler, show_progress,
simple_request, ssl_opts, timeout, use_alarm, use_eval
private methods (4) : _agent, _need_proxy, _new_response, _process_colonic_headers
internals: {
def_headers HTTP::Headers,
handlers {
response_header HTTP::Config
},
local_address undef,
max_redirect 7,
max_size undef,
no_proxy [],
protocols_allowed undef,
protocols_forbidden undef,
proxy {},
requests_redirectable [
[0] "GET",
[1] "HEAD"
],
show_progress undef,
ssl_opts {
verify_hostname 1
},
timeout 180,
use_eval 1
}
}

Puede configurarlo más, por lo que serializa ciertos objetos de cierta manera, o para incluir
objetos hasta una profundidad arbitraria. La configuración completa está disponible en la
documentación .

Desafortunadamente, Data :: Printer no se envía con Perl, por lo que necesita instalarlo desde
CPAN o a través de su sistema de administración de paquetes.

Dumping lista de matriz

my @data_array = (123, 456, 789, 'poi', 'uyt', "rew", "qas");

print Dumper @data_array;

El uso de Data :: Dumper permite acceder fácilmente a los valores de la lista de búsqueda. El
Dumper devuelve los valores de lista serializados de forma que se parece al código Perl.

Salida:

$VAR1 = 123;
$VAR2 = 456;
$VAR3 = 789;
$VAR4 = 'poi';
$VAR5 = 'uyt';

https://riptutorial.com/es/home 97
 $VAR6 = 'rew';
$VAR7 = 'qas';

Según lo sugerido por el usuario @dgw Cuando se eliminan matrices o hashes, es mejor usar
una referencia de matriz o una referencia de hash, se mostrará mejor el ajuste de la entrada.

$ref_data = [23,45,67,'mnb','vcx'];
print Dumper $ref_data;

Salida:

$VAR1 = [
23,
45,
67,
'mnb',
'vcx'
];

También puede hacer referencia a la matriz al imprimir.

my @data_array = (23,45,67,'mnb','vcx');
print Dumper \@data_array;

Salida:

$VAR1 = [
23,
45,
67,
'mnb',
'vcx'
];

Muestra de datos

La función show se exporta automáticamente cuando se use Data::Show; es ejecutado. Esta función
toma una variable como único argumento y genera:

1. El nombre de la variable
2. El contenido de esa variable (en un formato legible).
3. La línea del archivo que show se ejecuta desde
4. el archivo show se ejecuta desde

Suponiendo que lo siguiente es código del archivo example.pl :

use strict;
use warnings;
use Data::Show;

my @array = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

https://riptutorial.com/es/home 98
 my %hash = ( foo => 1, bar => { baz => 10, qux => 20 } );

my $href = \%hash;

show @array;
show %hash;
show $href;

perl example.pl da el siguiente resultado:

======( @array )=======================[ 'example.pl', line 11 ]======

[1 .. 10]

======( %hash )========================[ 'example.pl', line 12 ]======

{ bar => { baz => 10, qux => 20 }, foo => 1 }

======( $href )========================[ 'example.pl', line 13 ]======

{ bar => { baz => 10, qux => 20 }, foo => 1 }

Consulte la documentación de Data::Show .

Lea Salida de depuración en línea: https://riptutorial.com/es/perl/topic/983/salida-de-depuracion

https://riptutorial.com/es/home 99
Capítulo 34: Subrutinas
Observaciones
Las subrutinas llevan sus argumentos a la variable mágica llamada @_ . Si bien no tiene que
desempaquetarse, se recomienda, ya que ayuda a la legibilidad y evita cambios accidentales a
medida que los argumentos de @_ se pasan por referencia (se pueden modificar).

Examples
Creando subrutinas

Las subrutinas se crean utilizando la palabra clave sub seguido de un identificador y un bloque de
código entre llaves.

Puede acceder a los argumentos utilizando la variable especial @_ , que contiene todos los
argumentos como una matriz.

sub function_name {
my ($arg1, $arg2, @more_args) = @_;
# ...
}

Como la función shift predeterminada a desplazar @_ cuando se usa dentro de una subrutina, es
un patrón común extraer los argumentos de forma secuencial en variables locales al comienzo de
una subrutina:

sub function_name {
my $arg1 = shift;
my $arg2 = shift;
my @more_args = @_;
# ...
}

# emulate named parameters (instead of positional)

sub function_name {
my %args = (arg1 => 'default', @_);
my $arg1 = delete $args{arg1};
my $arg2 = delete $args{arg2};
# ...
}

sub {
my $arg1 = shift;
# ...
}->($arg);

5.20.0

Alternativamente, la característica experimental "signatures" puede usarse para desempaquetar

https://riptutorial.com/es/home 100
parámetros, que se pasan por valor ( no por referencia).

use feature "signatures";

sub function_name($arg1, $arg2, @more_args) {

# ...
}

Los valores por defecto se pueden utilizar para los parámetros.

use feature "signatures";

sub function_name($arg1=1, $arg2=2) {

# ...
}

Puede usar cualquier expresión para asignar un valor predeterminado a un parámetro, incluidos
otros parámetros.

sub function_name($arg1=1, $arg2=$arg1+1) {

# ...
}

Tenga en cuenta que no puede hacer referencia a los parámetros que se definen después del
parámetro actual; por lo tanto, el siguiente código no funciona como se esperaba.

sub function_name($arg1=$arg2, $arg2=1) {

print $arg1; # => <nothing>
print $arg2; # => 1
}

Los argumentos de subrutina se pasan por referencia (excepto los de las

firmas)

Los argumentos de subrutina en Perl se pasan por referencia, a menos que estén en la firma.
Esto significa que los miembros de la matriz @_ dentro del subgrupo son solo alias de los
argumentos reales. En el siguiente ejemplo, $text en el programa principal se deja modificado
después de la llamada de subrutina porque $_[0] dentro del sub es en realidad solo un nombre
diferente para la misma variable. La segunda invocación genera un error porque un literal de
cadena no es una variable y, por lo tanto, no se puede modificar.

use feature 'say';

sub edit {
$_[0] =~ s/world/sub/;
}

my $text = "Hello, world!";

edit($text);
say $text; # Hello, sub!

edit("Hello, world!"); # Error: Modification of a read-only value attempted

https://riptutorial.com/es/home 101
Para evitar obstruir las variables de su interlocutor, por lo tanto, es importante copiar @_ a las
variables de ámbito local ( my ... ) como se describe en "Crear subrutinas".

Subrutinas

Código de espera de subrutinas. A menos que se especifique lo contrario, se definen

globalmente.

# Functions do not (have to) specify their argument list

sub returns_one {
# Functions return the value of the last expression by default
# The return keyword here is unnecessary, but helps readability.
return 1;
}

# Its arguments are available in @_, however

sub sum {
my $ret = 0;
for my $value (@_) {
$ret += $value
}
return $ret;
}

# Perl makes an effort to make parens around argument list optional

say sum 1..3; # 6

# If you treat functions as variables, the & sigil is mandatory.

say defined &sum; # 1

Algunas incorporaciones como print o say son palabras clave, no funciones, por lo que, por
ejemplo, &say no está definido. También significa que puede definirlos, pero tendrá que especificar
el nombre del paquete para llamarlos

# This defines the function under the default package, 'main'

sub say {
# This is instead the say keyword
say "I say, @_";
}

# ...so you can call it like this:

main::say('wow'); # I say, wow.

5.18.0

Desde Perl 5.18, también puede tener funciones no globales:

use feature 'lexical_subs';

my $value;
{
# Nasty code ahead
my sub prod {
my $ret = 1;
$ret *= $_ for @_;
$ret;

https://riptutorial.com/es/home 102
 }
$value = prod 1..6; # 720
say defined &prod; # 1
}
say defined &prod; # 0

5.20.0

Desde 5.20, también puede tener parámetros con nombre.

use feature 'signatures';

sub greet($name) {
say "Hello, $name";
}

Esto no debe confundirse con los prototipos, una instalación que Perl tiene para permitirle definir
funciones que se comportan como integradas. Los prototipos de funciones deben ser visibles en
el momento de la compilación y sus efectos pueden ignorarse especificando el & sigil. Los
prototipos generalmente se consideran una característica avanzada que se utiliza mejor con gran
cuidado.

# This prototype makes it a compilation error to call this function with anything
# that isn't an array. Additionally, arrays are automatically turned into arrayrefs
sub receives_arrayrefs(\@\@) {
my $x = shift;
my $y = shift;
}

my @a = (1..3);
my @b = (1..4);
receives_arrayrefs(@a, @b); # okay, $x = \@a, $y = \@b, @_ = ();
receives_arrayrefs(\@a, \@b); # compilation error, "Type … must be array …"
BEGIN { receives_arrayrefs(\@a, \@b); }

# Specify the sigil to ignore the prototypes.

&receives_arrayrefs(\@a, \@b); # okay, $x = \@a, $y = \@b, @_ = ();
&receives_arrayrefs(@a, @b); # ok, but $x = 1, $y = 2, @_ = (3,1,2,3,4);

Lea Subrutinas en línea: https://riptutorial.com/es/perl/topic/711/subrutinas

https://riptutorial.com/es/home 103
Capítulo 35: Texto atribuido
Examples
Imprimiendo texto en color

#!/usr/bin/perl

use Term::ANSIColor;

print color("cyan"), "Hello", color("red"), "\tWorld", color("green"), "\tIt's Me!\n",

color("reset");

Lea Texto atribuido en línea: https://riptutorial.com/es/perl/topic/5922/texto-atribuido

https://riptutorial.com/es/home 104
Capítulo 36: Una forma sencilla de
comprobar los módulos instalados en Mac y
Ubuntu
Examples
Compruebe los módulos perl instalados a través de la terminal

Escriba abajo el comando:

instmodsh

Te mostrará el gremio de la siguiente manera:

Available commands are:

l - List all installed modules
m <module> - Select a module
q - Quit the program
cmd?

Luego escriba l para enumerar todos los módulos instalados, también puede usar el comando m
<module> para seleccionar el módulo y obtener su información.

Después de terminar, simplemente escribe q para salir.

Use perldoc para verificar la ruta de instalación del paquete Perl

$ perldoc -l Time::Local

Cómo comprobar los módulos de la lista de Perl.

$ corelist -v v5.23.1

¿Cómo comprobar la versión de un módulo instalado?

$> perl -MFoo::Bar\ 9999

$> Foo::Bar version 9999 required--this is only version 1.1.

Lea Una forma sencilla de comprobar los módulos instalados en Mac y Ubuntu en línea:
https://riptutorial.com/es/perl/topic/5925/una-forma-sencilla-de-comprobar-los-modulos-instalados-
en-mac-y-ubuntu

https://riptutorial.com/es/home 105
Capítulo 37: Unicode
Observaciones

Una advertencia sobre la codificación de

nombre de archivo

Cabe mencionar que la codificación de nombre de archivo no solo es específica de la plataforma,

sino también del sistema de archivos .

Nunca es completamente seguro asumir (pero a menudo lo es) que solo porque puede codificar y
escribir en un nombre de archivo dado, que cuando más tarde intente abrir ese mismo nombre de
archivo para leer, aún se llamará la misma cosa.

Por ejemplo, si escribe en un sistema de archivos como FAT16 que no admite Unicode, sus
nombres de archivo podrían traducirse silenciosamente a formularios compatibles con ASCII.

Pero es aún menos seguro suponer que un archivo que puede crear, leer y escribir con nombres
explícitos se llamará de la misma manera cuando se lo solicite a través de otras llamadas, por
ejemplo, readdir puede devolver diferentes bytes para su nombre de archivo de los que especificó
para open .

En algunos sistemas, como VAX, ni siquiera puede asumir siempre que readdir devolverá el
mismo nombre de archivo que especificó con open para los nombres de archivo tan simple como
foo.bar , ya que las extensiones de nombre de archivo pueden ser modificadas por el sistema
operativo.

Además, en UNIX, hay un conjunto muy liberal de caracteres legales para los nombres de archivo
que permite el sistema operativo, excluyendo solo / y \0 , donde, como en Windows, hay rangos
específicos de caracteres que están prohibidos en los nombres de archivo y causarán errores.

Ejercer mucha precaución aquí, evitar trucos de fantasía con los nombres de archivo, si
usted tiene una opción, y siempre tienen pruebas para asegurarse de que los trucos de fantasía
que usted hace uso son consistentes.

Tenga mucho cuidado si está escribiendo código destinado a ejecutarse en plataformas fuera de
su control, como si está escribiendo código destinado a CPAN , y suponga que al menos el 5% de
su base de usuarios se atascará con algunos Tecnología antigua o rota, ya sea por elección, por
accidente o por poderes fuera de su control, y que estos conspirarán para crear errores para
ellos.

: encoding (utf8) vs: utf8

https://riptutorial.com/es/home 106
Dado que UTF-8 es uno de los formatos internos para la representación de cadenas en Perl, el
paso de codificación / decodificación a menudo se puede omitir. En lugar de :encoding(utf-8) ,
simplemente puede usar :utf8 , si sus datos ya están en UTF-8. :utf8 puede usarse de forma
segura con flujos de salida, mientras que para el flujo de entrada puede ser peligroso, ya que
causa una inconsistencia interna cuando tiene secuencias de bytes no válidas. Además, el uso de
:utf8 para la entrada puede dar lugar a violaciones de seguridad, por lo que se recomienda el uso
de :encoding(utf-8) .

Más detalles: ¿Cuál es la diferencia entre: codificación y: utf8

UTF-8 vs utf8 vs UTF8

A partir de Perl v5.8.7 , "UTF-8" (con guión) significa UTF-8 en su forma estricta y consciente de la
seguridad, mientras que "utf8" significa UTF-8 en su forma liberal y holgada.

Por ejemplo, "utf8" se puede usar para puntos de código que no existen en Unicode, como
0xFFFFFFFF . Correspondientemente, las secuencias de bytes UTF-8 no válidas como
"\x{FE}\x{83}\x{BF}\x{BF}\x{BF}\x{BF}\x{BF}" se decodificarán en una 0xFFFFFFFF código Unicode
no válido (pero Perl válido) ( 0xFFFFFFFF ) cuando se utiliza "utf8" , mientras que la "UTF-8" no
permitiría la decodificación a puntos de código fuera del rango de Unicode válido y le daría un
carácter de sustitución ( 0xFFFD ).

Dado que los nombres de codificación no distinguen entre mayúsculas y minúsculas, "UTF8" es lo
mismo que "utf8" (es decir , variante no estricta ).

Más detalles: UTF-8 vs. utf8 vs. UTF8

Más lectura

Los detalles sobre el manejo de Perl en Unicode se describen con más detalle en las siguientes
fuentes:

• Perlunicode
• perlunitut
• perluniintro
• perlunifaq
• perlunicook
• utf8 pragma
• característica unicode_strings
• pragma abierto
• Perlio
• PerlIO :: codificación
• función abierta
• Codificar

https://riptutorial.com/es/home 107
 • perlrun - interruptores de línea de comando
• Capítulo 6, Programación Perl

Publicaciones de stackoverflow.com (advertencia: podría no estar actualizado):

• ¿Por qué Perl moderno evita UTF-8 por defecto?

Videos de Youtube:

• Un millón de billones de personajes ondulados de Ricardo Signes en YAPC NA 2016.

Examples
Crear nombres de archivos

Los siguientes ejemplos utilizan la codificación UTF-8 para representar nombres de archivos (y
nombres de directorio) en el disco. Si desea utilizar otra codificación, debe usar
Encode::encode(...) .

use v5.14;
# Make Perl recognize UTF-8 encoded characters in literal strings.
# For this to work: Make sure your text-editor is using UTF-8, so
# that bytes on disk are really UTF-8 encoded.
use utf8;

# Ensure that possible error messages printed to screen are converted to UTF-8.
# For this to work: Check that your terminal emulator is using UTF-8.
binmode STDOUT, ':utf8';
binmode STDERR, ':utf8';

my $filename = 'æ€'; # $filename is now an internally UTF-8 encoded string.

# Note: in the following it is assumed that $filename has the internal UTF-8
# flag set, if $filename is pure ASCII, it will also work since its encoding
# overlaps with UTF-8. However, if it has another encoding like extended ASCII,
# $filename will be written with that encoding and not UTF-8.
# Note: it is not necessary to encode $filename as UTF-8 here
# since Perl is using UTF-8 as its internal encoding of $filename already

# Example1 -- using open()

open ( my $fh, '>', $filename ) or die "Could not open '$filename': $!";
close $fh;

# Example2 -- using qx() and touch

qx{touch $filename};

# Example3 -- using system() and touch

system 'touch', $filename;

# Example4 -- using File::Touch

use File::Touch;
eval { touch( $filename ) }; die "Could not create file '$filename': $!" if $@;

Leer nombres de archivos

https://riptutorial.com/es/home 108
Perl no intenta decodificar los nombres de archivos devueltos por las funciones integradas o los
módulos. Tales cadenas que representan nombres de archivos siempre deben decodificarse
explícitamente, para que Perl los reconozca como Unicode.

use v5.14;
use Encode qw(decode_utf8);

# Ensure that possible error messages printed to screen are converted to UTF-8.
# For this to work: Check that you terminal emulator is using UTF-8.
binmode STDOUT, ':utf8';
binmode STDERR, ':utf8';

# Example1 -- using readdir()

my $dir = '.';
opendir(my $dh, $dir) or die "Could not open directory '$dir': $!";
while (my $filename = decode_utf8(readdir $dh)) {
# Do something with $filename
}
close $dh;

# Example2 -- using getcwd()

use Cwd qw(getcwd);
my $dir = decode_utf8( getcwd() );

# Example3 -- using abs2rel()

use File::Spec;
use utf8;
my $base = 'ø';
my $path = "$base/b/æ";
my $relpath = decode_utf8( File::Spec->abs2rel( $path, $base ) );
# Note: If you omit $base, you need to encode $path first:
use Encode qw(encode_utf8);
my $relpath = decode_utf8( File::Spec->abs2rel( encode_utf8( $path ) ) );

# Example4 -- using File::Find::Rule (part1 matching a filename)

use File::Find::Rule;
use utf8;
use Encode qw(encode_utf8);
my $filename = 'æ';
# File::Find::Rule needs $filename to be encoded
my @files = File::Find::Rule->new->name( encode_utf8($filename) )->in('.');
$_ = decode_utf8( $_ ) for @files;

# Example5 -- using File::Find::Rule (part2 matching a regular expression)

use File::Find::Rule;
use utf8;
my $pat = '[æ].$'; # Unicode pattern
# Note: In this case: File::Find::Rule->new->name( qr/$pat/ )->in('.')
# will not work since $pat is Unicode and filenames are bytes
# Also encoding $pat first will not work correctly
my @files;
File::Find::Rule->new->exec( sub { wanted( $pat, \@files ) } )->in('.');
$_ = decode_utf8( $_ ) for @files;
sub wanted {
my ( $pat, $files ) = @_;
my $name = decode_utf8( $_ );
my $full_name = decode_utf8( $File::Find::name );
push @$files, $full_name if $name =~ /$pat/;
}

https://riptutorial.com/es/home 109
Nota: si le preocupa el UTF-8 no válido en los nombres de archivo, el uso de decode_utf8( ... )
en los ejemplos anteriores probablemente debería ser reemplazado por decode( 'utf-8', ... ) .
Esto se debe a que decode_utf8( ... ) es un sinónimo de decode( 'utf8', ... ) y existe una
diferencia entre las codificaciones utf-8 y utf8 (consulte las Notas a continuación para obtener
más información) donde utf-8 es más estricto en lo que es aceptable que utf8 .

Interruptores de línea de comando para one-liners

Habilitar pragma utf8

Para habilitar pragma utf8 en one-liner, se debe llamar al intérprete perl con la opción -Mutf8 :

perl -Mutf8 -E 'my $ = "human"; say $ '

Manejo de Unicode con interruptor -C

El indicador de línea de comando -C permite controlar las funciones de Unicode. Puede ir seguido
de una lista de letras opcionales.

E / S estándar
• I - STDIN estará en UTF-8
• O - STDOUT estará en UTF-8
• E - STDERR estará en UTF-8
• S - taquigrafía para IOE , las secuencias de E / S estándar estarán en UTF-8

echo "Ματαιότης ματαιοτήτων" | perl -CS -Mutf8 -nE 'say "ok" if /Ματαιότης/'

Argumentos del guión

• A : trata a @ARGV como una matriz de cadenas codificadas en UTF-8

perl -CA -Mutf8 -E 'my $arg = shift; say "anteater" if $arg eq "муравьед"' муравьед

Capa PerlIO predeterminada

• i - UTF-8 es la capa PerlIO predeterminada para las secuencias de entrada
• o - UTF-8 es la capa PerlIO predeterminada para las secuencias de salida
• D - taquigrafía para io

perl -CD -Mutf8 -e 'open my $fh, ">", "utf8.txt" or die $!; print $fh " "'

https://riptutorial.com/es/home 110
-M interruptores -M y -C se pueden combinar:

perl -CASD -Mutf8 -E 'say "Ματαιότης ματαιοτήτων\n"';

E / S estándar

La codificación que se utilizará para los identificadores de binmode E / S estándar ( STDIN , STDOUT y
STDERR ) se puede configurar por separado para cada identificador utilizando binmode :

binmode STDIN, ':encoding(utf-8)';

binmode STDOUT, ':utf8';
binmode STDERR, ':utf8';

Nota: cuando se lee uno, en general, se prefiere :encoding(utf-8) sobre :utf8 , consulte
Observaciones para obtener más información.

Alternativamente, puede utilizar el pragma open .

# Setup such that all subsequently opened input streams will use ':encoding(utf-8)'
# and all subsequently opened output streams will use ':utf8'
# by default
use open (IN => ':encoding(utf-8)', OUT => ':utf8');
# Make the (already opened) standard file handles inherit the setting
# given by the IO settings for the open pragma
use open ( :std );
# Now, STDIN has been converted to ':encoding(utf-8)', and
# STDOUT and STDERR have ':utf8'

Alternativamente, para configurar todos los identificadores de archivo (tanto los que aún no se
han abierto como los estándar) para usar :encoding(utf-8) :

use open qw( :encoding(utf-8) :std );

Manijas de archivo

Configuración de la codificación con Open ()

Al abrir un archivo de texto, puede especificar su codificación explícitamente con un open() tres
argumentos open() . Este en- / decodificador adjunto a un identificador de archivo se llama "capa
de E / S":

my $filename = '/path/to/file';
open my $fh, '<:encoding(utf-8)', $filename or die "Failed to open $filename: $!";

Vea Observaciones para una discusión de las diferencias entre :utf8 y :encoding(utf-8) .

https://riptutorial.com/es/home 111
Configuración de la codificación con
binmode ()
Alternativamente, puede usar binmode () para establecer la codificación para el identificador de
archivo individual:

my $filename = '/path/to/file';
open my $fh, '<', $filename or die "Failed to open $filename: $!";
binmode $fh, ':encoding(utf-8)';

pragma abierto
Para evitar establecer la codificación para cada identificador de archivo por separado, puede usar
el pragma open para establecer una capa de E / S predeterminada utilizada por todas las llamadas
subsiguientes a la función open() y operadores similares dentro del alcance léxico de este
pragma:

# Set input streams to ':encoding(utf-8)' and output streams to ':utf8'

use open (IN => ':encoding(utf-8)', OUT => ':utf8');
# Or to set all input and output streams to ':encoding(utf-8)'
use open ':encoding(utf-8)';

Configuración de la codificación con la línea

de comando -C bandera
Finalmente, también es posible ejecutar el intérprete perl con un indicador -CD que aplica UTF-8
como la capa de E / S predeterminada. Sin embargo, esta opción debe evitarse, ya que se basa
en un comportamiento específico del usuario que no se puede predecir ni controlar.

El pragma utf8: usando Unicode en tus fuentes

El pragma utf8 indica que el código fuente se interpretará como UTF-8. Por supuesto, esto solo
funcionará si su editor de texto también guarda la fuente como codificación UTF-8.

Ahora, los literales de cadena pueden contener caracteres Unicode arbitrarios; los identificadores
también pueden contener caracteres Unicode pero solo de tipo palabra (consulte perldata y
perlrecharclass para obtener más información):

use utf8;
my $var1 = '§я§© '; # works fine
my $я = 4; # works since я is a word (matches \w) character
my $p§2 = 3; # does not work since § is not a word character.
say "ya" if $var1 =~ /я§/; # works fine (prints "ya")

https://riptutorial.com/es/home 112
Nota : al imprimir texto en el terminal, asegúrese de que sea compatible con UTF-8. *

Puede haber relaciones complejas y contraintuitivas entre la salida y la codificación de origen. Al

ejecutarse en una terminal UTF-8, puede encontrar que agregar el pragma utf8 parece romper las
cosas:

$ perl -e 'print "Møøse\n"'

Møøse
$ perl -Mutf8 -e 'print "Møøse\n"'
M��se
$ perl -Mutf8 -CO -e 'print "Møøse\n"'
Møøse

En el primer caso, Perl trata la cadena como bytes en bruto y los imprime así. Como estos bytes
son UTF-8 válidos, se ven correctos aunque Perl realmente no sabe qué caracteres son (por
ejemplo, la length("Møøse") devolverá 7, no 5). Una vez que agrega -Mutf8 , Perl decodifica
correctamente la fuente UTF-8 en caracteres, pero la salida está en modo Latin-1 por defecto y la
impresión de Latin-1 en un terminal UTF-8 no funciona. Solo cuando cambie STDOUT a UTF-8
usando -CO , la salida será correcta.

use utf8 no afecta la codificación de E / S estándar ni los manejadores de archivos!

Manejo de UTF-8 inválido

Lectura inválida de UTF-8

Al leer datos codificados en UTF-8, es importante tener en cuenta el hecho de que los datos
codificados en UTF-8 pueden ser inválidos o mal formados. Dichos datos generalmente no
deberían ser aceptados por su programa (a menos que sepa lo que está haciendo). Cuando se
encuentran datos malformados inesperadamente, se pueden considerar diferentes acciones:

• Imprima el seguimiento de pila o el mensaje de error, y cancele el programa correctamente,

o
• Inserte un carácter de sustitución en el lugar donde apareció la secuencia de bytes con
formato incorrecto, imprima un mensaje de advertencia a STDERR y continúe leyendo
mientras no sucede nada.

Por defecto, Perl le warn acerca de la codificación de fallos, pero no abortará su programa. Puede
hacer que su programa aborte haciendo que las advertencias de UTF-8 sean fatales, pero tenga
en cuenta las advertencias en Advertencias fatales .

El siguiente ejemplo escribe 3 bytes en la codificación ISO 8859-1 al disco. A continuación,

intenta volver a leer los bytes de nuevo como datos codificados en UTF-8. Uno de los bytes, 0xE5 ,
es una secuencia de un byte UTF-8 no válida:

use strict;
use warnings;
use warnings FATAL => 'utf8';

https://riptutorial.com/es/home 113
 binmode STDOUT, ':utf8';
binmode STDERR, ':utf8';
my $bytes = "\x{61}\x{E5}\x{61}"; # 3 bytes in iso 8859-1: aåa
my $fn = 'test.txt';
open ( my $fh, '>:raw', $fn ) or die "Could not open file '$fn': $!";
print $fh $bytes;
close $fh;
open ( $fh, "<:encoding(utf-8)", $fn ) or die "Could not open file '$fn': $!";
my $str = do { local $/; <$fh> };
close $fh;
print "Read string: '$str'\n";

El programa abortará con una advertencia fatal:

utf8 "\xE5" does not map to Unicode at ./test.pl line 10.

La línea 10 es aquí la segunda última línea, y el error se produce en la parte de la línea con <$fh>
cuando se intenta leer una línea del archivo.

Si no hace que las advertencias sean fatales en el programa anterior, Perl seguirá imprimiendo la
advertencia. Sin embargo, en este caso, intentará recuperarse del byte 0xE5 con formato
incorrecto insertando los cuatro caracteres \xE5 en el flujo y luego continuará con el siguiente
byte. Como resultado, el programa imprimirá:

Read string: 'a\xE5a'

Lea Unicode en línea: https://riptutorial.com/es/perl/topic/4375/unicode

https://riptutorial.com/es/home 114
Capítulo 38: Variables
Sintaxis
• mi # declaración léxica
• nuestra # declaración global
• $ foo # escalar
• @foo # Array
• $ # foo # Array Last-Index
• % foo # Hash
• $ {$ foo} # Decalar referencia
• @ {$ foo} # Array De-Reference
• $ # {$ foo} # Array-DeRef Last-Index
• % {$ foo} # Hash De-Reference
• $ foo [$ index] # Array se indexa
• $ {$ foo} [$ index] # Array De-Reference y se indexa.
• $ foo -> [$ index] # Array De-Reference y se indexa (simplificado)
• $ foo {$ clave} # Hash obtener valor por clave
• $ {$ foo} {$ clave} # Hash Dereference y obtener valor por clave
• $ foo -> {$ clave} # Hash Dereference y obtener valor por clave (simplificado)
• \ $ x # Referencia a escalar
• \ @x # Referencia a Array
• \% x # Referencia al hash
• = [] # Referencia a una matriz anónima (en línea)
• = {} # Referencia a Hash anónimo (en línea)

Examples
Escalares

Los escalares son el tipo de datos más básico de Perl. Están marcados con el sigil $ y tienen un
solo valor de uno de tres tipos:

• un número ( 3 , 42 , 3.141 , etc.)

• una cadena ( 'hi' , "abc" , etc.)
• una referencia a una variable (ver otros ejemplos).

my $integer = 3; # number
my $string = "Hello World"; # string
my $reference = \$string; # reference to $string

Perl convierte entre números y cadenas sobre la marcha , según lo que espera un operador
en particular.

my $number = '41'; # string '41'

https://riptutorial.com/es/home 115
 my $meaning = $number + 1; # number 42
my $sadness = '20 apples'; # string '20 apples'
my $danger = $sadness * 2; # number '40', raises warning

Al convertir una cadena en un número, Perl toma tantos dígitos del frente de una cadena como
puede, de ahí que 20 apples se conviertan en 20 en la última línea.

En función de si desea tratar el contenido de un escalar como una cadena o un número, debe
utilizar diferentes operadores. No los mezcle.

# String comparison # Number comparison

'Potato' eq 'Potato'; 42 == 42;
'Potato' ne 'Pomato'; 42 != 24;
'Camel' lt 'Potato'; 41 < 42;
'Zombie' gt 'Potato'; 43 > 42;

# String concatenation # Number summation

'Banana' . 'phone'; 23 + 19;

# String repetition # Number multiplication

'nan' x 3; 6 * 7;

Intentar usar operaciones de cadena en números no generará advertencias; intentar usar

operaciones numéricas en cadenas no numéricas lo hará. Tenga en cuenta que algunas cadenas
sin dígitos, como 'inf' , 'nan' , '0 but true' cuentan como números.

Arrays

Las matrices almacenan una secuencia ordenada de valores. Puede acceder a los contenidos por
índice, o iterar sobre ellos. Los valores se mantendrán en el orden en que los completó.

my @numbers_to_ten = (1,2,3,4,5,6,7,8,9,10); # More conveniently: (1..10)

my @chars_of_hello = ('h','e','l','l','o');
my @word_list = ('Hello','World');

# Note the sigil: access an @array item with $array[index]

my $second_char_of_hello = $chars_of_hello[1]; # 'e'

# Use negative indices to count from the end (with -1 being last)
my $last_char_of_hello = $chars_of_hello[-1];

# Assign an array to a scalar to get the length of the array

my $length_of_array = @chars_of_hello; # 5

# You can use $# to get the last index of an array, and confuse Stack Overflow
my $last_index_of_array = $#chars_of_hello; # 4

# You can also access multiple elements of an array at the same time
# This is called "array slice"
# Since this returns multiple values, the sigil to use here on the RHS is @
my @some_chars_of_hello = @chars_of_hello[1..3]; # ('H', 'e', 'l')
my @out_of_order_chars = @chars_of_hello[1,4,2]; # ('e', 'o', 'l')

# In Python you can say array[1:-1] to get all elements but first and last
# Not so in Perl: (1..-1) is an empty list. Use $# instead

https://riptutorial.com/es/home 116
 my @empty_list = @chars_of_hello[1..-1]; # ()
my @inner_chars_of_hello = @chars_of_hello[1..$#chars_of_hello-1]; # ('e','l','l')

# Access beyond the end of the array yields undef, not an error
my $undef = $chars_of_hello[6]; # undef

Las matrices son mutables:

use utf8; # necessary because this snippet is utf-8

$chars_of_hello[1] = 'u'; # ('h','u','l','l','o')
push @chars_of_hello, ('!', '!'); # ('h','u','l','l','o','!','!')
pop @chars_of_hello; # ('h','u','l','l','o','!')
shift @chars_of_hello; # ('u','l','l','o','!')
unshift @chars_of_hello, ('¡', 'H'); # ('¡','H','u','l','l','o','!')
@chars_of_hello[2..5] = ('O','L','A'); # ('¡','H','O','L','A',undef,'!') whoops!
delete $chars_of_hello[-2]; # ('¡','H','O','L','A', '!')

# Setting elements beyond the end of an array does not result in an error
# The array is extended with undef's as necessary. This is "autovivification."
my @array; # ()
my @array[3] = 'x'; # (undef, undef, undef, 'x')

Finalmente, puedes recorrer el contenido de una matriz:

use v5.10; # necessary for 'say'

for my $number (@numbers_to_ten) {
say $number ** 2;
}

Cuando se usan como valores booleanos, las matrices son verdaderas si no están vacías.

Hashes

Hashes puede entenderse como tablas de búsqueda. Puedes acceder a su contenido

especificando una clave para cada uno de ellos. Las llaves deben ser cadenas. Si no lo son, se
convertirán en cadenas.

Si le da al hash simplemente una clave conocida, le servirá su valor.

# Elements are in (key, value, key, value) sequence

my %inhabitants_of = ("London", 8674000, "Paris", 2244000);

# You can save some typing and gain in clarity by using the "fat comma"
# syntactical sugar. It behaves like a comma and quotes what's on the left.
my %translations_of_hello = (spanish => 'Hola', german => 'Hallo', swedish => 'Hej');

En el siguiente ejemplo, note los corchetes y el sigilo: accede a un elemento de %hash usando
$hash{key} porque el valor que desea es un escalar. Algunos consideran una buena práctica citar
la clave, mientras que otros encuentran este estilo visualmente ruidoso. Solo se requieren citas
para las claves que podrían confundirse con expresiones como $hash{'some-key'}

my $greeting = $translations_of_hello{'spanish'};

https://riptutorial.com/es/home 117
Mientras que Perl por defecto intentará usar las palabras peladas como cadenas, el modificador +
también se puede usar para indicar a Perl que la clave no debe interpolarse sino ejecutarse, y el
resultado de la ejecución se usa como una clave:

my %employee = ( name => 'John Doe', shift => 'night' );

# this example will print 'night'
print $employee{shift};

# but this one will execute [shift][1], extracting first element from @_,
# and use result as a key
print $employee{+shift};

Al igual que con las matrices, puede acceder a varios elementos hash al mismo tiempo. Esto se
llama una porción de hash . El valor resultante es una lista, así que use @ sigil:

my @words = @translations_of_hello{'spanish', 'german'}; # ('Hola', 'Hallo')

Iterar sobre las claves de un hash con keys keys devolverá los elementos en un orden aleatorio.
Combina con el sort si lo deseas.

for my $lang (sort keys %translations_of_hello) {

say $translations_of_hello{$lang};
}

Si no necesita las claves como en el ejemplo anterior, los values devuelven los valores de hash
directamente:

for my $translation (values %translations_of_hello) {

say $translation;
}

También puede usar un bucle while con each para iterar sobre el hash. De esta manera, obtendrá
la clave y el valor al mismo tiempo, sin una búsqueda de valor por separado. Sin embargo, se
desaconseja su uso, ya que each puede romper en formas de confusión.

# DISCOURAGED
while (my ($lang, $translation) = each %translations_of_hello) {
say $translation;
}

El acceso a los elementos no configurados devuelve undef, no un error:

my $italian = $translations_of_hello{'italian'}; # undef

map y el aplanamiento de listas se pueden utilizar para crear hashes a partir de matrices. Esta es
una forma popular de crear un 'conjunto' de valores, por ejemplo, para verificar rápidamente si un
valor está en @elems . Esta operación generalmente toma tiempo O (n) (es decir, proporcional al
número de elementos) pero se puede hacer en tiempo constante (O (1)) al convertir la lista en un
hash:

https://riptutorial.com/es/home 118
 @elems = qw(x y x z t);
my %set = map { $_ => 1 } @elems; # (x, 1, y, 1, t, 1)
my $y_membership = $set{'y'}; # 1
my $w_membership = $set{'w'}; # undef

Esto requiere alguna explicación. El contenido de @elems se lee en una lista, que se procesa por
map . map acepta un bloque de código al que se llama para cada valor de su lista de entrada; El
valor del elemento está disponible para su uso en $_ . Nuestro bloque de código devuelve dos
elementos de lista para cada elemento de entrada: $_ , el elemento de entrada y 1 , solo un valor.
Una vez que tenga en cuenta el aplanamiento de listas, el resultado es que el map { $_ => 1 }
@elems convierte qw(xyxzt) en (x => 1, y => 1, x => 1, z => 1, t => 1) .

A medida que esos elementos se asignan al hash, los elementos impares se convierten en claves
hash e incluso los elementos se convierten en valores hash. Cuando se especifica una clave
varias veces en una lista para asignarla a un hash, el último valor gana. Esto efectivamente
descarta los duplicados.

Una forma más rápida de convertir una lista en un hash usa la asignación a una porción de hash.
Utiliza el operador x para multiplicar la lista de un solo elemento (1) por el tamaño de @elems , por
lo que hay un valor de 1 para cada una de las claves en el sector en el lado izquierdo:

@elems = qw(x y x z t);

my %set;
@set{@elems} = (1) x @elems;

La siguiente aplicación de hashes también explota el hecho de que los hashes y las listas a
menudo se pueden usar indistintamente para implementar la función nombrada args:

sub hash_args {
my %args = @_;
my %defaults = (foo => 1, bar => 0);
my %overrides = (__unsafe => 0);
my %settings = (%defaults, %args, %overrides);
}

# This function can then be called like this:

hash_args(foo => 5, bar => 3); # (foo => 5, bar => 3, __unsafe ==> 0)
hash_args(); # (foo => 1, bar => 0, __unsafe ==> 0)
hash_args(__unsafe => 1) # (foo => 1, bar => 0, __unsafe ==> 0)

Cuando se usan como valores booleanos, los hashes son verdaderos si no están vacíos.

Referencias escalares

Una referencia es una variable escalar (una prefijada por $ ) que "se refiere a" algunos otros
datos.

my $value = "Hello";
my $reference = \$value;
print $value; # => Hello
print $reference; # => SCALAR(0x2683310)

https://riptutorial.com/es/home 119
Para obtener los datos referidos, usted de referencia .

say ${$reference}; # Explicit prefix syntax

say $$reference; # The braces can be left out (confusing)

5.24.0

Nueva sintaxis de desreferenciación de postfix, disponible por defecto desde v5.24

use v5.24;
say $reference->$*; # New postfix notation

Este "valor sin referencia" se puede cambiar como si fuera la variable original.

${$reference} =~ s/Hello/World/;
print ${$reference}; # => World
print $value; # => World

Una referencia es siempre veraz , incluso si el valor al que se refiere es falsy (como 0 o "" ).

Es posible que desee una referencia escalar si:

• Desea pasar una cadena a una función y hacer que la modifique para usted sin que sea un
valor de retorno.

• Desea evitar explícitamente que Perl copie implícitamente el contenido de una cadena
grande en algún punto de su paso de funciones (especialmente relevante en Perls
anteriores sin cadenas de copia en escritura)

• Desea desambiguar los valores de tipo cadena con un significado específico, a partir de
cadenas que transmiten contenido, por ejemplo:

○ Desambiguar un nombre de archivo del contenido del archivo

○ Desambiguar el contenido devuelto de una cadena de error devuelta

• Desea implementar un modelo de objetos ligero de adentro hacia afuera, donde los objetos
entregados al código de llamada no lleven metadatos visibles para el usuario:

our %objects;
my $next_id = 0;
sub new {
my $object_id = $next_id++;
$objects{ $object_id } = { ... }; # Assign data for object
my $ref = \$object_id;
return bless( $ref, "MyClass" );
}

Referencias de Array

Las Referencias de Array son escalares ( $ ) que se refieren a Arrays.

https://riptutorial.com/es/home 120
 my @array = ("Hello"); # Creating array, assigning value from a list
my $array_reference = \@array;

Estos pueden ser creados más cortos de la siguiente manera:

my $other_array_reference = ["Hello"];

La modificación / uso de las referencias de matriz requiere primero la eliminación de referencias.

my @contents = @{ $array_reference }; # Prefix notation

my @contents = @$array_reference; # Braces can be left out

5.24.0

Nueva sintaxis de desreferenciación de postfix, disponible por defecto desde v5.24

use v5.24;
my @contents = $array_reference->@*; # New postfix notation

Al acceder a los contenidos de un arrayref por índice, puede utilizar el -> azúcar sintáctica.

my @array = qw(one two three); my $arrayref = [ qw(one two three) ]

my $one = $array[0]; my $one = $arrayref->[0];

A diferencia de los arrays, arrayrefs puede ser anidado:

my @array = ( (1, 0), (0, 1) ) # ONE array of FOUR elements: (1, 0, 0, 1)

my @matrix = ( [1, 0], [0, 1] ) # an array of two arrayrefs
my $matrix = [ [0, 1], [1, 0] ] # an arrayref of arrayrefs
# There is no namespace conflict between scalars, arrays and hashes
# so @matrix and $matrix _both_ exist at this point and hold different values.

my @diagonal_1 = ($matrix[0]->[1], $matrix[1]->[0]) # uses @matrix

my @diagonal_2 = ($matrix->[0]->[1], $matrix->[1]->[0]) # uses $matrix
# Since chained []- and {}-access can only happen on references, you can
# omit some of those arrows.
my $corner_1 = $matrix[0][1]; # uses @matrix;
my $corner_2 = $matrix->[0][1]; # uses $matrix;

Cuando se usa como booleano, las referencias son siempre ciertas.

Hash Referencias

Las referencias de hash son escalares que contienen un puntero a la ubicación de memoria que
contiene los datos de un hash. Debido a que el escalar apunta directamente al hash, cuando se
pasa a una subrutina, los cambios realizados en el hash no son locales a la subrutina como
ocurre con un hash normal, sino que son globales.

Primero, examinemos lo que sucede cuando pasas un hash normal a una subrutina y lo
modificamos allí:

https://riptutorial.com/es/home 121
 use strict;
use warnings;
use Data::Dumper;

sub modify
{
my %hash = @_;

$hash{new_value} = 2;

print Dumper("Within the subroutine");

print Dumper(\%hash);

return;
}

my %example_hash = (
old_value => 1,
);

modify(%example_hash);

print Dumper("After exiting the subroutine");

print Dumper(\%example_hash);

Lo que resulta en:

$VAR1 = 'Within the subroutine';

$VAR1 = {
'new_value' => 2,
'old_value' => 1
};
$VAR1 = 'After exiting the subroutine';
$VAR1 = {
'old_value' => 1
};

Observe que después de salir de la subrutina, el hash permanece inalterado; todos los cambios
fueron locales a la subrutina de modificación, porque pasamos una copia del hash, no el hash en
sí.

En comparación, cuando se pasa un hashref, se pasa la dirección al hash original, por lo que
cualquier cambio realizado dentro de la subrutina se hará al hash original:

use strict;
use warnings;
use Data::Dumper;

sub modify
{
my $hashref = shift;

# De-reference the hash to add a new value

$hashref->{new_value} = 2;

print Dumper("Within the subroutine");

print Dumper($hashref);

https://riptutorial.com/es/home 122
 return;
}

# Create a hashref
my $example_ref = {
old_value => 1,
};

# Pass a hashref to a subroutine

modify($example_ref);

print Dumper("After exiting the subroutine");

print Dumper($example_ref);

Esto resultará en:

$VAR1 = 'Within the subroutine';

$VAR1 = {
'new_value' => 2,
'old_value' => 1
};
$VAR1 = 'After exiting the subroutine';
$VAR1 = {
'new_value' => 2,
'old_value' => 1
};

Typeglobs, typeglob refs, manejadores de archivos y constantes

Un typeglob *foo contiene referencias a los contenidos de las variables globales con ese nombre:
$foo , @foo , $foo , &foo , etc. Puedes acceder a él como un hash y asignarlo para manipular las
tablas de símbolos directamente (¡malvado!).

use v5.10; # necessary for say

our $foo = "foo";
our $bar;
say ref *foo{SCALAR}; # SCALAR
say ${ *foo{SCALAR} }; # bar
*bar = *foo;
say $bar; # bar
$bar = 'egg';
say $foo; # egg

Los typeglobs se manejan más comúnmente cuando se trata de archivos. open , por ejemplo,
produce una referencia a un typeglob cuando se le pide que cree un identificador de archivo no
global:

use v5.10; # necessary for say

open(my $log, '> utf-8', '/tmp/log') or die $!; # open for writing with encoding
say $log 'Log opened';

# You can dereference this globref, but it's not very useful.
say ref $log; # GLOB
say (*{$log}->{IO} // 'undef'); # undef

https://riptutorial.com/es/home 123
 close $log or die $!;

Los typeglobs también se pueden usar para hacer variables globales de solo lectura, aunque el
use constant es un uso más amplio.

# Global constant creation

*TRUE = \('1');
our $TRUE;
say $TRUE; # 1
$TRUE = ''; # dies, "Modification of a read-only value attempted"

# use constant instead defines a parameterless function, therefore it's not global,
# can be used without sigils, can be imported, but does not interpolate easily.
use constant (FALSE => 0);
say FALSE; # 0
say &FALSE; # 0
say "${\FALSE}"; # 0 (ugh)
say *FALSE{CODE}; # CODE(0xMA1DBABE)

# Of course, neither is truly constant when you can manipulate the symbol table...
*TRUE = \('');
use constant (EVIL => 1);
*FALSE = *EVIL;

Sigilos

Perl tiene una serie de sigilos:

$scalar = 1; # individual value

@array = ( 1, 2, 3, 4, 5 ); # sequence of values
%hash = ('it', 'ciao', 'en', 'hello', 'fr', 'salut'); # unordered key-value pairs
&function('arguments'); # subroutine
*typeglob; # symbol table entry

Estos parecen sigilos, pero no son

\@array; # \ returns the reference of what's on the right (so, a reference to @array)
$#array; # this is the index of the last element of @array

Puedes usar llaves después del sigilo si así lo deseas. Ocasionalmente, esto mejora la legibilidad.

say ${value} = 5;

Mientras usa diferentes sigilos para definir variables de diferentes tipos, se puede acceder a la
misma variable de diferentes maneras en función de los sigilos que use.

%hash; # we use % because we are looking at an entire hash

$hash{it}; # we want a single value, however, that's singular, so we use $
$array[0]; # likewise for an array. notice the change in brackets.
@array[0,3]; # we want multiple values of an array, so we instead use @
@hash{'it','en'}; # similarly for hashes (this gives the values: 'ciao', 'hello')
%hash{'it','fr'}; # we want an hash with just some of the keys, so we use %

https://riptutorial.com/es/home 124
 # (this gives key-value pairs: 'it', 'ciao', 'fr', 'salut')

Esto es especialmente cierto de las referencias. Para utilizar un valor de referencia, puede
combinar los sigilos juntos.

my @array = 1..5; # This is an array

my $reference_to_an_array = \@array; # A reference to an array is a singular value
push @array, 6; # push expects an array
push @$reference_to_an_array, 7; # the @ sigil means what's on the right is an array
# and what's on the right is $reference_to_an_array
# hence: first a @, then a $

Aquí hay una manera quizás menos confusa de pensar en ello. Como vimos anteriormente,
puedes usar llaves para envolver lo que está a la derecha de un sigilo. Así que puedes pensar en
@{} como algo que toma una referencia de matriz y te da la matriz de referencia.

# pop does not like array references

pop $reference_to_an_array; # ERROR in Perl 5.20+
# but if we use @{}, then...
pop @{ $reference_to_an_array }; # this works!

Como resultado, @{} realidad acepta una expresión:

my $values = undef;
say pop @{ $values }; # ERROR: can't use undef as an array reference
say pop @{ $values // [5] } # undef // [5] gives [5], so this prints 5

... y el mismo truco funciona para otros sigilos, también.

# This is not an example of good Perl. It is merely a demonstration of this language feature
my $hashref = undef;
for my $key ( %{ $hashref // {} } ) {
"This doesn't crash";
}

... pero si el "argumento" a un sigilo es simple, puedes dejar las llaves.

say $$scalar_reference;
say pop @$array_reference;
for keys (%$hash_reference) { ... };

Las cosas pueden volverse excesivamente extravagantes. Esto funciona, pero por favor Perl
responsablemente.

my %hash = (it => 'ciao', en => 'hi', fr => 'salut');

my $reference = \%hash;
my $reference_to_a_reference = \$reference;

my $italian = $hash{it}; # Direct access

my @greets = @$reference{'it', 'en'}; # Dereference, then access as array
my %subhash = %$$reference_to_a_reference{'en', 'fr'} # Dereference ×2 then access as hash

https://riptutorial.com/es/home 125
Para el uso más normal, puede usar nombres de subrutina sin un sigilo. (Las variables sin un
sigilo generalmente se llaman "palabras peladas"). El & sigil solo es útil en un número limitado de
casos.

• Haciendo referencia a una subrutina:

sub many_bars { 'bar' x $_[0] }

my $reference = \&many_bars;
say $reference->(3); # barbarbar

• Llamando a una función ignorando su prototipo.

• Combinado con goto, como una llamada de función un poco rara que tiene el marco de
llamada actual reemplazado con la persona que llama. Piense en la llamada a la API de
Linux exec() , pero para las funciones.

Lea Variables en línea: https://riptutorial.com/es/perl/topic/1566/variables

https://riptutorial.com/es/home 126
Capítulo 39: Variables especiales
Observaciones
PARA HACER: Añadir más contenidos.

Examples
Variables especiales en perl:

1. $_ : el espacio predeterminado de entrada y búsqueda de patrones.

Ejemplo 1:

my @array_variable = (1 2 3 4);
foreach (@array_variable){
print $_."\n"; # $_ will get the value 1,2,3,4 in loop, if no other variable is
supplied.
}

Ejemplo 2:

while (<FH>){
chomp($_); # $_ refers to the iterating lines in the loop.
}

Las siguientes funciones usan $_ como argumento predeterminado:

abs, alarm, chomp, chop, chr, chroot, cos, defined, eval,

evalbytes, exp, fc, glob, hex, int, lc, lcfirst, length, log,
lstat, mkdir, oct, ord, pos, print, printf, quotemeta, readlink,
readpipe, ref, require, reverse (in scalar context only), rmdir,
say, sin, split (for its second argument), sqrt, stat, study,
uc, ucfirst, unlink, unpack.

2. @_ : Esta matriz contiene los argumentos pasados a la subrutina.

Ejemplo 1:

example_sub( $test1, $test2, $test3 );

sub example_sub {
my ( $test1, $test2, $test3 ) = @_;
}

Dentro de una subrutina, la matriz @_ contiene los argumentos pasados a esa subrutina. Dentro
de una subrutina, @_ es la matriz default para los operadores de matriz pop y shift .

Lea Variables especiales en línea: https://riptutorial.com/es/perl/topic/7962/variables-especiales

https://riptutorial.com/es/home 127
Capítulo 40: Verdadero y falso
Sintaxis
• undef # falso
• '' # Definido, falso
• 0 # Definido, Tiene Longitud, Falso
• '0' # definido, tiene longitud, falso

Observaciones
Perl no tiene un tipo de datos booleano, ni tiene ninguna false clave true o false como muchos
otros idiomas. Sin embargo, cada valor escalar se evaluará como verdadero o falso cuando se
evalúe en un contexto booleano (la condición en una instrucción if o un bucle while, por ejemplo).

Los siguientes valores se consideran falsos:

• '' , la cadena vacía. Esto es lo que devuelven los operadores de comparación incorporados
(por ejemplo, 0 == 1 )
• 0 , el número 0, incluso si lo escribes como 000 o 0.0
• '0' , la cadena que contiene un solo 0 dígitos
• undef , el valor indefinido
• Objetos que utilizan la sobrecarga para numerar / encadenar en valores falsos, como
JSON::false

Todos los demás valores son verdaderos:

• cualquier número distinto de cero, como 1 , 3.14 , 'NaN' o 'Inf'
• cualquier cadena que sea numéricamente 0 pero no literalmente la cadena '0' , como '00' ,
'0e0' , "0\n" y "abc" .
Si intencionalmente está devolviendo un valor numérico verdadero 0, prefiera '0E0' (usado
por módulos conocidos) o '0 but true' (usado por las funciones de Perl)
• cualquier otra cadena que no esté vacía, como ' ' , 'false'
• todas las referencias, incluso si hacen referencia a valores falsos, como \'' , [] o {}
• Una matriz o hash de valores falsos.

Los siguientes operadores se tratan normalmente para

devolver un valor booleano en contexto escalar:
• @a devuelve si la matriz está vacía o no

• %h devuelve si el hash está vacío o no

• grep

https://riptutorial.com/es/home 128
 devuelve si se encontraron elementos coincidentes o no

• @a = LIST y (LIST) = LIST devuelve si la LISTA del lado derecho produjo o no escalas

Examples
Lista de valores verdaderos y falsos

use feature qw( say );

# Numbers are true if they're not equal to 0.

say 0 ? 'true' : 'false'; # false
say 1 ? 'true' : 'false'; # true
say 2 ? 'true' : 'false'; # true
say -1 ? 'true' : 'false'; # true
say 1-1 ? 'true' : 'false'; # false
say 0e7 ? 'true' : 'false'; # false
say -0.00 ? 'true' : 'false'; # false

# Strings are true if they're not empty.

say 'a' ? 'true' : 'false'; # true
say 'false' ? 'true' : 'false'; # true
say '' ? 'true' : 'false'; # false

# Even if a string would be treated as 0 in numeric context, it's true if nonempty.

# The only exception is the string "0", which is false.
# To force numeric context add 0 to the string
say '0' ? 'true' : 'false'; # false
say '0.0' ? 'true' : 'false'; # true
say '0e0' ? 'true' : 'false'; # true
say '0 but true' ? 'true' : 'false'; # true
say '0 whargarbl' ? 'true' : 'false'; # true
say 0+'0 argarbl' ? 'true' : 'false'; # false

# Things that become numbers in scalar context are treated as numbers.

my @c = ();
my @d = (0);
say @c ? 'true' : 'false'; # false
say @d ? 'true' : 'false'; # true

# Anything undefined is false.

say undef ? 'true' : 'false'; # false

# References are always true, even if they point at something false

my @c = ();
my $d = 0;
say \@c ? 'true' : 'false'; # true
say \$d ? 'true' : 'false'; # true
say \0 ? 'true' : 'false'; # true
say \'' ? 'true' : 'false'; # true

Lea Verdadero y falso en línea: https://riptutorial.com/es/perl/topic/649/verdadero-y-falso

https://riptutorial.com/es/home 129
Creditos
S.
Capítulos Contributors
No

Alan Haggai Alavi, choroba, Christopher Bottoms, Community,

Empezando con Perl
1 datageist, Denis Ibaev, eddy85br, Eugen Konkov, Jon Ericson,
Language
Leon Timmermans, oals, Pro Q, rlandster, xfix

2 Aleatoriedad Christopher Bottoms, Rebecca Close, Zaid

3 Análisis XML cbmckay, Drav Sloan, eballes, Sobrique

Aplicaciones GUI en
4 oldtechaa
Perl

Archivo I / O (lectura Christopher Bottoms, Denis Ibaev, Håkon Hægland, Kemi, Kent
5 y escritura de Fredric, matt freake, Nagaraju, rbennett485, SajithP, Sebi,
archivos) SREagle, Tim Hallyburton, yonyon100

6 Bailarín Chankey Pathak, vanHoesel

7 Clasificación Jon Ericson, kjpires, mbethke

Comandos Perl para

Windows Excel con
8 Jean-Francois T.
Win32 :: módulo
OLE

9 Comentarios 4444, Christopher Bottoms, lanti, Rebecca Close

Compilar el módulo
sapnwrfc de Perl
10 flotux
cpan a partir del
código fuente

Cuerdas y métodos badp, Christopher Bottoms, Denis Ibaev, digitalis_, Kent Fredric,
11
de citar. mbethke, svarog

Declaraciones de
12 callyalater, Christopher Bottoms, oals, Stephen Leppik
control

Depuración de
13 4444, Eugen Konkov
scripts Perl

Dividir una cadena

14 en separadores sin DVK, Ian Praxil, serenesat
comillas

https://riptutorial.com/es/home 130
 Empacar y
15 Denis Ibaev, Kent Fredric, mbethke
desempacar

Expresiones Al.G., Jon Ericson, rlandster, SajithP, Sarwesh Suman, Stephen

16
regulares Leppik

17 Fechas y hora Ngoan Tran, waghso

18 Instalacion de perl fanlim, flamey, Håkon Hægland, Iván Rodríguez Torres, luistm

Instalar módulos Perl Christopher Bottoms, Kemi, luistm, Ngoan Tran, Peter
19
a través de CPAN Mortensen, Randall

Interacción simple
con la base de datos
20 Ngoan Tran
a través del módulo
DBI.

21 Interpolación en Perl oals, Ruslan Batdalov

Leyendo el
contenido de un Alien Life Form, Christopher Bottoms, digitalis_, Jeff Y, Kemi,
22
archivo en una mbethke, mob, pwes, rlandster, SREagle
variable

brian d foy, Christopher Bottoms, David Mertens, Denis Ibaev,

23 Liza DVK, Eugen Konkov, Muaaz Rafi, pwes, reflective_mind, Rick
James, Wolf

Manejo de
24 badp, simbabque
excepciones

25 Mejores prácticas fifaltra, interduo

Optimización del uso

26 mbethke
de la memoria.

Orientado a objetos
27 badp, Dmitry Egorov, Ruslan Batdalov, simbabque
Perl

AntonH, Christopher Bottoms, John Hart, Jon Ericson, Kemi,

28 Paquetes y módulos
Kent Fredric, lepe, mbethke

29 Perl one-liners Dmitry Egorov, Eugen Konkov, Kemi, mbethke, zb226

30 Perl Testing nslntmnx

31 Perlbrew Håkon Hægland

32 Salida de depuración Ataul Haque, Christopher Bottoms, Joe, simbabque, waghso

https://riptutorial.com/es/home 131
 badp, Christopher Bottoms, dave, digitalis_, interduo, mbethke,
33 Subrutinas
Michael Carman, msh210, Wolf, xfix, xtreak

34 Texto atribuido SajithP

Una forma sencilla

de comprobar los
35 fanlim, Ngoan Tran,
módulos instalados
en Mac y Ubuntu

36 Unicode Håkon Hægland, Kemi, Kent Fredric, mbethke

Ataul Haque, badp, digitalis_, dmvrtx, Eugen Konkov, Håkon

37 Variables Hægland, interduo, Jon Ericson, Kent Fredric, mbethke, Mik,
nfanta, oals, Otterbein, zb226

38 Variables especiales AbhiNickz, Denis Ibaev, oals

badp, Bill the Lizard, Christopher Bottoms, ikegami, Kent Fredric

39 Verdadero y falso
, mbethke, msh210, Ole Tange, xfix

https://riptutorial.com/es/home 132