Perl es un lenguaje de programación estable y multiplataforma.
Aunque Perl no es oficialmente un acrónimo, pocas personas lo usaron como Practical Extraction and Report Language.
Se utiliza para proyectos de misión crítica en los sectores público y privado.
Perl es un software de código abierto, licenciado bajo su Licencia Artística o la Licencia Pública General GNU (GPL) .
Perl fue creado por Larry Wall.
Perl 1.0 fue lanzado a alt.comp.sources de Usenet en 1987
En el momento de escribir este tutorial, la última versión de perl es 5.16.2
Perl figura en el Oxford English Dictionary .
Perl toma las mejores características de otros lenguajes, como C, awk, sed, sh y BASIC, entre otros.
Interfaz de integración de bases de datos Perls DBI admite bases de datos de terceros, como Oracle, Sybase, Postgres, MySQL y otras.
Perl funciona con HTML, XML y otros lenguajes de marcado.
Perl es compatible con Unicode.
Perl es compatible con Y2K.
Perl admite programación tanto procedimental como orientada a objetos.
Perl interactúa con bibliotecas externas C / C ++ a través de XS o SWIG.
Perl es extensible. Hay más de 20.000 módulos de terceros disponibles en Comprehensive Perl Archive Network ( CPAN ).
El intérprete de Perl puede integrarse en otros sistemas.
Perl solía ser el lenguaje de programación web más popular debido a sus capacidades de manipulación de texto y su rápido ciclo de desarrollo.
Perl es ampliamente conocido como " la cinta adhesiva de Internet ".
Perl puede manejar datos web encriptados, incluidas transacciones de comercio electrónico.
Perl puede integrarse en servidores web para acelerar el procesamiento hasta en un 2000%.
De Perl mod_perl permite al servidor Web Apache para incrustar un intérprete de Perl.
El paquete DBI de Perl facilita la integración de la base de datos web.
¡Si! Perl es un lenguaje de programación sensible a mayúsculas y minúsculas.
Un identificador de Perl es un nombre que se usa para identificar una variable, función, clase, módulo u otro objeto. Un nombre de variable Perl comienza con $, @ o% seguido de cero o más letras, guiones bajos y dígitos (0 a 9).
Perl tiene tres tipos de datos básicos: escalares, matrices de escalares y hashes de escalares, también conocidos como matrices asociativas.
Los escalares son variables simples. Están precedidos por un signo de dólar ($). Un escalar es un número, una cadena o una referencia. Una referencia es en realidad la dirección de una variable, que veremos en los próximos capítulos.
Las matrices son listas ordenadas de escalares a las que accede con un índice numérico que comienza con 0. Están precedidas por un signo "arroba" (@).
Los hash son conjuntos desordenados de pares clave / valor a los que accede utilizando las claves como subíndices. Están precedidos por un signo de porcentaje (%).
Las variables de Perl no tienen que declararse explícitamente para reservar espacio en la memoria. La declaración ocurre automáticamente cuando asigna un valor a una variable. El signo igual (=) se utiliza para asignar valores a las variables.
Perl trata la misma variable de manera diferente según el contexto, es decir, la situación en la que se utiliza una variable.
La asignación a una variable escalar evalúa el lado derecho en un contexto escalar.
La asignación a una matriz o un hash evalúa el lado derecho en un contexto de lista.
El contexto booleano es simplemente cualquier lugar donde se evalúa una expresión para ver si es verdadera o falsa.
A este contexto no solo no le importa cuál es el valor de retorno, ni siquiera quiere un valor de retorno.
Este contexto solo ocurre entre comillas o cosas que funcionan como comillas.
La cadena entre comillas simples imprime la variable perl como una cadena, mientras que la cadena entre comillas dobles evalúa la variable y se utiliza para obtener el valor de la variable.
#!/usr/bin/perl
$var = "This is string scalar!";
$quote = 'I m inside single quote - $var';
$double = "This is inside double quote - $var";
$escape = "This example of escape -\tHello, World!";
print "var = $var\n";
print "quote = $quote\n";
print "double = $double\n";
print "escape = $escape\n";
Esto producirá el siguiente resultado:
var = This is string scalar!
quote = I m inside single quote - $var
double = This is inside double quote - This is string scalar!
escape = This example of escape - Hello, World!
Un literal de la forma v1.20.300.4000 se analiza como una cadena compuesta de caracteres con los ordinales especificados. Esta forma se conoce como v-strings.
Una v-string proporciona una forma alternativa y más legible de construir cadenas, en lugar de usar la forma de interpolación algo menos legible "\ x {1} \ x {14} \ x {12c} \ x {fa0}".
Se utiliza para obtener el nombre del archivo actual.
Se utiliza para obtener el número de línea actual.
Se utiliza para obtener el nombre del paquete actual.
Para hacer referencia a un solo elemento de una matriz, utilizará el signo de dólar ($) con el nombre de la variable seguido del índice del elemento entre corchetes.
Aquí hay un ejemplo simple de cómo usar las variables de matriz:
#!/usr/bin/perl
@ages = (25, 30, 40);
@names = ("John Paul", "Lisa", "Kumar");
print "\$ages[0] = $ages[0]\n";
print "\$ages[1] = $ages[1]\n";
print "\$ages[2] = $ages[2]\n";
print "\$names[0] = $names[0]\n";
print "\$names[1] = $names[1]\n";
print "\$names[2] = $names[2]\n";
Cuando se ejecuta, esto producirá el siguiente resultado:
$ages[0] = 25
$ages[1] = 30
$ages[2] = 40
$names[0] = John Paul
$names[1] = Lisa
$names[2] = Kumar
El operador de rango (..) se utiliza para crear matrices secuenciales.
#!/usr/bin/perl
@var_10 = (1..10);
@var_20 = (10..20);
@var_abc = (a..z);
print "@var_10\n"; # Prints number from 1 to 10
print "@var_20\n"; # Prints number from 10 to 20
print "@var_abc\n"; # Prints number from a to z
Aquí el doble punto (..) se llama operador de rango. Esto producirá el siguiente resultado:
1 2 3 4 5 6 7 8 9 10
10 11 12 13 14 15 16 17 18 19 20
a b c d e f g h i j k l m n o p q r s t u v w x y z
El tamaño de una matriz se puede determinar utilizando el contexto escalar en la matriz; el valor devuelto será el número de elementos en la matriz.
@array = (1,2,3);
print "Size: ",scalar @array,"\n";
El valor devuelto siempre será el tamaño físico de la matriz, no el número de elementos válidos.
push @ARRAY, LIST: inserta los valores de la lista al final de la matriz.
#!/usr/bin/perl
# create a simple array
@coins = ("Quarter","Dime","Nickel");
print "1. \@coins = @coins\n";
# add one element at the end of the array
push(@coins, "Penny");
print "2. \@coins = @coins\n";
Esto producirá el siguiente resultado:
1. @coins = Quarter Dime Nickel
2. @coins = Quarter Dime Nickel Penny
unshift @ARRAY, LIST: antepone la lista al principio de la matriz y devuelve el número de elementos de la nueva matriz.
#!/usr/bin/perl
# create a simple array
@coins = ("Quarter","Dime","Nickel");
print "1. \@coins = @coins\n";
# add one element at the beginning of the array
unshift(@coins, "Dollar");
print "2. \@coins = @coins\n";
Esto producirá el siguiente resultado:
1. @coins = Quarter Dime Nickel
2. @coins = Dollar Quarter Dime Nickel
pop @ARRAY: aparece y devuelve el último valor de la matriz.
#!/usr/bin/perl
# create a simple array
@coins = ("Quarter","Dime","Nickel");
print "1. \@coins = @coins\n";
# remove one element from the last of the array.
pop(@coins);
print "2. \@coins = @coins\n";
Esto producirá el siguiente resultado:
1. @coins = Quarter Dime Nickel
2. @coins = Quarter Dime
shift @ARRAY: desplaza el primer valor de la matriz y lo devuelve, acortando la matriz en 1 y moviendo todo hacia abajo.
#!/usr/bin/perl
# create a simple array
@coins = ("Quarter","Dime","Nickel");
print "1. \@coins = @coins\n";
# remove one element from the beginning of the array.
shift(@coins);
print "2. \@coins = @coins\n";
Esto producirá el siguiente resultado:
1. @coins = Quarter Dime Nickel
2. @coins = Dime Nickel
También puede extraer un "segmento" de una matriz, es decir, puede seleccionar más de un elemento de una matriz para producir otra matriz.
#!/usr/bin/perl
@days = qw/Mon Tue Wed Thu Fri Sat Sun/;
@weekdays = @days[3,4,5];
print "@weekdays\n";
Esto producirá el siguiente resultado:
Thu Fri Sat
La función splice () eliminará los elementos de @ARRAY designados por OFFSET y LENGTH, y los reemplazará con LIST, si se especifica. Finalmente, devuelve los elementos eliminados de la matriz.
splice @ARRAY, OFFSET [ , LENGTH [ , LIST ] ]
A continuación se muestra el ejemplo:
#!/usr/bin/perl
@nums = (1..20);
print "Before - @nums\n";
splice(@nums, 5, 5, 21..25);
print "After - @nums\n";
Esto producirá el siguiente resultado:
Before − 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
After − 1 2 3 4 5 21 22 23 24 25 11 12 13 14 15 16 17 18 19 20
split () divide una cadena en una matriz de cadenas y la devuelve. Si se especifica LIMIT, se divide en como máximo ese número de campos. Si se omite PATTERN, se divide en espacios en blanco.
split [ PATTERN [ , EXPR [ , LIMIT ] ] ]
A continuación se muestra el ejemplo:
#!/usr/bin/perl
# define Strings
$var_string = "Rain-Drops-On-Roses-And-Whiskers-On-Kittens";
$var_names = "Larry,David,Roger,Ken,Michael,Tom";
# transform above strings into arrays.
@string = split('-', $var_string);
@names = split(',', $var_names);
print "$string[3]\n"; # This will print Roses
print "$names[4]\n"; # This will print Michael
Esto producirá el siguiente resultado:
Roses
Michael
La función join () une las cadenas separadas de LIST en una sola cadena con campos separados por el valor de EXPR y devuelve la cadena.
join EXPR, LIST
A continuación se muestra el ejemplo:
#!/usr/bin/perl
# define Strings
$var_string = "Rain-Drops-On-Roses-And-Whiskers-On-Kittens";
$var_names = "Larry,David,Roger,Ken,Michael,Tom";
# transform above strings into arrays.
@string = split('-', $var_string);
@names = split(',', $var_names);
$string1 = join( '-', @string );
$string2 = join( ',', @names );
print "$string1\n";
print "$string2\n";
print "$string[3]\n"; # This will print Roses
print "$names[4]\n"; # This will print Michael
Esto producirá el siguiente resultado:
Rain-Drops-On-Roses-And-Whiskers-On-Kittens
Larry,David,Roger,Ken,Michael,Tom
La función sort () ordena cada elemento de una matriz de acuerdo con los estándares numéricos ASCII. Esta función tiene la siguiente sintaxis:
sort [ SUBROUTINE ] LIST
Esta función ordena la LISTA y devuelve el valor de la matriz ordenada. Si se especifica SUBROUTINE, la lógica especificada dentro de SUBTROUTINE se aplica mientras se clasifican los elementos.
#!/usr/bin/perl
# define an array
@foods = qw(pizza steak chicken burgers);
print "Before: @foods\n";
# sort this array
@foods = sort(@foods);
print "After: @foods\n";
Esto producirá el siguiente resultado:
Before: pizza steak chicken burgers
After: burgers chicken pizza steak
Esta variable especial es un escalar que contiene el primer índice de todas las matrices. Debido a que las matrices de Perl tienen indexación basada en cero, $ [casi siempre será 0. Pero si establece $ [en 1, todas sus matrices usarán indexación basada en on. Se recomienda no utilizar ningún otro índice que no sea cero. Sin embargo, tomemos un ejemplo para mostrar el uso de $ [variable -
#!/usr/bin/perl
# define an array
@foods = qw(pizza steak chicken burgers);
print "Foods: @foods\n";
# Let's reset first index of all the arrays.
$[ = 1;
print "Food at \@foods[1]: $foods[1]\n";
print "Food at \@foods[2]: $foods[2]\n";
Esto producirá el siguiente resultado:
Foods: pizza steak chicken burgers
Food at @foods[1]: pizza
Food at @foods[2]: steak
Debido a que una matriz es solo una secuencia de valores separados por comas, puede combinarlos como se muestra a continuación.
#!/usr/bin/perl
@numbers = (1,3,(4,5,6));
print "numbers = @numbers\n";
Esto producirá el siguiente resultado:
numbers = 1 3 4 5 6
Los hash se crean de una de las dos formas siguientes. En el primer método, asigna un valor a una clave nombrada uno por uno:
$data{'John Paul'} = 45;
$data{'Lisa'} = 30;
$data{'Kumar'} = 40;
En el segundo caso, usa una lista, que se convierte tomando pares individuales de la lista: el primer elemento del par se usa como clave y el segundo como valor. Por ejemplo
%data = ('John Paul', 45, 'Lisa', 30, 'Kumar', 40);
Al acceder a elementos individuales desde un hash, debe anteponer la variable con un signo de dólar ($) y luego agregar la clave del elemento entre corchetes después del nombre de la variable. Por ejemplo
#!/usr/bin/perl
%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);
print "$data{'John Paul'}\n";
print "$data{'Lisa'}\n";
print "$data{'Kumar'}\n";
Esto producirá el siguiente resultado:
45
30
40
Puede obtener una lista de todas las claves de un hash utilizando la función de claves, que tiene la siguiente sintaxis:
keys %HASH
Esta función devuelve una matriz de todas las claves del hash nombrado. A continuación se muestra el ejemplo:
#!/usr/bin/perl
%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);
@names = keys %data;
print "$names[0]\n";
print "$names[1]\n";
print "$names[2]\n";
Esto producirá el siguiente resultado:
Lisa
John Paul
Kumar
Puede obtener una lista de todos los valores de un hash utilizando la función de valores, que tiene la siguiente sintaxis:
values %HASH
Esta función devuelve una matriz de todos los valores del hash nombrado. A continuación se muestra el ejemplo:
#!/usr/bin/perl
%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);
@ages = values %data;
print "$ages[0]\n";
print "$ages[1]\n";
print "$ages[2]\n";
Esto producirá el siguiente resultado:
30
45
40
Usando la función existe, que devuelve verdadero si la clave nombrada existe, independientemente de cuál pueda ser su valor:
#!/usr/bin/perl
%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);
if( exists($data{'Lisa'} ) ){
print "Lisa is $data{'Lisa'} years old\n";
}
else{
print "I don't know age of Lisa\n";
}
Aquí hemos introducido la declaración IF ... ELSE, que estudiaremos en un capítulo aparte. Por ahora, asume que la parte if (condición) se ejecutará solo cuando la condición dada sea verdadera, de lo contrario se ejecutará la parte else. Entonces, cuando ejecutamos el programa anterior, produce el siguiente resultado porque aquí existe la condición dada ($ data {'Lisa'} devuelve verdadero -
Lisa is 30 years old
Puede obtener el tamaño, es decir, la cantidad de elementos de un hash utilizando el contexto escalar en claves o valores. Simplemente diciendo que primero debe obtener una matriz de las claves o valores y luego puede obtener el tamaño de la matriz de la siguiente manera:
#!/usr/bin/perl
%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);
@keys = keys %data;
$size = @keys;
print "1 - Hash size: is $size\n";
@values = values %data;
$size = @values;
print "2 - Hash size: is $size\n";
Esto producirá el siguiente resultado:
1 - Hash size: is 3
2 - Hash size: is 3
Se puede agregar un nuevo par clave / valor con una línea de código usando un operador de asignación simple.
#!/usr/bin/perl
%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);
@keys = keys %data;
$size = @keys;
print "1 - Hash size: is $size\n";
# adding an element to the hash;
$data{'Ali'} = 55;
@keys = keys %data;
$size = @keys;
print "2 - Hash size: is $size\n";
Esto producirá el siguiente resultado:
1 - Hash size: is 3
2 - Hash size: is 4
Para eliminar un elemento del hash, debe usar la función de eliminación como se muestra a continuación en el ejemplo
#!/usr/bin/perl
%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);
@keys = keys %data;
$size = @keys;
print "1 - Hash size: is $size\n";
# delete the same element from the hash;
delete $data{'John Paul'};
@keys = keys %data;
$size = @keys;
print "2 - Hash size: is $size\n";
Esto producirá el siguiente resultado:
1 - Hash size: is 3
2 - Hash size: is 2
Hace que el bucle omita el resto de su cuerpo e inmediatamente vuelva a probar su condición antes de reiterar. Ultima declaración.
Termina la instrucción de bucle y transfiere la ejecución a la instrucción que sigue inmediatamente al bucle. Continuar declaración.
Un BLOQUE continuo, siempre se ejecuta justo antes de que el condicional esté a punto de ser evaluado nuevamente.
El comando rehacer reinicia el bloque de bucle sin evaluar el condicional nuevamente. El bloque de continuación, si lo hay, no se ejecuta.
El formulario goto LABEL salta a la instrucción etiquetada con LABEL y reanuda la ejecución desde allí.
El formulario goto EXPR es solo una generalización de goto LABEL. Espera que la expresión devuelva un nombre de etiqueta y luego salta a esa declaración etiquetada.
Sustituye una llamada a la subrutina nombrada por la subrutina actualmente en ejecución.
Exponente: realiza cálculos exponenciales (potencia) en los operadores. Suponga que la variable $ a tiene 10 y la variable $ b tiene 20, entonces $ a ** $ b dará 10 a la potencia 20.
Comprueba si el valor de dos operandos es igual o no, y devuelve -1, 0 o 1 dependiendo de si el argumento de la izquierda es numéricamente menor, igual o mayor que el argumento de la derecha. Suponga que la variable $ a tiene 10 y la variable $ b tiene 20, entonces ($ a <=> $ b) devuelve -1.
Devuelve verdadero si el argumento de la izquierda es una cadena menor que el argumento de la derecha. Suponga que la variable $ a tiene "abc" y la variable $ b tiene "xyz", entonces ($ a lt $ b) es verdadera.
Devuelve verdadero si el argumento de la izquierda es una cadena mayor que el argumento de la derecha. Suponga que la variable $ a contiene "abc" y la variable $ b contiene "xyz", entonces ($ a gt $ b) es falsa.
Devuelve verdadero si el argumento de la izquierda es en sentido de cadena menor o igual que el argumento de la derecha. Suponga que la variable $ a tiene "abc" y la variable $ b tiene "xyz", entonces ($ a le $ b) es verdadera.
Devuelve verdadero si el argumento de la izquierda es en sentido de cadena mayor o igual que el argumento de la derecha. Suponga que la variable $ a contiene "abc" y la variable $ b contiene "xyz", entonces ($ a ge $ b) es falsa.
Devuelve verdadero si el argumento de la izquierda es igual en cadena al argumento de la derecha. Suponga que la variable $ a tiene "abc" y la variable $ b tiene "xyz", entonces ($ a eq $ b) es falsa.
Devuelve verdadero si el argumento de la izquierda no es igual al argumento de la derecha. Suponga que la variable $ a contiene "abc" y la variable $ b contiene "xyz", entonces ($ a ne $ b) es verdadera.
Devuelve -1, 0 o 1 dependiendo de si el argumento de la izquierda es menor, igual o mayor que el argumento de la derecha. Suponga que la variable $ a contiene "abc" y la variable $ b contiene "xyz", entonces ($ a cmp $ b) es -1.
Operador de asignación Y de exponente, realiza cálculos exponenciales (potencia) en operadores y asigna valor al operando izquierdo. $ c ** = $ a es equivalente a $ c = $ c ** $ a
Incluye una cadena entre comillas simples. q {abcd} da 'abcd'
Encierra una cadena entre comillas dobles. qq {abcd} da "abcd"
Incluye una cadena entre comillas inversas. qx {abcd} da `abcd`
El punto de operador binario (.) Concatena dos cadenas. Si $ a = "abc", $ b = "def" entonces $ a. $ B dará "abcdef"
El operador de repetición x devuelve una cadena que consta del operando izquierdo repetido el número de veces especificado por el operando derecho. ('-' x 3) dará ---.
El operador de rango ... devuelve una lista de valores contando (de a uno) desde el valor de la izquierda al valor de la derecha. (2..5) dará (2, 3, 4, 5).
El operador de incremento automático aumenta el valor entero en uno. $ a ++ dará 11.
El operador Auto Decrement reduce el valor entero en uno. $ a−− dará 9
El operador de flecha se usa principalmente para desreferenciar un método o variable de un objeto o un nombre de clase. $ obj -> $ a es un ejemplo para acceder a la variable $ a desde el objeto $ obj.
Función localtime (), que devuelve valores para la fecha y hora actuales si no se proporcionan argumentos.
#!/usr/local/bin/perl
@months = qw( Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec );
@days = qw(Sun Mon Tue Wed Thu Fri Sat Sun);
($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime();
print "$mday $months[$mon] $days[$wday]\n";
Cuando se ejecuta el código anterior, produce el siguiente resultado:
16 Feb Sat
La función gmtime () funciona igual que la función localtime () pero los valores devueltos están localizados para la zona horaria estándar de Greenwich. Cuando se llama en el contexto de la lista, $ isdst, el último valor devuelto por gmtime, siempre es 0. No hay horario de verano en GMT.
localtime () devolverá la hora local actual en la máquina que ejecuta el script y gmtime () devolverá la hora universal de Greenwich, o GMT (o UTC).
Puede usar la función time () para obtener el tiempo de época, es decir, el número de segundos que han transcurrido desde una fecha determinada, en Unix es el 1 de enero de 1970.
Puede utilizar la función POSIX strftime () para formatear la fecha y la hora.
La forma general de una definición de subrutina en el lenguaje de programación Perl es la siguiente:
sub subroutine_name{
body of the subroutine
}
La forma típica de llamar a esa subrutina de Perl es la siguiente:
subroutine_name( list of arguments );
se puede acceder a ellos dentro de la función utilizando la matriz especial @_. Por tanto, el primer argumento de la función está en $ _ [0], el segundo está en $ _ [1], y así sucesivamente.
usando escalar (@_), podemos obtener el número total de argumentos pasados.
El operador my limita una variable a una región particular de código en la que se puede utilizar y acceder a ella. Fuera de esa región, no se puede utilizar ni acceder a esta variable.
Por defecto, todas las variables en Perl son variables globales, lo que significa que se puede acceder a ellas desde cualquier lugar del programa.
Las variables léxicas son variables privadas creadas con mi operador.
El local se usa cuando el valor actual de una variable debe ser visible para las subrutinas llamadas.
Un local solo da valores temporales a las variables globales (es decir, paquete). Esto se conoce como alcance dinámico.
El alcance léxico se realiza con mi operador. Un ámbito léxico suele ser un bloque de código con un conjunto de llaves alrededor, como las que definen el cuerpo de la subrutina o las que marcan los bloques de código de las declaraciones if, while, for, foreach y eval. El operador my limita una variable a una región particular de código en la que se puede utilizar y acceder a ella. Fuera de esa región, no se puede utilizar ni acceder a esta variable.
Hay otro tipo de variables léxicas, que son similares a las variables privadas pero mantienen su estado y no se reinicializan en múltiples llamadas de las subrutinas. Estas variables se definen utilizando el operador estatal y están disponibles a partir de Perl 5.9.4.
El contexto de una subrutina o declaración se define como el tipo de valor de retorno que se espera. Esto le permite utilizar una única función que devuelve diferentes valores en función de lo que el usuario espera recibir. Por ejemplo, el siguiente localtime () devuelve una cadena cuando se llama en contexto escalar, pero devuelve una lista cuando se llama en contexto de lista.
my $datestring = localtime( time );
En este ejemplo, el valor de $ timestr ahora es una cadena formada por la fecha y hora actuales, por ejemplo, Thu Nov 30 15:21:33 2000. A la inversa,
($sec,$min,$hour,$mday,$mon, $year,$wday,$yday,$isdst) = localtime(time);
Ahora las variables individuales contienen los valores correspondientes devueltos por la subrutina localtime ().
Una referencia de Perl es un tipo de datos escalares que contiene la ubicación de otro valor que podría ser escalar, matrices o hashes. Debido a su naturaleza escalar, se puede usar una referencia en cualquier lugar, se puede usar un escalar.
Puede crear una referencia para cualquier variable prefijándola con una barra invertida de la siguiente manera:
$scalarref = \$foo;
Puede crear una referencia para cualquier matriz colocándola como prefijo con una barra invertida de la siguiente manera:
$arrayref = \@ARGV;
Puede crear una referencia para cualquier hash añadiéndole un prefijo con una barra invertida de la siguiente manera:
$hashref = \%ENV;
Puede crear una referencia para cualquier subenrutamiento prefijándolo con una barra invertida de la siguiente manera:
$cref = \&PrintHash;
La desreferenciación devuelve el valor de un punto de referencia a la ubicación.
Para eliminar la referencia de una referencia, simplemente use $, @ o% como prefijo de la variable de referencia, dependiendo de si la referencia apunta a un escalar, una matriz o un hash.
Una referencia circular se produce cuando dos referencias contienen una referencia entre sí. Debe tener cuidado al crear referencias, de lo contrario, una referencia circular puede provocar pérdidas de memoria. A continuación se muestra un ejemplo:
#!/usr/bin/perl
my $foo = 100;
$foo = \$foo;
print "Value of foo is : ", $$foo, "\n";
Cuando se ejecuta el programa anterior, produce el siguiente resultado:
Value of foo is : REF(0x9aae38)
A continuación se muestra la sintaxis para abrir file.txt en modo de solo lectura. Aquí, el signo menos que <indica que el archivo debe abrirse en modo de solo lectura.
open(DATA, "<file.txt");
Aquí DATA es el identificador de archivo que se utilizará para leer el archivo.
A continuación se muestra la sintaxis para abrir file.txt en modo de escritura. Aquí el signo menos que> indica que el archivo debe abrirse en el modo de escritura.
open(DATA, ">file.txt") or die "Couldn't open file file.txt, $!";
A continuación se muestra la sintaxis para abrir file.txt en modo de escritura sin truncarlo. En este caso, el signo menos que + <indica que el archivo debe abrirse en el modo de escritura sin truncarlo.
open(DATA, "+<file.txt") or die "Couldn't open file file.txt, $!";
Para cerrar un identificador de archivo y, por lo tanto, disociar el identificador de archivo del archivo correspondiente, utilice la función cerrar. Esto vacía los búferes del identificador de archivos y cierra el descriptor de archivos del sistema.
La función getc devuelve un solo carácter del FILEHANDLE especificado, o STDIN si no se especifica ninguno.
La función de lectura lee un bloque de información del identificador de archivo almacenado en búfer: esta función se utiliza para leer datos binarios del archivo.