3 perlintro -- a brief introduction and overview of Perl
7 This document is intended to give you a quick overview of the Perl
8 programming language, along with pointers to further documentation. It
9 is intended as a "bootstrap" guide for those who are new to the
10 language, and provides just enough information for you to be able to
11 read other peoples' Perl and understand roughly what it's doing, or
12 write your own simple scripts.
14 This introductory document does not aim to be complete. It does not
15 even aim to be entirely accurate. In some cases perfection has been
16 sacrificed in the goal of getting the general idea across. You are
17 I<strongly> advised to follow this introduction with more information
18 from the full Perl manual, the table of contents to which can be found
21 Throughout this document you'll see references to other parts of the
22 Perl documentation. You can read that documentation using the C<perldoc>
23 command or whatever method you're using to read this document.
27 Perl is a general-purpose programming language originally developed for
28 text manipulation and now used for a wide range of tasks including
29 system administration, web development, network programming, GUI
30 development, and more.
32 The language is intended to be practical (easy to use, efficient,
33 complete) rather than beautiful (tiny, elegant, minimal). Its major
34 features are that it's easy to use, supports both procedural and
35 object-oriented (OO) programming, has powerful built-in support for text
36 processing, and has one of the world's most impressive collections of
39 Different definitions of Perl are given in L<perl>, L<perlfaq1> and
40 no doubt other places. From this we can determine that Perl is different
41 things to different people, but that lots of people think it's at least
44 =head2 Running Perl programs
46 To run a Perl program from the Unix command line:
50 Alternatively, put this as the first line of your script:
54 ... and run the script as C</path/to/script.pl>. Of course, it'll need
55 to be executable first, so C<chmod 755 script.pl> (under Unix).
57 For more information, including instructions for other platforms such as
58 Windows and Mac OS, read L<perlrun>.
60 =head2 Basic syntax overview
62 A Perl script or program consists of one or more statements. These
63 statements are simply written in the script in a straightforward
64 fashion. There is no need to have a C<main()> function or anything of
67 Perl statements end in a semi-colon:
71 Comments start with a hash symbol and run to the end of the line
75 Whitespace is irrelevant:
81 ... except inside quoted strings:
83 # this would print with a linebreak in the middle
87 Double quotes or single quotes may be used around literal strings:
92 However, only double quotes "interpolate" variables and special
93 characters such as newlines (C<\n>):
95 print "Hello, $name\n"; # works fine
96 print 'Hello, $name\n'; # prints $name\n literally
98 Numbers don't need quotes around them:
102 You can use parentheses for functions' arguments or omit them
103 according to your personal taste. They are only required
104 occasionally to clarify issues of precedence.
106 print("Hello, world\n");
107 print "Hello, world\n";
109 More detailed information about Perl syntax can be found in L<perlsyn>.
111 =head2 Perl variable types
113 Perl has three main variable types: scalars, arrays, and hashes.
119 A scalar represents a single value:
121 my $animal = "camel";
124 Scalar values can be strings, integers or floating point numbers, and Perl
125 will automatically convert between them as required. There is no need
126 to pre-declare your variable types.
128 Scalar values can be used in various ways:
131 print "The animal is $animal\n";
132 print "The square of $answer is ", $answer * $answer, "\n";
134 There are a number of "magic" scalars with names that look like
135 punctuation or line noise. These special variables are used for all
136 kinds of purposes, and are documented in L<perlvar>. The only one you
137 need to know about for now is C<$_> which is the "default variable".
138 It's used as the default argument to a number of functions in Perl, and
139 it's set implicitly by certain looping constructs.
141 print; # prints contents of $_ by default
145 An array represents a list of values:
147 my @animals = ("camel", "llama", "owl");
148 my @numbers = (23, 42, 69);
149 my @mixed = ("camel", 42, 1.23);
151 Arrays are zero-indexed. Here's how you get at elements in an array:
153 print $animals[0]; # prints "camel"
154 print $animals[1]; # prints "llama"
156 The special variable C<$#array> tells you the index of the last element
159 print $mixed[$#mixed]; # last element, prints 1.23
161 You might be tempted to use C<$#array + 1> to tell you how many items there
162 are in an array. Don't bother. As it happens, using C<@array> where Perl
163 expects to find a scalar value ("in scalar context") will give you the number
164 of elements in the array:
166 if (@animals < 5) { ... }
168 The elements we're getting from the array start with a C<$> because
169 we're getting just a single value out of the array -- you ask for a scalar,
172 To get multiple values from an array:
174 @animals[0,1]; # gives ("camel", "llama");
175 @animals[0..2]; # gives ("camel", "llama", "owl");
176 @animals[1..$#animals]; # gives all except the first element
178 This is called an "array slice".
180 You can do various useful things to lists:
182 my @sorted = sort @animals;
183 my @backwards = reverse @numbers;
185 There are a couple of special arrays too, such as C<@ARGV> (the command
186 line arguments to your script) and C<@_> (the arguments passed to a
187 subroutine). These are documented in L<perlvar>.
191 A hash represents a set of key/value pairs:
193 my %fruit_color = ("apple", "red", "banana", "yellow");
195 You can use whitespace and the C<< => >> operator to lay them out more
203 To get at hash elements:
205 $fruit_color{"apple"}; # gives "red"
207 You can get at lists of keys and values with C<keys()> and
210 my @fruits = keys %fruit_colors;
211 my @colors = values %fruit_colors;
213 Hashes have no particular internal order, though you can sort the keys
214 and loop through them.
216 Just like special scalars and arrays, there are also special hashes.
217 The most well known of these is C<%ENV> which contains environment
218 variables. Read all about it (and other special variables) in
223 Scalars, arrays and hashes are documented more fully in L<perldata>.
225 More complex data types can be constructed using references, which allow
226 you to build lists and hashes within lists and hashes.
228 A reference is a scalar value and can refer to any other Perl data
229 type. So by storing a reference as the value of an array or hash
230 element, you can easily create lists and hashes within lists and
231 hashes. The following example shows a 2 level hash of hash
232 structure using anonymous hash references.
236 description => "single item",
240 description => "ordered list of items",
244 description => "key/value pairs",
249 print "Scalars begin with a $variables->{'scalar'}->{'sigil'}\n";
251 Exhaustive information on the topic of references can be found in
252 L<perlreftut>, L<perllol>, L<perlref> and L<perldsc>.
254 =head2 Variable scoping
256 Throughout the previous section all the examples have used the syntax:
260 The C<my> is actually not required; you could just use:
264 However, the above usage will create global variables throughout your
265 program, which is bad programming practice. C<my> creates lexically
266 scoped variables instead. The variables are scoped to the block
267 (i.e. a bunch of statements surrounded by curly-braces) in which they
271 if ($some_condition) {
273 print $a; # prints "foo"
274 print $b; # prints "bar"
276 print $a; # prints "foo"
277 print $b; # prints nothing; $b has fallen out of scope
279 Using C<my> in combination with a C<use strict;> at the top of
280 your Perl scripts means that the interpreter will pick up certain common
281 programming errors. For instance, in the example above, the final
282 C<print $b> would cause a compile-time error and prevent you from
283 running the program. Using C<strict> is highly recommended.
285 =head2 Conditional and looping constructs
287 Perl has most of the usual conditional and looping constructs except for
288 case/switch (but if you really want it, there is a Switch module in Perl
289 5.8 and newer, and on CPAN. See the section on modules, below, for more
290 information about modules and CPAN).
292 The conditions can be any Perl expression. See the list of operators in
293 the next section for information on comparison and boolean logic operators,
294 which are commonly used in conditional statements.
302 } elsif ( other condition ) {
308 There's also a negated version of it:
310 unless ( condition ) {
314 This is provided as a more readable version of C<if (!I<condition>)>.
316 Note that the braces are required in Perl, even if you've only got one
317 line in the block. However, there is a clever way of making your one-line
318 conditional blocks more English like:
320 # the traditional way
325 # the Perlish post-condition way
326 print "Yow!" if $zippy;
327 print "We have no bananas" unless $bananas;
331 while ( condition ) {
335 There's also a negated version, for the same reason we have C<unless>:
337 until ( condition ) {
341 You can also use C<while> in a post-condition:
343 print "LA LA LA\n" while 1; # loops forever
349 for ($i=0; $i <= $max; $i++) {
353 The C style for loop is rarely needed in Perl since Perl provides
354 the more friendly list scanning C<foreach> loop.
359 print "This element is $_\n";
362 print $list[$_] foreach 1 .. $max;
364 # you don't have to use the default $_ either...
365 foreach my $key (keys %hash) {
366 print "The value of $key is $hash{$key}\n";
371 For more detail on looping constructs (and some that weren't mentioned in
372 this overview) see L<perlsyn>.
374 =head2 Builtin operators and functions
376 Perl comes with a wide selection of builtin functions. Some of the ones
377 we've already seen include C<print>, C<sort> and C<reverse>. A list of
378 them is given at the start of L<perlfunc> and you can easily read
379 about any given function by using C<perldoc -f I<functionname>>.
381 Perl operators are documented in full in L<perlop>, but here are a few
382 of the most common ones:
393 =item Numeric comparison
399 <= less than or equal
400 >= greater than or equal
402 =item String comparison
408 le less than or equal
409 ge greater than or equal
411 (Why do we have separate numeric and string comparisons? Because we don't
412 have special variable types, and Perl needs to know whether to sort
413 numerically (where 99 is less than 100) or alphabetically (where 100 comes
422 (C<and>, C<or> and C<not> aren't just in the above table as descriptions
423 of the operators -- they're also supported as operators in their own
424 right. They're more readable than the C-style operators, but have
425 different precedence to C<&&> and friends. Check L<perlop> for more
431 . string concatenation
432 x string multiplication
433 .. range operator (creates a list of numbers)
437 Many operators can be combined with a C<=> as follows:
439 $a += 1; # same as $a = $a + 1
440 $a -= 1; # same as $a = $a - 1
441 $a .= "\n"; # same as $a = $a . "\n";
445 You can open a file for input or output using the C<open()> function.
446 It's documented in extravagant detail in L<perlfunc> and L<perlopentut>,
449 open(my $in, "<", "input.txt") or die "Can't open input.txt: $!";
450 open(my $out, ">", "output.txt") or die "Can't open output.txt: $!";
451 open(my $log, ">>", "my.log") or die "Can't open my.log: $!";
453 You can read from an open filehandle using the C<< <> >> operator. In
454 scalar context it reads a single line from the filehandle, and in list
455 context it reads the whole file in, assigning each line to an element of
461 Reading in the whole file at one time is called slurping. It can
462 be useful but it may be a memory hog. Most text file processing
463 can be done a line at a time with Perl's looping constructs.
465 The C<< <> >> operator is most often seen in a C<while> loop:
467 while (<$in>) { # assigns each line in turn to $_
468 print "Just read in this line: $_";
471 We've already seen how to print to standard output using C<print()>.
472 However, C<print()> can also take an optional first argument specifying
473 which filehandle to print to:
475 print STDERR "This is your final warning.\n";
477 print $log $logmessage;
479 When you're done with your filehandles, you should C<close()> them
480 (though to be honest, Perl will clean up after you if you forget):
482 close $in or die "$in: $!";
484 =head2 Regular expressions
486 Perl's regular expression support is both broad and deep, and is the
487 subject of lengthy documentation in L<perlrequick>, L<perlretut>, and
488 elsewhere. However, in short:
492 =item Simple matching
494 if (/foo/) { ... } # true if $_ contains "foo"
495 if ($a =~ /foo/) { ... } # true if $a contains "foo"
497 The C<//> matching operator is documented in L<perlop>. It operates on
498 C<$_> by default, or can be bound to another variable using the C<=~>
499 binding operator (also documented in L<perlop>).
501 =item Simple substitution
503 s/foo/bar/; # replaces foo with bar in $_
504 $a =~ s/foo/bar/; # replaces foo with bar in $a
505 $a =~ s/foo/bar/g; # replaces ALL INSTANCES of foo with bar in $a
507 The C<s///> substitution operator is documented in L<perlop>.
509 =item More complex regular expressions
511 You don't just have to match on fixed strings. In fact, you can match
512 on just about anything you could dream of by using more complex regular
513 expressions. These are documented at great length in L<perlre>, but for
514 the meantime, here's a quick cheat sheet:
517 \s a whitespace character (space, tab, newline)
518 \S non-whitespace character
521 \w a word character (a-z, A-Z, 0-9, _)
522 \W a non-word character
523 [aeiou] matches a single character in the given set
524 [^aeiou] matches a single character outside the given set
525 (foo|bar|baz) matches any of the alternatives specified
530 Quantifiers can be used to specify how many of the previous thing you
531 want to match on, where "thing" means either a literal character, one
532 of the metacharacters listed above, or a group of characters or
533 metacharacters in parentheses.
535 * zero or more of the previous thing
536 + one or more of the previous thing
537 ? zero or one of the previous thing
538 {3} matches exactly 3 of the previous thing
539 {3,6} matches between 3 and 6 of the previous thing
540 {3,} matches 3 or more of the previous thing
544 /^\d+/ string starts with one or more digits
545 /^$/ nothing in the string (start and end are adjacent)
546 /(\d\s){3}/ a three digits, each followed by a whitespace
547 character (eg "3 4 5 ")
548 /(a.)+/ matches a string in which every odd-numbered letter
551 # This loop reads from STDIN, and prints non-blank lines:
557 =item Parentheses for capturing
559 As well as grouping, parentheses serve a second purpose. They can be
560 used to capture the results of parts of the regexp match for later use.
561 The results end up in C<$1>, C<$2> and so on.
563 # a cheap and nasty way to break an email address up into parts
565 if ($email =~ /([^@]+)@(.+)/) {
566 print "Username is $1\n";
567 print "Hostname is $2\n";
570 =item Other regexp features
572 Perl regexps also support backreferences, lookaheads, and all kinds of
573 other complex details. Read all about them in L<perlrequick>,
574 L<perlretut>, and L<perlre>.
578 =head2 Writing subroutines
580 Writing subroutines is easy:
583 my $logmessage = shift;
584 open my $logfile, ">>", "my.log" or die "Could not open my.log: $!";
585 print $logfile $logmessage;
588 Now we can use the subroutine just as any other built-in function:
590 logger("We have a logger subroutine!");
592 What's that C<shift>? Well, the arguments to a subroutine are available
593 to us as a special array called C<@_> (see L<perlvar> for more on that).
594 The default argument to the C<shift> function just happens to be C<@_>.
595 So C<my $logmessage = shift;> shifts the first item off the list of
596 arguments and assigns it to C<$logmessage>.
598 We can manipulate C<@_> in other ways too:
600 my ($logmessage, $priority) = @_; # common
601 my $logmessage = $_[0]; # uncommon, and ugly
603 Subroutines can also return values:
607 my $result = $num * $num;
615 For more information on writing subroutines, see L<perlsub>.
619 OO Perl is relatively simple and is implemented using references which
620 know what sort of object they are based on Perl's concept of packages.
621 However, OO Perl is largely beyond the scope of this document.
622 Read L<perlboot>, L<perltoot>, L<perltooc> and L<perlobj>.
624 As a beginning Perl programmer, your most common use of OO Perl will be
625 in using third-party modules, which are documented below.
627 =head2 Using Perl modules
629 Perl modules provide a range of features to help you avoid reinventing
630 the wheel, and can be downloaded from CPAN ( http://www.cpan.org/ ). A
631 number of popular modules are included with the Perl distribution
634 Categories of modules range from text manipulation to network protocols
635 to database integration to graphics. A categorized list of modules is
636 also available from CPAN.
638 To learn how to install modules you download from CPAN, read
641 To learn how to use a particular module, use C<perldoc I<Module::Name>>.
642 Typically you will want to C<use I<Module::Name>>, which will then give
643 you access to exported functions or an OO interface to the module.
645 L<perlfaq> contains questions and answers related to many common
646 tasks, and often provides suggestions for good CPAN modules to use.
648 L<perlmod> describes Perl modules in general. L<perlmodlib> lists the
649 modules which came with your Perl installation.
651 If you feel the urge to write Perl modules, L<perlnewmod> will give you
656 Kirrily "Skud" Robert <skud@cpan.org>