0% found this document useful (0 votes)
15 views14 pages

Perl 2

This document is an in-depth tutorial on Perl scripting, covering topics from setting up a Perl environment to advanced features like regular expressions and file handling. It includes sections on basic syntax, data types, operators, control structures, subroutines, and best practices. The tutorial aims to provide comprehensive guidance for both beginners and experienced programmers looking to enhance their Perl skills.

Uploaded by

aditya
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
15 views14 pages

Perl 2

This document is an in-depth tutorial on Perl scripting, covering topics from setting up a Perl environment to advanced features like regular expressions and file handling. It includes sections on basic syntax, data types, operators, control structures, subroutines, and best practices. The tutorial aims to provide comprehensive guidance for both beginners and experienced programmers looking to enhance their Perl skills.

Uploaded by

aditya
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 14

Perl Scripting: An In-Depth Tutorial

March 30, 2025

Contents
1 Introduction to Perl 2

2 Setting Up a Perl Environment 3

3 Basic Syntax and Structure 3


3.1 Comments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

4 Variables and Data Types 4


4.1 Scalar Variables ($) . . . . . . . . . . . . . . . . . . . . . . . . . . 4
4.2 Arrays (@) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
4.3 Hashes (%) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

5 Operators 5
5.1 Arithmetic Operators . . . . . . . . . . . . . . . . . . . . . . . . 5
5.2 String Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
5.3 Comparison Operators . . . . . . . . . . . . . . . . . . . . . . . . 6
5.3.1 Numeric Comparisons . . . . . . . . . . . . . . . . . . . . 6
5.3.2 String Comparisons . . . . . . . . . . . . . . . . . . . . . 6
5.4 Logical Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

6 Control Structures 6
6.1 Conditionals (if, elsif, else, unless) . . . . . . . . . . . . . . 6
6.2 Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
6.2.1 for Loop . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
6.2.2 foreach Loop . . . . . . . . . . . . . . . . . . . . . . . . . 7
6.2.3 while, until . . . . . . . . . . . . . . . . . . . . . . . . . 7
6.2.4 Loop Controls: next, last, redo . . . . . . . . . . . . . . 7

7 Subroutines (Functions) 8

8 I/O Operations 8
8.1 Reading from STDIN . . . . . . . . . . . . . . . . . . . . . . . . . 8
8.2 Writing to STDOUT . . . . . . . . . . . . . . . . . . . . . . . . . 8
8.3 Command-Line Arguments . . . . . . . . . . . . . . . . . . . . . 8

1
9 Regular Expressions (Regex) 9
9.1 Match: = /̃pattern/ . . . . . . . . . . . . . . . . . . . . . . . . . 9
9.2 Substitution: s/// . . . . . . . . . . . . . . . . . . . . . . . . . . 9
9.3 Transliteration: tr/// . . . . . . . . . . . . . . . . . . . . . . . . 10

10 References and Complex Data Structures 10


10.1 Creating References . . . . . . . . . . . . . . . . . . . . . . . . . 10
10.2 Dereferencing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
10.3 Anonymous References . . . . . . . . . . . . . . . . . . . . . . . . 10
10.4 Nested Data Structures . . . . . . . . . . . . . . . . . . . . . . . 11

11 Modules and Packages 11


11.1 CPAN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

12 File Handling 12
12.1 Reading from a File . . . . . . . . . . . . . . . . . . . . . . . . . 12
12.2 Writing to a File . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
12.3 Appending to a File . . . . . . . . . . . . . . . . . . . . . . . . . 12

13 Additional Topics 12
13.1 Taint Mode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
13.2 Special Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
13.3 One-Liners . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

14 Best Practices 13

15 Conclusion 14

1 Introduction to Perl
Perl (Practical Extraction and Reporting Language) is a high-level, dynamic
programming language originally developed by Larry Wall in 1987. It excels
at text processing, system administration, and web development, among other
domains. A common Perl motto, "There’s more than one way to do it" (TM-
TOWTDI), reflects the language’s flexibility in problem-solving.
Key features of Perl:

• Strong text processing capabilities: Regular expressions are deeply


integrated.
• Dynamic typing: Variables’ types are inferred at runtime.
• CPAN (Comprehensive Perl Archive Network): A large repository
of community-contributed modules.

2
2 Setting Up a Perl Environment
Most Unix-like systems (Linux, macOS) come with Perl pre-installed. Check
with:
1 perl -v

If Perl is not installed:

• Linux: Use your package manager, e.g., apt-get install perl or yum
install perl.
• macOS: Often already installed; if not, install via brew install perl.
• Windows: Use Strawberry Perl (includes a C compiler) or ActivePerl.

Run scripts with:


1 perl your_script.pl

Or start an interactive shell (debugger) with:


1 perl -de 1

3 Basic Syntax and Structure


A minimal Perl script:
1 #!/usr/bin/perl
2 use strict;
3 use warnings;
4
5 print "Hello, World!\n";

Shebang line: #! /usr/bin/perl tells the system which interpreter to use.


use strict and use warnings: Enforce good coding practices, catch errors
early.
Printing: print outputs to STDOUT.

3.1 Comments
Single-line comments use the # symbol:
1 # This is a single-line comment

For multi-line commentary, Perl does not have a native multi-line comment
syntax; use POD (Plain Old Documentation) if extensive commenting is needed.

3
4 Variables and Data Types
Perl has three primary data types, each with its own sigil (prefix):
• Scalars: $variable
• Arrays: @array
• Hashes: %hash

4.1 Scalar Variables ($)


A scalar can hold a string, number, or reference:
1 my $name = "Alice";
2 my $age = 30;
3 my $score = 95.5;

String Interpolation:
1 print "Name: $name\n"; # interpolates $name
2 print ’Name: $name\n’; # does not interpolate

Variable Context: Automatic conversion between numeric and string context:


1 my $mixed = "42";
2 my $sum = $mixed + 10; # interpreted as number => 52

4.2 Arrays (@)


Arrays are ordered lists of scalars:
1 my @fruits = ("apple", "banana", "cherry");

Accessing Elements:
1 print $fruits[0]; # apple
2 print $fruits[1]; # banana

Special Indices and Length:


1 my $last_index = $#fruits; # last index
2 my $count = scalar(@fruits); # number of elements

Adding & Removing Elements:


1 push @fruits, "date"; # add to end
2 my $popped = pop @fruits; # remove from end
3
4 unshift @fruits, "mango"; # add to front
5 my $shifted = shift @fruits; # remove from front

Array Slices:
1 my @subset = @fruits[0,2]; # get elements at indices 0 and 2

4
4.3 Hashes (%)
Hashes store key-value pairs:
1 my %capitals = (
2 "France" => "Paris",
3 "Germany" => "Berlin",
4 "Switzerland" => "Bern"
5 );

Accessing and Modifying:


1 print $capitals{"France"}; # Paris
2 $capitals{"Spain"} = "Madrid"; # add new pair

Keys and Values:


1 my @countries = keys %capitals; # all keys
2 my @city_names = values %capitals; # all values
3
4 while ( my ($country, $city) = each %capitals ) {
5 print "Country: $country -> City: $city\n";
6 }

Deleting Entries:
1 delete $capitals{"France"};

5 Operators
5.1 Arithmetic Operators
• +, -, *, /, % (modulus)
• ** (exponentiation)

1 my $x = 10;
2 my $y = 3;
3 print $x + $y; # 13
4 print $x % $y; # 1
5 print $x ** $y; # 10^3 = 1000

5.2 String Operators


• Concatenation (.):
1 my $str = "Hello" . " " . "World"; # "Hello World"

• Repetition (x):
1 my $repeat = "Ha" x 3; # "HaHaHa"

5
5.3 Comparison Operators
5.3.1 Numeric Comparisons
==, !=, <, >, <=, >=
1 if ($x == $y) {
2 print "Equal numbers\n";
3 }

5.3.2 String Comparisons


eq, ne, lt, gt, le, ge
1 if ($name eq "Alice") {
2 print "Hello, Alice!\n";
3 }

5.4 Logical Operators


&& (AND), || (OR), ! (NOT) and their lower-precedence counterparts and, or,
not.
1 if ($x < 10 && $y > 5) {
2 print "x < 10 AND y > 5\n";
3 }

