Tutorial de Perl: aprenda Perl con ejemplos

Perl es un lenguaje de programación dinámico, de alto nivel interpretado y de propósito general. Al principio, Perl se desarrolló solo para la administración del sistema y el manejo de texto, pero en versiones posteriores, Perl obtuvo la capacidad de manejar expresiones regulares y sockets de red, etc. En la actualidad, Perl es popular por su capacidad para manejar Regex (Expresiones regulares ). La primera versión de Perl fue la 1.0, que se lanzó el 18 de diciembre de 1987. Perl 6 es diferente de Perl 5 porque es una reimplementación totalmente orientada a objetos de Perl 5.

Temas:

Características clave

Perl tiene muchas razones para ser popular y demandado. Algunas de las razones se mencionan a continuación:

• Fácil de comenzar: Perl es un lenguaje de alto nivel, por lo que está más cerca de otros lenguajes de programación populares como C , C++ y, por lo tanto, se vuelve fácil de aprender para cualquiera.
• Procesamiento de texto: como el acrónimo «Lenguaje práctico de extracción e informes» sugiere que Perl tiene una alta capacidad de manipulación de texto mediante la cual puede generar informes de diferentes archivos de texto fácilmente.
• Mejores funciones incluidas: Perl contiene las funciones de diferentes lenguajes como C , sed, awk y sh, etc., lo que hace que Perl sea más útil y productivo.
• Administración del sistema: Perl facilita mucho la tarea de administración del sistema. En lugar de volverse dependiente de muchos idiomas, simplemente use Perl para completar toda la tarea de administración del sistema.
• Web y Perl: Perl puede integrarse en servidores web para aumentar su capacidad de procesamiento y tiene el paquete DBI, lo que facilita mucho la integración de la base de datos web.

Áreas de aplicación

¿Por qué y por qué no utilizar Perl?

Primeros pasos con Perl

Dado que Perl es muy similar sintácticamente a otros lenguajes ampliamente utilizados, es más fácil codificar y aprender en Perl. Los programas de Perl se pueden escribir en cualquier editor de texto sin formato, como el bloc de notas, el bloc de notas ++ o cualquier cosa por el estilo. También se puede usar un IDE en línea para escribir códigos Perl o incluso puede instalar uno en su sistema para que sea más factible escribir estos códigos porque los IDE brindan muchas características como editor de código intuitivo, depurador, compilador, etc.
Para empezar, escribir códigos Perl y realizar varias operaciones intrigantes y útiles, uno debe tener Perl instalado en su sistema. Esto se puede hacer siguiendo las instrucciones paso a paso que se proporcionan a continuación:

¿Qué pasa si Perl ya existe? ¡¡¡Vamos a revisar!!!

En la actualidad, muchas aplicaciones de software requieren Perl para realizar sus operaciones, por lo que es posible que se incluya una versión de Perl en el paquete de instalación del software. Muchos sistemas Linux tienen Perl preinstalado, también Macintosh proporciona un Perl preinstalado con sus sistemas.

Para verificar si su dispositivo está preinstalado con Perl o no, simplemente vaya a la línea de comando (para Windows , busque cmd en el cuadro de diálogo Ejecutar ( + R ), para Linux , abra el terminal usando Ctrl+Alt+T, para MacOS use Control+Option+Shift+T)
Ahora ejecute el siguiente comando :

perl -v

Si Perl ya está instalado, generará un mensaje con todos los detalles de la versión de Perl disponible; de ​​lo contrario, si Perl no está instalado, aparecerá un error que indicará un comando o nombre de archivo incorrecto.

Descarga e instalación de Perl:

Antes de comenzar con el proceso de instalación, debe descargarlo. Para eso, todas las versiones de Perl para Windows, Linux y MacOS están disponibles en perl.org

Descargue Perl y siga las instrucciones adicionales para la instalación de Perl.

Comenzando con la instalación:

Getting Started:Getting done with the User’s License Agreement:Choosing what to Install:Installation Process:Finished Installation:

Changing Directory to install Perl:Starting the Installation Process:Choosing the Directory to Install Perl:Finishing the Installation:

