CS

 Useful links:

POLI's homepage


[back]

Perl - Pocket Guide


Shortest PERL Documentation

Petr Olivka, dept. of Computer Science, VSB-TU Ostrava, email

This documentation is not for beginners, it is short pocket guide designed for little experienced users.

Content

Variable

$name scalar
@name array
%name associative array, hash table
\$name, $$name reference, dereference

Scalar - Number or String

Scalar - number or string, used acording to context.

    $num = 32;
    $flo = 3.14;
    $ret = "hello";
    
    print $num + $flo, "\n";
    print "2^5 is",  $num, "\n";
    print "$ret, pi is $flo\n";
    

Aritmetic operations and functions:

+, -, /, *, %, **, ++, -- Aritmetic operators
==, !=, <. <=, >, >= Equality operators
~, &, |, <<, >> Bitwise operators
sin, cos, atan2, abs, sqrt, log, exp Math. functions
int( x ), hex( str ), oct( str ), rand( n ), srand Other functions
and, &&, or, ||, not, ! Logical operators

String operations and functions:

eq, ne, lt, le, gt, ge Equality operators:
. concatenate
chomp delete EOL
chop delete last char
chr( ch ) return ordinal number of char
index( str, substr [, offset ] ) position of substring or -1, start at offset
join( separator, array ) return joined strings
lc( str ) string to lower case
lcfirst( str ) first char to lower case
length( str ) number of characters
ord( num ) get character form num
rindex( str, substr [, offset] ) last position of substring, start before offset
split( /pattern/, string [, limit ] ) splits string into array of string
substr( str, +/-index [, +/-num [, new ] ] return string from index and replace with new, if defined
uc( str ) string to upper case
ucfirst( str ) first char to lower case

Array

    @ar1 = ( 1, 2, 3, 4, 5 );
    @ar2 = ( "yes", "no" );
    @ar3 = @ar1[ 1 .. 3 ];
    ($yes, $no) = @ar2;
    
    print $ar2[ 0 ], "/", $ar2[ 1 ], "\n";
    print @ar1[ 0, 2, 4 ], @ar3, "\n";
  
    print "\@ar1: first index", $[, "\n";
    print "\@ar1: last index ", $#ar1, "\n";
    print "\@ar1: (",  join ( ",", @ar1 ), ")\n";
    

Functions:

pop( @ar ) delete and return last element
push( @ar, list ) add list to end of array
shift( @ar ) remove and return first element
unshift( @ar, list ) prepend list to front of array
splice( @ar, from [, num [, list ] ] remove and return num elements from and replace them with list, if defined

Hash

Associative array is pair of key and value.

    #           key1 - val  key2 - val   key3   - val
    %speed = ( "slow", 50, "fast", 100, "fastest", 150 );
    %speed2 = ( "slow" => 50, "fast" => 100, "fastest" => 150 );
    
    $speed{ race } = 300;
    
    print $speed{ slow };
    print $speed{ "fast" };
    print $speed{ Fastest }; # key not defined !
    print $speed{ 'race' };
    
    print $ENV{ PATH };
  
    foreach $k ( keys %ENV ) { print "$k\n"; }
    foreach $v ( values %ENV ) { print "$v\n"; }
    

Functions:

delete( %speed{ key } ) delete key
exists( %speed{ key } ) exists hash key ?
keys( %speed ) return list of keys
values( %speed } ) return list of values

Reference

Reference can be defined for all types of variables.

    $str = "hello";
    @ara = ( 1, 2, 3 );
    %hash = ( true, 1, false, 0 );
    
    $rstr = \$str;
    $rara = \@ara;
    $rhash = \%hash;
    
    print $$rstr;                   # "hello"
    print @$rara; 		  # print whole array - 123
    print $$rara[ 1 ];
    print ${$rara}[ 2 ];            # 3
    print keys %$rhash;             # truefalse
    print $$rhash{ "false" };       # 0
    

Predefined variable

$_default input
$<digit> last pattern match
$&, $MATCH last matched string
$`, $PREMATCH string preceding matched string
$', $POSTMATCH string following matched string
$., $NR current line number
$? status of last pipe, `` command or system() ($?>>8)=code, ($? & 255)=signal
$! current errno
$@ last eval() error
$$, $PID this process number
$<, $UID real uid of this process
$>, $EUID efective uid
$(, $GID real gid
$), $EGID efective gid
$0 script name
$[ index of first array element
$] perl version + pathlevel / 1000
$ARGV current file name when reading from <>
@ARGV command line arguments
$#ARGV last argument index, first is 0
@_ parameters passed to subroutine
%ENV, $ENV{name} environment variables
%SIG, $SIG{name} signal handlers

Simple statement

The simple statement is an expression terminated with a semicolon.

Any statement may be followed by single modifier. The possible modifiers are:

  • if EXPR
  • unless EXPR
  • while EXPR
  • until EXPR
    print "Hello\n" if $debug;
    die "No arguments\n" unless $#ARGV + 1;
    print while <>;
    $line =  <> until $line =~ /^end/;
    

Compound statements

Sequence of statements delimited by curly brackets is called a block.

To control flow may be used:

    if (EXPR) BLOCK
    if (EXPR) BLOCK else BLOCK
    if (EXPR) BLOCK elsif (EXPR) BLOCK ... else BLOCK
    LABEL while (EXPR) BLOCK
    LABEL while (EXPR) BLOCK continue BLOCK
    LABEL for (EXPR; EXPR; EXPR) BLOCK
    LABEL foreach VAR (LIST) BLOCK
    LABEL BLOCK continue BLOCK
    

The LABEL is optional.

Loop control

Two commands can be used in loop:

next LABEL skip rest of loop and start next iteration (like continue in C)
last LABEL exit the loop and continue block is not executed (like break in C)

For loop

For loop work like in C:

    for ( Init_Expr; Condition_Expr; PostLoop_Expr ; ) { ... }
  
    for ( $i; $i < 10; $i++ ) { print $i; } # print 123456789
    

Foreach loop

Foreach is synonym for for.

    for $arg ( @ARGV ) { print "$arg\n"; }
  
    foreach $num ( 1, 3, 5, 7, 11, 17, 23 ) { print "$num is a prime\n"; }
  
    for $i ( 1 .. 10 ) { print "$i\n"; }
    

Regular expressions

RegExp is used in pattern matching. The following metacharacters have their standard meaning:

\ quote the next metacharacter
^ begin of the line
$ end of line
. any character
| alternation
() grouping
[] character class
\d [0-9]
\D [^0-9]
\w [a-zA-Z0-9_]
\W [^a-zA-Z0-9_]
\s [ \r\n\t\f]
\S [^ \r\n\t\f]

Standard quantifiers:

* match 0 or more times
+ match 1 or more times
? match 1 or 0 times
{n} match exactly n times
{n,} match at least n times
{n,m} match at least n and no more than n times

Quantified pattern match as many times as possible. To match minimum number of times posible, follow the quantifier with ? - *?, +?, ....

Files and Pipes

<FILE> read from file
getc( FILE ) read char from file
open( FILE, name ) open file
print FILE list print string
printf FILE list print string
close( FILE ) close file
STDIN, STDOUT, STDERR standard file handles

'<name' open file for read
'>name' create new file for write
'>>name' open for append
'+<name' open for read/write
'+>name'
'-' open stdin
'>-' open stdout
'| program' open program as pipe - for read "netstat |"

Test file:

-r file is readable
-w file is writable
-x file is executable
-e file exist
-f is a file
-d is a directory
-l is a symbolic link
-z file is empty
-s file is not empty

Directories

chdir( dir ) change directory
chmod( rights, list ) change rights
chown( uid, gid, list ) change owner
closedir( DIR ) close opened directory
link( existing, link ) make hard link
mkdir( dir, rights ) make directory
opendir( DIR, dir ) open directory
readdir( DIR ) return next filename
rename( old, new ) rename file
rmdir( dir ) delete directory
symlink( existing, link ) make symbolic link
unlink( list ) delete files