=head1 DESCRIPTION
-The biggest trap of all is forgetting to use the B<-w> switch; see
-L<perlrun>. The second biggest trap is not making your entire program
-runnable under C<use strict>.
+The biggest trap of all is forgetting to C<use warnings> or use the B<-w>
+switch; see L<perllexwarn> and L<perlrun>. The second biggest trap is not
+making your entire program runnable under C<use strict>. The third biggest
+trap is not reading the list of changes in this version of Perl; see
+L<perldelta>.
=head2 Awk Traps
=item *
+A Perl program executes only once, not once for each input line. You can
+do an implicit loop with C<-n> or C<-p>.
+
+=item *
+
The English module, loaded via
use English;
-allows you to refer to special variables (like $RS) as
-though they were in B<awk>; see L<perlvar> for details.
+allows you to refer to special variables (like C<$/>) with names (like
+
$RS), as though they were in B<awk>; see L<perlvar> for details.
=item *
=item *
-Variables begin with "$" or "@" in Perl.
+Variables begin with "$", "@" or "%" in Perl.
=item *
=item *
-Associative array values do not spring into existence upon mere
-reference.
+Hash values do not spring into existence upon mere reference.
=item *
=item *
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.
+to an array yourself. And the split() operator has different
+arguments than B<awk>'s.
=item *
=item *
-$<I<digit>> does not refer to fields--it refers to substrings matched by
-the last match pattern.
+$<I<digit>> does not refer to fields--it refers to substrings matched
+by the last match pattern.
=item *
The print() statement does not add field and record separators unless
-you set C<$,> and C<$.>. You can set $OFS and $ORS if you're using
+you set C<$,> and C<$\>. You can set $OFS and $ORS if you're using
the English module.
=item *
=item *
The concatenation operator is ".", not the null string. (Using the
-null string would render C</pat/ /pat/> unparsable, since the third slash
-would be interpreted as a division operator--the tokener is in fact
+null string would render C</pat/ /pat/> unparsable, because the third slash
+would be interpreted as a division operator--the tokenizer is in fact
slightly context sensitive for operators like "/", "?", and ">".
And in fact, "." itself can be the beginning of a number.)
The following variables work differently:
Awk Perl
- ARGC $#ARGV or scalar @ARGV
+ ARGC scalar @ARGV (compare with $#ARGV)
ARGV[0] $0
FILENAME $ARGV
FNR $. - something
=back
-=head2 C Traps
+=head2 C/C++ Traps
-Cerebral C programmers should take note of the following:
+Cerebral C and C++ programmers should take note of the following:
=over 4
=item *
-The C<break> and C<continue> keywords from C become in
-Perl C<last> and C<next>, respectively.
-Unlike in C, these do I<NOT> work within a C<do { } while> construct.
+The C<break> and C<continue> keywords from C become in Perl C<last>
+and C<next>, respectively. Unlike in C, these do I<not> work within a
+C<do { } while> construct. See L<perlsyn/"Loop Control">.
=item *
-There's no switch statement. (But it's easy to build one on the fly.)
+The switch statement is called C<given/when> and only available in
+perl 5.10 or newer. See L<perlsyn/"Switch Statements">.
=item *
-Variables begin with "$" or "@" in Perl.
+Variables begin with "$", "@" or "%" in Perl.
=item *
-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.
-
-=item *
-
-Comments begin with "#", not "/*".
+Comments begin with "#", not "/*" or "//". Perl may interpret C/C++
+comments as division operators, unterminated regular expressions or
+the defined-or operator.
=item *
You can't take the address of anything, although a similar operator
-in Perl 5 is the backslash, which creates a reference.
+in Perl is the backslash, which creates a reference.
=item *
=item *
System calls such as link(), unlink(), rename(), etc. return nonzero for
-success, not 0.
+success, not 0. (system(), however, returns zero for success.)
=item *
=back
-=head2 Sed Traps
+=head2 JavaScript Traps
-Seasoned B<sed> programmers should take note of the following:
+Judicious JavaScript programmers should take note of the following:
=over 4
=item *
-Backreferences in substitutions use "$" rather than "\".
+In Perl, binary C<+> is always addition. C<$string1 + $string2> converts
+both strings to numbers and then adds them. To concatenate two strings,
+use the C<.> operator.
=item *
-The pattern matching metacharacters "(", ")", and "|" do not have backslashes
-in front.
+The C<+> unary operator doesn't do anything in Perl. It exists to avoid
+syntactic ambiguities.
=item *
-The range operator is C<...>, rather than comma.
+Unlike C<for...in>, Perl's C<for> (also spelled C<foreach>) does not allow
+the left-hand side to be an arbitrary expression. It must be a variable:
-=back
+ for my $variable (keys %hash) {
+ ...
+ }
-=head2 Shell Traps
-
-Sharp shell programmers should take note of the following:
-
-=over 4
+Furthermore, don't forget the C<keys> in there, as
+C<foreach my $kv (%hash) {}> iterates over the keys and values, and is
+generally not useful ($kv would be a key, then a value, and so on).
=item *
-The backtick operator does variable interpretation without regard to
-the presence of single quotes in the command.
+To iterate over the indices of an array, use C<foreach my $i (0 .. $#array)
+{}>. C<foreach my $v (@array) {}> iterates over the values.
=item *
-The backtick operator does no translation of the return value, unlike B<csh>.
+Perl requires braces following C<if>, C<while>, C<foreach>, etc.
=item *
-Shells (especially B<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.
+In Perl, C<else if> is spelled C<elsif>.
=item *
-Shells interpret scripts a little bit at a time. Perl compiles the
-entire program before executing it (except for C<BEGIN> blocks, which
-execute at compile time).
+C<? :> has higher precedence than assignment. In JavaScript, one can
+write:
-=item *
+ condition ? do_something() : variable = 3
-The arguments are available via @ARGV, not $1, $2, etc.
+and the variable is only assigned if the condition is false. In Perl, you
+need parentheses:
-=item *
-
-The environment is not automatically made available as separate scalar
-variables.
+ $condition ? do_something() : ($variable = 3);
-=back
-
-=head2 Perl Traps
-
-Practicing Perl Programmers should take note of the following:
-
-=over 4
+Or just use C<if>.
=item *
-Remember that many operations behave differently in a list
-context than they do in a scalar one. See L<perldata> for details.
+Perl requires semicolons to separate statements.
=item *
-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.
+Variables declared with C<my> only affect code I<after> the declaration.
+You cannot write C<$x = 1; my $x;> and expect the first assignment to
+affect the same variable. It will instead assign to an C<$x> declared
+previously in an outer scope, or to a global variable.
-=item *
-
-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 B<only> be list operators, never
-unary ones.) See L<perlop>.
+Note also that the variable is not visible until the following
+I<statement>. This means that in C<my $x = 1 + $x> the second $x refers
+to one declared previously.
=item *
-People have a hard time remembering that some functions
-default to $_, or @ARGV, or whatever, but that others which
-you might expect to do not.
-
-=item *
-
-The <FH> construct is not the name of the filehandle, it is a readline
-operation on that handle. The data read is only assigned to $_ if the
-file read is the sole condition in a while loop:
-
- while (<FH>) { }
- while ($_ = <FH>) { }..
- <FH>; # data discarded!
-
-=item *
-
-Remember not to use "C<=>" when you need "C<=~>";
-these two constructs are quite different:
-
- $x = /foo/;
- $x =~ /foo/;
+C<my> variables are scoped to the current block, not to the current
+function. If you write C<{my $x;} $x;>, the second C<$x> does not refer to
+the one declared inside the block.
=item *
-The C<do {}> construct isn't a real loop that you can use
-loop control on.
+An object's members cannot be made accessible as variables. The closest
+Perl equivalent to C<with(object) { method() }> is C<for>, which can alias
+C<$_> to the object:
-=item *
-
-Use my() for local variables whenever you can get away with
-it (but see L<perlform> 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.
+ for ($object) {
+ $_->method;
+ }
=item *
-If you localize an exported variable in a module, its exported value will
-not change. The local name becomes an alias to a new value but the
-external name is still an alias for the original.
+The object or class on which a method is called is passed as one of the
+method's arguments, not as a separate C<this> value.
=back
-=head2 Perl4 Traps
+=head2 Sed Traps
-Penitent Perl 4 Programmers should take note of the following
-incompatible changes that occurred between release 4 and release 5:
+Seasoned B<sed> programmers should take note of the following:
=over 4
=item *
-C<@> now always interpolates an array in double-quotish strings. Some programs
-may now need to use backslash to protect any C<@> that shouldn't interpolate.
+A Perl program executes only once, not once for each input line. You can
+do an implicit loop with C<-n> or C<-p>.
=item *
-Barewords that used to look like strings to Perl will now look like subroutine
-calls if a subroutine by that name is defined before the compiler sees them.
-For example:
-
- 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 B<-w> switch to find such places.
+Backreferences in substitutions use "$" rather than "\".
=item *
-Symbols starting with C<_> are no longer forced into package C<main>, except
-for $_ itself (and @_, etc.).
+The pattern matching metacharacters "(", ")", and "|" do not have backslashes
+in front.
=item *
-Double-colon is now a valid package separator in an identifier. Thus these
-behave differently in perl4 vs. perl5:
-
- print "$a::$b::$c\n";
- print "$var::abc::xyz\n";
+The range operator is C<...>, rather than comma.
-=item *
+=back
-C<s'$lhs'$rhs'> now does no interpolation on either side. It used to
-interpolate C<$lhs> but not C<$rhs>.
+=head2 Shell Traps
-=item *
+Sharp shell programmers should take note of the following:
-The second and third arguments of splice() are now evaluated in scalar
-context (as the book says) rather than list context.
+=over 4
=item *
-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;
+The backtick operator does variable interpolation without regard to
+the presence of single quotes in the command.
=item *
-The precedence of assignment operators is now the same as the precedence
-of assignment. Perl 4 mistakenly gave them the precedence of the associated
-operator. So you now must parenthesize them in expressions like
-
- /foo/ ? ($a += 2) : ($a -= 2);
-
-Otherwise
-
- /foo/ ? $a += 2 : $a -= 2;
-
-would be erroneously parsed as
-
- (/foo/ ? $a += 2 : $a) -= 2;
-
-On the other hand,
-
- $a += /foo/ ? 1 : 2;
-
-now works as a C programmer would expect.
+The backtick operator does no translation of the return value, unlike B<csh>.
=item *
-C<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.
+Shells (especially B<csh>) do several levels of substitution on each
+command line. Perl does substitution in only certain constructs
+such as double quotes, backticks, angle brackets, and search patterns.
=item *
-The elements of argument lists for formats are now evaluated in list
-context. This means you can interpolate list values now.
+Shells interpret scripts a little bit at a time. Perl compiles the
+entire program before executing it (except for C<BEGIN> blocks, which
+execute at compile time).
=item *
-You can't do a C<goto> into a block that is optimized away. Darn.
+The arguments are available via @ARGV, not $1, $2, etc.
=item *
-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 environment is not automatically made available as separate scalar
+variables.
=item *
-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.
+The shell's C<test> uses "=", "!=", "<" etc for string comparisons and "-eq",
+"-ne", "-lt" etc for numeric comparisons. This is the reverse of Perl, which
+uses C<eq>, C<ne>, C<lt> for string comparisons, and C<==>, C<!=> C<< < >> etc
+for numeric comparisons.
-=item *
+=back
-C<m//g> now attaches its state to the searched string rather than the
-regular expression.
+=head2 Perl Traps
-=item *
+Practicing Perl Programmers should take note of the following:
-C<reverse> is no longer allowed as the name of a sort subroutine.
+=over 4
=item *
-B<taintperl> is no longer a separate executable. There is now a B<-T>
-switch to turn on tainting when it isn't turned on automatically.
+Remember that many operations behave differently in a list
+context than they do in a scalar one. See L<perldata> for details.
=item *
-Double-quoted strings may no longer end with an unescaped C<$> or C<@>.
+Avoid barewords if you can, especially all lowercase ones.
+You can't tell by just looking at it whether a bareword is
+a function or a string. By using quotes on strings and
+parentheses on function calls, you won't ever get them confused.
=item *
-The archaic C<while/if> BLOCK BLOCK syntax is no longer supported.
-
+You cannot discern from mere inspection which builtins
+are unary operators (like chop() and chdir())
+and which are list operators (like print() and unlink()).
+(Unless prototyped, user-defined subroutines can B<only> be list
+operators, never unary ones.) See L<perlop> and L<perlsub>.
=item *
-Negative array subscripts now count from the end of the array.
+People have a hard time remembering that some functions
+default to $_, or @ARGV, or whatever, but that others which
+you might expect to do not.
=item *
-The comma operator in a scalar context is now guaranteed to give a
-scalar context to its arguments.
-
-=item *
+The <FH> construct is not the name of the filehandle, it is a readline
+operation on that handle. The data read is assigned to $_ only if the
+file read is the sole condition in a while loop:
-The C<**> operator now binds more tightly than unary minus.
-It was documented to work this way before, but didn't.
+ while (<FH>) { }
+ while (defined($_ = <FH>)) { }..
+ <FH>; # data discarded!
=item *
-Setting C<$#array> lower now discards array elements.
-
-=item *
+Remember not to use C<=> when you need C<=~>;
+these two constructs are quite different:
-delete() is not guaranteed to return the old value for tie()d arrays,
-since this capability may be onerous for some modules to implement.
+ $x = /foo/;
+ $x =~ /foo/;
=item *
-The construct "this is $$x" used to interpolate the pid at that
-point, but now tries to dereference $x. C<$$> by itself still
-works fine, however.
+The C<do {}> construct isn't a real loop that you can use
+loop control on.
=item *
-The meaning of foreach has changed slightly when it is iterating over a
-list which is not an array. This used to assign the list to a
-temporary array, but no longer does so (for efficiency). This means
-that you'll now be iterating over the actual values, not over copies of
-the values. Modifications to the loop variable can change the original
-values. To retain Perl 4 semantics you need to assign your list
-explicitly to a temporary array and then iterate over that. For
-example, you might need to change
-
- foreach $var (grep /x/, @list) { ... }
-
-to
-
- foreach $var (my @tmp = grep /x/, @list) { ... }
-
-Otherwise changing C<$var> will clobber the values of @list. (This most often
-happens when you use C<$_> for the loop variable, and call subroutines in
-the loop that don't properly localize C<$_>.)
+Use C<my()> for local variables whenever you can get away with
+it (but see L<perlform> for where you can't).
+Using C<local()> actually gives a local value to a global
+variable, which leaves you open to unforeseen side-effects
+of dynamic scoping.
=item *
-Some error messages will be different.
+If you localize an exported variable in a module, its exported value will
+not change. The local name becomes an alias to a new value but the
+external name is still an alias for the original.
-=item *
+=back
-Some bugs may have been inadvertently removed.
+As always, if any of these are ever officially declared as bugs,
+they'll be fixed and removed.
-=back
https://perl5.git.perl.org / perl5.git / blobdiff