Perl ist eine leistungsstarke objektorientierte Skriptsprache, die für ihre Flexibilität und Benutzerfreundlichkeit bekannt ist.

=====Variablen=====
<code perl>
#!/usr/bin/perl

# Scalar variables (mit $, can hold a single value)
my $name = "John";
my $age = 30;

# Print the variables
print "Name: $name\n";
print "Age: $age\n";

# Array (mit @)
my @result = (1, 2, 3, 4, 5);


my $a = 1;
my $b = $a;
$b = 2;
print "$a -> $b"; # 1 -> 2


my $a = 1;
my $b = $a;
$a = 2;
print "$a -> $b"; # 2 -> 1
</code>

=====Parameter=====

<code perl>
# Die SCRIPT (!) Parameter abrufen
my ($arg1, $arg2) = @ARGV;

# Die Parameter verwenden
print "Argument 1: $arg1\n";
print "Argument 2: $arg2\n";

sub func {
    my ($a, $b) = @_; # ARGV
}
</code>

=====Kontrollstrukturen=====
<code perl>
# If-Else 
my $x = 10;
if ($x > 5) {
    print "x is greater than 5\n";
} else {
    print "x is less than or equal to 5\n";
}

# For loop
for my $i (1..5) {
    print "$i\n";
}

# While loop
my $count = 0;
while ($count < 5) {
    next if $count == 1; # skip 1. index
    last if $count == 3; # break after 2. index
    print "$count\n";
    $count++;
}

# Foreach loop
my @numbers = (1, 2, 3, 4, 5);
foreach my $num (@numbers) {
    print "$num\n";
}
</code>

=====Funktionen=====
<code perl>
sub greet {
    my $name = shift; # Erstes Element aus ARGV
    # oder
    # my($name, $age) = @_; # ARGV
    print "Hello, $name!\n";
}

greet("Alice");
greet("Bob");
</code>

=====Referenz (Pointer)=====

Perl verwendet Referenzen, um auf komplexe Datenstrukturen wie Arrays, Hashes und sogar auf Subroutinen zu verweisen. Referenzen ermöglichen es, komplexe Datenstrukturen zu erstellen und zu manipulieren, indem sie auf diese referenzieren.

<code perl>
# Erstellen eines einfachen Arrays
my @array = (1, 2, 3, 4, 5);

# Referenz auf das Array erstellen
my $array_ref = \@array;

# Elemente des Arrays über die Referenz zugreifen
print "Erstes Element des Arrays: " . $array_ref->[0] . "\n";
print "Letztes Element des Arrays: " . $array_ref->[-1] . "\n";

# Auf das Array über die Referenz zugreifen und es ändern
$array_ref->[0] = 10;
print "Erstes Element des geänderten Arrays: " . $array_ref->[0] . "\n";

# Das ursprüngliche Array ausgeben, um die Änderungen zu bestätigen
print "Ursprüngliches Array: @array\n";
</code>
=====Klassen=====

Obwohl Perl keine streng typisierte Sprache ist, können Klassen und Objekte in Perl implementiert werden. Perl verwendet das Konzept der sogenannten Packages, um Klassen zu erstellen und zu organisieren. Eine Package in Perl kann als Klassencontainer betrachtet werden. Eine typische Vorgehensweise besteht darin, in einer Package eine oder mehrere Subroutinen zu definieren, die als Methoden der Klasse fungieren. 

<code perl>
package Person;

sub new {
    my ($class, $name, $age) = @_;
    my $self = {
        name => $name,
        age  => $age,
    };
    bless $self, $class;
    return $self;
}

sub get_name {
    my ($self) = @_;
    return $self->{name};
}

sub get_age {
    my ($self) = @_;
    return $self->{age};
};

my $person = Person->new("John Doe", 30);
my $name = $person->get_name();
my $age = $person->get_age();

print "Name: $name\n";
print "Age: $age\n";
</code>

=====Files=====

<code perl>
# Reading from a file
open(my $file, '<', 'input.txt') or die "Cannot open file: $!";
while (my $line = <$file>) {
    chomp $line;
    print "Line: $line\n";
}
close($file);

# Writing to a file
open(my $output, '>', 'output.txt') or die "Cannot open file: $!";
print $output "Hello, World!\n";
close($output);
</code>

=====Diamond Operator=====

"<>" ist ein spezieller Operator in Perl, der als "Diamond Operator" bekannt ist. Wenn <> ohne Argumente verwendet wird, versucht Perl, Zeilen von der Standardeingabe (STDIN) zu lesen. Wenn jedoch Dateinamen als Argumente angegeben werden, versucht Perl, Zeilen aus diesen Dateien zu lesen.

Angenommen, man hat ein Perl-Skript mit dem Namen mein_skript.pl und möchte die Datei input.txt lesen.
<code>
perl mein_skript.pl input.txt
</code>
Man kann dann <> verwenden, um Zeilen aus der Datei input.txt zu lesen.
<code perl>
while (<>) {
    chomp;
    my @array = split(/:/);
    foreach my $part (@array) {
        print "$part\n";
    }
}
</code>