perlintro - Online en la nube

PROGRAMA:

NOMBRE

perlintro - una breve introducción y descripción general de Perl

DESCRIPCIÓN

Este documento está destinado a brindarle una descripción general rápida del lenguaje de programación Perl,
junto con sugerencias para obtener más documentación. Tiene la intención de ser una guía "bootstrap" para
aquellos que son nuevos en el idioma, y ​​proporciona la información suficiente para que pueda
para leer el Perl de otras personas y comprender aproximadamente lo que está haciendo, o escribir el suyo
guiones sencillos.

Este documento introductorio no pretende ser completo. Ni siquiera pretende ser
totalmente exacto. En algunos casos se ha sacrificado la perfección con el objetivo de conseguir
la idea general al otro lado. Usted está se mostró plenamente Se recomienda seguir esta introducción con más
información del manual completo de Perl, cuya tabla de contenido se puede encontrar en
perltoc.

A lo largo de este documento, verá referencias a otras partes de la documentación de Perl.
Puedes leer esa documentación usando el comando "perldoc" o cualquier método que estés
usando para leer este documento.

A lo largo de la documentación de Perl, encontrará numerosos ejemplos destinados a ayudar a explicar
las características discutidas. Tenga en cuenta que muchos de ellos son fragmentos de código en lugar de
que los programas completos.

Estos ejemplos a menudo reflejan el estilo y la preferencia del autor de esa pieza del
documentación, y puede ser más breve que una línea de código correspondiente en un programa real.
Excepto donde se indique lo contrario, debe asumir que "use estricto" y "use advertencias"
declaraciones aparecen anteriormente en el "programa", y que cualquier variable utilizada ya ha sido
declarado, incluso si esas declaraciones se han omitido para facilitar la lectura del ejemplo.

Tenga en cuenta que los ejemplos han sido escritos por muchos autores diferentes durante un período de
varias decadas. Por lo tanto, los estilos y las técnicas serán diferentes, aunque se ha realizado algún esfuerzo.
se ha hecho para no variar los estilos demasiado en las mismas secciones. No consideres un estilo
ser mejor que los demás: "Hay más de una manera de hacerlo" es uno de los lemas de Perl.
Después de todo, en su viaje como programador, es probable que encuentre diferentes estilos.

Qué is Perl?
Perl es un lenguaje de programación de propósito general desarrollado originalmente para la manipulación de texto.
y ahora se utiliza para una amplia gama de tareas, incluida la administración del sistema, el desarrollo web,
programación de redes, desarrollo de GUI y más.

El lenguaje está destinado a ser práctico (fácil de usar, eficiente, completo) en lugar de
hermoso (diminuto, elegante, minimalista). Sus principales características son que es fácil de usar,
Admite programación tanto procedimental como orientada a objetos (OO), tiene una potente función incorporada
soporte para el procesamiento de texto, y tiene una de las colecciones más impresionantes del mundo de
módulos de terceros.

Se dan diferentes definiciones de Perl en perl, perlfaq1 y sin duda en otros lugares. De
esto podemos determinar que Perl es cosas diferentes para diferentes personas, pero que muchos
la gente piensa que al menos vale la pena escribir sobre él.

Correr Perl programas
Para ejecutar un programa Perl desde la línea de comandos de Unix:

programaperl.pl

Alternativamente, ponga esto como la primera línea de su secuencia de comandos:

#!/ usr / bin / env perl

... y ejecuta el script como /ruta/a/script.pl. Por supuesto, deberá ser ejecutable.
primero, entonces "chmod 755 script.pl" (bajo Unix).

(Esta línea de salida asume que tienes el env programa. También puede poner directamente la ruta a
su ejecutable de perl, como en "#!/ usr / bin / perl").

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

Seguridad red
Perl por defecto es muy indulgente. Para hacerlo más robusto se recomienda
inicie cada programa con las siguientes líneas:

#!/ usr / bin / perl
uso estricto
use advertencias;

Las dos líneas adicionales solicitan a perl detectar varios problemas comunes en su código.
Verifican diferentes cosas, por lo que necesita ambas. Un problema potencial detectado por "use estricto";
hará que su código se detenga inmediatamente cuando se encuentre, mientras que "use advertencias";
simplemente dará una advertencia (como el interruptor de línea de comando -w) y deje que su código se ejecute. Para
Lea más sobre ellos consulte sus respectivas páginas de manual en estrictas y advertencias.

