8 A Perl program consists of a sequence of declarations and statements
9 which run from the top to the bottom. Loops, subroutines and other
10 control structures allow you to jump around within the code.
12 Perl is a B<free-form> language, you can format and indent it however
13 you like. Whitespace mostly serves to separate tokens, unlike
14 languages like Python where it is an important part of the syntax.
16 Many of Perl's syntactic elements are B<optional>. Rather than
17 requiring you to put parentheses around every function call and
18 declare every variable, you can often leave such explicit elements off
19 and Perl will figure out what you meant. This is known as B<Do What I
20 Mean>, abbreviated B<DWIM>. It allows programmers to be B<lazy> and to
21 code in a style with which they are comfortable.
23 Perl B<borrows syntax> and concepts from many languages: awk, sed, C,
24 Bourne Shell, Smalltalk, Lisp and even English. Other
25 languages have borrowed syntax from Perl, particularly its regular
26 expression extensions. So if you have programmed in another language
27 you will see familiar pieces in Perl. They often work the same, but
28 see L<perltrap> for information about how they differ.
31 X<declaration> X<undef> X<undefined> X<uninitialized>
33 The only things you need to declare in Perl are report formats and
34 subroutines (and sometimes not even subroutines). A variable holds
35 the undefined value (C<undef>) until it has been assigned a defined
36 value, which is anything other than C<undef>. When used as a number,
37 C<undef> is treated as C<0>; when used as a string, it is treated as
38 the empty string, C<"">; and when used as a reference that isn't being
39 assigned to, it is treated as an error. If you enable warnings,
40 you'll be notified of an uninitialized value whenever you treat
41 C<undef> as a string or a number. Well, usually. Boolean contexts,
47 are exempt from warnings (because they care about truth rather than
48 definedness). Operators such as C<++>, C<-->, C<+=>,
49 C<-=>, and C<.=>, that operate on undefined left values such as:
54 are also always exempt from such warnings.
56 A declaration can be put anywhere a statement can, but has no effect on
57 the execution of the primary sequence of statements--declarations all
58 take effect at compile time. Typically all the declarations are put at
59 the beginning or the end of the script. However, if you're using
60 lexically-scoped private variables created with C<my()>, you'll
62 your format or subroutine definition is within the same block scope
63 as the my if you expect to be able to access those private variables.
65 Declaring a subroutine allows a subroutine name to be used as if it were a
66 list operator from that point forward in the program. You can declare a
67 subroutine without defining it by saying C<sub name>, thus:
68 X<subroutine, declaration>
71 $me = myname $0 or die "can't get myname";
73 Note that myname() functions as a list operator, not as a unary operator;
74 so be careful to use C<or> instead of C<||> in this case. However, if
75 you were to declare the subroutine as C<sub myname ($)>, then
76 C<myname> would function as a unary operator, so either C<or> or
79 Subroutines declarations can also be loaded up with the C<require> statement
80 or both loaded and imported into your namespace with a C<use> statement.
81 See L<perlmod> for details on this.
83 A statement sequence may contain declarations of lexically-scoped
84 variables, but apart from declaring a variable name, the declaration acts
85 like an ordinary statement, and is elaborated within the sequence of
86 statements as if it were an ordinary statement. That means it actually
87 has both compile-time and run-time effects.
92 Text from a C<"#"> character until the end of the line is a comment,
93 and is ignored. Exceptions include C<"#"> inside a string or regular
96 =head2 Simple Statements
97 X<statement> X<semicolon> X<expression> X<;>
99 The only kind of simple statement is an expression evaluated for its
100 side effects. Every simple statement must be terminated with a
101 semicolon, unless it is the final statement in a block, in which case
102 the semicolon is optional. (A semicolon is still encouraged if the
103 block takes up more than one line, because you may eventually add
104 another line.) Note that there are some operators like C<eval {}> and
105 C<do {}> that look like compound statements, but aren't (they're just
106 TERMs in an expression), and thus need an explicit termination if used
107 as the last item in a statement.
109 =head2 Truth and Falsehood
110 X<truth> X<falsehood> X<true> X<false> X<!> X<not> X<negation> X<0>
112 The number 0, the strings C<'0'> and C<''>, the empty list C<()>, and
113 C<undef> are all false in a boolean context. All other values are true.
114 Negation of a true value by C<!> or C<not> returns a special false value.
115 When evaluated as a string it is treated as C<''>, but as a number, it
118 =head2 Statement Modifiers
119 X<statement modifier> X<modifier> X<if> X<unless> X<while>
120 X<until> X<when> X<foreach> X<for>
122 Any simple statement may optionally be followed by a I<SINGLE> modifier,
123 just before the terminating semicolon (or block ending). The possible
134 The C<EXPR> following the modifier is referred to as the "condition".
135 Its truth or falsehood determines how the modifier will behave.
137 C<if> executes the statement once I<if> and only if the condition is
138 true. C<unless> is the opposite, it executes the statement I<unless>
139 the condition is true (i.e., if the condition is false).
141 print "Basset hounds got long ears" if length $ear >= 10;
142 go_outside() and play() unless $is_raining;
144 C<when> executes the statement I<when> C<$_> smart matches C<EXPR>, and
145 then either C<break>s out if it's enclosed in a C<given> scope or skips
146 to the C<next> element when it lies directly inside a C<for> loop.
147 See also L</"Switch statements">.
150 $abc = 1 when /^abc/;
151 $just_a = 1 when /^a/;
156 admin($_) when [ qw/Alice Bob/ ];
157 regular($_) when [ qw/Chris David Ellen/ ];
160 The C<foreach> modifier is an iterator: it executes the statement once
161 for each item in the LIST (with C<$_> aliased to each item in turn).
163 print "Hello $_!\n" foreach qw(world Dolly nurse);
165 C<while> repeats the statement I<while> the condition is true.
166 C<until> does the opposite, it repeats the statement I<until> the
167 condition is true (or while the condition is false):
169 # Both of these count from 0 to 10.
170 print $i++ while $i <= 10;
171 print $j++ until $j > 10;
173 The C<while> and C<until> modifiers have the usual "C<while> loop"
174 semantics (conditional evaluated first), except when applied to a
175 C<do>-BLOCK (or to the deprecated C<do>-SUBROUTINE statement), in
176 which case the block executes once before the conditional is
177 evaluated. This is so that you can write loops like:
182 } until $line eq ".\n";
184 See L<perlfunc/do>. Note also that the loop control statements described
185 later will I<NOT> work in this construct, because modifiers don't take
186 loop labels. Sorry. You can always put another block inside of it
187 (for C<next>) or around it (for C<last>) to do that sort of thing.
188 For C<next>, just double the braces:
189 X<next> X<last> X<redo>
196 For C<last>, you have to be more elaborate:
206 B<NOTE:> The behaviour of a C<my> statement modified with a statement
207 modifier conditional or loop construct (e.g. C<my $x if ...>) is
208 B<undefined>. The value of the C<my> variable may be C<undef>, any
209 previously assigned value, or possibly anything else. Don't rely on
210 it. Future versions of perl might do something different from the
211 version of perl you try it out on. Here be dragons.
214 =head2 Compound Statements
215 X<statement, compound> X<block> X<bracket, curly> X<curly bracket> X<brace>
216 X<{> X<}> X<if> X<unless> X<while> X<until> X<foreach> X<for> X<continue>
218 In Perl, a sequence of statements that defines a scope is called a block.
219 Sometimes a block is delimited by the file containing it (in the case
220 of a required file, or the program as a whole), and sometimes a block
221 is delimited by the extent of a string (in the case of an eval).
223 But generally, a block is delimited by curly brackets, also known as braces.
224 We will call this syntactic construct a BLOCK.
226 The following compound statements may be used to control flow:
229 if (EXPR) BLOCK else BLOCK
230 if (EXPR) BLOCK elsif (EXPR) BLOCK ... else BLOCK
232 unless (EXPR) BLOCK else BLOCK
233 unless (EXPR) BLOCK elsif (EXPR) BLOCK ... else BLOCK
234 LABEL while (EXPR) BLOCK
235 LABEL while (EXPR) BLOCK continue BLOCK
236 LABEL until (EXPR) BLOCK
237 LABEL until (EXPR) BLOCK continue BLOCK
238 LABEL for (EXPR; EXPR; EXPR) BLOCK
239 LABEL foreach VAR (LIST) BLOCK
240 LABEL foreach VAR (LIST) BLOCK continue BLOCK
241 LABEL BLOCK continue BLOCK
244 Note that, unlike C and Pascal, these are defined in terms of BLOCKs,
245 not statements. This means that the curly brackets are I<required>--no
246 dangling statements allowed. If you want to write conditionals without
247 curly brackets there are several other ways to do it. The following
248 all do the same thing:
250 if (!open(FOO)) { die "Can't open $FOO: $!"; }
251 die "Can't open $FOO: $!" unless open(FOO);
252 open(FOO) or die "Can't open $FOO: $!"; # FOO or bust!
253 open(FOO) ? 'hi mom' : die "Can't open $FOO: $!";
254 # a bit exotic, that last one
256 The C<if> statement is straightforward. Because BLOCKs are always
257 bounded by curly brackets, there is never any ambiguity about which
258 C<if> an C<else> goes with. If you use C<unless> in place of C<if>,
259 the sense of the test is reversed. Like C<if>, C<unless> can be followed
260 by C<else>. C<unless> can even be followed by one or more C<elsif>
261 statements, though you may want to think twice before using that particular
262 language construct, as everyone reading your code will have to think at least
263 twice before they can understand what's going on.
265 The C<while> statement executes the block as long as the expression is
266 L<true|/"Truth and Falsehood">.
267 The C<until> statement executes the block as long as the expression is
269 The LABEL is optional, and if present, consists of an identifier followed
270 by a colon. The LABEL identifies the loop for the loop control
271 statements C<next>, C<last>, and C<redo>.
272 If the LABEL is omitted, the loop control statement
273 refers to the innermost enclosing loop. This may include dynamically
274 looking back your call-stack at run time to find the LABEL. Such
275 desperate behavior triggers a warning if you use the C<use warnings>
276 pragma or the B<-w> flag.
278 If there is a C<continue> BLOCK, it is always executed just before the
279 conditional is about to be evaluated again. Thus it can be used to
280 increment a loop variable, even when the loop has been continued via
281 the C<next> statement.
283 When a block is preceding by a compilation phase keyword such as C<BEGIN>,
284 C<END>, C<INIT>, C<CHECK>, or C<UNITCHECK>, then the block will run only
285 during the corresponding phase of execution. See L<perlmod> for more details.
287 Extension modules can also hook into the Perl parser to define new
288 kinds of compound statement. These are introduced by a keyword which
289 the extension recognizes, and the syntax following the keyword is
290 defined entirely by the extension. If you are an implementor, see
291 L<perlapi/PL_keyword_plugin> for the mechanism. If you are using such
292 a module, see the module's documentation for details of the syntax that
296 X<loop control> X<loop, control> X<next> X<last> X<redo> X<continue>
298 The C<next> command starts the next iteration of the loop:
300 LINE: while (<STDIN>) {
301 next LINE if /^#/; # discard comments
305 The C<last> command immediately exits the loop in question. The
306 C<continue> block, if any, is not executed:
308 LINE: while (<STDIN>) {
309 last LINE if /^$/; # exit when done with header
313 The C<redo> command restarts the loop block without evaluating the
314 conditional again. The C<continue> block, if any, is I<not> executed.
315 This command is normally used by programs that want to lie to themselves
316 about what was just input.
318 For example, when processing a file like F</etc/termcap>.
319 If your input lines might end in backslashes to indicate continuation, you
320 want to skip ahead and get the next record.
331 which is Perl short-hand for the more explicitly written version:
333 LINE: while (defined($line = <ARGV>)) {
335 if ($line =~ s/\\$//) {
337 redo LINE unless eof(); # not eof(ARGV)!
342 Note that if there were a C<continue> block on the above code, it would
343 get executed only on lines discarded by the regex (since redo skips the
344 continue block). A continue block is often used to reset line counters
345 or C<m?pat?> one-time matches:
347 # inspired by :1,$g/fred/s//WILMA/
349 m?(fred)? && s//WILMA $1 WILMA/;
350 m?(barney)? && s//BETTY $1 BETTY/;
351 m?(homer)? && s//MARGE $1 MARGE/;
353 print "$ARGV $.: $_";
354 close ARGV if eof; # reset $.
355 reset if eof; # reset ?pat?
358 If the word C<while> is replaced by the word C<until>, the sense of the
359 test is reversed, but the conditional is still tested before the first
362 The loop control statements don't work in an C<if> or C<unless>, since
363 they aren't loops. You can double the braces to make them such, though.
367 next if /barney/; # same effect as "last", but doesn't document as well
371 This is caused by the fact that a block by itself acts as a loop that
372 executes once, see L<"Basic BLOCKs">.
374 The form C<while/if BLOCK BLOCK>, available in Perl 4, is no longer
375 available. Replace any occurrence of C<if BLOCK> by C<if (do BLOCK)>.
380 Perl's C-style C<for> loop works like the corresponding C<while> loop;
381 that means that this:
383 for ($i = 1; $i < 10; $i++) {
396 There is one minor difference: if variables are declared with C<my>
397 in the initialization section of the C<for>, the lexical scope of
398 those variables is exactly the C<for> loop (the body of the loop
399 and the control sections).
402 Besides the normal array index looping, C<for> can lend itself
403 to many other interesting applications. Here's one that avoids the
404 problem you get into if you explicitly test for end-of-file on
405 an interactive file descriptor causing your program to appear to
407 X<eof> X<end-of-file> X<end of file>
409 $on_a_tty = -t STDIN && -t STDOUT;
410 sub prompt { print "yes? " if $on_a_tty }
411 for ( prompt(); <STDIN>; prompt() ) {
415 Using C<readline> (or the operator form, C<< <EXPR> >>) as the
416 conditional of a C<for> loop is shorthand for the following. This
417 behaviour is the same as a C<while> loop conditional.
418 X<readline> X<< <> >>
420 for ( prompt(); defined( $_ = <STDIN> ); prompt() ) {
427 The C<foreach> loop iterates over a normal list value and sets the
428 variable VAR to be each element of the list in turn. If the variable
429 is preceded with the keyword C<my>, then it is lexically scoped, and
430 is therefore visible only within the loop. Otherwise, the variable is
431 implicitly local to the loop and regains its former value upon exiting
432 the loop. If the variable was previously declared with C<my>, it uses
433 that variable instead of the global one, but it's still localized to
434 the loop. This implicit localization occurs I<only> in a C<foreach>
438 The C<foreach> keyword is actually a synonym for the C<for> keyword, so
439 you can use C<foreach> for readability or C<for> for brevity. (Or because
440 the Bourne shell is more familiar to you than I<csh>, so writing C<for>
441 comes more naturally.) If VAR is omitted, C<$_> is set to each value.
444 If any element of LIST is an lvalue, you can modify it by modifying
445 VAR inside the loop. Conversely, if any element of LIST is NOT an
446 lvalue, any attempt to modify that element will fail. In other words,
447 the C<foreach> loop index variable is an implicit alias for each item
448 in the list that you're looping over.
451 If any part of LIST is an array, C<foreach> will get very confused if
452 you add or remove elements within the loop body, for example with
453 C<splice>. So don't do that.
456 C<foreach> probably won't do what you expect if VAR is a tied or other
457 special variable. Don't do that either.
461 for (@ary) { s/foo/bar/ }
463 for my $elem (@elements) {
467 for $count (10,9,8,7,6,5,4,3,2,1,'BOOM') {
468 print $count, "\n"; sleep(1);
471 for (1..15) { print "Merry Christmas\n"; }
473 foreach $item (split(/:[\\\n:]*/, $ENV{TERMCAP})) {
474 print "Item: $item\n";
477 Here's how a C programmer might code up a particular algorithm in Perl:
479 for (my $i = 0; $i < @ary1; $i++) {
480 for (my $j = 0; $j < @ary2; $j++) {
481 if ($ary1[$i] > $ary2[$j]) {
482 last; # can't go to outer :-(
484 $ary1[$i] += $ary2[$j];
486 # this is where that last takes me
489 Whereas here's how a Perl programmer more comfortable with the idiom might
492 OUTER: for my $wid (@ary1) {
493 INNER: for my $jet (@ary2) {
494 next OUTER if $wid > $jet;
499 See how much easier this is? It's cleaner, safer, and faster. It's
500 cleaner because it's less noisy. It's safer because if code gets added
501 between the inner and outer loops later on, the new code won't be
502 accidentally executed. The C<next> explicitly iterates the other loop
503 rather than merely terminating the inner one. And it's faster because
504 Perl executes a C<foreach> statement more rapidly than it would the
505 equivalent C<for> loop.
510 A BLOCK by itself (labeled or not) is semantically equivalent to a
511 loop that executes once. Thus you can use any of the loop control
512 statements in it to leave or restart the block. (Note that this is
513 I<NOT> true in C<eval{}>, C<sub{}>, or contrary to popular belief
514 C<do{}> blocks, which do I<NOT> count as loops.) The C<continue>
517 The BLOCK construct can be used to emulate case structures.
520 if (/^abc/) { $abc = 1; last SWITCH; }
521 if (/^def/) { $def = 1; last SWITCH; }
522 if (/^xyz/) { $xyz = 1; last SWITCH; }
526 Such constructs are quite frequently used, because older versions
527 of Perl had no official C<switch> statement.
529 =head2 Switch statements
531 X<switch> X<case> X<given> X<when> X<default>
533 Starting from Perl 5.10, you can say
535 use feature "switch";
537 which enables a switch feature that is closely based on the
538 Perl 6 proposal. Starting from Perl 5.16, one can prefix the switch
539 keywords with C<CORE::> to access the feature without a C<use feature>
542 The keywords C<given> and C<when> are analogous
543 to C<switch> and C<case> in other languages, so the code
544 above could be written as
547 when (/^abc/) { $abc = 1; }
548 when (/^def/) { $def = 1; }
549 when (/^xyz/) { $xyz = 1; }
550 default { $nothing = 1; }
553 This construct is very flexible and powerful. For example:
558 say '$foo is undefined';
561 say '$foo is the string "foo"';
564 say '$foo is an odd digit';
565 continue; # Fall through
568 say '$foo is numerically less than 100';
570 when (\&complicated_check) {
571 say 'a complicated check for $foo is true';
574 die q(I don't know what to do with $foo);
578 C<given(EXPR)> will assign the value of EXPR to C<$_>
579 within the lexical scope of the block, so it's similar to
581 do { my $_ = EXPR; ... }
583 except that the block is automatically broken out of by a
584 successful C<when> or an explicit C<break>.
586 Most of the power comes from implicit smart matching:
590 is exactly equivalent to
594 Most of the time, C<when(EXPR)> is treated as an implicit smart match of
595 C<$_>, i.e. C<$_ ~~ EXPR>. (See L</"Smart matching in detail"> for more
596 information on smart matching.) But when EXPR is one of the below
597 exceptional cases, it is used directly as a boolean:
603 a subroutine or method call
607 a regular expression match, i.e. C</REGEX/> or C<$foo =~ /REGEX/>,
608 or a negated regular expression match (C<!/REGEX/> or C<$foo !~ /REGEX/>).
612 a comparison such as C<$_ E<lt> 10> or C<$x eq "abc">
613 (or of course C<$_ ~~ $c>)
617 C<defined(...)>, C<exists(...)>, or C<eof(...)>
621 a negated expression C<!(...)> or C<not (...)>, or a logical
622 exclusive-or C<(...) xor (...)>.
626 a filetest operator, with the exception of C<-s>, C<-M>, C<-A>, and C<-C>,
627 that return numerical values, not boolean ones.
631 the C<..> and C<...> flip-flop operators.
635 In those cases the value of EXPR is used directly as a boolean.
637 Furthermore, Perl inspects the operands of the binary boolean operators to
638 decide whether to use smart matching for each one by applying the above test to
645 If EXPR is C<... && ...> or C<... and ...>, the test
646 is applied recursively to both operands. If I<both>
647 operands pass the test, then the expression is treated
648 as boolean; otherwise, smart matching is used.
652 If EXPR is C<... || ...>, C<... // ...> or C<... or ...>, the test
653 is applied recursively to the first operand (which may be a
654 higher-precedence AND operator, for example). If the first operand
655 is to use smart matching, then both operands will do so; if it is
656 not, then the second argument will not be either.
660 These rules look complicated, but usually they will do what
661 you want. For example:
663 when (/^\d+$/ && $_ < 75) { ... }
665 will be treated as a boolean match because the rules say both a regex match and
666 an explicit test on $_ will be treated as boolean.
670 when ([qw(foo bar)] && /baz/) { ... }
672 will use smart matching because only I<one> of the operands is a boolean; the
673 other uses smart matching, and that wins.
677 when ([qw(foo bar)] || /^baz/) { ... }
679 will use smart matching (only the first operand is considered), whereas
681 when (/^baz/ || [qw(foo bar)]) { ... }
683 will test only the regex, which causes both operands to be treated as boolean.
684 Watch out for this one, then, because an arrayref is always a true value, which
685 makes it effectively redundant.
687 Tautologous boolean operators are still going to be optimized away. Don't be
690 when ('foo' or 'bar') { ... }
692 This will optimize down to C<'foo'>, so C<'bar'> will never be considered (even
693 though the rules say to use a smart match on C<'foo'>). For an alternation like
694 this, an array ref will work, because this will instigate smart matching:
696 when ([qw(foo bar)] { ... }
698 This is somewhat equivalent to the C-style switch statement's fallthrough
699 functionality (not to be confused with I<Perl's> fallthrough functionality - see
700 below), wherein the same block is used for several C<case> statements.
702 Another useful shortcut is that, if you use a literal array
703 or hash as the argument to C<given>, it is turned into a
704 reference. So C<given(@foo)> is the same as C<given(\@foo)>,
707 C<default> behaves exactly like C<when(1 == 1)>, which is
708 to say that it always matches.
712 You can use the C<break> keyword to break out of the enclosing
713 C<given> block. Every C<when> block is implicitly ended with
718 You can use the C<continue> keyword to fall through from one
722 when (/x/) { say '$foo contains an x'; continue }
723 when (/y/) { say '$foo contains a y' }
724 default { say '$foo does not contain a y' }
729 When a C<given> statement is also a valid expression (e.g.
730 when it's the last statement of a block), it evaluates to :
736 an empty list as soon as an explicit C<break> is encountered.
740 the value of the last evaluated expression of the successful
741 C<when>/C<default> clause, if there's one.
745 the value of the last evaluated expression of the C<given> block if no
750 In both last cases, the last expression is evaluated in the context that
751 was applied to the C<given> block.
753 Note that, unlike C<if> and C<unless>, failed C<when> statements always
754 evaluate to an empty list.
756 my $price = do { given ($item) {
757 when ([ 'pear', 'apple' ]) { 1 }
758 break when 'vote'; # My vote cannot be bought
759 1e10 when /Mona Lisa/;
763 Currently, C<given> blocks can't always be used as proper expressions. This
764 may be addressed in a future version of perl.
766 =head3 Switching in a loop
768 Instead of using C<given()>, you can use a C<foreach()> loop.
769 For example, here's one way to count how many times a particular
770 string occurs in an array:
774 when ("foo") { ++$count }
776 print "\@array contains $count copies of 'foo'\n";
778 At the end of all C<when> blocks, there is an implicit C<next>.
779 You can override that with an explicit C<last> if you're only
780 interested in the first match.
782 This doesn't work if you explicitly specify a loop variable,
783 as in C<for $item (@array)>. You have to use the default
784 variable C<$_>. (You can use C<for my $_ (@array)>.)
786 =head3 Smart matching in detail
788 The behaviour of a smart match depends on what type of thing its arguments
789 are. The behaviour is determined by the following table: the first row
790 that applies determines the match behaviour (which is thus mostly
791 determined by the type of the right operand). Note that the smart match
792 implicitly dereferences any non-blessed hash or array ref, so the "Hash"
793 and "Array" entries apply in those cases. (For blessed references, the
794 "Object" entries apply.)
796 Note that the "Matching Code" column is not always an exact rendition. For
797 example, the smart match operator short-circuits whenever possible, but
800 $a $b Type of Match Implied Matching Code
801 ====== ===== ===================== =============
802 Any undef undefined !defined $a
804 Any Object invokes ~~ overloading on $object, or dies
806 Hash CodeRef sub truth for each key[1] !grep { !$b->($_) } keys %$a
807 Array CodeRef sub truth for each elt[1] !grep { !$b->($_) } @$a
808 Any CodeRef scalar sub truth $b->($a)
810 Hash Hash hash keys identical (every key is found in both hashes)
811 Array Hash hash keys intersection grep { exists $b->{$_} } @$a
812 Regex Hash hash key grep grep /$a/, keys %$b
813 undef Hash always false (undef can't be a key)
814 Any Hash hash entry existence exists $b->{$a}
816 Hash Array hash keys intersection grep { exists $a->{$_} } @$b
817 Array Array arrays are comparable[2]
818 Regex Array array grep grep /$a/, @$b
819 undef Array array contains undef grep !defined, @$b
820 Any Array match against an array element[3]
823 Hash Regex hash key grep grep /$b/, keys %$a
824 Array Regex array grep grep /$b/, @$a
825 Any Regex pattern match $a =~ /$b/
827 Object Any invokes ~~ overloading on $object, or falls back:
828 undef Any undefined !defined($b)
829 Any Num numeric equality $a == $b
830 Num numish[4] numeric equality $a == $b
831 Any Any string equality $a eq $b
833 1 - empty hashes or arrays will match.
834 2 - that is, each element smart-matches the element of same index in the
836 3 - If a circular reference is found, we fall back to referential equality.
837 4 - either a real number, or a string that looks like a number
839 =head3 Custom matching via overloading
841 You can change the way that an object is matched by overloading
842 the C<~~> operator. This may alter the usual smart match semantics.
844 It should be noted that C<~~> will refuse to work on objects that
845 don't overload it (in order to avoid relying on the object's
846 underlying structure).
848 Note also that smart match's matching rules take precedence over
849 overloading, so if C<$obj> has smart match overloading, then
853 will not automatically invoke the overload method with X as an argument;
854 instead the table above is consulted as normal, and based in the type of X,
855 overloading may or may not be invoked.
859 =head3 Differences from Perl 6
861 The Perl 5 smart match and C<given>/C<when> constructs are not
862 absolutely identical to their Perl 6 analogues. The most visible
863 difference is that, in Perl 5, parentheses are required around
864 the argument to C<given()> and C<when()> (except when this last
865 one is used as a statement modifier). Parentheses in Perl 6
866 are always optional in a control construct such as C<if()>,
867 C<while()>, or C<when()>; they can't be made optional in Perl
868 5 without a great deal of potential confusion, because Perl 5
869 would parse the expression
875 as though the argument to C<given> were an element of the hash
876 C<%foo>, interpreting the braces as hash-element syntax.
878 The table of smart matches is not identical to that proposed by the
879 Perl 6 specification, mainly due to the differences between Perl 6's
880 and Perl 5's data models.
882 In Perl 6, C<when()> will always do an implicit smart match
883 with its argument, whilst it is convenient in Perl 5 to
884 suppress this implicit smart match in certain situations,
885 as documented above. (The difference is largely because Perl 5
886 does not, even internally, have a boolean type.)
891 Although not for the faint of heart, Perl does support a C<goto>
892 statement. There are three forms: C<goto>-LABEL, C<goto>-EXPR, and
893 C<goto>-&NAME. A loop's LABEL is not actually a valid target for
894 a C<goto>; it's just the name of the loop.
896 The C<goto>-LABEL form finds the statement labeled with LABEL and resumes
897 execution there. It may not be used to go into any construct that
898 requires initialization, such as a subroutine or a C<foreach> loop. It
899 also can't be used to go into a construct that is optimized away. It
900 can be used to go almost anywhere else within the dynamic scope,
901 including out of subroutines, but it's usually better to use some other
902 construct such as C<last> or C<die>. The author of Perl has never felt the
903 need to use this form of C<goto> (in Perl, that is--C is another matter).
905 The C<goto>-EXPR form expects a label name, whose scope will be resolved
906 dynamically. This allows for computed C<goto>s per FORTRAN, but isn't
907 necessarily recommended if you're optimizing for maintainability:
909 goto(("FOO", "BAR", "GLARCH")[$i]);
911 The C<goto>-&NAME form is highly magical, and substitutes a call to the
912 named subroutine for the currently running subroutine. This is used by
913 C<AUTOLOAD()> subroutines that wish to load another subroutine and then
914 pretend that the other subroutine had been called in the first place
915 (except that any modifications to C<@_> in the current subroutine are
916 propagated to the other subroutine.) After the C<goto>, not even C<caller()>
917 will be able to tell that this routine was called first.
919 In almost all cases like this, it's usually a far, far better idea to use the
920 structured control flow mechanisms of C<next>, C<last>, or C<redo> instead of
921 resorting to a C<goto>. For certain applications, the catch and throw pair of
922 C<eval{}> and die() for exception processing can also be a prudent approach.
924 =head2 PODs: Embedded Documentation
925 X<POD> X<documentation>
927 Perl has a mechanism for intermixing documentation with source code.
928 While it's expecting the beginning of a new statement, if the compiler
929 encounters a line that begins with an equal sign and a word, like this
931 =head1 Here There Be Pods!
933 Then that text and all remaining text up through and including a line
934 beginning with C<=cut> will be ignored. The format of the intervening
935 text is described in L<perlpod>.
937 This allows you to intermix your source code
938 and your documentation text freely, as in
942 The snazzle() function will behave in the most spectacular
943 form that you can possibly imagine, not even excepting
944 cybernetic pyrotechnics.
946 =cut back to the compiler, nuff of this pod stuff!
953 Note that pod translators should look at only paragraphs beginning
954 with a pod directive (it makes parsing easier), whereas the compiler
955 actually knows to look for pod escapes even in the middle of a
956 paragraph. This means that the following secret stuff will be
957 ignored by both the compiler and the translators.
961 warn "Neither POD nor CODE!?"
965 You probably shouldn't rely upon the C<warn()> being podded out forever.
966 Not all pod translators are well-behaved in this regard, and perhaps
967 the compiler will become pickier.
969 One may also use pod directives to quickly comment out a section
972 =head2 Plain Old Comments (Not!)
973 X<comment> X<line> X<#> X<preprocessor> X<eval>
975 Perl can process line directives, much like the C preprocessor. Using
976 this, one can control Perl's idea of filenames and line numbers in
977 error or warning messages (especially for strings that are processed
978 with C<eval()>). The syntax for this mechanism is almost the same as for
979 most C preprocessors: it matches the regular expression
981 # example: '# line 42 "new_filename.plx"'
984 (?:\s("?)([^"]+)\g2)? \s*
987 with C<$1> being the line number for the next line, and C<$3> being
988 the optional filename (specified with or without quotes). Note that
989 no whitespace may precede the C<< # >>, unlike modern C preprocessors.
991 There is a fairly obvious gotcha included with the line directive:
992 Debuggers and profilers will only show the last source line to appear
993 at a particular line number in a given file. Care should be taken not
994 to cause line number collisions in code you'd like to debug later.
996 Here are some examples that you should be able to type into your command
1001 # the `#' on the previous line must be the first char on line
1004 foo at bzzzt line 201.
1008 eval qq[\n#line 2001 ""\ndie 'foo']; print $@;
1013 eval qq[\n#line 200 "foo bar"\ndie 'foo']; print $@;
1015 foo at foo bar line 200.
1019 eval "\n#line " . __LINE__ . ' "' . __FILE__ ."\"\ndie 'foo'";
1022 foo at goop line 345.