Getting Started:Getting done with the User’s License Agreement:Choosing Installation location:Installation Process:Finishing Installation:

¿Cómo ejecutar un programa Perl?

Consideremos un simple programa Hola Mundo.

#!/usr/bin/perl 
    
# Modules used 
use strict; 
use warnings; 
    
# Print function  
print("Hello World\n"); 

En general, hay dos formas de ejecutar un programa Perl:

• Uso de IDE en línea : puede usar varios IDE en línea que se pueden usar para ejecutar programas Perl sin instalar.
• Uso de la línea de comandos: también puede usar las opciones de la línea de comandos para ejecutar un programa Perl. Los pasos a continuación demuestran cómo ejecutar un programa Perl en la línea de comandos en el sistema operativo Windows/Unix:
   
  ventanas

  Abra Commandline y luego para compilar el tipo de código perl HelloWorld.pl . Si su código no tiene ningún error, se ejecutará correctamente y se mostrará la salida.
  

  Unix/Linux

  Abra la Terminal de su sistema operativo Unix/Linux y luego, para compilar el código, escriba perl hello.pl . Si su código no tiene ningún error, se ejecutará correctamente y se mostrará la salida.
  

Variables

Las variables son palabras definidas por el usuario que se utilizan para contener los valores pasados ​​al programa que se utilizarán para evaluar el código. Cada programa Perl contiene valores en los que el Código realiza sus operaciones. Estos valores no se pueden manipular ni almacenar sin el uso de una variable. Un valor puede procesarse solo si está almacenado en una variable, utilizando el nombre de la variable.
Un valor son los datos pasados ​​al programa para realizar operaciones de manipulación. Estos datos pueden ser números, strings, caracteres, listas, etc.
Ejemplo:

Values: 
5
geeks
15

Variables:
$a = 5;
$b = "geeks";
$c = 15;

Operadores

Los operadores son el bloque de construcción principal de cualquier lenguaje de programación. Los operadores permiten al programador realizar diferentes tipos de operaciones en los operandos. Estos operadores se pueden clasificar en función de sus diferentes funciones:

• Operadores aritméticos
• Operadores relacionales
• Operadores logicos
• Operadores bit a bit
• Operadores de Asignación
• Operador Ternario

# Perl Program to illustrate the Operators 
    
# Operands 
$a = 10; 
$b = 4; 
$c = true;
$d = false;
    
# using arithmetic operators  
print "Addition is: ", $a + $b, "\n"; 
print "Subtraction is: ", $a - $b, "\n" ; 
  
# using Relational Operators 
if ($a == $b) 
{ 
   print "Equal To Operator is True\n"; 
}  
else 
{ 
   print "Equal To Operator is False\n"; 
} 
  
# using Logical Operator 'AND'
$result = $a && $b; 
print "AND Operator: ", $result, "\n"; 
  
# using Bitwise AND Operator 
$result = $a & $b; 
print "Bitwise AND: ", $result, "\n"; 
  
# using Assignment Operators 
print "Addition Assignment Operator: ", $a += $b, "\n"; 

Addition is: 14
Subtraction is: 6
Equal To Operator is False
AND Operator: 4
Bitwise AND: 0
Addition Assignment Operator: 14

Número y sus tipos

Un Número en Perl es un objeto matemático usado para contar, medir y realizar varias operaciones matemáticas. Un símbolo notacional que representa un número se denomina numeral. Estos números, además de su uso en operaciones matemáticas, también se utilizan para ordenar (en forma de números de serie).

Tipos de números:

• enteros
• números flotantes
• números hexadecimales
• números octales
• Numeros binarios

#!/usr/bin/perl
  
# Perl program to illustrate
# the use of numbers
  
# Integer 
$a = 20; 
  
# Floating Number 
$b = 20.5647; 
  
# Scientific value 
$c = 123.5e-10; 
  
# Hexadecimal Number 
$d = 0xc; 
  
# Octal Number 
$e = 074; 
  
# Binary Number 
$f = 0b1010; 
  
# Printing these values 
print("Integer: ", $a, "\n");
print("Float Number: ", $b, "\n"); 
print("Scientific Number: ", $c, "\n"); 
print("Hex Number: ", $d, "\n"); 
print("Octal number: ", $e, "\n"); 
print("Binary Number: ", $f, "\n"); 

