Perl Introduction

Perl Welcome Pratical Extraction and Reporting Language Marcos Rebelo oleber@gmail.com

Perl - Larry Wall Larry Wall, programmer, linguist, author, born March 10, 1949 in Duncan, British Columbia, Canada. Perl computer language creation in 1987.

Quotes: The three chief virtues of a programmer are: Laziness, Impatience and Hubris

There's More Than One Way to Do It

What is Perl? Perl is a general-purpose programming language originally developed for text manipulation and now used for a wide range of tasks including web development, system administration, network programming, code generation and more. It's intended to be practical rather than beautiful.

Supports both procedural and OO programming.

It has powerful built-in support for text processing

It has one of the world's most impressive collections of third-party modules (http://www.cpan.org).

Perl – Pros Quick development phases

Open Source, and free licencing

Excellent text handling and regular expressions

Large experienced active user base

Fast, for an interpreted language

Code developed is generally cross plaform

Very easy to write powerful programs in a few lines of code

Perl – Cons Limited GUI support

Can look complicated, initially, particularly if you're not familiar with regular expressions

Consider using for Web applications

Most command line applications

Database access and manipulation

Any application involving significant text processing

Hello World in a file: print "Hello, World!\n" on the shell #> perl -e 'print "Hello, World!\n"' with perl 5.10 #> perl -E 'say "Hello, World!"'

Basic syntax overview Perl statements end in a semi-colon. say("Hello, world!") ;

You can use parentheses for subroutines arguments or omit them according to your personal taste. say "Hello, world!";

Comments start with a # and run to the end of the line. # This is a comment

Basic syntax overview Double quotes or single quotes may be used around literal strings: say( " Hello, world! " ); say( ' Hello, world! ' );

However, only double quotes interpolate variables and special characters such as newlines (\n): print("Hello, $name!\n "); # interpolate $name print('Hello, $name!\n '); # prints $name!\n literally

Basic syntax overview Whitespaces are irrelevant: print( "Hello world");

... except inside quoted strings: print("Hello world"); # this would print with a # line break in the middle.

Use feature qw(say) Perl 5.10 as added a new feature use feature qw(say); say 'Hello, world!'; Is equivalent to: print 'Hello, world!', "\n"; We will see later that the correct expression is: { local $\ = "\n"; print 'Hello, world!' }

Running Perl programs To run a Perl program from the Unix command line: #> perl progname.pl

Alternatively, put this shebang in your script : #!/usr/bin/perl and run your executable script #> progname.pl

-e : allows you to define the Perl code in the command line to be executed, -E to get 5.10 #> perl -e 'print("Hello, World!\n")'

Perl variable types Scalars my $ animal = 'camel'; my $ answer = 42; my $ scalar_ref = \$scalar;

Arrays my @ animals = ('camel', 'lama'); my @ numbers = (23, 42, 69); my @ mixed = ('camel', 42, 1.23);

Associative Array / Hash Tables my % fruit_color = ( apple => 'red', banana => 'yellow' );

Scalar Type Scalar values can be strings, integers, floating point numbers or references. The variable name starts with a $ . my $ animal = 'camel';

my $ scalar_ref = \$scalar; Perl will automatically convert between types as required. print('3' + 4.5); # prints 7.5

Array Type An array represents a list of scalars. The variable name starts with a @ . my @ animals = ('camel', 'llama');

my @ mixed = ('camel', 42, 1.23); Arrays are zero-indexed, negative index start by -1 at the end of the array. print( $ animals [0] ); # prints "camel"

print( $ numbers [-1] ); # prints 69

Array Slice To get multiple values from an array: @ numbers [0,1] ; # gives (23, 42);

@ numbers [0..2] ; # gives (23, 42, 69);

