|
|
|
  |
||
| ||||||
|
|
Man Page for PERLTRAP
NAME
perltrap - Perl traps for the unwary
DESCRIPTION
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
following:
+ 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
details.
+ 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
manpage.
+ $<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
number.)
+ 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
command.
+ 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
following:
+ 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
look
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.
Darn.
+ 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
subroutine.
+ 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
supported.
+ Negative array subscripts now count from the end of the
array.
+ 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 |
