perl-language-es

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 info@zzzprojects.com

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

5.8.8

perl581delta ,

perl582delta ,

perl583delta ,

perl584delta ,

perl585delta ,

perl586delta ,

perl587delta ,

Perl588delta

2006-02-01

5.10.0 perl5100delta 2007-12-18


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


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/empezandocon-perl-language


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 ...

0

Véase también el perldoc para rand .

Accediendo a un elemento del array al azar


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


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 //


__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>







<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();


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">


<author>Ralls, Kim</author>

<title>Midnight Rain</title>

<genre>Fantasy</genre>

<price>5.95</price>


<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>


<price>5.95</price>


<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>


<price>5.95</price>


<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


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


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-guien-perl


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';


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: $!";


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


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;


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;


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


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

autodie permite trabajar con archivos sin tener que verificar

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 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


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 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:


#!/bin/env perl

use strict;

use warnings;


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-archivoshttps://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


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 .


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


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


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

Celda 1

(requerido)

Cell2

(opcional)

Detalles

El nombre del rango. Esta debe ser una referencia de estilo A1 en el idioma

de la macro. Puede incluir el operador de rango (dos puntos), el operador

de intersección (un espacio) o el operador de unión (una coma).

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

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


Enlace para obtener información sobre las constantes de Excel: http://msdn.microsoft.com/enus/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')


|| 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)";

$Sheet->Range("C1")->{FormulaR1C1} = "=SUM(RC[-2]:RC[-1])";

# Sum of rows

# Sum of columns


#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;

text;

$Sheet -> Range("A1:A2") -> {Orientation} = 90;

text

# Center

# Rotate

#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};


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----moduloole


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


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


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");


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-delcodigo-fuente


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";


... 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';


{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;


{ 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 .


use feature 'say';

say "2 + 2 == @{[ 2 + 2 ]}";

say "2 + 2 == ${\( 2 + 2 )}";

# 2 + 2 = 4 (avoid this)

# 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


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-ymetodos-de-citar-


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;

}


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-decontrol


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:

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

• 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-descripts-perl


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


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


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 ) = @_;


}

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() :


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

B16

$id

sprintf("%03b%013b",

$flags, $frag_off)

Igual que DSCP / ECN

C2 $ttl, $proto Dos octetos sin firmar consecutivos

n

0 / $checksum

x podría utilizarse para insertar un byte nulo, pero n

nos permite especificar un argumento en el caso de

que decidamos calcular una suma de comprobación

N2

$src_ip, $dst_ip

¡use a4a4 para empaquetar el resultado de dos

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-ydesempacar


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/ } ],


[ 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


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/expresionesregulares


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,


);

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


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


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

OS X

Ver también Perlbrew.

Hay varias opciones:

• Perlbrew

# You need to install Command Line Tools for Xcode

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


• Perlbrew con soporte de hilo:

# You need to install Command Line Tools for Xcode


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


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.


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


• 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


Capítulo 21: Interacción simple con la base

de datos a través del módulo DBI.

Parámetros

Columna

$driver

$database

$userid

$password

$query

Columna

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

el nombre de su base de datos

su ID de base de datos

su contraseña de base de datos

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");


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

o

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-delmodulo-dbi-


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


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}

\o{350436}

\N{U+1d11e}

by hexadecimal code

by octal code

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


\012 octal

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

\c@

\ca

\cb

...

\cz

\c[

\c\

\c]

\c^

\c_

\c?

chr(0)

chr(1)

chr(2)

chr(26)

chr(27)

chr(28) # Cannot be used at the end of a string

# since backslash will interpolate the terminating quote

chr(29)

chr(30)

chr(31)

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


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.


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

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

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 .


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


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 .


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:


$_[0] += 2;

}

my $x = 7;

test_subroutine( $x );

print $x; # 9

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


my( $copy_arg1, $copy_arg2 ) = @_;

$copy_arg1 += 2;

}

my $x = 7;

test_subroutine $x; # in this case $copy_arg2 will have ùndef` value

print $x; # 7

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


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' )


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


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


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());


$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-deexcepciones


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.


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:


[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:


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 ùse

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 ùse overload'.

Backtick operator used at line 230, near 'my $filesystem_diff = join q{}, `diff


$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


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


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


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


}

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-memoriahttps://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.


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;


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;


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.


• 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(...);

3.

simplemente lo llamará.

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.


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;


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:


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:

Alce

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

• Class::Accessor - una alternativa ligera a Moose

• Class::Tiny - constructor de clase verdaderamente minimalista

package Foo;

use Moose;


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;


use Moose::Role;

requires 'introduce'; # a method consuming classes must implement

sub greet {

print "Hi!\n";

}

# a method already implemented in the role

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 {

print "Hi!\n";

}

# a method already implemented in the role

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-aobjetos-perl


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";


}

$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:


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:


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:


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

o

perl -MCPAN -e shell

Módulos de consulta


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


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:


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


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


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();


};

# 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


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


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


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


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 {


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';


$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);


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


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


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


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 ∑ # 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;


}

$value = prod 1..6; # 720

say defined ∏ # 1

}

say defined ∏ # 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


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


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-instaladosen-mac-y-ubuntu


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


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


• 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


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.



# 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/;

}


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 " "'