Integer: 20
Float Number: 20.5647
Scientific Number: 1.235e-08
Hex Number: 12
Octal number: 60
Binary Number: 10

Para obtener más información sobre Numbers, consulte Numbers en Perl

Los tipos de datos especifican el tipo de datos que puede contener una variable Perl válida. Perl es un lenguaje poco tipificado. No es necesario especificar un tipo para los datos mientras se usan en el programa Perl. El intérprete de Perl elegirá el tipo según el contexto de los datos en sí.

escalares

Es una sola unidad de datos que puede ser un número entero, un punto flotante, un carácter, una string, un párrafo o una página web completa.

Ejemplo:

# Perl program to demonstrate  
# scalars variables 
  
# a string scalar 
$name = "Alex"; 
    
# Integer Scalar 
$rollno = 13; 
    
# a floating point scalar 
$percentage = 87.65; 
  
# In hexadecimal form 
$hexadec = 0xcd; 
  
# Alphanumeric String
$alphanumeric = "gfg21"; 
  
# special character in string scalar 
$specialstring = "^gfg"; 
  
# to display the result 
print "Name = $name\n"; 
print "Roll number = $rollno\n"; 
print "Percentage = $percentage\n"; 
print "Hexadecimal Form = $hexadec\n"; 
print "String with alphanumeric values = $alphanumeric\n"; 
print "String with special characters = $specialstring\n";

Name = Alex
Roll number = 13
Percentage = 87.65
Hexadecimal Form = 205
String with alphanumeric values = gfg21
String with special characters = ^gfg

Para obtener más información sobre los escalares, consulte Escalares en Perl .

arreglos

Una array es una variable que almacena el valor del mismo tipo de datos en forma de lista. Para declarar una array en Perl, usamos el signo ‘@’ delante del nombre de la variable.

@number = (40, 55, 63, 17, 22, 68, 89, 97, 89)

Creará una array de enteros que contiene los valores 40, 55, 63, 17 y muchos más. Para acceder a un solo elemento de una array, usamos el signo ‘$’.

$number[0]

Producirá la salida como 40.

Creación de arrays y elementos de acceso:

#!/usr/bin/perl
  
# Perl Program for array creation
# and accessing its elements
  
# Define an array
@arr1 = (1, 2, 3, 4, 5);
  
# using qw function 
@arr2 = qw /This is a Perl Tutorial by GeeksforGeeks/; 
  
# Accessing array elements
print "Elements of arr1 are:\n"; 
print "$arr1[0]\n";
print "$arr1[3]\n";
  
# Accessing array elements
# with negative index
print "\nElements of arr2 are:\n"; 
print "$arr2[-1]\n";
print "$arr2[-3]\n";

Elements of arr1 are:
1
4

Elements of arr2 are:
GeeksforGeeks
Tutorial

Iterando a través de una array:

#!/usr/bin/perl
  
# Perl program to illustrate  
# iteration through an array
  
# array creation 
@arr = (11, 22, 33, 44, 55);
  
# Iterating through the range
print("Iterating through range:\n");
  
# size of array 
$len = @arr; 
    
for ($b = 0; $b < $len; $b = $b + 1) 
{ 
    print "\@arr[$b] = $arr[$b]\n"; 
} 
  
# Iterating through loops
print("\nIterating through loops:\n");
  
# foreach loop 
foreach $a (@arr) 
{ 
    print "$a "; 
} 

Iterating through range:
@arr[0] = 11
@arr[1] = 22
@arr[2] = 33
@arr[3] = 44
@arr[4] = 55

Iterating through loops:
11 22 33 44 55

Para obtener más información sobre las arrays, consulte Arreglos en Perl

Hashes (arrays asociativas)

Es un conjunto de pares clave-valor. También se denomina arrays asociativas. Para declarar un hash en Perl, usamos el signo ‘%’. Para acceder al valor particular, usamos el símbolo ‘$’ seguido de la tecla entre llaves.

Creación y acceso a elementos hash:

#!/usr/bin/perl
  
# Perl Program for Hash creation
# and accessing its elements
  