Básico sintaxis visión de conjunto
Un script o programa de Perl consta de una o más declaraciones. Estas declaraciones son simplemente
escrito en el guión de una manera sencilla. No es necesario tener un "main ()"
función o algo por el estilo.

Las declaraciones de Perl terminan en punto y coma:

imprimir "Hola, mundo";

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

# Esto es un comentario

El espacio en blanco es irrelevante:

Imprimir
"Hola Mundo"
;

... excepto dentro de las cadenas entre comillas:

# esto se imprimiría con un salto de línea en el medio
imprimir "Hola
mundo";

Se pueden usar comillas dobles o simples alrededor de cadenas literales:

imprimir "Hola, mundo";
imprimir 'Hola, mundo';

Sin embargo, solo las comillas dobles "interpolan" variables y caracteres especiales como
nuevas líneas ("\ n"):

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

Los números no necesitan comillas alrededor de ellos:

imprimir 42;

Puede usar paréntesis para los argumentos de las funciones u omitirlos según su
gusto. Solo se requieren ocasionalmente para aclarar cuestiones de precedencia.

print ("Hola, mundo \ n");
imprimir "Hola, mundo \ n";

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

Perl variable tipos
Perl tiene tres tipos de variables principales: escalares, matrices y hashes.

Escalares
Un escalar representa un valor único:

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

Los valores escalares pueden ser cadenas, enteros o números de coma flotante, y Perl
convertir automáticamente entre ellos según sea necesario. No es necesario declarar previamente su
tipos de variables, pero tienes que declararlos con la palabra clave "my" la primera vez que
usalos, usalos a ellos. (Este es uno de los requisitos de "uso estricto".)

Los valores escalares se pueden utilizar de varias formas:

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

Hay varios escalares "mágicos" con nombres que parecen signos de puntuación o líneas.
ruido. Estas variables especiales se utilizan para todo tipo de propósitos y están documentadas
en perlvar. El único que debe conocer por ahora es $ _, que es el "valor predeterminado
variable ". Se utiliza como argumento predeterminado para una serie de funciones en Perl, y
se establece implícitamente mediante ciertas construcciones de bucle.

impresión; # imprime el contenido de $ _ por defecto

Matrices
Una matriz representa una lista de valores:

my @animals = ("camello", "llama", "búho");
mis @números = (23, 42, 69);
mi @mixed = ("camello", 42, 1.23);

Las matrices están indexadas a cero. Así es como se llega a los elementos de una matriz:

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

La variable especial $ # matriz le dice el índice del último elemento de una matriz:

imprimir $ mixto [$ # mixto]; # último elemento, imprime 1.23

Puede tener la tentación de usar "$ # array + 1" para decirle cuántos elementos hay en una
formación. No se moleste. Da la casualidad de que usar @array donde Perl espera encontrar un escalar
value ("en contexto escalar") le dará el número de elementos en la matriz:

si (@animals <5) {...}

Los elementos que obtenemos de la matriz comienzan con un "$" porque solo obtenemos
un solo valor fuera de la matriz; pides un escalar, obtienes un escalar.

Para obtener varios valores de una matriz:

@animals [0,1]; # da ("camello", "llama");
@animals [0..2]; # da ("camello", "llama", "búho");
@animals [1 .. $ # animales]; # da todo excepto el primer elemento

Esto se denomina "sector de matriz".

Puede hacer varias cosas útiles con las listas:

my @ordenado = ordenar @animales;
mi @hacia atrás = invertir @números;

También hay un par de matrices especiales, como @ARGV (los argumentos de la línea de comando para
su script) y @_ (los argumentos pasados ​​a una subrutina). Estos están documentados en
perlvar.

Hashes
Un hash representa un conjunto de pares clave / valor:

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

Puede usar espacios en blanco y el operador "=>" para diseñarlos mejor:

my% fruit_color = (
manzana => "rojo",
banana => "amarillo",
);

Para obtener elementos hash:

$ fruit_color {"manzana"}; # da "rojo"

Puede obtener listas de claves y valores con "claves ()" y "valores ()".

my @fruits = keys% fruit_colors;
mis @colors = valores% fruit_colors;

Los hash no tienen un orden interno particular, aunque puede ordenar las claves y el bucle
a través de ellos.

Al igual que los escalares y matrices especiales, también hay hash especiales. El mas bien
conocido de estos es% ENV que contiene variables de entorno. Lea todo sobre esto (y
otras variables especiales) en perlvar.

Los escalares, matrices y hashes se documentan de forma más completa en perldata.

Se pueden construir tipos de datos más complejos usando referencias, que le permiten construir
listas y hashes dentro de listas y hashes.

Una referencia es un valor escalar y puede hacer referencia a cualquier otro tipo de datos de Perl. Entonces, al almacenar un
referencia como el valor de una matriz o elemento hash, puede crear fácilmente listas y hash
dentro de listas y hashes. El siguiente ejemplo muestra un hash de 2 niveles de estructura hash
utilizando referencias hash anónimas.

my $ variables = {
escalar => {
description => "artículo único",
sigil => '$',
},
array => {
description => "lista ordenada de elementos",
sigil => '@',
},
hash => {
description => "pares clave / valor",
sigil => '%',
},
};

print "Los escalares comienzan con $ variables -> {'escalar'} -> {'sigil'} \ n";

Se puede encontrar información exhaustiva sobre el tema de las referencias en perlreftut, perllol,
perlref y perldsc.

Variable alcance
A lo largo de la sección anterior, todos los ejemplos han utilizado la sintaxis:

my $ var = "valor";

El "mi" en realidad no es obligatorio; solo podrías usar:

$ var = "valor";

Sin embargo, el uso anterior creará variables globales en todo su programa, que es
mala práctica de programación. "mi" crea variables de ámbito léxico en su lugar. Las variables
tienen el alcance del bloque (es decir, un grupo de declaraciones rodeadas por llaves) en el que
están definidos.

my $ x = "foo";
my $ alguna_condición = 1;
if ($ alguna_condición) {
my $ y = "barra";
imprimir $ x; # imprime "foo"
imprimir $ y; # imprime "barra"
}
imprimir $ x; # imprime "foo"
imprimir $ y; # no imprime nada; $ y ha caído fuera de alcance

Usando "mi" en combinación con un "uso estricto"; en la parte superior de sus scripts de Perl significa que
el intérprete detectará ciertos errores de programación comunes. Por ejemplo, en el
ejemplo anterior, la "impresión $ y" final causaría un error en tiempo de compilación y le impediría
ejecutando el programa. Se recomienda encarecidamente utilizar "estricto".

Condicional y bucle construcciones
Perl tiene la mayoría de las construcciones condicionales y de bucle habituales. A partir de Perl 5.10, incluso
tiene una instrucción case / switch (deletreada "dado" / "cuando"). Ver "Cambiar declaraciones" en perlsyn
para obtener más información.

Las condiciones pueden ser cualquier expresión de Perl. Consulte la lista de operadores en la siguiente sección.
para obtener información sobre los operadores lógicos de comparación y booleanos, que se utilizan comúnmente en
declaraciones condicionales.

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

También hay una versión negada:

a menos que (condición) {
...
}

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

Tenga en cuenta que las llaves son necesarias en Perl, incluso si solo tiene una línea en el
cuadra. Sin embargo, existe una forma inteligente de hacer que sus bloques condicionales de una línea sean más
Inglés como:

# la forma tradicional
if ($ zippy) {
imprimir "¡Yow!";
}

# la forma de poscondición de Perlish
imprimir "¡Yow!" si $ zippy;
imprimir "No tenemos bananas" a menos que $ bananas;

mientras
while (condición) {
...
}

También hay una versión negada, por la misma razón que tenemos "a menos que":

hasta (condición) {
...
}

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

imprimir "LA LA LA \ n" mientras que 1; # bucles para siempre

para Exactamente como C:

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

El estilo C para bucle rara vez se necesita en Perl, ya que Perl proporciona el estilo más amigable.
lista de exploración del bucle "foreach".

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

imprimir $ lista [$ _] para cada 0 .. $ max;

# tampoco tienes que usar el $ _ predeterminado ...
foreach my $ key (claves% hash) {
print "El valor de $ key es $ hash {$ key} \ n";
}

La palabra clave "foreach" es en realidad un sinónimo de la palabra clave "for". Ver "" Foreach
Bucles "en perlsyn".

Para obtener más detalles sobre las construcciones de bucle (y algunas que no se mencionaron en esta descripción general)
ver perlsyn.

incorporado operadores y funciones
Perl viene con una amplia selección de funciones integradas. Algunos de los que ya tenemos
que se ven incluyen "imprimir", "ordenar" y "invertir". Se da una lista de ellos al comienzo de
perlfunc y puede leer fácilmente sobre cualquier función dada usando "perldoc -f
nombre de la función".

Los operadores de Perl están documentados en su totalidad en Perlop, pero aquí se muestran algunos de los más comunes.
unos

Aritmética
+ adición
- resta
* multiplicación
/ división

Comparación numérica
== igualdad
! = desigualdad
<menor que
> mayor que
<= menor o igual que
> = mayor o igual que

Comparación de cadenas
igualdad eq
ne desigualdad
es menos que
gt mayor que
le menor o igual
ge mayor o igual

(¿Por qué tenemos comparaciones numéricas y de cadenas separadas? Porque no tenemos
tipos de variables especiales, y Perl necesita saber si ordenar numéricamente (donde 99
es menor que 100) o alfabéticamente (donde 100 viene antes de 99).

lógica booleana
&& y
|| o
! no

("y", "o" y "no" no se encuentran solo en la tabla anterior como descripciones del
operadores. También se les admite como operadores por derecho propio. Son mas
legible que los operadores de estilo C, pero tienen una precedencia diferente a "&&" y
amigos. Consulte perlop para obtener más detalles).

Misceláneos
= asignación
. concatenación de cadenas
x multiplicación de cadenas
.. operador de rango (crea una lista de números o cadenas)

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

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

Archivos y I / O
Puede abrir un archivo para entrada o salida usando la función "abrir ()". Esta documentado en
detalle extravagante en perlfunc y perlopentut, pero en resumen:

abrir (my $ in, "<", "input.txt") o morir "¡No se puede abrir input.txt: $!";
open (my $ out, ">", "output.txt") o muere "No se puede abrir output.txt: $!";
abrir (my $ log, ">>", "my.log") o morir "¡No se puede abrir my.log: $!";

Puede leer desde un identificador de archivo abierto utilizando el operador "<>". En contexto escalar se lee
una sola línea del identificador de archivo, y en el contexto de la lista lee todo el archivo en,
asignando cada línea a un elemento de la lista:

mi $ línea = <$ en>;
my @lines = <$ en>;

Leer todo el archivo a la vez se denomina sorber. Puede ser útil pero puede ser
un cerdo de memoria. La mayor parte del procesamiento de archivos de texto se puede hacer una línea a la vez con el bucle de Perl
construcciones

El operador "<>" se ve con mayor frecuencia en un bucle "while":

while (<$ in>) {# asigna cada línea a su vez a $ _
print "Solo lee en esta línea: $ _";
}

Ya hemos visto cómo imprimir en salida estándar usando "print ()". Sin embargo, "print ()"
también puede tomar un primer argumento opcional que especifique en qué identificador de archivo imprimir:

print STDERR "Esta es tu última advertencia. \ n";
imprimir $ registro $;
imprimir $ log $ logmessage;

Cuando haya terminado con los identificadores de archivos, debe "cerrarlos ()" (aunque, para ser honesto,
Perl limpiará después de ti si lo olvidas):

cerrar $ in o morir "$ in: $!";

Regular expresiones
El soporte de expresiones regulares de Perl es amplio y profundo, y es objeto de extensos
documentación en perlrequick, perlretut y en otros lugares. Sin embargo, en resumen:

Emparejamiento simple
if (/ foo /) {...} # verdadero si $ _ contiene "foo"
if ($ a = ~ / foo /) {...} # true si $ a contiene "foo"

El operador de coincidencia "//" está documentado en perlop. Opera en $ _ por defecto, o
se puede vincular a otra variable usando el operador de vinculación "= ~" (también documentado en
Perlo).

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

El operador de sustitución "s ///" está documentado en perlop.

Expresiones regulares más complejas
No solo tiene que hacer coincidir cadenas fijas. De hecho, puede hacer coincidir casi
cualquier cosa con la que puedas soñar usando expresiones regulares más complejas. Estos son
documentado extensamente en perlre, pero mientras tanto, aquí hay un truco rápido
hoja:

. un solo personaje
\ sa carácter de espacio en blanco (espacio, tabulación, nueva línea,
...)
\ S carácter que no es un espacio en blanco
\ da dígito (0-9)
\ D un no dígito
\ wa carácter de palabra (az, AZ, 0-9, _)
\ W un carácter que no es una palabra
[aeiou] coincide con un solo carácter en el conjunto dado
[^ aeiou] coincide con un solo carácter fuera del dado
.
(foo | bar | baz) coincide con cualquiera de las alternativas especificadas

^ inicio de cadena
$ fin de cadena

Los cuantificadores se pueden usar para especificar cuántos elementos anteriores desea hacer coincidir
en, donde "cosa" significa un carácter literal, uno de los metacaracteres enumerados
arriba, o un grupo de caracteres o metacaracteres entre paréntesis.

* cero o más de lo anterior
+ uno o más de lo anterior
? cero o uno de lo anterior
{3} coincide exactamente con 3 de lo anterior
{3,6} coincide entre 3 y 6 de lo anterior
{3,} coincide con 3 o más de lo anterior

Algunos breves ejemplos:

/ ^ \ d + / cadena comienza con uno o más dígitos
/ ^ $ / nada en la cadena (el inicio y el final son
adyacente)
/ (\ d \ s) {3} / tres dígitos, cada uno seguido de un espacio en blanco
carácter (por ejemplo, "3 4 5")
/(a.)+/ coincide con una cadena en la que todos los números impares
la letra es una (por ejemplo, "abacadaf")

# Este bucle lee de STDIN e imprime líneas que no están en blanco:
while (<>) {
siguiente si / ^ $ /;
impresión;
}

Paréntesis para capturar
Además de agrupar, los paréntesis sirven para un segundo propósito. Pueden usarse para capturar
los resultados de partes de la expresión regular coinciden para su uso posterior. Los resultados terminan en $ 1, $ 2
y así sucesivamente.

# una forma barata y desagradable de dividir una dirección de correo electrónico en partes

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

Otras características de expresiones regulares
Las expresiones regulares de Perl también admiten backreferences, lookaheads y todo tipo de otros complejos
detalles. Lea todo sobre ellos en perlrequick, perlretut y perlre.

Escritura subrutinas
Escribir subrutinas es fácil:

registrador secundario {
my $ logmessage = turno;
abrir mi $ logfile, ">>", "my.log" o morir "¡No se pudo abrir my.log: $!";
imprimir $ archivo de registro $ mensaje de registro;
}

Ahora podemos usar la subrutina como cualquier otra función incorporada:

logger ("¡Tenemos una subrutina de registrador!");

¿Qué es ese "cambio"? Bueno, los argumentos de una subrutina están disponibles para nosotros como un
matriz llamada @_ (ver perlvar para más información). El argumento predeterminado para el "cambio"
La función resulta ser @_. Entonces "my $ logmessage = shift;" quita el primer elemento
la lista de argumentos y la asigna a $ logmessage.

También podemos manipular @_ de otras formas:

my ($ mensaje de registro, $ prioridad) = @_; # común
my $ logmessage = $ _ [0]; # poco común y feo

Las subrutinas también pueden devolver valores:

subcuadrado {
my $ num = turno;
mi $ resultado = $ num * $ num;
devolver $ resultado;
}

Entonces úsalo como:

$ sq = cuadrado(8);

Para obtener más información sobre la escritura de subrutinas, consulte perlsub.

OO Perl
OO Perl es relativamente simple y se implementa utilizando referencias que saben qué tipo de
objeto se basan en el concepto de paquetes de Perl. Sin embargo, OO Perl va mucho más allá
el alcance de este documento. Leer perlootut y perlobj.

Como programador principiante de Perl, su uso más común de OO Perl será el uso de terceros
módulos de fiesta, que se documentan a continuación.

Usando Perl módulos
Los módulos de Perl proporcionan una gama de características para ayudarlo a evitar reinventar la rueda y pueden
ser descargado de CPAN ( http://www.cpan.org/ ). Varios módulos populares son
incluido con la propia distribución de Perl.

Las categorías de módulos van desde la manipulación de texto hasta los protocolos de red y la base de datos.
integración a gráficos. CPAN también dispone de una lista categorizada de módulos.

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

Para aprender a usar un módulo en particular, use "perldoc Nombre del módulo". Normalmente lo harás
quiere usar Nombre del módulo", que luego le dará acceso a funciones exportadas o una OO
interfaz al módulo.

perlfaq contiene preguntas y respuestas relacionadas con muchas tareas comunes y, a menudo, proporciona
sugerencias para el uso de buenos módulos CPAN.

perlmod describe los módulos de Perl en general. perlmodlib enumera los módulos que vienen con
su instalación de Perl.

Si siente la necesidad de escribir módulos en Perl, perlnewmod le dará un buen consejo.

Use perlintro en línea usando los servicios de onworks.net