nit in perlsyn.pod

[perl5.git] / pod / perlsyn.pod

diff --git a/pod/perlsyn.pod b/pod/perlsyn.pod
index 0dd842d..8f1af95 100644 (file)
--- a/pod/perlsyn.pod
+++ b/pod/perlsyn.pod
@@ -5,21 +5,14 @@ perlsyn - Perl syntax
 =head1 DESCRIPTION
 
 A Perl script consists of a sequence of declarations and statements.
 =head1 DESCRIPTION
 
 A Perl script consists of a sequence of declarations and statements.

-The only things that need to be declared in Perl are report formats
-and subroutines.  See the sections below for more information on those
-declarations.  All uninitialized user-created objects are assumed to
-start with a C<null> or C<0> value until they are defined by some explicit
-operation such as assignment.  (Though you can get warnings about the
-use of undefined values if you like.)  The sequence of statements is
-executed just once, unlike in B<sed> and B<awk> scripts, where the
-sequence of statements is executed for each input line.  While this means
-that you must explicitly loop over the lines of your input file (or
-files), it also means you have much more control over which files and
-which lines you look at.  (Actually, I'm lying--it is possible to do an
-implicit loop with either the B<-n> or B<-p> switch.  It's just not the
-mandatory default like it is in B<sed> and B<awk>.)
-
-=head2 Declarations
+The sequence of statements is executed just once, unlike in B<sed>
+and B<awk> scripts, where the sequence of statements is executed
+for each input line.  While this means that you must explicitly
+loop over the lines of your input file (or files), it also means
+you have much more control over which files and which lines you look at.
+(Actually, I'm lying--it is possible to do an implicit loop with
+either the B<-n> or B<-p> switch.  It's just not the mandatory
+default like it is in B<sed> and B<awk>.)

 
 Perl is, for the most part, a free-form language.  (The only exception
 to this is format declarations, for obvious reasons.)  Text from a
 
 Perl is, for the most part, a free-form language.  (The only exception
 to this is format declarations, for obvious reasons.)  Text from a


@@ -29,11 +22,27 @@ interpreted either as division or pattern matching, depending on the
 context, and C++ C<//> comments just look like a null regular
 expression, so don't do that.
 
 context, and C++ C<//> comments just look like a null regular
 expression, so don't do that.
 

+=head2 Declarations
+
+The only things you need to declare in Perl are report formats
+and subroutines--and even undefined subroutines can be handled
+through AUTOLOAD.  A variable holds the undefined value (C<undef>)
+until it has been assigned a defined value, which is anything
+other than C<undef>.  When used as a number, C<undef> is treated
+as C<0>; when used as a string, it is treated the empty string,
+C<"">; and when used as a reference that isn't being assigned
+to, it is treated as an error.  If you enable warnings, you'll
+be notified of an uninitialized value whenever you treat C<undef>
+as a string or a number.  Well, usually.  Boolean ("don't-care")
+contexts and operators such as C<++>, C<-->, C<+=>, C<-=>, and
+C<.=> are always exempt from such warnings.
+

 A declaration can be put anywhere a statement can, but has no effect on
 the execution of the primary sequence of statements--declarations all
 take effect at compile time.  Typically all the declarations are put at
 the beginning or the end of the script.  However, if you're using
 A declaration can be put anywhere a statement can, but has no effect on
 the execution of the primary sequence of statements--declarations all
 take effect at compile time.  Typically all the declarations are put at
 the beginning or the end of the script.  However, if you're using

-lexically-scoped private variables created with C<my()>, you'll have to make sure
+lexically-scoped private variables created with C<my()>, you'll
+have to make sure

 your format or subroutine definition is within the same block scope
 as the my if you expect to be able to access those private variables.
 
 your format or subroutine definition is within the same block scope
 as the my if you expect to be able to access those private variables.
 


@@ -44,8 +53,8 @@ subroutine without defining it by saying C<sub name>, thus:
     sub myname;
     $me = myname $0            or die "can't get myname";
 
     sub myname;
     $me = myname $0            or die "can't get myname";
 