# Initializing Hash by 
# directly assigning values 
$Fruit{'Mango'} = 10; 
$Fruit{'Apple'} = 20; 
$Fruit{'Strawberry'} = 30; 
  
# printing elements of Hash
print "Printing values of Hash:\n"; 
print "$Fruit{'Mango'}\n"; 
print "$Fruit{'Apple'}\n"; 
print "$Fruit{'Strawberry'}\n"; 
  
# Initializing Hash using '=>' 
%Fruit2 = ('Mango' => 45, 'Apple' => 42, 'Strawberry' => 35); 
  
# printing elements of Fruit2
print "\nPrinting values of Hash:\n"; 
print "$Fruit2{'Mango'}\n"; 
print "$Fruit2{'Apple'}\n"; 
print "$Fruit2{'Strawberry'}\n"; 

Printing values of Hash:
10
20
30

Printing values of Hash:
45
42
35

Para obtener más información sobre hashes, consulte Hashes en Perl

Instrumentos de cuerda

Una string en Perl es una variable escalar y comienza con un signo ($) y puede contener letras, números y caracteres especiales. La string puede constar de una sola palabra, un grupo de palabras o un párrafo de varias líneas. La string la define el usuario entre comillas simples (‘) o comillas dobles («).

#!/usr/bin/perl
  
# An array of integers from 1 to 10 
@list = (1..10);  
    
# Non-interpolated string 
$strng1 = 'Using Single quotes: @list';  
    
# Interpolated string 
$strng2 = "Using Double-quotes: @list"; 
print("$strng1\n$strng2"); 

Using Single quotes: @list
Using Double-quotes: 1 2 3 4 5 6 7 8 9 10

Usando el carácter de escape en strings:

La interpolación crea un problema para las strings que contienen símbolos que pueden dejar de ser útiles después de la interpolación. Por ejemplo, cuando una dirección de correo electrónico debe almacenarse en una string entre comillas dobles, el signo ‘arroba’ (@) se interpola automáticamente y se toma como el comienzo del nombre de una array y se sustituye por él. Para superar esta situación, se utiliza el carácter de escape, es decir, la barra invertida (\). La barra invertida se inserta justo antes de la ‘@’ como se muestra a continuación:

#!/usr/bin/perl
  
# Assigning a variable with an email  
# address using double-quotes 
  
# String without an escape sequence 
$email = "GeeksforGeeks0402@gmail.com";  
    
# Printing the interpolated string 
print("$email\n"); 
    
# Using '' to escape the  
# interpolation of '@' 
$email = "GeeksforGeeks0402\@gmail.com";  
    
# Printing the interpolated string 
print($email); 

GeeksforGeeks0402.com
GeeksforGeeks0402@gmail.com

Escapando del carácter de escape:

La barra invertida es el carácter de escape y se usa para hacer uso de secuencias de escape. Cuando es necesario insertar el carácter de escape en una string interpolada, se usa la misma barra invertida, para escapar de la sustitución del carácter de escape con ” (en blanco). Esto permite el uso de caracteres de escape en la string interpolada.

#!/usr/bin/perl 
    
# Using Two escape characters to avoid 
# the substitution of escape(\) with blank 
$string1 = "Using the escape(\\) character";  
    
# Printing the Interpolated string 
print($string1); 

Using the escape(\) character

Para obtener más información sobre strings, consulte Strings en Perl

Toma de decisiones

La toma de decisiones en la programación es similar a la toma de decisiones en la vida real. Un lenguaje de programación utiliza declaraciones de control para controlar el flujo de ejecución del programa en función de ciertas condiciones. Estos se utilizan para hacer que el flujo de ejecución avance y se bifurque en función de los cambios en el estado de un programa.

Declaraciones de toma de decisiones en Perl:

• Si
• si – más
• Anidado – Si
• si – escalera elsif
• A no ser que
• a menos que – de lo contrario
• A menos que – elsif

Ejemplo 1: para ilustrar el uso de if y if-else

#!/usr/bin/perl
  
# Perl program to illustrate 
# Decision-Making statements
  
$a = 10;  
$b = 15;
  
# if condition to check 
# for even number 
if($a % 2 == 0 ) 
{  
    printf "Even Number";  
}  
  
# if-else condition to check 
# for even number or odd number
if($b % 2 == 0 ) 
{  
    printf "\nEven Number";  
}  
else
{    
    printf "\nOdd Number";  
} 

Even Number
Odd Number

Ejemplo 2: Para ilustrar el uso de Nested-if

#!/usr/bin/perl
  
# Perl program to illustrate  
# Nested if statement 
    
$a = 10; 
      
if($a % 2 == 0) 
{  
    # Nested - if statement 
    # Will only be executed  
    # if above if statement 
    # is true 
    if($a % 5 == 0) 
    {   
        printf "Number is divisible by 2 and 5\n";   
    }  
} 

Number is divisible by 2 and 5

Para obtener más información sobre la toma de decisiones, consulte Toma de decisiones en Perl

Bucles

El bucle en los lenguajes de programación es una característica que facilita la ejecución de un conjunto de instrucciones o funciones repetidamente mientras alguna condición se evalúa como verdadera. Los bucles simplifican la tarea del programador. Perl proporciona los diferentes tipos de bucle para manejar la situación basada en condiciones en el programa. Los bucles en Perl son:

• en bucle

  #!/usr/bin/perl    # Perl program to illustrate  # the use of for Loop    # for loop  print("For Loop:\n"); for ($count = 1 ; $count <= 3 ; $count++)  {      print "GeeksForGeeks\n" }

  Producción:

  For Loop:
  GeeksForGeeks
  GeeksForGeeks
  GeeksForGeeks
  

• bucle foreach

  #!/usr/bin/perl    # Perl program to illustrate  # the use of foreach Loop    # Array  @data = ('GEEKS', 4, 'GEEKS');     # foreach loop  print("For-each Loop:\n"); foreach $word (@data)  {      print ("$word "); }

  Producción:

  For-each Loop:
  GEEKS 4 GEEKS
  

• mientras y hacer…. mientras bucle

  #!/usr/bin/perl    # Perl program to illustrate  # the use of foreach Loop    # while loop  $count = 3;     print("While Loop:\n"); while ($count >= 0)  {      $count = $count - 1;      print "GeeksForGeeks\n";  }     print("\ndo...while Loop:\n"); $a = 10;       # do..While loop  do {           print "$a ";      $a = $a - 1;  } while ($a > 0);

  Producción:

  While Loop:
  GeeksForGeeks
  GeeksForGeeks
  GeeksForGeeks
  GeeksForGeeks
  
  do...while Loop:
  10 9 8 7 6 5 4 3 2 1
  

Para obtener más información sobre los bucles, consulte Bucles en Perl .

La programación orientada a objetos tiene como objetivo implementar entidades del mundo real como herencia, ocultación, polimorfismo, etc. en la programación. El objetivo principal de OOP es unir los datos y las funciones que operan en ellos para que ninguna otra parte del código pueda acceder a estos datos excepto esa función.

Creación de una Clase y un Objeto :

#!/usr/bin/perl
  
# Perl Program for creation of a
# Class and its object
use strict; 
use warnings; 
    
package student; 
    
# constructor 
sub student_data 
{ 
    
    # shift will take package name 'student'  
    # and assign it to variable 'class' 
    my $class_name = shift; 
    my $self = { 
                'StudentFirstName' => shift, 
                'StudentLastName' => shift
               }; 
    # Using bless function 
    bless $self, $class_name; 
        
    # returning object from constructor 
    return $self; 
} 
    
# Object creating and constructor calling 
my $Data = student_data student("Geeks", "forGeeks"); 
    
# Printing the data 
print "$Data->{'StudentFirstName'}\n"; 
print "$Data->{'StudentLastName'}\n"; 

Geeks
forGeeks

Métodos : –
Los métodos son las entidades que se utilizan para acceder y modificar los datos de un objeto. Un método es una colección de declaraciones que realizan alguna tarea específica y devuelven un resultado a la persona que llama. Un método puede realizar alguna tarea específica sin devolver nada. Los métodos ahorran tiempo y nos ayudan a reutilizar el código sin tener que volver a escribirlo.

