Perl - Pocket Guide

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
Scalar
Array
Hash
Reference
Predefined variable
Simple statement
Compound statements
Loop control
For loop
Foreach loop
Regular expressions
Files and Pipes
Directories

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

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

`+, -, /, , %, *, ++, --`	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

`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

`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

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

`$_`	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

`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)

`\`	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]

`*`	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

`<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 \|"`

`-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

`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