6 Control Structures
6.1 Conditionals (if, elsif, else, unless)

1 my $age = 18;
2
3 if ($age < 13) {
4 print "Child\n";
5 } elsif ($age < 20) {
6 print "Teen\n";
7 } else {
8 print "Adult\n";
9 }
10
11 # unless is the logical opposite of if
12 unless ($age > 18) {
13 print "You are not older than 18.\n";
14 }

6
6.2 Loops
6.2.1 for Loop

1 for (my $i = 0; $i < 5; $i++) {


2 print "i = $i\n";
3 }

6.2.2 foreach Loop

1 my @colors = ("red", "green", "blue");


2 foreach my $color (@colors) {
3 print "$color\n";
4 }
5
6 # Shorthand
7 for my $color (@colors) {
8 print "$color\n";
9 }

6.2.3 while, until

1 my $count = 0;
2 while ($count < 3) {
3 print "Count is $count\n";
4 $count++;
5 }
6
7 my $value = 5;
8 until ($value <= 0) {
9 print "Value is $value\n";
10 $value--;
11 }

6.2.4 Loop Controls: next, last, redo

1 for my $num (1..10) {


2 next if $num == 3; # skip 3
3 last if $num == 8; # stop at 7
4 print "$num\n";
5 }

7
7 Subroutines (Functions)
1 sub greet {
2 my ($name) = @_; # @_ holds subroutine arguments
3 print "Hello, $name!\n";
4 }
5
6 greet("Alice");
7 greet("Bob");

Returning Values:
1 sub add {
2 my ($a, $b) = @_;
3 return $a + $b;
4 }
5
6 my $sum = add(2, 3); # 5

8 I/O Operations
8.1 Reading from STDIN

1 print "Enter your name: ";


2 my $input = <STDIN>;
3 chomp($input); # remove trailing newline
4 print "Hello, $input!\n";

8.2 Writing to STDOUT

1 print "Some output here\n";

8.3 Command-Line Arguments


Accessed via @ARGV:
1 my $first_arg = $ARGV[0];
2 print "First argument: $first_arg\n";

Usage:
1 perl script.pl arg1 arg2

8
9 Regular Expressions (Regex)
Perl is famous for its integrated regex support.

9.1 Match: = /̃pattern/

1 my $text = "Hello World";


2 if ($text =~ /World/) {
3 print "Found ’World’!\n";
4 }
5
6 # Case-insensitive:
7 if ($text =~ /world/i) {
8 print "Found ’world’ ignoring case!\n";
9 }

Capturing Groups ((...)) store matched substrings in $1, $2, etc.:


1 my $str = "Name: Alice, Age: 30";
2 if ($str =~ /Name: (\w+), Age: (\d+)/) {
3 print "Name: $1, Age: $2\n";
4 }

Common Special Characters:

• . matches any character except newline


• startof string, $endof string+(oneormore), *(zeroormore), ?(zeroorone)
• \d digit, \w word char, \s whitespace
• Character classes: [abc], [a-z], [a − z](negation)
Quantifiers:
• +, *, ?, {n}, {n,}, {n,m}
Lookahead/Lookbehind (advanced):
1 # Positive lookahead: "abc" only if followed by "def"
2 if ($string =~ /abc(?=def)/) { ... }
3
4 # Negative lookbehind: "xyz" only if NOT preceded by "123"
5 if ($string =~ /(?<!123)xyz/) { ... }

9.2 Substitution: s///

1 my $phrase = "I love cats.";


2 $phrase =~ s/cats/dogs/; # "I love dogs."
3

9
4 # Global replacement
5 my $text = "apple banana apple pear";
6 $text =~ s/apple/orange/g; # "orange banana orange pear"

9.3 Transliteration: tr///

1 my $dna = "ATTGCC";
2 $dna =~ tr/ACGT/TGCA/; # complement
3 print $dna; # "TAACGG"

10 References and Complex Data Structures


References allow more complex structures such as arrays of arrays, hashes of
hashes, etc.

10.1 Creating References

1 my @arr = (1, 2, 3);