sub Student_data 
{  
    my $self = shift;  
          
    # Calculating the result  
    my $result = $self->{'Marks_obtained'} /  
                 $self->{'Total_marks'};  
                       
    print "Marks scored by the student are: $result";  
}  

El método anterior se puede llamar una y otra vez donde sea necesario, sin hacer el esfuerzo de volver a escribir el código.
Para obtener más información sobre los métodos, consulte Métodos en Perl

Polimorfismo : –
El polimorfismo se refiere a la capacidad de los lenguajes de programación OOP para diferenciar entre entidades con el mismo nombre de manera eficiente. Esto lo hace Perl con la ayuda de la firma y declaración de estas entidades.
 
El polimorfismo se puede explicar mejor con la ayuda del siguiente ejemplo:

use warnings;
   
# Creating class using package
package A;
sub poly_example
{
   print("This corresponds to class A\n");
}
   
package B;
sub poly_example
{
  print("This corresponds to class B\n");
}
  
B->poly_example();
A->poly_example();

Producción:

Para obtener más información sobre el polimorfismo, consulte Polimorfismo en Perl

Herencia :
la herencia es la capacidad de cualquier clase para extraer y utilizar características de otras clases. Es el proceso mediante el cual se crean nuevas clases llamadas clases derivadas a partir de clases existentes llamadas clases base.
La herencia en Perl se puede implementar con el uso de paquetes . Los paquetes se usan para crear una clase principal que se puede usar en las clases derivadas para heredar las funcionalidades.
Para obtener más información sobre la herencia, consulte Herencia en Perl

Encapsulación : –
La encapsulación es el proceso de empaquetar datos para protegerlos de fuentes externas que no necesitan tener acceso a esa parte del código. Técnicamente, en encapsulación, las variables o datos de una clase están ocultos de cualquier otra clase y solo se puede acceder a ellos a través de cualquier función miembro de la propia clase en la que se declaran. Este proceso también se denomina Ocultación de datos .
Para obtener más información sobre la encapsulación, consulte Encapsulación en Perl

Abstracción : –
La abstracción es el proceso por el cual el usuario obtiene acceso solo a los detalles esenciales de un programa y la parte trivial se oculta al usuario. Ej: Un automóvil se ve como un automóvil en lugar de sus componentes individuales. El usuario solo puede saber qué se está haciendo pero no la parte de cómo se está haciendo. Esto es lo que es la abstracción.
Para obtener más información sobre Abstracción, consulte Abstracción en Perl

¿Qué son las subrutinas?

Una función o subrutina de Perl es un grupo de sentencias que juntas realizan una tarea específica. En cada lenguaje de programación, el usuario quiere reutilizar el código. Entonces, el usuario pone la sección de código en función o subrutina para que no haya necesidad de escribir código una y otra vez.
Ejemplo:

#!/usr/bin/perl
  
# Perl Program to demonstrate the  
# subroutine declaration and calling 
  
# defining subroutine 
sub ask_user
{ 
    print "Hello Geeks!\n"; 
} 
    
# calling subroutine 
# you can also use 
# &ask_user(); 
ask_user(); 

Hello Geeks!

Múltiples subrutinas

Se pueden crear múltiples subrutinas en Perl usando la palabra clave ‘multi’. Esto ayuda en la creación de múltiples subrutinas con el mismo nombre.
Ejemplo:

multi Func1($var){statement};
multi Func1($var1, $var2){statement1; statement2;}

Ejemplo:

#!/usr/bin/perl 
# Program to print factorial of a number 
    
# Factorial of 0 
multi Factorial(0) 
{ 
    1; # returning 1 
} 
    
# Recursive Function  
# to calculate Factorial 
multi Factorial(Int $n where $n > 0) 
{ 
    $n * Factorial($n - 1); # Recursive Call 
} 
    
# Printing the result  
# using Function Call 
print Factorial(15); 

Producción:

3628800

Para obtener más información sobre las subrutinas múltiples, consulte Subrutinas múltiples en Perl

Módulos y Paquetes

