pod/perltrap.pod

   1 =head1 NAME
   2
   3 perltrap - Perl traps for the unwary
   4
   5 =head1 DESCRIPTION
   6
   7 The biggest trap of all is forgetting to use the B<-w> switch;
   8 see L<perlrun>.  Making your entire program runnable under
   9
  10     use strict;
  11
  12 can help make your program more bullet-proof, but sometimes
  13 it's too annoying for quick throw-away programs.
  14
  15 =head2 Awk Traps
  16
  17 Accustomed B<awk> users should take special note of the following:
  18
  19 =over 4
  20
  21 =item *
  22
  23 The English module, loaded via
  24
  25     use English;
  26
  27 allows you to refer to special variables (like $RS) as
  28 though they were in B<awk>; see L<perlvar> for details.
  29
  30 =item *
  31
  32 Semicolons are required after all simple statements in Perl (except
  33 at the end of a block).  Newline is not a statement delimiter.
  34
  35 =item *
  36
  37 Curly brackets are required on C<if>s and C<while>s.
  38
  39 =item *
  40
  41 Variables begin with "$" or "@" in Perl.
  42
  43 =item *
  44
  45 Arrays index from 0.  Likewise string positions in substr() and
  46 index().
  47
  48 =item *
  49
  50 You have to decide whether your array has numeric or string indices.
  51
  52 =item *
  53
  54 Associative array values do not spring into existence upon mere
  55 reference.
  56
  57 =item *
  58
  59 You have to decide whether you want to use string or numeric
  60 comparisons.
  61
  62 =item *
  63
  64 Reading an input line does not split it for you.  You get to split it
  65 yourself to an array.  And split() operator has different
  66 arguments.
  67
  68 =item *
  69
  70 The current input line is normally in $_, not $0.  It generally does
  71 not have the newline stripped.  ($0 is the name of the program
  72 executed.)  See L<perlvar>.
  73
  74 =item *
  75
  76 $<I<digit>> does not refer to fields--it refers to substrings matched by
  77 the last match pattern.
  78
  79 =item *
  80
  81 The print() statement does not add field and record separators unless
  82 you set C<$,> and C<$.>.  You can set $OFS and $ORS if you're using
  83 the English module.
  84
  85 =item *
  86
  87 You must open your files before you print to them.
  88
  89 =item *
  90
  91 The range operator is "..", not comma.  The comma operator works as in
  92 C.
  93
  94 =item *
  95
  96 The match operator is "=~", not "~".  ("~" is the one's complement
  97 operator, as in C.)
  98
  99 =item *
 100
 101 The exponentiation operator is "**", not "^".  "^" is the XOR
 102 operator, as in C.  (You know, one could get the feeling that B<awk> is
 103 basically incompatible with C.)
 104
 105 =item *
 106
 107 The concatenation operator is ".", not the null string.  (Using the
 108 null string would render C</pat/ /pat/> unparsable, since the third slash
 109 would be interpreted as a division operator--the tokener is in fact
 110 slightly context sensitive for operators like "/", "?", and ">".
 111 And in fact, "." itself can be the beginning of a number.)
 112
 113 =item *
 114
 115 The C<next>, C<exit>, and C<continue> keywords work differently.
 116
 117 =item *
 118
 119
 120 The following variables work differently:
 121
 122       Awk       Perl
 123       ARGC      $#ARGV or scalar @ARGV
 124       ARGV[0]   $0
 125       FILENAME  $ARGV
 126       FNR       $. - something
 127       FS        (whatever you like)
 128       NF        $#Fld, or some such
 129       NR        $.
 130       OFMT      $#
 131       OFS       $,
 132       ORS       $\
 133       RLENGTH   length($&)
 134       RS        $/
 135       RSTART    length($`)
 136       SUBSEP    $;
 137
 138 =item *
 139
 140 You cannot set $RS to a pattern, only a string.
 141
 142 =item *
 143
 144 When in doubt, run the B<awk> construct through B<a2p> and see what it
 145 gives you.
 146
 147 =back
 148
 149 =head2 C Traps
 150
 151 Cerebral C programmers should take note of the following:
 152
 153 =over 4
 154
 155 =item *
 156
 157 Curly brackets are required on C<if>'s and C<while>'s.
 158
 159 =item *
 160
 161 You must use C<elsif> rather than C<else if>.
 162
 163 =item *
 164
 165 The C<break> and C<continue> keywords from C become in
 166 Perl C<last> and C<next>, respectively.
 167 Unlike in C, these do I<NOT> work within a C<do { } while> construct.
 168
 169 =item *
 170
 171 There's no switch statement.  (But it's easy to build one on the fly.)
 172
 173 =item *
 174
 175 Variables begin with "$" or "@" in Perl.
 176
 177 =item *
 178
 179 printf() does not implement the "*" format for interpolating
 180 field widths, but it's trivial to use interpolation of double-quoted
 181 strings to achieve the same effect.
 182
 183 =item *
 184
 185 Comments begin with "#", not "/*".
 186
 187 =item *
 188
 189 You can't take the address of anything, although a similar operator
 190 in Perl 5 is the backslash, which creates a reference.
 191
 192 =item *
 193
 194 C<ARGV> must be capitalized.  C<$ARGV[0]> is C's C<argv[1]>, and C<argv[0]>
 195 ends up in C<$0>.
 196
 197 =item *
 198
 199 System calls such as link(), unlink(), rename(), etc. return nonzero for
 200 success, not 0.
 201
 202 =item *
 203
 204 Signal handlers deal with signal names, not numbers.  Use C<kill -l>
 205 to find their names on your system.
 206
 207 =back
 208
 209 =head2 Sed Traps
 210
 211 Seasoned B<sed> programmers should take note of the following:
 212
 213 =over 4
 214
 215 =item *
 216
 217 Backreferences in substitutions use "$" rather than "\".
 218
 219 =item *
 220
 221 The pattern matching metacharacters "(", ")", and "|" do not have backslashes
 222 in front.
 223
 224 =item *
 225
 226 The range operator is C<...>, rather than comma.
 227
 228 =back
 229
 230 =head2 Shell Traps
 231
 232 Sharp shell programmers should take note of the following:
 233
 234 =over 4
 235
 236 =item *
 237
 238 The backtick operator does variable interpretation without regard to
 239 the presence of single quotes in the command.
 240
 241 =item *
 242
 243 The backtick operator does no translation of the return value, unlike B<csh>.
 244
 245 =item *
 246
 247 Shells (especially B<csh>) do several levels of substitution on each
 248 command line.  Perl does substitution only in certain constructs
 249 such as double quotes, backticks, angle brackets, and search patterns.
 250
 251 =item *
 252
 253 Shells interpret scripts a little bit at a time.  Perl compiles the
 254 entire program before executing it (except for C<BEGIN> blocks, which
 255 execute at compile time).
 256
 257 =item *
 258
 259 The arguments are available via @ARGV, not $1, $2, etc.
 260
 261 =item *
 262
 263 The environment is not automatically made available as separate scalar
 264 variables.
 265
 266 =back
 267
 268 =head2 Perl Traps
 269
 270 Practicing Perl Programmers should take note of the following:
 271
 272 =over 4
 273
 274 =item *
 275
 276 Remember that many operations behave differently in a list
 277 context than they do in a scalar one.  See L<perldata> for details.
 278
 279 =item *
 280
 281 Avoid barewords if you can, especially all lower-case ones.
 282 You can't tell just by looking at it whether a bareword is
 283 a function or a string.  By using quotes on strings and
 284 parens on function calls, you won't ever get them confused.
 285
 286 =item *
 287
 288 You cannot discern from mere inspection which built-ins
 289 are unary operators (like chop() and chdir())
 290 and which are list operators (like print() and unlink()).
 291 (User-defined subroutines can B<only> be list operators, never
 292 unary ones.)  See L<perlop>.
 293
 294 =item *
 295
 296 People have a hard time remembering that some functions
 297 default to $_, or @ARGV, or whatever, but that others which
 298 you might expect to do not.
 299
 300 =item *
 301
 302 The <FH> construct is not the name of the filehandle, it is a readline
 303 operation on that handle.  The data read is only assigned to $_ if the
 304 file read is the sole condition in a while loop:
 305
 306     while (<FH>)      { }
 307     while ($_ = <FH>) { }..
 308     <FH>;  # data discarded!
 309
 310 =item *
 311
 312 Remember not to use "C<=>" when you need "C<=~>";
 313 these two constructs are quite different:
 314
 315     $x =  /foo/;
 316     $x =~ /foo/;
 317
 318 =item *
 319
 320 The C<do {}> construct isn't a real loop that you can use
 321 loop control on.
 322
 323 =item *
 324
 325 Use my() for local variables whenever you can get away with
 326 it (but see L<perlform> for where you can't).
 327 Using local() actually gives a local value to a global
 328 variable, which leaves you open to unforeseen side-effects
 329 of dynamic scoping.
 330
 331 =back
 332
 333 =head2 Perl4 Traps
 334
 335 Penitent Perl 4 Programmers should take note of the following
 336 incompatible changes that occurred between release 4 and release 5:
 337
 338 =over 4
 339
 340 =item *
 341
 342 C<@> now always interpolates an array in double-quotish strings.  Some programs
 343 may now need to use backslash to protect any C<@> that shouldn't interpolate.
 344
 345 =item *
 346
 347 Barewords that used to look like strings to Perl will now look like subroutine
 348 calls if a subroutine by that name is defined before the compiler sees them.
 349 For example:
 350
 351     sub SeeYa { die "Hasta la vista, baby!" }
 352     $SIG{'QUIT'} = SeeYa;
 353
 354 In Perl 4, that set the signal handler; in Perl 5, it actually calls the
 355 function!  You may use the B<-w> switch to find such places.
 356
 357 =item *
 358
 359 Symbols starting with C<_> are no longer forced into package C<main>, except
 360 for $_ itself (and @_, etc.).
 361
 362 =item *
 363
 364 C<s'$lhs'$rhs'> now does no interpolation on either side.  It used to
 365 interpolate C<$lhs> but not C<$rhs>.
 366
 367 =item *
 368
 369 The second and third arguments of splice() are now evaluated in scalar
 370 context (as the book says) rather than list context.
 371
 372 =item *
 373
 374 These are now semantic errors because of precedence:
 375
 376     shift @list + 20;
 377     $n = keys %map + 20;
 378
 379 Because if that were to work, then this couldn't:
 380
 381     sleep $dormancy + 20;
 382
 383 =item *
 384
 385 The precedence of assignment operators is now the same as the precedence
 386 of assignment.  Perl 4 mistakenly gave them the precedence of the associated
 387 operator.  So you now must parenthesize them in expressions like
 388
 389     /foo/ ? ($a += 2) : ($a -= 2);
 390
 391 Otherwise
 392
 393     /foo/ ? $a += 2 : $a -= 2;
 394
 395 would be erroneously parsed as
 396
 397     (/foo/ ? $a += 2 : $a) -= 2;
 398
 399 On the other hand,
 400
 401     $a += /foo/ ? 1 : 2;
 402
 403 now works as a C programmer would expect.
 404
 405 =item *
 406
 407 C<open FOO || die> is now incorrect.  You need parens around the filehandle.
 408 While temporarily supported, using such a construct will
 409 generate a non-fatal (but non-suppressible) warning.
 410
 411 =item *
 412
 413 The elements of argument lists for formats are now evaluated in list
 414 context.  This means you can interpolate list values now.
 415
 416 =item *
 417
 418 You can't do a C<goto> into a block that is optimized away.  Darn.
 419
 420 =item *
 421
 422 It is no longer syntactically legal to use whitespace as the name
 423 of a variable, or as a delimiter for any kind of quote construct.
 424 Double darn.
 425
 426 =item *
 427
 428 The caller() function now returns a false value in a scalar context if there
 429 is no caller.  This lets library files determine if they're being required.
 430
 431 =item *
 432
 433 C<m//g> now attaches its state to the searched string rather than the
 434 regular expression.
 435
 436 =item *
 437
 438 C<reverse> is no longer allowed as the name of a sort subroutine.
 439
 440 =item *
 441
 442 B<taintperl> is no longer a separate executable.  There is now a B<-T>
 443 switch to turn on tainting when it isn't turned on automatically.
 444
 445 =item *
 446
 447 Double-quoted strings may no longer end with an unescaped C<$> or C<@>.
 448
 449 =item *
 450
 451 The archaic C<while/if> BLOCK BLOCK syntax is no longer supported.
 452
 453
 454 =item *
 455
 456 Negative array subscripts now count from the end of the array.
 457
 458 =item *
 459
 460 The comma operator in a scalar context is now guaranteed to give a
 461 scalar context to its arguments.
 462
 463 =item *
 464
 465 The C<**> operator now binds more tightly than unary minus.
 466 It was documented to work this way before, but didn't.
 467
 468 =item *
 469
 470 Setting C<$#array> lower now discards array elements.
 471
 472 =item *
 473
 474 delete() is not guaranteed to return the old value for tie()d arrays,
 475 since this capability may be onerous for some modules to implement.
 476
 477 =item *
 478
 479 The construct "this is $$x" used to interpolate the pid at that
 480 point, but now tries to dereference $x.  C<$$> by itself still
 481 works fine, however.
 482
 483 =item *
 484
 485 Some error messages will be different.
 486
 487 =item *
 488
 489 Some bugs may have been inadvertently removed.
 490
 491 =back