@ numbers [1..$#numbers] ; The single element we're getting from the array start with a $ , the sub-array start with @ .

@ numbers [2, 1] = @ numbers [1, 2] ;

($scalar1, $scalar2) = @numbers;

Array Type The special variable $# array tells you the index of the last element of an array: print($mixed[ $# mixed]); # prints 1.23 You might be tempted to use $#array+1 to tell you how many items there are in an array. Using @array in a scalar context will give you the number of elements: if (@animals < 5) { ... }

if ( scalar( @animals ) < 5) { ... }

Associative Array Type Hash table A hash represents a set of key/value pairs: my % fruit_color = ( 'apple', 'red', 'banana', 'yellow' ); You can use whitespace and the => operator to lay them out more nicely: my % fruit_color = ( apple => 'red', ' banana ' => 'yellow' );

Associative Array Type Hash table To get at hash elements: $ fruit_color{ ' apple ' }; # "red"

$ fruit_color{banana}; # "yellow" You can get at lists of keys and values with keys() and values() . my @fruits = keys (%fruit_colors);

my @colors = values (%fruit_colors); Hashes have no particular internal order, though you can sort the keys and loop through them.

Hash Slice To get/set multiple values from an hash @ fruit_color { 'watermelon', 'orange' } = ('green', 'orange'); Removing repetition from an array my @array = (1,2,9,5,2,5); my %hash ; @hash{@array} = (); @array = keys(%hash) ; say "@array"; # 1 9 2 5

Variable Reference Scalar references \$ scalar, \ '' , \ 123 Array references \@ array, [ 'camel', 42, 1.23 ] Hash references \% hash, { apple => 'red', banana => 'yellow' } Unref a variable $$ scalar_ref, @$ array_ref, %$ hash_ref

Complex data types More complex data types can be constructed using references: my $cities = { IT => [ 'Milan', 'Rome', ... ] , PT => [ 'Lisbon', 'Oporto', ... ] , ... } ; You can access it throw: print($cities ->{ ' IT' } -> [ 1 ] ); print($cities ->{ ' IT' }[ 1 ] );

my @citiesPT = @{ $cities->{PT} } ;

Lexical Variables Throughout the previous slides the examples have used the syntax: my $var = 'value'; The my is actually not required, you could use: $var = 'value'; However, the above usage will create global variables throughout your program. my creates lexically scoped variables instead. The variables are scoped to the block in which they are defined.

Lexical Variables Not having the variables scoped is usually a bad programming practice. my $a = 'foo'; if ($some_condition) { my $b = 'bar'; print($a); # prints "foo" print($b); # prints "bar" } print($a); # prints "foo" print($b); # prints nothing; $b has # fallen out of scope

Lexical Variables It’s recommended to use my in combination with a use strict at the top of your programs. Using the pragma strict is highly recommended. use strict; my $first = "first"; # OK $second = "second"; # NOT OK Also highly recommended is the pragma warnings for having aditional warnings. You can enable or deseable this warnings.

Magic variables There are some ‘magic’ variables. These special variables are used for all kinds of purposes. $_ : is the ‘default variable’.

@ARGV : the command line arguments to your script.

$ARGV : contains the name of the current file when reading from <> or readline() .

@_ : the arguments passed to a subroutine.

$a , $b : Special package variables when using sort() .

$/ : The input record separator, newline by default.

Most common operators Arithmetic + += addition

/ /= division Boolean logic && and

Most common operators Miscellaneous = assignment

.. range operator (creates a list of numbers)

Conditional constructs Perl has most of the usual conditional if COND BLOCK

if COND BLOCK elsif COND BLOCK

if COND BLOCK elsif COND BLOCK else BLOCK The COND shall be conditional statement surround by ( and ) , and BLOCK shall be one ore more statements surround by { and } . if ( is_valid( $value ) ) { … }

Conditional constructs There's also a negated version of if (don't use it): unless ( is_valid( $value ) ) { ... }

This is provided as a 'more readable' version of if ( not( is_valid( $value ) ) ) { ... }

0, '0', '', () and undef are all false in a boolean context. All other values are true.

Conditional constructs Note that the braces are required in Perl, even if you've only got one line in the block. However, there is a clever way of making your one-line conditional blocks more English like: The traditional way if ($zippy) { print("Yow!"); }

The Perlish post-condition way print("Yow!") if $zippy; print("No cubes") unless $cubes;

while looping constructs Perl has most of the usual loop constructs. While Loop: while ( is_valid( $value ) ) { … }

There's also a negated version (don't use it): until ( is_valid( $value ) ) { … }

You can also use while in a post-condition: print("xpto\n") while condition;

Going throw a hash: while (my ($key,$value) = each (%ENV)){ print "$key=$value\n"; }

for looping constructs for (my $i=0; $i <= $max; $i++) { ... } The C style for loop is rarely needed in Perl since Perl provides the more friendly foreach loop. foreach my $i (0 .. $max) { ... }

foreach looping constructs Passing all elements of an array, foreach is an alias to for . foreach my $var (@array) { ... }

for my $value (values(%hash)) { ... } By default the value goes on $_ foreach (@array) { print " $_ \n" } Changing the variable, changes the value inside the array. $var is an alias. for my $var (@array) { $var += $var }

Jump on loops LINE: while ( defined(my $line = <>) ) { next LINE if not is_valid( $line ); #... }

Jump on loops: last LABEL : immediately exits the loop in question

next LABEL : starts the next iteration of the loop

redo LABEL : restarts the loop block without evaluating the conditional again If the LABEL is omitted, the command refers to the innermost enclosing loop.

Inverting the cycle With a single command print foreach (0..9) With multiply commands do { ... } while ($true)

Warning: last , next , and redo don't work in this case.

Exercises 1 - Scalars 1) Implement the ‘Guess the lucky number’. The program shall chose a random number between 0 and 100 and ask the user for a guess. Notice the user if the guess is bigger, smaller or equal to the random number. If the guess is correct the program shall leave otherwise re-ask for a number.

Exercises 1 - Array 2) Create an array that contains the names of 5 students of this class. 2a) Print the array. 2b) Create a new Array shifting the elements left by one positions (element 1 goes to 0, …) and setting the first element in the last position. Print the array. 2c) Ask a user to input a number. Print the name with that index.