Un módulo en Perl es una colección de subrutinas y variables relacionadas que realizan un conjunto de tareas de programación. Los módulos Perl son reutilizables. El módulo Perl es un paquete definido en un archivo que tiene el mismo nombre que el del paquete y tiene la extensión .pm. Un paquete de Perl es una colección de código que reside en su propio espacio de nombres.
Para importar un módulo, usamos require o use functions. Para acceder a una función o una variable desde un módulo, se utiliza ::.

Ejemplos:

#!/usr/bin/perl
  
# Using the Package 'Calculator'
use Calculator;
  
print "Enter two numbers to multiply";
  
# Defining values to the variables
$a = 5;
$b = 10;
  
# Subroutine call
Calculator::multiplication($a, $b);
  
print "\nEnter two numbers to divide";
  
# Defining values to the variables
$a = 45;
$b = 5;
  
# Subroutine call
Calculator::division($a, $b);

Producción:

Referencias

Una referencia en Perl es un tipo de datos escalares que contiene la ubicación de otra variable. Otra variable puede ser escalar, hash, arrays, nombres de funciones, etc. Se puede crear una referencia prefijándola con una barra invertida.
Ejemplo:

# Perl program to illustrate the  
# Referencing and Dereferencing 
# of an Array 
    
# defining an array 
@array = ('1', '2', '3');   
    
# making an reference to an array variable 
$reference_array = \@array;   
    
# Dereferencing 
# printing the value stored  
# at $reference_array by prefixing  
# @ as it is a array reference 
print @$reference_array;     

123

Para obtener más información sobre las referencias, consulte Referencias en Perl

La expresión regular (Regex o Regexp o RE) en Perl es una string de texto especial para describir un patrón de búsqueda dentro de un texto dado. Regex en Perl está vinculado al lenguaje host y no es lo mismo que en PHP, Python, etc.
La mayoría de los operadores de enlace se usan con el operador m// para que el patrón requerido pueda coincidir.

Ejemplo:

# Perl program to demonstrate 
# the m// and =~ operators 
    
# Actual String 
$a = "GEEKSFORGEEKS"; 
    
# Prints match found if  
# its found in $a 
if ($a =~ m[GEEKS])  
{ 
    print "Match Found\n"; 
} 
    
# Prints match not found  
# if its not found in $a 
else 
{ 
    print "Match Not Found\n"; 
} 

Match Found

Producción:

Match Found

Cuantificadores en Regex

Perl proporciona varios cuantificadores de expresiones regulares que se utilizan para especificar cuántas veces se puede repetir un carácter dado antes de que se realice la coincidencia. Esto se usa principalmente cuando se desconoce el número de caracteres que se van a emparejar.
Hay seis tipos de cuantificadores de Perl que se dan a continuación:

• * = Esto dice que el componente debe estar presente cero o más veces.
• + = Esto dice que el componente debe estar presente una o más veces.
• ? = Esto dice que el componente debe estar presente cero o una vez.
• {n} = Esto dice que el componente debe estar presente n veces.
• {n, } = Esto dice que el componente debe estar presente al menos n veces.
• {n, m} = Esto dice que el componente debe estar presente al menos n veces y no más de m veces.

En Perl, un FileHandle asocia un nombre a un archivo externo, que se puede utilizar hasta el final del programa o hasta que se cierre el FileHandle. En resumen, un FileHandle es como una conexión que se puede usar para modificar el contenido de un archivo externo y se le da un nombre a la conexión (FileHandle) para un acceso más rápido y sencillo.
Los tres FileHandles básicos en Perl son STDIN, STDOUT y STDERR, que representan dispositivos de entrada estándar, salida estándar y error estándar, respectivamente.

Leer y escribir en un archivo usando FileHandle

La lectura de un FileHandle se puede hacer a través de la función de impresión.

# Opening the file  
open(fh, "GFG2.txt") or die "File '$filename' can't be opened"; 
    
# Reading First line from the file 
$firstline = <fh>; 
print "$firstline\n"; 

Producción :

También se puede escribir en un archivo a través de la función de impresión.

# Opening file Hello.txt in write mode
open (fh, ">", "Hello.txt");
  
# Getting the string to be written
# to the file from the user
print "Enter the content to be added\n";
$a = <>;
  
# Writing to the file
print fh $a;
  
