7 A Perl program consists of a sequence of declarations and statements
8 which run from the top to the bottom. Loops, subroutines and other
9 control structures allow you to jump around within the code.
11 Perl is a B<free-form> language, you can format and indent it however
12 you like. Whitespace mostly serves to separate tokens, unlike
13 languages like Python where it is an important part of the syntax.
15 Many of Perl's syntactic elements are B<optional>. Rather than
16 requiring you to put parentheses around every function call and
17 declare every variable, you can often leave such explicit elements off
18 and Perl will figure out what you meant. This is known as B<Do What I
19 Mean>, abbreviated B<DWIM>. It allows programmers to be B<lazy> and to
20 code in a style with which they are comfortable.
22 Perl B<borrows syntax> and concepts from many languages: awk, sed, C,
23 Bourne Shell, Smalltalk, Lisp and even English. Other
24 languages have borrowed syntax from Perl, particularly its regular
25 expression extensions. So if you have programmed in another language
26 you will see familiar pieces in Perl. They often work the same, but
27 see L<perltrap> for information about how they differ.
31 The only things you need to declare in Perl are report formats
32 and subroutines--and even undefined subroutines can be handled
33 through AUTOLOAD. A variable holds the undefined value (C<undef>)
34 until it has been assigned a defined value, which is anything
35 other than C<undef>. When used as a number, C<undef> is treated
36 as C<0>; when used as a string, it is treated the empty string,
37 C<"">; and when used as a reference that isn't being assigned
38 to, it is treated as an error. If you enable warnings, you'll
39 be notified of an uninitialized value whenever you treat C<undef>
40 as a string or a number. Well, usually. Boolean contexts, such as:
45 are exempt from warnings (because they care about truth rather than
46 definedness). Operators such as C<++>, C<-->, C<+=>,
47 C<-=>, and C<.=>, that operate on undefined left values such as:
52 are also always exempt from such warnings.
54 A declaration can be put anywhere a statement can, but has no effect on
55 the execution of the primary sequence of statements--declarations all
56 take effect at compile time. Typically all the declarations are put at
57 the beginning or the end of the script. However, if you're using
58 lexically-scoped private variables created with C<my()>, you'll
60 your format or subroutine definition is within the same block scope
61 as the my if you expect to be able to access those private variables.
63 Declaring a subroutine allows a subroutine name to be used as if it were a
64 list operator from that point forward in the program. You can declare a
65 subroutine without defining it by saying C<sub name>, thus:
68 $me = myname $0 or die "can't get myname";
70 Note that myname() functions as a list operator, not as a unary operator;
71 so be careful to use C<or> instead of C<||> in this case. However, if
72 you were to declare the subroutine as C<sub myname ($)>, then
73 C<myname> would function as a unary operator, so either C<or> or
76 Subroutines declarations can also be loaded up with the C<require> statement
77 or both loaded and imported into your namespace with a C<use> statement.
78 See L<perlmod> for details on this.
80 A statement sequence may contain declarations of lexically-scoped
81 variables, but apart from declaring a variable name, the declaration acts
82 like an ordinary statement, and is elaborated within the sequence of
83 statements as if it were an ordinary statement. That means it actually
84 has both compile-time and run-time effects.
88 Text from a C<"#"> character until the end of the line is a comment,
89 and is ignored. Exceptions include C<"#"> inside a string or regular
92 =head2 Simple Statements
94 The only kind of simple statement is an expression evaluated for its
95 side effects. Every simple statement must be terminated with a
96 semicolon, unless it is the final statement in a block, in which case
97 the semicolon is optional. (A semicolon is still encouraged there if the
98 block takes up more than one line, because you may eventually add another line.)
99 Note that there are some operators like C<eval {}> and C<do {}> that look
100 like compound statements, but aren't (they're just TERMs in an expression),
101 and thus need an explicit termination if used as the last item in a statement.
103 Any simple statement may optionally be followed by a I<SINGLE> modifier,
104 just before the terminating semicolon (or block ending). The possible
113 The C<if> and C<unless> modifiers have the expected semantics,
114 presuming you're a speaker of English. The C<foreach> modifier is an
115 iterator: For each value in EXPR, it aliases C<$_> to the value and
116 executes the statement. The C<while> and C<until> modifiers have the
117 usual "C<while> loop" semantics (conditional evaluated first), except
118 when applied to a C<do>-BLOCK (or to the deprecated C<do>-SUBROUTINE
119 statement), in which case the block executes once before the
120 conditional is evaluated. This is so that you can write loops like:
125 } until $line eq ".\n";
127 See L<perlfunc/do>. Note also that the loop control statements described
128 later will I<NOT> work in this construct, because modifiers don't take
129 loop labels. Sorry. You can always put another block inside of it
130 (for C<next>) or around it (for C<last>) to do that sort of thing.
131 For C<next>, just double the braces:
138 For C<last>, you have to be more elaborate:
147 B<NOTE:> The behaviour of a C<my> statement modified with a statement
148 modifier conditional or loop construct (e.g. C<my $x if ...>) is
149 B<undefined>. The value of the C<my> variable may be C<undef>, any
150 previously assigned value, or possibly anything else. Don't rely on
151 it. Future versions of perl might do something different from the
152 version of perl you try it out on. Here be dragons.
154 =head2 Compound Statements
156 In Perl, a sequence of statements that defines a scope is called a block.
157 Sometimes a block is delimited by the file containing it (in the case
158 of a required file, or the program as a whole), and sometimes a block
159 is delimited by the extent of a string (in the case of an eval).
161 But generally, a block is delimited by curly brackets, also known as braces.
162 We will call this syntactic construct a BLOCK.
164 The following compound statements may be used to control flow:
167 if (EXPR) BLOCK else BLOCK
168 if (EXPR) BLOCK elsif (EXPR) BLOCK ... else BLOCK
169 LABEL while (EXPR) BLOCK
170 LABEL while (EXPR) BLOCK continue BLOCK
171 LABEL for (EXPR; EXPR; EXPR) BLOCK
172 LABEL foreach VAR (LIST) BLOCK
173 LABEL foreach VAR (LIST) BLOCK continue BLOCK
174 LABEL BLOCK continue BLOCK
176 Note that, unlike C and Pascal, these are defined in terms of BLOCKs,
177 not statements. This means that the curly brackets are I<required>--no
178 dangling statements allowed. If you want to write conditionals without
179 curly brackets there are several other ways to do it. The following
180 all do the same thing:
182 if (!open(FOO)) { die "Can't open $FOO: $!"; }
183 die "Can't open $FOO: $!" unless open(FOO);
184 open(FOO) or die "Can't open $FOO: $!"; # FOO or bust!
185 open(FOO) ? 'hi mom' : die "Can't open $FOO: $!";
186 # a bit exotic, that last one
188 The C<if> statement is straightforward. Because BLOCKs are always
189 bounded by curly brackets, there is never any ambiguity about which
190 C<if> an C<else> goes with. If you use C<unless> in place of C<if>,
191 the sense of the test is reversed.
193 The C<while> statement executes the block as long as the expression is
194 true (does not evaluate to the null string C<""> or C<0> or C<"0">).
195 The LABEL is optional, and if present, consists of an identifier followed
196 by a colon. The LABEL identifies the loop for the loop control
197 statements C<next>, C<last>, and C<redo>.
198 If the LABEL is omitted, the loop control statement
199 refers to the innermost enclosing loop. This may include dynamically
200 looking back your call-stack at run time to find the LABEL. Such
201 desperate behavior triggers a warning if you use the C<use warnings>
202 pragma or the B<-w> flag.
204 If there is a C<continue> BLOCK, it is always executed just before the
205 conditional is about to be evaluated again. Thus it can be used to
206 increment a loop variable, even when the loop has been continued via
207 the C<next> statement.
211 The C<next> command starts the next iteration of the loop:
213 LINE: while (<STDIN>) {
214 next LINE if /^#/; # discard comments
218 The C<last> command immediately exits the loop in question. The
219 C<continue> block, if any, is not executed:
221 LINE: while (<STDIN>) {
222 last LINE if /^$/; # exit when done with header
226 The C<redo> command restarts the loop block without evaluating the
227 conditional again. The C<continue> block, if any, is I<not> executed.
228 This command is normally used by programs that want to lie to themselves
229 about what was just input.
231 For example, when processing a file like F</etc/termcap>.
232 If your input lines might end in backslashes to indicate continuation, you
233 want to skip ahead and get the next record.
244 which is Perl short-hand for the more explicitly written version:
246 LINE: while (defined($line = <ARGV>)) {
248 if ($line =~ s/\\$//) {
250 redo LINE unless eof(); # not eof(ARGV)!
255 Note that if there were a C<continue> block on the above code, it would
256 get executed only on lines discarded by the regex (since redo skips the
257 continue block). A continue block is often used to reset line counters
258 or C<?pat?> one-time matches:
260 # inspired by :1,$g/fred/s//WILMA/
262 ?(fred)? && s//WILMA $1 WILMA/;
263 ?(barney)? && s//BETTY $1 BETTY/;
264 ?(homer)? && s//MARGE $1 MARGE/;
266 print "$ARGV $.: $_";
267 close ARGV if eof(); # reset $.
268 reset if eof(); # reset ?pat?
271 If the word C<while> is replaced by the word C<until>, the sense of the
272 test is reversed, but the conditional is still tested before the first
275 The loop control statements don't work in an C<if> or C<unless>, since
276 they aren't loops. You can double the braces to make them such, though.
280 next if /barney/; # same effect as "last", but doesn't document as well
284 This is caused by the fact that a block by itself acts as a loop that
285 executes once, see L<"Basic BLOCKs and Switch Statements">.
287 The form C<while/if BLOCK BLOCK>, available in Perl 4, is no longer
288 available. Replace any occurrence of C<if BLOCK> by C<if (do BLOCK)>.
292 Perl's C-style C<for> loop works like the corresponding C<while> loop;
293 that means that this:
295 for ($i = 1; $i < 10; $i++) {
308 There is one minor difference: if variables are declared with C<my>
309 in the initialization section of the C<for>, the lexical scope of
310 those variables is exactly the C<for> loop (the body of the loop
311 and the control sections).
313 Besides the normal array index looping, C<for> can lend itself
314 to many other interesting applications. Here's one that avoids the
315 problem you get into if you explicitly test for end-of-file on
316 an interactive file descriptor causing your program to appear to
319 $on_a_tty = -t STDIN && -t STDOUT;
320 sub prompt { print "yes? " if $on_a_tty }
321 for ( prompt(); <STDIN>; prompt() ) {
325 Using C<readline> (or the operator form, C<< <EXPR> >>) as the
326 conditional of a C<for> loop is shorthand for the following. This
327 behaviour is the same as a C<while> loop conditional.
329 for ( prompt(); defined( $_ = <STDIN> ); prompt() ) {
335 The C<foreach> loop iterates over a normal list value and sets the
336 variable VAR to be each element of the list in turn. If the variable
337 is preceded with the keyword C<my>, then it is lexically scoped, and
338 is therefore visible only within the loop. Otherwise, the variable is
339 implicitly local to the loop and regains its former value upon exiting
340 the loop. If the variable was previously declared with C<my>, it uses
341 that variable instead of the global one, but it's still localized to
342 the loop. This implicit localisation occurs I<only> in a C<foreach>
345 The C<foreach> keyword is actually a synonym for the C<for> keyword, so
346 you can use C<foreach> for readability or C<for> for brevity. (Or because
347 the Bourne shell is more familiar to you than I<csh>, so writing C<for>
348 comes more naturally.) If VAR is omitted, C<$_> is set to each value.
350 If any element of LIST is an lvalue, you can modify it by modifying
351 VAR inside the loop. Conversely, if any element of LIST is NOT an
352 lvalue, any attempt to modify that element will fail. In other words,
353 the C<foreach> loop index variable is an implicit alias for each item
354 in the list that you're looping over.
356 If any part of LIST is an array, C<foreach> will get very confused if
357 you add or remove elements within the loop body, for example with
358 C<splice>. So don't do that.
360 C<foreach> probably won't do what you expect if VAR is a tied or other
361 special variable. Don't do that either.
365 for (@ary) { s/foo/bar/ }
367 for my $elem (@elements) {
371 for $count (10,9,8,7,6,5,4,3,2,1,'BOOM') {
372 print $count, "\n"; sleep(1);
375 for (1..15) { print "Merry Christmas\n"; }
377 foreach $item (split(/:[\\\n:]*/, $ENV{TERMCAP})) {
378 print "Item: $item\n";
381 Here's how a C programmer might code up a particular algorithm in Perl:
383 for (my $i = 0; $i < @ary1; $i++) {
384 for (my $j = 0; $j < @ary2; $j++) {
385 if ($ary1[$i] > $ary2[$j]) {
386 last; # can't go to outer :-(
388 $ary1[$i] += $ary2[$j];
390 # this is where that last takes me
393 Whereas here's how a Perl programmer more comfortable with the idiom might
396 OUTER: for my $wid (@ary1) {
397 INNER: for my $jet (@ary2) {
398 next OUTER if $wid > $jet;
403 See how much easier this is? It's cleaner, safer, and faster. It's
404 cleaner because it's less noisy. It's safer because if code gets added
405 between the inner and outer loops later on, the new code won't be
406 accidentally executed. The C<next> explicitly iterates the other loop
407 rather than merely terminating the inner one. And it's faster because
408 Perl executes a C<foreach> statement more rapidly than it would the
409 equivalent C<for> loop.
411 =head2 Basic BLOCKs and Switch Statements
413 A BLOCK by itself (labeled or not) is semantically equivalent to a
414 loop that executes once. Thus you can use any of the loop control
415 statements in it to leave or restart the block. (Note that this is
416 I<NOT> true in C<eval{}>, C<sub{}>, or contrary to popular belief
417 C<do{}> blocks, which do I<NOT> count as loops.) The C<continue>
420 The BLOCK construct is particularly nice for doing case
424 if (/^abc/) { $abc = 1; last SWITCH; }
425 if (/^def/) { $def = 1; last SWITCH; }
426 if (/^xyz/) { $xyz = 1; last SWITCH; }
430 There is no official C<switch> statement in Perl, because there are
431 already several ways to write the equivalent.
433 However, starting from Perl 5.8 to get switch and case one can use
434 the Switch extension and say:
438 after which one has switch and case. It is not as fast as it could be
439 because it's not really part of the language (it's done using source
440 filters) but it is available, and it's very flexible.
442 In addition to the above BLOCK construct, you could write
445 $abc = 1, last SWITCH if /^abc/;
446 $def = 1, last SWITCH if /^def/;
447 $xyz = 1, last SWITCH if /^xyz/;
451 (That's actually not as strange as it looks once you realize that you can
452 use loop control "operators" within an expression. That's just the binary
453 comma operator in scalar context. See L<perlop/"Comma Operator">.)
458 /^abc/ && do { $abc = 1; last SWITCH; };
459 /^def/ && do { $def = 1; last SWITCH; };
460 /^xyz/ && do { $xyz = 1; last SWITCH; };
464 or formatted so it stands out more as a "proper" C<switch> statement:
487 /^abc/ and $abc = 1, last SWITCH;
488 /^def/ and $def = 1, last SWITCH;
489 /^xyz/ and $xyz = 1, last SWITCH;
504 A common idiom for a C<switch> statement is to use C<foreach>'s aliasing to make
505 a temporary assignment to C<$_> for convenient matching:
507 SWITCH: for ($where) {
508 /In Card Names/ && do { push @flags, '-e'; last; };
509 /Anywhere/ && do { push @flags, '-h'; last; };
510 /In Rulings/ && do { last; };
511 die "unknown value for form variable where: `$where'";
514 Another interesting approach to a switch statement is arrange
515 for a C<do> block to return the proper value:
518 if ($flag & O_RDONLY) { "r" } # XXX: isn't this 0?
519 elsif ($flag & O_WRONLY) { ($flag & O_APPEND) ? "a" : "w" }
520 elsif ($flag & O_RDWR) {
521 if ($flag & O_CREAT) { "w+" }
522 else { ($flag & O_APPEND) ? "a+" : "r+" }
529 ($flags & O_WRONLY) ? "write-only" :
530 ($flags & O_RDWR) ? "read-write" :
534 Or if you are certain that all the C<&&> clauses are true, you can use
535 something like this, which "switches" on the value of the
536 C<HTTP_USER_AGENT> environment variable.
539 # pick out jargon file page based on browser
540 $dir = 'http://www.wins.uva.nl/~mes/jargon';
541 for ($ENV{HTTP_USER_AGENT}) {
542 $page = /Mac/ && 'm/Macintrash.html'
543 || /Win(dows )?NT/ && 'e/evilandrude.html'
544 || /Win|MSIE|WebTV/ && 'm/MicroslothWindows.html'
545 || /Linux/ && 'l/Linux.html'
546 || /HP-UX/ && 'h/HP-SUX.html'
547 || /SunOS/ && 's/ScumOS.html'
548 || 'a/AppendixB.html';
550 print "Location: $dir/$page\015\012\015\012";
552 That kind of switch statement only works when you know the C<&&> clauses
553 will be true. If you don't, the previous C<?:> example should be used.
555 You might also consider writing a hash of subroutine references
556 instead of synthesizing a C<switch> statement.
560 Although not for the faint of heart, Perl does support a C<goto>
561 statement. There are three forms: C<goto>-LABEL, C<goto>-EXPR, and
562 C<goto>-&NAME. A loop's LABEL is not actually a valid target for
563 a C<goto>; it's just the name of the loop.
565 The C<goto>-LABEL form finds the statement labeled with LABEL and resumes
566 execution there. It may not be used to go into any construct that
567 requires initialization, such as a subroutine or a C<foreach> loop. It
568 also can't be used to go into a construct that is optimized away. It
569 can be used to go almost anywhere else within the dynamic scope,
570 including out of subroutines, but it's usually better to use some other
571 construct such as C<last> or C<die>. The author of Perl has never felt the
572 need to use this form of C<goto> (in Perl, that is--C is another matter).
574 The C<goto>-EXPR form expects a label name, whose scope will be resolved
575 dynamically. This allows for computed C<goto>s per FORTRAN, but isn't
576 necessarily recommended if you're optimizing for maintainability:
578 goto(("FOO", "BAR", "GLARCH")[$i]);
580 The C<goto>-&NAME form is highly magical, and substitutes a call to the
581 named subroutine for the currently running subroutine. This is used by
582 C<AUTOLOAD()> subroutines that wish to load another subroutine and then
583 pretend that the other subroutine had been called in the first place
584 (except that any modifications to C<@_> in the current subroutine are
585 propagated to the other subroutine.) After the C<goto>, not even C<caller()>
586 will be able to tell that this routine was called first.
588 In almost all cases like this, it's usually a far, far better idea to use the
589 structured control flow mechanisms of C<next>, C<last>, or C<redo> instead of
590 resorting to a C<goto>. For certain applications, the catch and throw pair of
591 C<eval{}> and die() for exception processing can also be a prudent approach.
593 =head2 PODs: Embedded Documentation
595 Perl has a mechanism for intermixing documentation with source code.
596 While it's expecting the beginning of a new statement, if the compiler
597 encounters a line that begins with an equal sign and a word, like this
599 =head1 Here There Be Pods!
601 Then that text and all remaining text up through and including a line
602 beginning with C<=cut> will be ignored. The format of the intervening
603 text is described in L<perlpod>.
605 This allows you to intermix your source code
606 and your documentation text freely, as in
610 The snazzle() function will behave in the most spectacular
611 form that you can possibly imagine, not even excepting
612 cybernetic pyrotechnics.
614 =cut back to the compiler, nuff of this pod stuff!
621 Note that pod translators should look at only paragraphs beginning
622 with a pod directive (it makes parsing easier), whereas the compiler
623 actually knows to look for pod escapes even in the middle of a
624 paragraph. This means that the following secret stuff will be
625 ignored by both the compiler and the translators.
629 warn "Neither POD nor CODE!?"
633 You probably shouldn't rely upon the C<warn()> being podded out forever.
634 Not all pod translators are well-behaved in this regard, and perhaps
635 the compiler will become pickier.
637 One may also use pod directives to quickly comment out a section
640 =head2 Plain Old Comments (Not!)
642 Perl can process line directives, much like the C preprocessor. Using
643 this, one can control Perl's idea of filenames and line numbers in
644 error or warning messages (especially for strings that are processed
645 with C<eval()>). The syntax for this mechanism is the same as for most
646 C preprocessors: it matches the regular expression
648 # example: '# line 42 "new_filename.plx"'
651 (?:\s("?)([^"]+)\2)? \s*
654 with C<$1> being the line number for the next line, and C<$3> being
655 the optional filename (specified with or without quotes).
657 There is a fairly obvious gotcha included with the line directive:
658 Debuggers and profilers will only show the last source line to appear
659 at a particular line number in a given file. Care should be taken not
660 to cause line number collisions in code you'd like to debug later.
662 Here are some examples that you should be able to type into your command
667 # the `#' on the previous line must be the first char on line
670 foo at bzzzt line 201.
674 eval qq[\n#line 2001 ""\ndie 'foo']; print $@;
679 eval qq[\n#line 200 "foo bar"\ndie 'foo']; print $@;
681 foo at foo bar line 200.
685 eval "\n#line " . __LINE__ . ' "' . __FILE__ ."\"\ndie 'foo'";
688 foo at goop line 345.