1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Single line comment
=pod
Multi-line comment
or documentation block
=cut

# Print statement
print "Hello, World!\n";

# Semicolons are required to end statements
my $variable = "value";

# Blocks use curly braces, not indentation
if ($condition) {
    print "Condition is true";
}

1
2
3
4
5
my $integer = 42;           # Integer
my $float = 3.14;           # Floating point
my $string = "Hello";       # String
my $undef = undef;          # Undefined value

1
2
3
4
5
my @fruits = ("apple", "banana", "cherry");
print $fruits[0];           # Accessing first element
push @fruits, "date";       # Add to end
pop @fruits;                # Remove last element

1
2
3
4
5
6
7
8
my %person = (
    "name" => "John",
    "age" => 30,
    "city" => "New York"
);
print $person{"name"};      # Accessing hash value
$person{"country"} = "USA"; # Adding new key-value pair

1
2
3
4
5
6
7
8
9
my $scalar_ref = \42;               # Scalar reference
my $array_ref = ["a", "b", "c"];    # Array reference
my $hash_ref = {"key" => "value"};  # Hash reference

# Dereferencing
print $$scalar_ref;
print $array_ref->[1];
print $hash_ref->{"key"};

1
2
3
4
5
6
7
8
9
my $local_var = "local";     # Lexically scoped variable
our $global_var = "global";  # Package-level variable
constant PI => 3.14159;      # Constant definition

# Special variables
$_ = "default variable";    # Default input/pattern-searching space
@ARGV;                      # Command-line arguments
%ENV;                       # Environment variables

1
2
3
4
5
6
7
my $sum = 5 + 3;        # Addition
my $diff = 10 - 4;      # Subtraction
my $prod = 6 * 7;       # Multiplication
my $div = 15 / 3;       # Division
my $mod = 10 % 3;       # Modulo
my $pow = 2 ** 3;       # Exponentiation

1
2
3
4
5
6
7
8
9
10
11
# Numeric comparisons
if (5 == 5) { }         # Equal
if (10 != 5) { }        # Not equal
if (10 > 5) { }         # Greater than
if (5 <= 10) { }        # Less than or equal

# String comparisons
if ("abc" eq "abc") { } # String equal
if ("abc" ne "def") { } # String not equal
if ("abc" lt "def") { } # Less than (lexically)

1
2
3
4
if ($a && $b) { }       # Logical AND
if ($a || $b) { }       # Logical OR
if (!$condition) { }    # Logical NOT

1
2
3
4
5
if ($string =~ /pattern/) {     # Match regex
    # Do something
}
$string =~ s/old/new/g;         # Global substitution

1
2
3
4
5
6
7
8
9
10
11
if ($condition) {
    # Code block
} elsif ($another_condition) {
    # Alternative block
} else {
    # Default block
}

# Ternary operator
my $result = $condition ? $true_value : $false_value;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# For loop
for (my $i = 0; $i < 10; $i++) {
    print $i;
}

# Foreach loop
my @array = (1, 2, 3, 4, 5);
foreach my $item (@array) {
    print $item;
}

# While loop
while ($condition) {
    # Code block
}

# Do-while loop
do {
    # Code block
} while ($condition);

1
2
3
4
5
6
7
use feature 'switch';
given ($variable) {
    when ('value1') { /* code */ }
    when ('value2') { /* code */ }
    default { /* code */ }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# Simple subroutine
sub greet {
    my $name = shift;
    return "Hello, $name!";
}

# Subroutine with multiple parameters
sub calculate {
    my ($a, $b, $operation) = @_;
    given ($operation) {
        when ('add') { return $a + $b; }
        when ('subtract') { return $a - $b; }
    }
}

# Anonymous subroutine (function reference)
my $multiply = sub {
    my ($a, $b) = @_;
    return $a * $b;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# Class definition
package Person;
use strict;
use warnings;

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

sub introduce {
    my ($self) = @_;
    return "I'm " . $self->{name};
}

# Inheritance
package Employee;
use parent 'Person';

sub new {
    my ($class, $name, $age, $job) = @_;
    my $self = $class->SUPER::new($name, $age);
    $self->{job} = $job;
    return $self;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Die (terminate program)
die "Fatal error message" if $error_condition;

# Warn (print warning)
warn "Warning message" if $warning_condition;

# Exception handling with eval
eval {
    # Risky code
    die "Something went wrong";
};
if ($@) {
    print "Caught error: $@";
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# Reading from a file
open(my $fh, '<', 'filename.txt') or die "Can't open file: $!";
while (my $line = <$fh>) {
    chomp $line;
    print $line;
}
close $fh;

# Writing to a file
open(my $out, '>', 'output.txt') or die "Can't open file: $!";
print $out "Some text\n";
close $out;

# Appending to a file
open(my $append, '>>', 'log.txt') or die "Can't open file: $!";

1
2
3
4
5
6
7
8
9
10
11
12
use Test::More;

sub add {
    my ($a, $b) = @_;
    return $a + $b;
}

# Test cases
is(add(2, 3), 5, "Addition works");
isnt(add(2, 2), 5, "Not equal test");
done_testing();