The structure of the Perl programming language encompasses both the syntactical rules of the language and the general ways in which programs are organized. Perl's design philosophy is expressed in the commonly cited motto "there's more than one way to do it". As a multi-paradigm, dynamically typed language, Perl allows a great degree of flexibility in program design. Perl also encourages modularization; this has been attributed to the component-based design structure of its Unix roots, and is responsible for the size of the CPAN archive, a community-maintained repository of more than 100,000 modules.
Basic syntax In Perl, the minimal Hello World program may be written as follows: print "Hello, World!\n" This prints the string Hello, World! and a newline, symbolically expressed by an n character whose interpretation is altered by the preceding escape character (a backslash). Since version 5.10, the new 'say' builtin produces the same effect even more simply: say "Hello, World!"
An entire Perl program may also be specified as a command-line parameter to Perl, so the same program can also be executed from the command line (example shown for Unix): $ perl -e 'print "Hello, World!\n"'
The canonical form of the program is slightly more verbose:
#!/usr/bin/env perl print "Hello, World!\n";
The hash mark character introduces a comment in Perl, which runs up to the end of the line of code and is ignored by the compiler (except on Windows). The comment used here is of a special kind: it's called the shebang line. This tells Unix-like operating systems to find the Perl interpreter, making it possible to invoke the program without explicitly mentioning perl. (Note that, on Microsoft Windows systems, Perl programs are typically invoked by associating the .pl extension with the Perl interpreter. In order to deal with such circumstances, perl detects the shebang line and parses it for switches.)
The second line in the canonical form includes a semicolon, which is used to separate statements in Perl. With only a single statement in a block or file, a separator is unnecessary, so it can be omitted from the minimal form of the program—or more generally from the final statement in any block or file. The canonical form includes it, because it is common to terminate every statement even when it is unnecessary to do so, as this makes editing easier: code can be added to, or moved away from, the end of a block or file without having to adjust semicolons.
Version 5.10 of Perl introduces a say function that implicitly appends a newline character to its output, making the minimal "Hello World" program even shorter:
use 5.010; # must be present to import the new 5.10 functions, notice that it is 5.010 not 5.10 say 'Hello, World!'
Data types
Perl has a number of fundamental data types. The most commonly used and discussed are scalars, arrays, hashes, filehandles, and subroutines:
Type Sigil Example DescriptionScalarA single value; it may be a number, a string, a filehandle, or a reference.ArrayAn ordered collection of scalars.HashA map from strings to scalars; the strings are called keys, and the scalars are called values. Also known as an associative array.File handle or An opaque representation of an open file or other target for reading, writing, or both.SubroutineA piece of code that may be passed arguments, be executed, and return data.TypeglobThe symbol table entry for all types with the name 'foo'.
Scalar values
String values (literals) must be enclosed by quotes. Enclosing a string in double quotes allows the values of variables whose names appear in the string to automatically replace the variable name (or be interpolated) in the string. Enclosing a string in single quotes prevents variable interpolation.
For example, if $name is "Jim":
then print("My name is $name") will print "My name is Jim" (interpolation within double quotes), but print('My name is $name') will print "My name is $name" (no interpolation within single quotes).
To include a double quotation mark in a string, precede it with a backslash or enclose the string in single quotes. To include a single quotation mark, precede it with a backslash or enclose the string in double quotes.
Strings can also be quoted with the q and qq quote-like operators: 'this' and q(this) are identical, "$this" and qq($this) are identical.
Finally, multiline strings can be defined using here documents:
$multilined_string = <<EOF; This is my multilined string note that I am terminating it with the word "EOF". EOF
Numbers (numeric constants) do not require quotation. Perl will convert numbers into strings and vice versa depending on the context in which they are used. When strings are converted into numbers, trailing non-numeric parts of the strings are discarded. If no leading part of a string is numeric, the string will be converted to the number 0. In the following example, the strings $n and $m are treated as numbers. This code prints the number '5'. The values of the variables remain the same. Note that in Perl, + is always the numeric addition operator. The string concatenation operator is the period.
$n = '3 apples'; $m = '2 oranges'; print $n + $m; Functions are provided for the rounding of fractional values to integer values: int chops off the fractional part, rounding towards zero; POSIX::ceil and POSIX::floor round always up and always down, respectively. The number-to-string conversion of printf "%f" or sprintf "%f" round out even, use bankers' rounding.
Perl also has a boolean context that it uses in evaluating conditional statements. The following values all evaluate as false in Perl:
$false = 0; # the number zero $false = 0.0; # the number zero as a float $false = 0b0; # the number zero in binary $false = 0x0; # the number zero in hexadecimal $false = '0'; # the string zero $false = ""; # the empty string $false = (); # the empty list $false = undef; # the return value from undef $false = 2-3+1 # computes to 0 that is converted to "0" so it is false
All other (non-zero evaluating) values evaluate to true. This includes the odd self-describing literal string of "0 but true", which in fact is 0 as a number, but true when used as a boolean. All non-numeric strings also have this property, but this particular string is truncated by Perl without a numeric warning. A less explicit but more conceptually portable version of this string is '' or '', which does not rely on characters being evaluated as 0, because '0E0' is literally zero times ten to the power zero. The empty hash {} is also true; in this context {} is not an empty block, because perl -e 'print ref {}' returns HASH.
Evaluated boolean expressions are also scalar values. The documentation does not promise which particular value of true or false is returned. Many boolean operators return 1 for true and the empty-string for false. The function determines whether a variable has any value set. In the above examples, is true for every value except .
If either 1 or 0 are specifically needed, an explicit conversion can be done using the conditional operator:
my $real_result = $boolean_result ? 1 : 0;
Array values
An array value (or list) is specified by listing its elements, separated by commas, enclosed by parentheses (at least where required by operator precedence).
@scores = (32, 45, 16, 5);
The qw() quote-like operator allows the definition of a list of strings without typing of quotes and commas. Almost any delimiter can be used instead of parentheses. The following lines are equivalent:
@names = ('Billy', 'Joe', 'Jim-Bob'); @names = qw(Billy Joe Jim-Bob);
The split function returns a list of strings, which are split from a string expression using a delimiter string or regular expression.
@scores = split(',', '32,45,16,5');
Individual elements of a list are accessed by providing a numerical index in square brackets. The scalar sigil must be used. Sublists (array slices) can also be specified, using a range or list of numeric indices in brackets. The array sigil is used in this case. For example, $month is "April" (the first element in an array has an index value of 0), and @month[4..6] is ("May", "June", "July").
Hash values
Perl programmers may initialize a hash (or associative array) from a list of key/value pairs. If the keys are separated from the values with the => operator (sometimes called a fat comma), rather than a comma, they may be unquoted (barewords). The following lines are equivalent:
%favorite = ('joe', "red", 'sam', "blue"); %favorite = (joe => 'red', sam => 'blue');
Individual values in a hash are accessed by providing the corresponding key, in curly braces. The $ sigil identifies the accessed element as a scalar. For example, equals . A hash can also be initialized by setting its values individually:
$favorite{joe} = 'red'; $favorite{sam} = 'blue'; $favorite{oscar} = 'green';
Multiple elements may be accessed using the @ sigil instead (identifying the result as a list). For example, equals .
Filehandles
Filehandles provide read and write access to resources. These are most often files on disk, but can also be a device, a pipe, or even a scalar value.
Originally, filehandles could only be created with package variables, using the ALL_CAPS convention to distinguish it from other variables. Perl 5.6 and newer also accept a scalar variable, which will be set (autovivified) to a reference to an anonymous filehandle, in place of a named filehandle.
Typeglob values
A typeglob value is a symbol table entry. The main use of typeglobs is creating symbol table aliases. For example:
*PI = \3.141592653; # creating constant scalar $PI *this = *that; # creating aliases for all data types 'this' to all data types 'that'
Array functions
The number of elements in an array can be determined either by evaluating the array in scalar context or with the help of the $# sigil. The latter gives the index of the last element in the array, not the number of elements. The expressions scalar() and ($#array + 1) are equivalent.
Hash functions
There are a few functions that operate on entire hashes. The keys function takes a hash and returns the list of its keys. Similarly, the values function returns a hash's values. Note that the keys and values are returned in a consistent but arbitrary order.
# Every call to each returns the next key/value pair. # All values will be eventually returned, but their order # cannot be predicted. while (($name, $address) = each %addressbook) { print "$name lives at $address\n"; }
# Similar to the above, but sorted alphabetically foreach my $next_name (sort keys %addressbook) { print "$next_name lives at $addressbook{$next_name}\n"; }
Control structures
Perl has several kinds of control structures.
It has block-oriented control structures, similar to those in the C, JavaScript, and Java programming languages. Conditions are surrounded by parentheses, and controlled blocks are surrounded by braces:
label while ( cond ) { ... } label while ( cond ) { ... } continue { ... } label for ( init-expr ; cond-expr ; incr-expr ) { ... } label foreach var ( list ) { ... } label foreach var ( list ) { ... } continue { ... } if ( cond ) { ... } if ( cond ) { ... } else { ... } if ( cond ) { ... } elsif ( cond ) { ... } else { ... }
Where only a single statement is being controlled, statement modifiers provide a more-concise syntax:
statement if cond ; statement unless cond ; statement while cond ; statement until cond ; statement foreach list ;
Short-circuit logical operators are commonly used to affect control flow at the expression level:
expr and expr expr && expr expr or expr expr || expr
(The "and" and "or" operators are similar to && and || but have lower precedence, which makes it easier to use them to control entire statements.)