-Note that my() functions as a list operator, not as a unary operator; so
-be careful to use C<or> instead of C<||> in this case.  However, if
+Note that myname() functions as a list operator, not as a unary operator;
+so be careful to use C<or> instead of C<||> in this case.  However, if

 you were to declare the subroutine as C<sub myname ($)>, then
 C<myname> would function as a unary operator, so either C<or> or
 C<||> would work.
 you were to declare the subroutine as C<sub myname ($)>, then
 C<myname> would function as a unary operator, so either C<or> or
 C<||> would work.


@@ -162,7 +171,10 @@ statements C<next>, C<last>, and C<redo>.
 If the LABEL is omitted, the loop control statement
 refers to the innermost enclosing loop.  This may include dynamically
 looking back your call-stack at run time to find the LABEL.  Such
 If the LABEL is omitted, the loop control statement
 refers to the innermost enclosing loop.  This may include dynamically
 looking back your call-stack at run time to find the LABEL.  Such

-desperate behavior triggers a warning if you use the B<-w> flag.
+desperate behavior triggers a warning if you use the C<use warnings>
+pragma or the B<-w> flag.
+Unlike a C<foreach> statement, a C<while> statement never implicitly
+localises any variables.

 
 If there is a C<continue> BLOCK, it is always executed just before the
 conditional is about to be evaluated again, just like the third part of a
 
 If there is a C<continue> BLOCK, it is always executed just before the
 conditional is about to be evaluated again, just like the third part of a


@@ -218,9 +230,10 @@ which is Perl short-hand for the more explicitly written version:
        # now process $line
     }
 
        # now process $line
     }
 

