About Us Documentation

Contact Site Map



Man Page for PERLTRAP

     perltrap - Perl traps for the unwary

     The biggest trap of all is forgetting to use the -w switch;
     see the perlrun manpage.  Making your entire program
     runnable under

         use strict;

     can help make your program more bullet-proof, but sometimes
     it's too annoying for quick throw-away programs.

     Awk Traps

     Accustomed awk users should take special note of the

     +   The English module, loaded via

             use English;

         allows you to refer to special variables (like $RS) as
         though they were in awk; see the perlvar manpage for

     +   Semicolons are required after all simple statements in
         Perl (except at the end of a block).  Newline is not a
         statement delimiter.

     +   Curly brackets are required on ifs and whiles.

     +   Variables begin with "$" or "@" in Perl.

     +   Arrays index from 0.  Likewise string positions in
         substr() and index().

     +   You have to decide whether your array has numeric or
         string indices.

     +   Associative array values do not spring into existence
         upon mere reference.

     +   You have to decide whether you want to use string or
         numeric comparisons.

     +   Reading an input line does not split it for you.  You
         get to split it yourself to an array.  And split()
         operator has different arguments.

     +   The current input line is normally in $_, not $0.  It
         generally does not have the newline stripped.  ($0 is
         the name of the program executed.)  See the perlvar

     +   $<digit> does not refer to fields--it refers to
         substrings matched by the last match pattern.

     +   The print() statement does not add field and record
         separators unless you set $, and $..  You can set $OFS
         and $ORS if you're using the English module.

     +   You must open your files before you print to them.

     +   The range operator is "..", not comma.  The comma
         operator works as in C.

     +   The match operator is "=~", not "~".  ("~" is the one's
         complement operator, as in C.)

     +   The exponentiation operator is "**", not "^".  "^" is
         the XOR operator, as in C.  (You know, one could get the
         feeling that awk is basically incompatible with C.)

     +    The concatenation operator is ".", not the null string.
         (Using the null string would render /pat/ /pat/
         unparsable, since the third slash would be interpreted
         as a division operator--the tokener is in fact slightly
         context sensitive for operators like "/", "?", and  ">".
         And in fact, "." itself can be the beginning of a

     +    The next, exit, and continue keywords work differently.

     +   The following variables work differently:

               Awk       Perl
               ARGC      $#ARGV or scalar @ARGV
               ARGV[0]   $0
               FILENAME  $ARGV
               FNR       $. - something
               FS        (whatever you like)
               NF        $#Fld, or some such
               NR        $.
               OFMT      $#
               OFS       $,
               ORS       $\
               RLENGTH   length($&)
               RS        $/
               RSTART    length($`)
               SUBSEP    $;

     +   You cannot set $RS to a pattern, only a string.

     +   When in doubt, run the awk construct through a2p and see
         what it gives you.

     C Traps

     Cerebral C programmers should take note of the following:

     +   Curly brackets are required on if's and while's.

     +   You must use elsif rather than else if.

     +   The break and continue keywords from C become in Perl
         last and next, respectively.  Unlike in C, these do NOT
         work within a do { } while construct.

     +   There's no switch statement.  (But it's easy to build
         one on the fly.)

     +   Variables begin with "$" or "@" in Perl.

     +   printf() does not implement the "*" format for
         interpolating field widths, but it's trivial to use
         interpolation of double-quoted strings to achieve the
         same effect.

     +   Comments begin with "#", not "/*".

     +   You can't take the address of anything, although a
         similar operator in Perl 5 is the backslash, which
         creates a reference.

     +   ARGV must be capitalized.

     +   System calls such as link(), unlink(), rename(), etc.
         return nonzero for success, not 0.

     +   Signal handlers deal with signal names, not numbers.
         Use kill -l to find their names on your system.

     Sed Traps

     Seasoned sed programmers should take note of the following:

     +   Backreferences in substitutions use "$" rather than "

     +   The pattern matching metacharacters "(", ")", and "|" do
         not have backslashes in front.

     +   The range operator is ..., rather than comma.

     Shell Traps

     Sharp shell programmers should take note of the following:

     +   The backtick operator does variable interpretation
         without regard to the presence of single quotes in the

     +   The backtick operator does no translation of the return
         value, unlike csh.

     +   Shells (especially csh) do several levels of
         substitution on each command line.  Perl does
         substitution only in certain constructs such as double
         quotes, backticks, angle brackets, and search  patterns.

     +   Shells interpret scripts a little bit at a time.  Perl
         compiles the entire program before executing it (except
         for BEGIN blocks, which execute at compile time).

     +    The arguments are available via @ARGV, not $1, $2, etc.

     +   The environment is not automatically made available as
         separate scalar variables.

     Perl Traps

     Practicing Perl Programmers should take note of the

     +   Remember that many operations behave differently in a
         list context than they do in a scalar one.  See the
         perldata manpage for details.

     +   Avoid barewords if you can, especially all lower-case
         ones.  You can't tell just by looking at it whether a
         bareword is a function or a string.  By using quotes on
         strings and parens on function calls, you won't ever get
         them confused.

     +   You cannot discern from mere inspection which built-ins
         are unary operators (like chop() and chdir()) and which
         are list operators (like print() and unlink()).  (User-
         defined subroutines can only be list operators, never
         unary ones.)  See the perlop manpage.

     +   People have a hard type remembering that some functions
         default to $_, or @ARGV, or whatever, but that others
         which you might expect to do not.

     +   Remember not to use "=" when you need "=~"; these two
         constructs are quite different:

             $x =  /foo/;
             $x =~ /foo/;

     +   The do {} construct isn't a real loop that you can use
         loop control on.

     +   Use my() for local variables whenever you can get away
         with it (but see the perlform manpage for where you
         can't). Using local() actually gives a local value to a
         global variable, which leaves you open to unforeseen
         side-effects of dynamic scoping.

     Perl4 Traps

     Penitent Perl 4 Programmers should take note of the
     following incompatible changes that occurred between release
     4 and release 5:

     +   @ now always interpolates an array in double-quotish
         strings.  Some programs may now need to use backslash to
         protect any @ that shouldn't interpolate.

like  subroutine  calls  if  a subroutine by that name is defined
before the compiler sees them. For example:
     + Barewords that used to look like strings to Perl will  now

             sub SeeYa { die "Hasta la vista, baby!" }
             $SIG{QUIT} = SeeYa;

         In Perl 4, that set the signal handler; in Perl 5, it
         actually calls the function!  You may use the -w switch
         to find such places.

     +   Symbols starting with _ are no longer forced into
         package main, except for $_ itself (and @_, etc.).

     +   s'$lhs'$rhs' now does no interpolation on either side.
         It used to interpolate $lhs but not $rhs.

     +   The second and third arguments of splice() are now
         evaluated in scalar context (as the book says) rather
         than list context.

     +   These are now semantic errors because of precedence:

             shift @list + 20;
             $n = keys %map + 20;

         Because if that were to work, then this couldn't:

             sleep $dormancy + 20;

     +   open FOO || die is now incorrect.  You need parens
         around the filehandle.  While temporarily supported,
         using such a construct will generate a non-fatal (but
         non-suppressible) warning.

     +   The elements of argument lists for formats are now
         evaluated in list context.  This means you can
         interpolate list values now.

     +   You can't do a goto into a block that is optimized away.

     +   It is no longer syntactically legal to use whitespace as
         the name of a variable, or as a delimiter for any kind
         of quote construct.  Double darn.

     +   The caller() function now returns a false value in a
         scalar context if there is no caller.  This lets library
         files determine if they're being required.

     +   m//g now attaches its state to the searched string
         rather than the regular expression.

     +   reverse is no longer allowed as the name of a sort

     +   taintperl is no longer a separate executable.  There is
         now a -T switch to turn on tainting when it isn't turned
         on automatically.

     +   Double-quoted strings may no longer end with an
         unescaped $ or @.

     +   The archaic while/if BLOCK BLOCK syntax is no longer

     +   Negative array subscripts now count from the end of the

     +   The comma operator in a scalar context is now guaranteed
         to give a scalar context to its arguments.

     +   The ** operator now binds more tightly than unary minus.
         It was documented to work this way before, but didn't.

     +   Setting $#array lower now discards array elements.

     +   delete() is not guaranteed to return the old value for
         tie()d arrays, since this capability may be onerous for
         some modules to implement.

     +   Some error messages will be different.

     +   Some bugs may have been inadvertently removed.



Email addresses listed on this site may  NOT be used for unsolicited commercial email.

Ready-to-Run Software, Inc Privacy Statement

Portions (c)Copyright, 1996-2005 by Ready-to-Run Software, Inc
(All rights reserved.)
212 Cedar Cove
Lansing, NY 14882
Phone: 607 533 UNIX (8649)
Fax: 607 533 4002