# Closing the file
close(fh) or "Couldn't close the file"; 

Ejecutando código para escribir:

Archivo actualizado:

Operaciones básicas en archivos
Se pueden realizar múltiples operaciones en archivos usando FileHandles. Estos son:

• Abrir y leer un archivo
• Escribir en un archivo
• Agregar a un archivo
• Lectura de un archivo CSV

Operadores de prueba de archivos

Los operadores de prueba de archivo en Perl son los operadores lógicos que devuelven valores verdaderos o falsos. Hay muchos operadores en Perl que puede usar para probar varios aspectos diferentes de un archivo. Por ejemplo, para comprobar la existencia de un archivo se utiliza el operador -e.
El siguiente ejemplo utiliza el operador de existencia ‘-e’ para verificar si un archivo existe o no:

#!/usr/bin/perl
  
# Using predefined modules
use warnings;
use strict;
   
# Providing path of file to a variable
my $filename = 'C:\Users\GeeksForGeeks\GFG.txt';
  
# Checking for the file existence
if(-e $filename)
{
      
    # If File exists
    print("File $filename exists\n");
}
  
else
{
      
    # If File doesn't exists
    print("File $filename does not exists\n");
}

Producción:

Para obtener más información sobre los diferentes operadores en las pruebas de archivos, consulte Operadores de pruebas de archivos en Perl

Trabajar con archivos de Excel

Los archivos de Excel son la aplicación de oficina más utilizada para comunicarse con las computadoras. Para crear archivos de Excel con Perl, puede usar padre IDE, también usaremos el módulo Excel::Writer::XLSX.
Perl usa la función write() para agregar contenido al archivo de Excel.

Creación de un archivo de
Excel: los archivos de Excel se pueden crear utilizando la línea de comandos de Perl, pero primero debemos cargar el módulo Excel::Writer::XLSX.

#!/usr/bin/perl 
use Excel::Writer::XLSX;
  
my $Excelbook = Excel::Writer::XLSX->new( 'GFG_Sample.xlsx' );
my $Excelsheet = $Excelbook->add_worksheet();
  
$Excelsheet->write( "A1", "Hello!" );
$Excelsheet->write( "A2", "GeeksForGeeks" );
$Excelsheet->write( "B1", "Next_Column" );
  
$Excelbook->close;

Producción:

Lectura de un archivo de Excel:
la lectura de un archivo de Excel en Perl se realiza mediante el uso Spreadsheet::Readde un módulo en un script de Perl. Este módulo exporta una serie de funciones que usted importa o usa en su script de código Perl. ReadData()La función se utiliza para leer desde un archivo de Excel.
Ejemplo:

use 5.016;
use Spreadsheet::Read qw(ReadData);
my $book_data = ReadData (‘new_excel.xlsx');
say 'A2: ' . $book_data->[1]{A2};

Producción:

A2: GeeksForGeeks

El manejo de errores en Perl es el proceso de tomar las medidas apropiadas contra un programa que causa dificultad en la ejecución debido a algún error en el código o el compilador. Por ejemplo, si al abrir un archivo que no existe genera un error, o al acceder a una variable que no ha sido declarada genera un error.
El programa se detendrá si ocurre un error y, por lo tanto, mediante el manejo de errores podemos tomar las medidas adecuadas en lugar de detener el programa por completo. El manejo de errores es un requisito importante para cualquier idioma que sea propenso a errores.

Perl proporciona dos funciones integradas para generar excepciones fatales y advertencias, que son:

1. morir()
2. advertir()

 
die(): para señalar la ocurrencia de errores fatales en el sentido de que no se debe permitir que el programa en cuestión continúe.
Por ejemplo, acceder a un archivo con open()indica si la operación de apertura se realizó correctamente antes de continuar con otras operaciones de archivo.

open FILE, "filename.txt" or die "Cannot open file: $!\n";

warn(): a diferencia die()de la función, warn()genera una advertencia en lugar de una excepción fatal.

Por ejemplo:

open FILE, "filename.txt" or warn "Cannot open file: $!\n";

Para obtener más información sobre las distintas técnicas de gestión de errores, consulte Gestión de errores en Perl