-Note that if there were a C<continue> block on the above code, it would get
-executed even on discarded lines.  This is often used to reset line counters 
-or C<?pat?> one-time matches.
+Note that if there were a C<continue> block on the above code, it would
+get executed only on lines discarded by the regex (since redo skips the
+continue block). A continue block is often used to reset line counters
+or C<?pat?> one-time matches:

 
     # inspired by :1,$g/fred/s//WILMA/
     while (<>) {
 
     # inspired by :1,$g/fred/s//WILMA/
     while (<>) {


@@ -251,7 +264,7 @@ available.   Replace any occurrence of C<if BLOCK> by C<if (do BLOCK)>.
 
 =head2 For Loops
 
 
 =head2 For Loops
 

-Perl's C-style C<for> loop works exactly like the corresponding C<while> loop;
+Perl's C-style C<for> loop works like the corresponding C<while> loop;

 that means that this:
 
     for ($i = 1; $i < 10; $i++) {
 that means that this:
 
     for ($i = 1; $i < 10; $i++) {


@@ -267,8 +280,10 @@ is the same as this:
        $i++;
     }
 
        $i++;
     }
 

-(There is one minor difference: The first form implies a lexical scope
-for variables declared with C<my> in the initialization expression.)
+There is one minor difference: if variables are declared with C<my>
+in the initialization section of the C<for>, the lexical scope of
+those variables is exactly the C<for> loop (the body of the loop
+and the control sections).

 
 Besides the normal array index looping, C<for> can lend itself
 to many other interesting applications.  Here's one that avoids the
 
 Besides the normal array index looping, C<for> can lend itself
 to many other interesting applications.  Here's one that avoids the


@@ -297,9 +312,12 @@ The C<foreach> keyword is actually a synonym for the C<for> keyword, so
 you can use C<foreach> for readability or C<for> for brevity.  (Or because
 the Bourne shell is more familiar to you than I<csh>, so writing C<for>
 comes more naturally.)  If VAR is omitted, C<$_> is set to each value.
 you can use C<foreach> for readability or C<for> for brevity.  (Or because
 the Bourne shell is more familiar to you than I<csh>, so writing C<for>
 comes more naturally.)  If VAR is omitted, C<$_> is set to each value.

-If any element of LIST is an lvalue, you can modify it by modifying VAR
-inside the loop.  That's because the C<foreach> loop index variable is
-an implicit alias for each item in the list that you're looping over.
+
+If any element of LIST is an lvalue, you can modify it by modifying
+VAR inside the loop.  Conversely, if any element of LIST is NOT an
+lvalue, any attempt to modify that element will fail.  In other words,
+the C<foreach> loop index variable is an implicit alias for each item
+in the list that you're looping over.

 
 If any part of LIST is an array, C<foreach> will get very confused if
 you add or remove elements within the loop body, for example with
 
 If any part of LIST is an array, C<foreach> will get very confused if
 you add or remove elements within the loop body, for example with


@@ -312,7 +330,7 @@ Examples:
 
     for (@ary) { s/foo/bar/ }
 
 
     for (@ary) { s/foo/bar/ }
 

-    foreach my $elem (@elements) {
+    for my $elem (@elements) {

        $elem *= 2;
     }
 
        $elem *= 2;
     }
 


@@ -341,8 +359,8 @@ Here's how a C programmer might code up a particular algorithm in Perl:
 Whereas here's how a Perl programmer more comfortable with the idiom might
 do it:
 
 Whereas here's how a Perl programmer more comfortable with the idiom might
 do it:
 

-    OUTER: foreach my $wid (@ary1) {
-    INNER:   foreach my $jet (@ary2) {
+    OUTER: for my $wid (@ary1) {
+    INNER:   for my $jet (@ary2) {

                next OUTER if $wid > $jet;
                $wid += $jet;
             }
                next OUTER if $wid > $jet;
                $wid += $jet;
             }


@@ -376,8 +394,18 @@ structures.
     }
 
 There is no official C<switch> statement in Perl, because there are
     }
 
 There is no official C<switch> statement in Perl, because there are

-already several ways to write the equivalent.  In addition to the
-above, you could write
+already several ways to write the equivalent.
+
+However, starting from Perl 5.8 to get switch and case one can use
+the Switch extension and say:
+
+       use Switch;
+
+after which one has switch and case.  It is not as fast as it could be
+because it's not really part of the language (it's done using source
+filters) but it is available, and it's very flexible.
+
+In addition to the above BLOCK construct, you could write

 
     SWITCH: {
        $abc = 1, last SWITCH  if /^abc/;
 
     SWITCH: {
        $abc = 1, last SWITCH  if /^abc/;


@@ -469,9 +497,9 @@ Or
                                   "read-only";
         };
 
                                   "read-only";
         };
 

-Or if you are certainly that all the C<&&> clauses are true, you can use
+Or if you are certain that all the C<&&> clauses are true, you can use

 something like this, which "switches" on the value of the
 something like this, which "switches" on the value of the

-C<HTTP_USER_AGENT> envariable.
+C<HTTP_USER_AGENT> environment variable.

 
     #!/usr/bin/perl 
     # pick out jargon file page based on browser
 
     #!/usr/bin/perl 
     # pick out jargon file page based on browser


@@ -513,7 +541,7 @@ The C<goto>-EXPR form expects a label name, whose scope will be resolved
 dynamically.  This allows for computed C<goto>s per FORTRAN, but isn't
 necessarily recommended if you're optimizing for maintainability:
 
 dynamically.  This allows for computed C<goto>s per FORTRAN, but isn't
 necessarily recommended if you're optimizing for maintainability:
 

-    goto ("FOO", "BAR", "GLARCH")[$i];
+    goto(("FOO", "BAR", "GLARCH")[$i]);

 
 The C<goto>-&NAME form is highly magical, and substitutes a call to the
 named subroutine for the currently running subroutine.  This is used by
 
 The C<goto>-&NAME form is highly magical, and substitutes a call to the
 named subroutine for the currently running subroutine.  This is used by


@@ -582,10 +610,15 @@ this, one can control Perl's idea of filenames and line numbers in
 error or warning messages (especially for strings that are processed
 with C<eval()>).  The syntax for this mechanism is the same as for most
 C preprocessors: it matches the regular expression
 error or warning messages (especially for strings that are processed
 with C<eval()>).  The syntax for this mechanism is the same as for most
 C preprocessors: it matches the regular expression

-C</^#\s*line\s+(\d+)\s*(?:\s"([^"]*)")?/> with C<$1> being the line
+C</^#\s*line\s+(\d+)\s*(?:\s"([^"]+)")?\s*$/> with C<$1> being the line

 number for the next line, and C<$2> being the optional filename
 (specified within quotes).
 
 number for the next line, and C<$2> being the optional filename
 (specified within quotes).
 

+There is a fairly obvious gotcha included with the line directive:
+Debuggers and profilers will only show the last source line to appear
+at a particular line number in a given file.  Care should be taken not
+to cause line number collisions in code you'd like to debug later.
+

 Here are some examples that you should be able to type into your command
 shell:
 
 Here are some examples that you should be able to type into your command
 shell: