Document Conventions

Contents

Command-Line Options

Contents

Literals

Numeric:

String:

"abc" Variables are interpolated and escape sequences are processed.
qq/abc/.

Escape sequences: \t (Tab), \n (Newline), \r (Return), \f (Formfeed), \b (Backspace), \a (Alarm), \e (Escape), \033 (octal), \x1b (hex), \c[ (control)
\l and \u lowercase/uppercase the following character. \L and \U lowercase/uppercase until a \E is encountered.
\Q quote regular expression characters until a \E is encountered.

`COMMAND` evaluates to the output of the COMMAND.
qx/COMMAND/.

Array: (1, 2, 3). () is an empty array. (1..4) is the same as (1,2,3,4), likewise ('a'..'z'). qw/foo bar …/ is the same as ('foo','bar',…). Array reference: [1,2,3]

Hash (associative array): (KEY1, VAL1, KEY2, VAL2,…) Also (KEY1=> VAL1, KEY2=> VAL2,…) Hash reference: {KEY1, VAL1, KEY2, VAL2,…}

Code reference: sub {STATEMENTS}

Filehandles: <STDIN>, <STDOUT>, <STDERR>, <ARGV>, <DATA>.
User-specified: HANDLE, $VAR.

Globs: <PATTERN> evaluates to all filenames according to the pattern. Use <${VAR}> or glob $VAR to glob from a variable.

Here-Is: <<IDENTIFIER
Shell-style "here document."

Special tokens: __FILE__: filename; __LINE__: line number; __END__: end of program; remaining lines can be read using the filehandle DATA.

Contents

Variables

You can always use a {BLOCK} returning the right type of reference instead of the variable identifier, e.g., ${…}, &{…}. $$p is just a shorthand for ${$p}.

Contents

Operators

**		Exponentiation
+ -  * /		Addition, subtraction, multiplication, division
%		Modulo division i.e. remainder
& | ^		Bitwise AND, OR, exclusiveOR
>>	<<	Bitwise shift right, left
||	&&	Logical OR, AND
.		string Concatenation
x		the left operand (an array or a string) repeated the number of times specified by the right operand
All of the above operators also have an assignment operator, e.g., .=
->		Dereference operator
\		Reference (unary)
!	~	Negation (unary), bitwise complement (unary)
++	--	Auto-increment (magical on strings), auto-decrement
==	!=	Numeric equality, inequality
eq	ne	String equality, inequality
<	>	Numeric less than, greater than
lt	gt	String less than, greater than
<=	>=	Numeric less (greater) than or equal to
le	ge	String less (greater) than or equal to
<=>	cmp	Numeric (string) compare. Returns -1, 0, 1.
=~	!~	Search pattern, substitution, or translation (negated)
..		Range (scalar context) or enumeration (array context)
?:		Alternation (if-then-else) operator
,		Comma operator, also list element separator. You can also use =>.
not		Low-precedence negation
and		Low-precedence AND
or	xor	Low-precedence OR, exclusiveOR

All Perl functions can be used as list operators, in which case they have very high or very low precedence, depending on whether you look at the left or the right side of the operator. Only the operators not, and, or and xor have lower precedence.

A "list" is a list of expressions, variables, or lists. An array variable or an array slice may always be used instead of a list.

Parentheses can be added around the parameter lists to avoid precedence problems.

Contents

Statements

Every statement is an expression, optionally followed by a modifier, and terminated by a semicolon. The semicolon may be omitted if the statement is the final one in a BLOCK.

Execution of expressions can depend on other expressions using one of the modifiers if, unless, while or until, for example:

EXPR1 if EXPR2 ;
EXPR1 until EXPR2 ;

The logical operators ||, && or ?: also allow conditional execution:

EXPR1 || EXPR2 ;
EXPR1 ? EXPR2 : EXPR3 ;

Statements can be combined to form a BLOCK when enclosed in {}. Blocks may be used to control flow:

if (EXPR) BLOCK [ [ elsif (EXPR) BLOCK … ] else BLOCK ]
unless (EXPR) BLOCK [ else BLOCK ]
[ LABEL: ] while (EXPR) BLOCK [ continue BLOCK ]
[ LABEL: ] until (EXPR) BLOCK [ continue BLOCK ]
[ LABEL: ] for (EXPR; EXPR; EXPR) BLOCK
[ LABEL: ] foreach VAR^£ (LIST) BLOCK
[ LABEL: ] BLOCK [ continue BLOCK ]

Program flow can be controlled with:

goto LABEL	Continue execution at the specified label.
last [ LABEL ]	Immediately exits the loop in question. Skips continue block.
next [ LABEL ]	Starts the next iteration of the loop.
redo [ LABEL ]	Restarts the loop block without evaluating the conditional again.

Special forms are:

do BLOCK while EXPR ;
do BLOCK until EXPR ;

which are guaranteed to perform BLOCK once before testing EXPR, and

do BLOCK

which effectively turns BLOCK into an expression.

Contents

Subroutines, Packages and Modules

sub name {
     @arrayOfAllArgs aka @_;
     $firstArg aka $_[1]; $_[2] aka xxx;… ;
     statments;
     return }

&SUBROUTINE LIST	Executes a SUBROUTINE declared by sub , and returns the value of the last expression evaluated in SUBROUTINE. SUBROUTINE can be an expression yielding a reference to a code object. The & may be omitted if the subroutine has been declared before being used.
[sub] BEGIN { EXPR; … }	Defines a setup BLOCK called before execution.
[sub] END { EXPR; … }	Defines a cleanup BLOCK called prior to termination.
sub NAME { EXPR; … }	Designates NAME as a subroutine. Parameters are passed by reference as array @_. Returns the value of the last expression evaluated.
bless REF [,PACKAGE]	Turns the object REF into an object in PACKAGE. Returns the reference.
caller [EXPR]	Returns an array ($package,$file,$line,…) for a specific subroutine call. caller returns this info for the current subroutine, caller(1) for the caller of this subroutine, etc. Returns false if no caller.
do SUBROUTINE LIST	Deprecated form of &SUBROUTINE.
goto &SUBROUTINE	Substitutes a call to SUBROUTINE for the current subroutine.
import MODULE [ [VERSION] LIST ]
no MODULE [ LIST ]	Cancels imported semantics. See use.
package NAME	Designates the remainder of the current block as a package.
require EXPR£	If EXPR is numeric, requires Perl to be at least that version. Otherwise EXPR must be the name of a file that is included from the Perl library. Does not include more than once, and yields a fatal error if the file does not evaluate to a true value. If EXPR is a bare word, assumes extension .pm for the name of the file.
return EXPR
tie VAR, PACKAGE, [LIST]	Can be used to bind a dbm or ndbm file to a hash. example: BEGIN { @AnyDBM_File::ISA = qw(DB_File GDBM_File NDBM_File SDBM_File); } use AnyDBM_File ; tie %fin, "AnyDBM_File",$filein, O_RDWR, 0600 or die "Cannot open:\"$ts\" $! \n"; If O_RDONLY assignments fail without warning! (example:$fin{$key}="0909";)
untie VAR	Breaks the binding between the variable and the package.
use MODULE [ [VERSION] LIST ]	Imports semantics from the named module into the current package.

Contents

Object-Oriented Programming

Perl rules of object oriented programming:

• An object is simply a reference that happens to know which class it belongs to. Objects are blessed, references are not.
• A class is simply a package that happens to provide methods to deal with object references. If a package fails to provide a method, the base classes as listed in @ISA are searched.
• A method is simply a subroutine that expects an object reference (or a package name, for static methods) as the first argument.

Methods can be applied with:

METHOD OBJREF PARAMETERS           or
OBJREF->METHOD PARAMETERS

Contents

Arithmetic Functions

Contents

Conversion Functions

In array context, returns a 9-element array with the time analyzed for the local time zone.
$mon has the range 0..11 and $wday has the range 0..6.
($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time); ## for display and log name
$month=(January,February,March,April,May,June,July,August,September,October,November,December)[$mon];
if ($mday< 10) { $mday= "0$mday" }; if (++$mon< 10) { $mon= "0$mon" }; $year = 1900 + $year;
if ($hour< 10) { $hour= "0$hour" }; if ( $min< 10) { $min= "0$min" }; if ( $sec< 10) { $sec = "0$sec" };


gmtime EXPR^£     Converts a time as returned by the time function to a 9-element array Greenwich

chr EXPR^£     Returns the character represented by the decimal value EXPR.
hex EXPR^£     Returns the decimal value of EXPR interpreted as a hex string.
oct EXPR^£     Returns the decimal value of EXPR interpreted as an octal string.
If EXPR starts off with 0x, interprets it as a hex string instead.
ord EXPR^£     Returns the ASCII value of the first character of EXPR.

vec EXPR, OFFSET, BITS Treats string EXPR as a vector of unsigned integers, and yields the bit at OFFSET. BITS must be between 1 and 32. May be assigned to.

Contents

Structure Conversion

TEMPLATE is a sequence of characters as follows:

a	A	ASCII string, null-	space-padded
b	B	Bit string in ascending	descending order
c	C	Native	unsigned char value
f	d	Single	double float in native format
h	H	Hex string, low	high nybble first
i	I	Signed	unsigned integer value
l	L	Signed	unsigned long value
n	N	Short	long in network (big endian) byte order
s	S	Signed	unsigned short value
u	P	Uuencoded string	pointer to a string
v	V	Short	long in VAX (little endian) byte order
x	@	Null byte	null fill until position
X		Backup a byte

Character may be followed by a decimal repeat count; an asterisk (*) specifies all remaining arguments.
If the format is preceded with %N, unpack returns an N-bit checksum instead.
Spaces may be included in the template for readability purposes.

Contents

String Functions

Contents

Array and List Functions

delete $HASH{KEY}	Deletes value from the hash at KEY. Returns the deleted value unless HASH is tied to a package that does not support this.
each %HASH	Returns a 2-element array consisting of the key and value for the next value of the hash. Entries are returned in an unpredictable order. After all values have been returned, a null array is returned. The next call to each restarts iteration.
exists EXPR£	Checks if the specified key exists in its hash array.
grep EXPR, LIST grep BLOCK LIST	Evaluates EXPR or BLOCK for each element of the LIST, locally setting $_ to refer to the element. Modifying $_ will modify the corresponding element from LIST. Returns the array of elements from LIST for which EXPR returned true.
join EXPR, LIST	Joins the separate strings of LIST into a single string with fields separated by the value of EXPR, and returns the string.
keys %HASH	Returns an array of the keys of HASH.
map EXPR, LIST map BLOCK LIST	Evaluates EXPR or BLOCK for each element of the LIST, locally setting $_ to refer to the element. Modifying $_ will modify the corresponding element from LIST. Returns the list of results.
pop @ARRAY	Pops off and returns the last value of the array.
push @ARRAY, LIST	Pushes the values of LIST onto the end of the array.
reverse LIST	In array context, returns the LIST in reverse order. In scalar context: returns the first element of LIST with bytes reversed.
scalar @ARRAY	Returns the number of elements in the array.
scalar %HASH	Returns a true value if the hash has elements defined.
shift [ @ARRAY ]	Shifts the first value of the array off and returns it, shortening the array by 1 and moving everything down. If @ARRAY is omitted, shifts @ARGV in main and @_ in subroutines.
sort [ SUBROUTINE ] LIST	Sorts the LIST and returns the sorted array value. SUBROUTINE, if specified, must return less than zero, zero, or greater than zero, depending on how the elements of the array (available to the routine as $a and $b) are to be ordered. SUBROUTINE may be the name of a user-defined routine, or a BLOCK.
splice @ARRAY, OFFSET [ , LENGTH [ , LIST ] ]	Removes the elements of @ARRAY designated by OFFSET and LENGTH, and replaces them with LIST (if specified). Returns the elements removed.
split [ PATTERN [ , EXPR£ [ , LIMIT ] ] ]	Splits a string into an array of strings, and returns it. If LIMIT is specified, splits into at most that number of fields. If PATTERN is also omitted, splits at the whitespace. If not in array context, returns number of fields and splits to @_. See also Search and Replace.
unshift @ARRAY, LIST	Prepends list to the front of the array, and returns the number of elements in the new array.
values %HASH	Returns a normal array consisting of all the values of the named hash.

Contents

Regular Expressions

Each character matches itself, except + ? . * ^ $ ( ) [ ] { } | \.
The special meaning of these characters is escaped using a \.

Variables local to the current block:
$`	string preceding
$&	string matched by the last successful pattern match.
$'	string following
$+	last bracket matched by the last search pattern.
$1…$9…nbsp;  $10… and up (only available if Contain subpatterns from the corresponding sets of parentheses in the last pattern successfully matched.)

match contained that many subpatterns.

With modifier x, whitespace can be used in the patterns for readability purposes.

Contents

Search and Replace

Contents

File Test Operators

-r -w -x	readable/writable/executable by effective uid/gid.
-R -W -X	readable/writable/executable by real uid/gid.
-o -O	owned by effective/real uid.
-e -z	exists/has zero size.
-s	exists and has non-zero size. Returns the size.
-f -d	a plain file/ directory.
-l -S -p	a symbolic link/ socket/ named pipe (FIFO).
-b -c	a block/character special file.
-u -g -k	setuid/setgid/sticky bit set.
-t	filehandle (STDIN by default) is opened to a tty.
-T -B	text/non-text (binary) file. Return true on a null file, or a file at EOF when testing a filehandle.
-M -A -C	File modification / access / inode-change time. Measured in days. Value returned reflects the file age at the time the script started. See also $^T Special Variables.

Contents

File Operations

Contents

Input / Output

Contents

Formats

write [ FILEHANDLE ]
Writes a formatted record to the specified file, using the format associated with that file.

Formats are defined as:

format [NAME] =
FORMLIST
.

FORMLIST pictures the lines, and contains the arguments which will give values to the fields in the lines. NAME defaults STDOUT

Picture fields are:

@<<<…	left adjusted field, repeat the < to denote the desired width
@>>>…	right adjusted field
@|||…	centered field
@#.##…	numeric format with implied decimal point
@*	a multi-line field

Contents

Directory Reading Routines

Contents

System Interaction

Contents

Networking

Contents

System V IPC

You need to require "sys/ipc.ph" before you can use the symbolic names of the operations.

Contents

Miscellaneous

Contents

Information from System Files

Contents

Special Variables

Contents

Special Arrays

Contents

Environment Variables

Perl uses the following environment variables.

Contents

Contents