Exercises 1 - Hash 3) Homer Family my %relatives = ( Lisa => 'daughter', Bart => 'son', Maggie => 'daughter', Marge => 'mother', Homer => 'father', Santa => 'dog'); 3a) Print all the characters name’s. 3b) Demand for a name and print is position. 3c) Print all the characters position’s, no repetitions. 3d) Demand for a position and print the name.

Subroutines The Perl model for subroutine call and return values is simple: all subroutine are passed as parameters one single flat list of scalars (goes to @_ )

all subroutines likewise return to their caller one scalar or a list of scalars.

lists or hashes in these lists will collapse, losing their identities - but you may always pass a reference.

The subroutine name start with a & , for simplification can be omitted.

Subroutine - example sub max { my $mval = shift(@_) ; # my ($mval, @rest) = @_ ; # big copy foreach my $foo ( @_ ) { if ( $mval < $foo ) { $mval = $foo; } } return $mval; }

my $my_max = max( 1, 9, 3, 7 ) ; print $my_max; # prints 9

Subroutine input and output The parameters are passed to the subroutine in the array @_ , changing the values of the array will change the values outside the subroutine call. sub double { $_[0] *= 2 ; } my $b = 5; double($b); print($b); # prints 10 The last statement value is returned by default. print(double($b)); # prints 20

Subroutine input and output Using @_ is dangerouse and shall be carefully considered. It's always possible to do a copy. sub double { my ($a) = @_; $a *= 2; return $a; } my $b = 5; print( double( $b ) ); # prints 10 print($b); # prints 5

Persistent Private Variables Just because a lexical variable is statically scoped to its enclosing block, eval, or file. { my $secretVal = 0; sub gimmeAnother { return ++$secretVal; } } print gimmeAnother; # OK ++$secretVal; # NOT OK

state variables From perl 5.10 you may use static variables. use feature 'state'; sub gimmeAnother { state $secretVal = 0; return ++$secretVal; } print gimmeAnother; # OK Some features in perl 5.10 have to be activated to avoid colisions with old code. Activating all them: use feature ':5.10'; use v5.10; # use perl 5.10

Named Parameters We can implement named parameters using a hash. This provides an elegant way to pass in parameters without having to define them formally. sub login { my %param = @_; ... } login( user=>'User', pass=>'Pass' );

Named Parameters We may pass the hash directly. sub login { my ($param) = @_; ... } login({ user=>'User', pass=>'Pass' });

Named Parameters We can easily give default values by checking the hash. sub login { my ($param) = @_; $param->{user} = $DEFAULT_USER if not exists $param->{user}; $param -> {pass} = $DEFAULT_PASS if not exists $param->{pass}; $param->{host} = $DEFAULT_HOST if not exists $param->{host}; ... }

Named Parameters We can easily give default values by checking the hash. sub login { my $param = { 'user' => $DEFAULT_USER, 'pass' => $DEFAULT_PASS, 'host' => $DEFAULT_HOST, %{shift(@_)} }; ... }

Named Parameters We can also write the subroutine so that it accepts both named parameters and a simple list. sub login { my $param; if ( ref($_[0]) eq 'HASH' ) { $param = $_[0]; } else { @{$param}{qw(user pass host)}=@_; } ... } login('Login', 'Pass'); login({user => 'Login', pass => 'Pass'});

Exercises 2 1) Create a new subroutine that calculates the Fibonacci series. Using this subroutine, do a program that receives multiple numbers as argument and prints the Fibonacci value. F(0) = 0 F(1) = 1 F(n) = F(n-1) + F(n-2) 1a) with presistent variable 1b) with state variable

Read a File open( FH, '<', 'path/to/file' ) or die "can't open file: $! "; while ( defined( my $line = <FH> ) ) { chomp($line); … } close( FH ) ;

Open a Filehandler Opening a file for input. open (INFH, " < ", "input.txt") or die $!;

open (INFH, " < input.txt") or die $!;

open (INFH, "input.txt") or die $!; Opening a file for output. open (OUTFH, " > ", "output.txt") or die $!;

open (OUTFH, " > output.txt") or die $!; Opening a file for appending open (LOGFH, " >> ", "my.log") or die $!;

open (LOGFH, " >> my.log") or die $!;

Open a Filehandler You can also use a scalar variable as filehandle: open( my $inFH , "input.txt") or die $!;

a lexical scalar variable closes at the end of the block if it wasn't closed before It's possible to pipe from a command: open(my $net, "netstat | ") or die "Can't netstat: $!"; It's possible to pipe to a command: open(my $sendmail, " | sendmail -t") or die "Can't open sendmail: $!";

Write to a Filehandle We've already seen how to print to standard output using print(). However, print() can also take an optional first argument specifying which filehandle to print to: print STDERR ('Are you there?');

Note: There is no ‘,’ between filehandle and the text. Closing File Handles: close($inFH);

Read from a Filehandle You can read from an open filehandle using the <> operator or the readline() subroutine. Line by line: my $line = <$fh> ; my $line = readline($fh) ;

Perl Introduction

More Related Content

What's hot

Viewers also liked

Similar to Perl Introduction

More from Marcos Rebelo

Recently uploaded

Perl Introduction

Editor's Notes