Perl

From the official docs:

"Perl officially stands for Practical Extraction and Report Language, except when it doesn't."

It's a general purpose programming language developed for manipulating texts mainly. It has been used to perform system administration tasks, networking, building websites and more.

• Scalar: This is a simple variable that stores single data items. It can be a string, number or reference.

my $number = 5;

• Arrays: This is a list of scalars.

my @numbers = (1, 2, 3, 4, 5);
# or using the `qw` keyword (quote word):
my @numbers = qw/1 2 3 4 5/;
# '/' can be another symbol, e.g qw@1 2 3 4 5@

• Hashes (or associative arrays): This is an unordered collection of key-value pairs. We can access to a hash using the keys.

my %numbers = (
  First => '1',
  Second => '2',
  Third => '3'
);

my %numbers = (
  'First' => '1',
  'Second' => '2',
  'Third' => '3'
);

• Access:

print($numbers{'First'});

• Add:

$numbers{'Fourth'} = 4;

• Delete:

delete $numbers{'Third'};

• Modify:

$numbers{'Fifth'} = 6;
$numbers{'Fifth'} = 5;

• Array:

my @numbers = qw/1 2 3 4 5/;

# Using `$_` that represents the current iteration in a loop. It starts from index array 0 until the last index.
foreach (@numbers) {
    print($_);
}
# Output: 12345

# "$#" returns the max index of an array. That's the reason because we can iterate accessing to the array from the index 0 to the max index.
for my $i (0..$#numbers) {
    print($numbers[$i]);
}
# Output: 12345

# Using the `map` keyword:
print map {$_} @numbers;
# Output: 12345

# Using `while`. We should take care with this option. When we use `shift` we're deleting the first element of the array and assigning it to the `element` variable.
# After this `loop` the `numbers` array will not have elements.
while (my $element = shift(@numbers)) {
    print($element);
}
# Output: 12345

• Hashes:

my %capital_cities = (
 'Madrid' => 'Spain',
 'Rome' => 'Italy',
 'Berlin' => 'Germany'
);

# Iterate and get the `keys`:
foreach my $city (keys %capital_cities) {
   print($city . "\n");
}
# Iterate and get the `values`:
foreach my $country (values %capital_cities) {
   print($country . "\n");
}

# Iterate and get the values and keys (first option):
foreach my $city (keys %capital_cities) {
   print("City: $city - Country: $capital_cities{$city}" . "\n");
}

# Iterate and get the values and keys (first option):
while(my ($city, $country) = each %capital_cities) {
   print("City: $city - Country: $capital_cities{$city}" . "\n");
}

It's the perl model for user defined functions (this is also called function like other programming languages). We can define a subroutine with the keyword sub.

sub hello {
  print "hello";
}

• List assignment: Using the @_ array. It's a list with the elements that are being passed as parameters.

sub power {
    my ($b, $e) = @_;
    return $b ** $e;
}

&power(2, 3);

• Individual assignment: We should access to every element of the @_ array. It starts from zero.

sub power {
    my $b = $_[0];
    my $e = $_[1];
    return $b ** $e;
}

&power(2, 3);

• Using shift keyword: It's used to remove the first value of an array and it's returned.

sub power {
    my $b = shift;
    my $3 = shift;
    return $b ** $e;
}

&power(2, 3);

Source

We can also read the best way in the same S.O answer.

You can check perlstyle

From the official docs:

"Pod is a simple-to-use markup language used for writing documentation for Perl, Perl programs, and Perl modules."

=item
    This function returns the factorial of a number.
    Input: $n (number you wanna calculate).
    Output: number factorial.
=cut
sub factorial {
    my ($i, $result, $n) = (1, 1, shift);
    $result = $result *= $i && $i++ while $i <= $n;
    return $result;
}

my $string = "The longest accepted word by RAE is: electroencefalografista";
if ($string =~ /electroencefalografista/) {
    print "Match!";
}

my $string = "The longest not accepted word by RAE is: Ciclopentanoperhidrofenantreno";
if ($string !~ /electroencefalografista/) {
    print "Does not match!";
}

my $string = "Perl is amazing!";
$string =~ s/amazing/incredible/;
print $string;
# Perl is incredible!

my $date = "Fri Nov 19 20:09:37 CET 2021";
my @matches = $date =~ /(.*)(\d{2}:\d{2}:\d{2})(.*)/;
print $matches[1];
# Output: 20:09:37

my @array = ('a', 1, 'b', 2, 'c', 3);
my @numbers = grep (/\d/, @array);    # Note: \d involves more digits than 0-9
map {print $_ . "\n" } @numbers;

• With a Perl one liner :D

open(my $fh, ';
map { print $& . "\n" if $_ =~ /^d([^:]*)/  } @user_info;
close $fh;

• Avoiding one-liners

foreach my $user_line (@user_info) {
    if ($user_line =~ /^d([^:]*)/) {
        print $& . "\n";
    }
}

• Read only: ``
• Append mode. It creates the file if doesn't exist: >>
• Read and write mode: +
• Read and append. It creates the file if doesn't exist: +>>

# We can use:
# '>' Write (it clears a previous content if exists).
# '>>' Append.
open(my $fh, '>>', 'file_name.ext') or die "Error: file can't be opened";
print $fh "writing text...\n";
close($fh);

open(my $fh, ';
foreach my $line (@file) {
    print $line;
}

We can use the file handle without assigning it to an array:

open(my $fh, ') {
    print $line;
}

From the official docs:

"By default, Perl's built-in OO system is very minimal, leaving you to do most of the work."

The function os the bless function is used to turning a plain data structure into an object.

• Let's create the package: Example.pm

package Example;

sub new {
    my $class = shift;
    my $self = {};
    bless $self, $class;
    return $self;
}

sub is_working {
    print "Working!";
}

1;

• Now we can instance the Example class and call is_working method:

my $e = new Example();
$e->is_working();
# Output: Working!

Yes, Perl supports inheritance. We can read about it in the official docs. We also can read about SUPER keyword that is used to call a method from the parent class. It gives an example about how we can apply inheritance.

Yes, it has polymorphism. In fact method overriding is a way to apply it in Perl.

Method overriding in simple words appears when we have a class with a method that already exist in a parent class.

Example:

package A;

sub new { return bless {}, shift; };
sub printMethod { print "A\n"; };

package B;

use parent -norequire, 'A';

sub new { return bless {}, shift; };
sub printMethod { print "B\n"; };

my $a = A->new();
my $b = B->new();

A->new()->printMethod();
B->new()->printMethod();

# Output:
# A
# B

# Class `A` with `printA` method.
package A;

sub new { return bless {}, shift; };
sub printA { print "A"; };

# Class `B` that extends or use the parent class `A`.
package B;

use parent -norequire, 'A';

sub new { return bless {}, shift; };

# Instance class `B` allows call the inherited method
my $b = B->new();
$b->printA();

From the official eval docs:

"eval in all its forms is used to execute a little Perl program, trapping any errors encountered so they don't crash the calling program.".

e.g:

eval {
    die;
};
if ($@) {
    print "Error. Details: $@";
}

If we execute this we get the next output:

Error. Details: Died at eval.pl line 2.

The eval (try in another programming languages) is trying to execute a code. This code fails (it's a die), and then the code continues into the if condition that evaluates $@ error variable have something stored. This is like a catch in another programming languages. At this way we can handle errors.

From the official IPC::Open3 docs:

"IPC::Open3 - open a process for reading, writing, and error handling using open3()".

With open3 we can have the full control of the STDIN, STDOUT, STDERR. It's usually used to execute commands.

• Code:

use IPC::Open3;
use Data::Dumper;

sub execute_command {
    my @command_to_execute = @_;
    my ($stdin, $stdout, $stderr);
    eval {
        open3($stdin, $stdout, $stderr, @command_to_execute);
    };
    if ($@) {
        print "Error. Details: $@";
    }
    close($stdin);
    return $stdout;
}

my $file_name = 'perl_open3_test';
&execute_command('truncate', '-s', '15M', $file_name);
my $result = &execute_command('stat', '-c', '%s', $file_name);
print Dumper();

• Result:

$ -> perl command.pl
$VAR1 = '15728640
';

With a Perl package we are defining a namespace. A Perl module in one simple word can be defined as a class. When we create a class in Perl we use the package keyword. A module can be used with the use keyword.

There's no a real difference between a .pm and .pl extensions. Perl use .pm extensions just to difference it as a perl module (a class). .pl extensions are usually named for perl scripts without OOP classes.

If we want to use a Perl module (import a class), this module should end in a value different than 0. This is necessary because if we try to import the class and it has a false value, we will not be able to use it.

package A;

sub new { return bless {}, shift; };
sub printMethod { print "A\n"; };

1;

CPAN is the Comprehensive Perl Archive Network.

CPANM From the official App::cpanminus: "App::cpanminus - get, unpack, build and install modules from CPAN".

Find CPAN modules

There are some different alternatives to install Perl modules. We will use cpanm.

• Install cpanm:

$ cpan App::cpanminus

• Install the Test module with cpanm:

cpanm Test

Now we can test the Test installed module:

$ perl -M'Test::Simple tests => 1' -e 'ok( 1 + 1 == 2 );'
1..1
ok 1

$ perl -M'Test::Simple tests => 1' -e 'ok( 1 + 1 == 3 );'
1..1
not ok 1
#   Failed test at -e line 1.
# Looks like you failed 1 test of 1.