-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)';



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":


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) .


Configuración de la codificación con

binmode ()

Alternativamente, puede usar binmode () para establecer la codificación para el identificador de

archivo individual:


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")


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"'

Mse

$ 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';




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


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;

my $string = "Hello World";

my $reference = \$string;

# number

# 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'


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


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'};


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:


@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)


Para obtener los datos referidos, usted de referencia .

say ${$reference};

say $$reference;

# Explicit prefix syntax

# 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.


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

my @contents = @$array_reference;

# Prefix notation

# 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í:


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


}

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


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 %


# (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


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


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


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


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


say -1


say 1-1


say 0e7


say -0.00


# Strings are true if they're not empty.

say 'a'


say 'false' ? 'true' : 'false'; # true

say ''


# 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'


say '0.0'


say '0e0'


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


say @d


# Anything undefined is false.

say undef


# References are always true, even if they point at something false

my @c = ();

my $d = 0;

say \@c


say \$d


say \0


say \''


Lea Verdadero y falso en línea: https://riptutorial.com/es/perl/topic/649/verdadero-y-falso


Creditos

S.

No

Capítulos Contributors

1

Empezando con Perl

Language

Alan Haggai Alavi, choroba, Christopher Bottoms, Community,

datageist, Denis Ibaev, eddy85br, Eugen Konkov, Jon Ericson,

Leon Timmermans, oals, Pro Q, rlandster, xfix

2 Aleatoriedad Christopher Bottoms, Rebecca Close, Zaid

3 Análisis XML cbmckay, Drav Sloan, eballes, Sobrique

4

5

Aplicaciones GUI en

Perl

Archivo I / O (lectura

y escritura de

archivos)

oldtechaa

Christopher Bottoms, Denis Ibaev, Håkon Hægland, Kemi, Kent

Fredric, matt freake, Nagaraju, rbennett485, SajithP, Sebi,

SREagle, Tim Hallyburton, yonyon100

6 Bailarín Chankey Pathak, vanHoesel

7 Clasificación Jon Ericson, kjpires, mbethke

8

Comandos Perl para

Windows Excel con

Win32 :: módulo

OLE

Jean-Francois T.

9 Comentarios 4444, Christopher Bottoms, lanti, Rebecca Close

10

11

12

13

14

Compilar el módulo

sapnwrfc de Perl

cpan a partir del

código fuente

Cuerdas y métodos

de citar.

Declaraciones de

control

Depuración de

scripts Perl

Dividir una cadena

en separadores sin

comillas

flotux

badp, Christopher Bottoms, Denis Ibaev, digitalis_, Kent Fredric,

mbethke, svarog

callyalater, Christopher Bottoms, oals, Stephen Leppik

4444, Eugen Konkov

DVK, Ian Praxil, serenesat


15

16

Empacar y

desempacar

Expresiones

regulares

Denis Ibaev, Kent Fredric, mbethke

Al.G., Jon Ericson, rlandster, SajithP, Sarwesh Suman, Stephen

Leppik

17 Fechas y hora Ngoan Tran, waghso

18 Instalacion de perl fanlim, flamey, Håkon Hægland, Iván Rodríguez Torres, luistm

19

20

Instalar módulos Perl

a través de CPAN

Interacción simple

con la base de datos

a través del módulo

DBI.

Christopher Bottoms, Kemi, luistm, Ngoan Tran, Peter

Mortensen, Randall

Ngoan Tran

21 Interpolación en Perl oals, Ruslan Batdalov

22

Leyendo el

contenido de un

archivo en una

variable

Alien Life Form, Christopher Bottoms, digitalis_, Jeff Y, Kemi,

mbethke, mob, pwes, rlandster, SREagle

23 Liza

brian d foy, Christopher Bottoms, David Mertens, Denis Ibaev,

DVK, Eugen Konkov, Muaaz Rafi, pwes, reflective_mind, Rick

James, Wolf

24

Manejo de

excepciones

badp, simbabque

25 Mejores prácticas fifaltra, interduo

26

27

Optimización del uso

de la memoria.

Orientado a objetos

Perl

mbethke

badp, Dmitry Egorov, Ruslan Batdalov, simbabque

28 Paquetes y módulos

AntonH, Christopher Bottoms, John Hart, Jon Ericson, Kemi,

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


33 Subrutinas

badp, Christopher Bottoms, dave, digitalis_, interduo, mbethke,

Michael Carman, msh210, Wolf, xfix, xtreak

34 Texto atribuido SajithP

35

Una forma sencilla

de comprobar los

módulos instalados

en Mac y Ubuntu

fanlim, Ngoan Tran,

36 Unicode Håkon Hægland, Kemi, Kent Fredric, mbethke

37 Variables

Ataul Haque, badp, digitalis_, dmvrtx, Eugen Konkov, Håkon

Hægland, interduo, Jon Ericson, Kent Fredric, mbethke, Mik,

nfanta, oals, Otterbein, zb226

38 Variables especiales AbhiNickz, Denis Ibaev, oals

39 Verdadero y falso

badp, Bill the Lizard, Christopher Bottoms, ikegami, Kent Fredric

, mbethke, msh210, Ole Tange, xfix


perl-language-es

Create successful ePaper yourself

Delete template?

Save as template?