2 my $arr_ref = \@arr; # reference to @arr
3
4 my %hash = (a => 1, b => 2);
5 my $hash_ref = \%hash; # reference to %hash

10.2 Dereferencing

1 my @original = @$arr_ref;
2 my $first = $arr_ref->[0]; # array index via ->
3
4 my %orig_hash = %$hash_ref;
5 my $value = $hash_ref->{"a"}; # access by key

10.3 Anonymous References

1 my $array_ref = [1, 2, 3]; # anonymous array


2 my $hash_ref = {a => 1, b => 2}; # anonymous hash
3
4 print $array_ref->[1]; # 2
5 print $hash_ref->{"a"}; # 1

10
10.4 Nested Data Structures
1 my $users = {
2 "alice" => {
3 "age" => 25,
4 "email" => "[email protected]"
5 },
6 "bob" => {
7 "age" => 30,
8 "email" => "[email protected]"
9 }
10 };
11
12 print $users->{"alice"}->{"email"}; # "[email protected]"

11 Modules and Packages


Perl code can be organized into reusable modules (packages). A package defines
a separate namespace:
1 package MyModule;
2
3 use strict;
4 use warnings;
5 use Exporter ’import’;
6
7 our @EXPORT_OK = (’greet’);
8
9 sub greet {
10 my ($name) = @_;
11 print "Hello, $name\n";
12 }
13
14 1; # modules must end with a true value

Then in another script:


1 use strict;
2 use warnings;
3 use lib ’.’; # add current dir to @INC
4 use MyModule ’greet’; # import greet function
5
6 greet("Alice");

11.1 CPAN
CPAN (Comprehensive Perl Archive Network) hosts thousands of modules.
Install modules with cpan or cpanm:

11
1 cpanm JSON

Then use JSON; in your script.

12 File Handling
12.1 Reading from a File

1 my $filename = "input.txt";
2 open(my $fh, "<", $filename) or die "Could not open ’$filename’: $!";
3 while (my $line = <$fh>) {
4 chomp($line);
5 print "Line: $line\n";
6 }
7 close($fh);

12.2 Writing to a File

1 my $out = "output.txt";
2 open(my $fh_out, ">", $out) or die "Could not open ’$out’: $!";
3 print $fh_out "Some text here\n";
4 close($fh_out);

12.3 Appending to a File

1 open(my $fh_app, ">>", "logfile.txt") or die "Could not open ’logfile.txt


’: $!";
2 print $fh_app "Appending this line\n";
3 close($fh_app);

13 Additional Topics
13.1 Taint Mode
Run scripts with -T to enable taint mode for better security (prevents using
untrusted data without sanitization):
1 perl -T script.pl

12
13.2 Special Variables
• $_: Default variable in many operations (e.g., print if /regex/;).
• @_: Holds arguments passed to a subroutine.
• $0: Name of the script.

• $?: Exit status of the last command.

13.3 One-Liners
Perl is great for command-line one-liners:
1 echo "Hello World" | perl -pe ’s/Hello/Goodbye/’

• -p: Loops over lines of input, printing automatically.


• -n: Loops over lines without printing automatically.
• -e: Executes the provided code.

14 Best Practices
1. Use strict and warnings to catch errors early:
1 use strict;
2 use warnings;

2. Use lexical variables: Always declare with my.


3. Write clear code: Perl allows terse code, but clarity is key.
4. File operations: Always check return values with die or warn if errors
occur.

5. Avoid deprecated features: Use modern Perl features and references.


6. Regex usage: Regexes are powerful but can become complex. Comment
complex patterns.
7. Testing: Use testing frameworks like Test::Simple or Test::More.

8. Use CPAN: Reuse existing modules instead of reinventing the wheel.

13
15 Conclusion
This tutorial has covered a broad range of Perl topics:

• Installation and running Perl


• Fundamental syntax (variables, operators, control structures)
• Subroutines, references, and modules

• Powerful regular expressions


• File handling
• Best practices
With the motto “There’s more than one way to do it”, Perl offers flexibility
for solving diverse problems. Continue exploring by working on real text pro-
cessing tasks, discovering CPAN modules, and writing your own scripts using
strict and warnings to help ensure robust and maintainable code.

14

You might also like