This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Documenting the perl-thanks address
[perl5.git] / pod / perltrap.pod
CommitLineData
a0d0e21e
LW
1=head1 NAME
2
3perltrap - Perl traps for the unwary
4
5=head1 DESCRIPTION
6
cb1a09d0
AD
7The biggest trap of all is forgetting to use the B<-w> switch; see
8L<perlrun>. The second biggest trap is not making your entire program
daff0e37
CS
9runnable under C<use strict>. The third biggest trap is not reading
10the list of changes in this version of Perl; see L<perldelta>.
a0d0e21e
LW
11
12=head2 Awk Traps
13
14Accustomed B<awk> users should take special note of the following:
15
16=over 4
17
18=item *
19
20The English module, loaded via
21
22 use English;
23
54310121
PP
24allows you to refer to special variables (like C<$/>) with names (like
25C<$RS>), as though they were in B<awk>; see L<perlvar> for details.
a0d0e21e
LW
26
27=item *
28
29Semicolons are required after all simple statements in Perl (except
30at the end of a block). Newline is not a statement delimiter.
31
32=item *
33
34Curly brackets are required on C<if>s and C<while>s.
35
36=item *
37
38Variables begin with "$" or "@" in Perl.
39
40=item *
41
42Arrays index from 0. Likewise string positions in substr() and
43index().
44
45=item *
46
47You have to decide whether your array has numeric or string indices.
48
49=item *
50
aa689395 51Hash values do not spring into existence upon mere reference.
a0d0e21e
LW
52
53=item *
54
55You have to decide whether you want to use string or numeric
56comparisons.
57
58=item *
59
60Reading an input line does not split it for you. You get to split it
54310121
PP
61to an array yourself. And the split() operator has different
62arguments than B<awk>'s.
a0d0e21e
LW
63
64=item *
65
66The current input line is normally in $_, not $0. It generally does
67not have the newline stripped. ($0 is the name of the program
68executed.) See L<perlvar>.
69
70=item *
71
8b0a4b75
PP
72$E<lt>I<digit>E<gt> does not refer to fields--it refers to substrings matched
73by the last match pattern.
a0d0e21e
LW
74
75=item *
76
77The print() statement does not add field and record separators unless
8b0a4b75 78you set C<$,> and C<$\>. You can set $OFS and $ORS if you're using
a0d0e21e
LW
79the English module.
80
81=item *
82
83You must open your files before you print to them.
84
85=item *
86
87The range operator is "..", not comma. The comma operator works as in
88C.
89
90=item *
91
92The match operator is "=~", not "~". ("~" is the one's complement
93operator, as in C.)
94
95=item *
96
97The exponentiation operator is "**", not "^". "^" is the XOR
98operator, as in C. (You know, one could get the feeling that B<awk> is
99basically incompatible with C.)
100
101=item *
102
103The concatenation operator is ".", not the null string. (Using the
5f05dabc
PP
104null string would render C</pat/ /pat/> unparsable, because the third slash
105would be interpreted as a division operator--the tokenizer is in fact
8b0a4b75 106slightly context sensitive for operators like "/", "?", and "E<gt>".
a0d0e21e
LW
107And in fact, "." itself can be the beginning of a number.)
108
109=item *
110
111The C<next>, C<exit>, and C<continue> keywords work differently.
112
113=item *
114
115
116The following variables work differently:
117
118 Awk Perl
119 ARGC $#ARGV or scalar @ARGV
120 ARGV[0] $0
121 FILENAME $ARGV
122 FNR $. - something
123 FS (whatever you like)
124 NF $#Fld, or some such
125 NR $.
126 OFMT $#
127 OFS $,
128 ORS $\
129 RLENGTH length($&)
130 RS $/
131 RSTART length($`)
132 SUBSEP $;
133
134=item *
135
136You cannot set $RS to a pattern, only a string.
137
138=item *
139
140When in doubt, run the B<awk> construct through B<a2p> and see what it
141gives you.
142
143=back
144
145=head2 C Traps
146
147Cerebral C programmers should take note of the following:
148
149=over 4
150
151=item *
152
153Curly brackets are required on C<if>'s and C<while>'s.
154
155=item *
156
157You must use C<elsif> rather than C<else if>.
158
159=item *
160
54310121 161The C<break> and C<continue> keywords from C become in
a0d0e21e
LW
162Perl C<last> and C<next>, respectively.
163Unlike in C, these do I<NOT> work within a C<do { } while> construct.
164
165=item *
166
167There's no switch statement. (But it's easy to build one on the fly.)
168
169=item *
170
171Variables begin with "$" or "@" in Perl.
172
173=item *
174
6dbacca0 175C<printf()> does not implement the "*" format for interpolating
a0d0e21e
LW
176field widths, but it's trivial to use interpolation of double-quoted
177strings to achieve the same effect.
178
179=item *
180
181Comments begin with "#", not "/*".
182
183=item *
184
185You can't take the address of anything, although a similar operator
5f05dabc 186in Perl is the backslash, which creates a reference.
a0d0e21e
LW
187
188=item *
189
4633a7c4
LW
190C<ARGV> must be capitalized. C<$ARGV[0]> is C's C<argv[1]>, and C<argv[0]>
191ends up in C<$0>.
a0d0e21e
LW
192
193=item *
194
195System calls such as link(), unlink(), rename(), etc. return nonzero for
196success, not 0.
197
198=item *
199
200Signal handlers deal with signal names, not numbers. Use C<kill -l>
201to find their names on your system.
202
203=back
204
205=head2 Sed Traps
206
207Seasoned B<sed> programmers should take note of the following:
208
209=over 4
210
211=item *
212
213Backreferences in substitutions use "$" rather than "\".
214
215=item *
216
217The pattern matching metacharacters "(", ")", and "|" do not have backslashes
218in front.
219
220=item *
221
222The range operator is C<...>, rather than comma.
223
224=back
225
226=head2 Shell Traps
227
228Sharp shell programmers should take note of the following:
229
230=over 4
231
232=item *
233
54310121 234The backtick operator does variable interpolation without regard to
a0d0e21e
LW
235the presence of single quotes in the command.
236
237=item *
238
54310121 239The backtick operator does no translation of the return value, unlike B<csh>.
a0d0e21e
LW
240
241=item *
242
243Shells (especially B<csh>) do several levels of substitution on each
5f05dabc 244command line. Perl does substitution in only certain constructs
54310121 245such as double quotes, backticks, angle brackets, and search patterns.
a0d0e21e
LW
246
247=item *
248
249Shells interpret scripts a little bit at a time. Perl compiles the
250entire program before executing it (except for C<BEGIN> blocks, which
251execute at compile time).
252
253=item *
254
255The arguments are available via @ARGV, not $1, $2, etc.
256
257=item *
258
259The environment is not automatically made available as separate scalar
260variables.
261
262=back
263
264=head2 Perl Traps
265
266Practicing Perl Programmers should take note of the following:
267
268=over 4
269
270=item *
271
272Remember that many operations behave differently in a list
273context than they do in a scalar one. See L<perldata> for details.
274
275=item *
276
68dc0745 277Avoid barewords if you can, especially all lowercase ones.
54310121
PP
278You can't tell by just looking at it whether a bareword is
279a function or a string. By using quotes on strings and
5f05dabc 280parentheses on function calls, you won't ever get them confused.
a0d0e21e
LW
281
282=item *
283
54310121
PP
284You cannot discern from mere inspection which builtins
285are unary operators (like chop() and chdir())
a0d0e21e 286and which are list operators (like print() and unlink()).
5f05dabc 287(User-defined subroutines can be B<only> list operators, never
a0d0e21e
LW
288unary ones.) See L<perlop>.
289
290=item *
291
748a9306 292People have a hard time remembering that some functions
a0d0e21e 293default to $_, or @ARGV, or whatever, but that others which
54310121 294you might expect to do not.
a0d0e21e 295
6dbacca0 296=item *
a0d0e21e 297
8b0a4b75 298The E<lt>FHE<gt> construct is not the name of the filehandle, it is a readline
5f05dabc 299operation on that handle. The data read is assigned to $_ only if the
748a9306
LW
300file read is the sole condition in a while loop:
301
302 while (<FH>) { }
54310121 303 while (defined($_ = <FH>)) { }..
748a9306
LW
304 <FH>; # data discarded!
305
6dbacca0 306=item *
748a9306 307
a0d0e21e
LW
308Remember not to use "C<=>" when you need "C<=~>";
309these two constructs are quite different:
310
311 $x = /foo/;
312 $x =~ /foo/;
313
314=item *
315
54310121 316The C<do {}> construct isn't a real loop that you can use
a0d0e21e
LW
317loop control on.
318
319=item *
320
54310121
PP
321Use C<my()> for local variables whenever you can get away with
322it (but see L<perlform> for where you can't).
323Using C<local()> actually gives a local value to a global
a0d0e21e
LW
324variable, which leaves you open to unforeseen side-effects
325of dynamic scoping.
326
c07a80fd
PP
327=item *
328
329If you localize an exported variable in a module, its exported value will
330not change. The local name becomes an alias to a new value but the
331external name is still an alias for the original.
332
a0d0e21e
LW
333=back
334
5f05dabc 335=head2 Perl4 to Perl5 Traps
a0d0e21e 336
54310121 337Practicing Perl4 Programmers should take note of the following
6dbacca0
PP
338Perl4-to-Perl5 specific traps.
339
340They're crudely ordered according to the following list:
a0d0e21e
LW
341
342=over 4
343
6dbacca0 344=item Discontinuance, Deprecation, and BugFix traps
a0d0e21e 345
6dbacca0
PP
346Anything that's been fixed as a perl4 bug, removed as a perl4 feature
347or deprecated as a perl4 feature with the intent to encourage usage of
348some other perl5 feature.
a0d0e21e 349
6dbacca0 350=item Parsing Traps
748a9306 351
6dbacca0 352Traps that appear to stem from the new parser.
a0d0e21e 353
6dbacca0 354=item Numerical Traps
a0d0e21e 355
6dbacca0 356Traps having to do with numerical or mathematical operators.
a0d0e21e 357
6dbacca0 358=item General data type traps
a0d0e21e 359
6dbacca0 360Traps involving perl standard data types.
a0d0e21e 361
6dbacca0
PP
362=item Context Traps - scalar, list contexts
363
364Traps related to context within lists, scalar statements/declarations.
365
366=item Precedence Traps
367
368Traps related to the precedence of parsing, evaluation, and execution of
369code.
370
371=item General Regular Expression Traps using s///, etc.
372
373Traps related to the use of pattern matching.
374
375=item Subroutine, Signal, Sorting Traps
376
377Traps related to the use of signals and signal handlers, general subroutines,
378and sorting, along with sorting subroutines.
379
380=item OS Traps
381
382OS-specific traps.
383
384=item DBM Traps
385
386Traps specific to the use of C<dbmopen()>, and specific dbm implementations.
387
388=item Unclassified Traps
389
390Everything else.
391
392=back
393
394If you find an example of a conversion trap that is not listed here,
9607fc9c
PP
395please submit it to Bill Middleton <F<wjm@best.com>> for inclusion.
396Also note that at least some of these can be caught with B<-w>.
6dbacca0
PP
397
398=head2 Discontinuance, Deprecation, and BugFix traps
399
400Anything that has been discontinued, deprecated, or fixed as
54310121 401a bug from perl4.
a0d0e21e 402
6dbacca0
PP
403=over 4
404
54310121 405=item * Discontinuance
6dbacca0
PP
406
407Symbols starting with "_" are no longer forced into package main, except
408for C<$_> itself (and C<@_>, etc.).
409
410 package test;
411 $_legacy = 1;
cb1a09d0 412
6dbacca0
PP
413 package main;
414 print "\$_legacy is ",$_legacy,"\n";
54310121 415
6dbacca0
PP
416 # perl4 prints: $_legacy is 1
417 # perl5 prints: $_legacy is
418
54310121 419=item * Deprecation
6dbacca0
PP
420
421Double-colon is now a valid package separator in a variable name. Thus these
5f05dabc 422behave differently in perl4 vs. perl5, because the packages don't exist.
6dbacca0
PP
423
424 $a=1;$b=2;$c=3;$var=4;
425 print "$a::$b::$c ";
cb1a09d0 426 print "$var::abc::xyz\n";
6dbacca0
PP
427
428 # perl4 prints: 1::2::3 4::abc::xyz
429 # perl5 prints: 3
cb1a09d0 430
6dbacca0
PP
431Given that C<::> is now the preferred package delimiter, it is debatable
432whether this should be classed as a bug or not.
433(The older package delimiter, ' ,is used here)
cb1a09d0 434
6dbacca0
PP
435 $x = 10 ;
436 print "x=${'x}\n" ;
54310121 437
6dbacca0
PP
438 # perl4 prints: x=10
439 # perl5 prints: Can't find string terminator "'" anywhere before EOF
a0d0e21e 440
5e77893f
G
441You can avoid this problem, and remain compatible with perl4, if you
442always explicitly include the package name:
443
444 $x = 10 ;
445 print "x=${main'x}\n" ;
446
54310121 447Also see precedence traps, for parsing C<$:>.
a0d0e21e 448
6dbacca0 449=item * BugFix
a0d0e21e 450
6dbacca0
PP
451The second and third arguments of C<splice()> are now evaluated in scalar
452context (as the Camel says) rather than list context.
a0d0e21e 453
6dbacca0
PP
454 sub sub1{return(0,2) } # return a 2-elem array
455 sub sub2{ return(1,2,3)} # return a 3-elem array
54310121 456 @a1 = ("a","b","c","d","e");
6dbacca0
PP
457 @a2 = splice(@a1,&sub1,&sub2);
458 print join(' ',@a2),"\n";
54310121 459
6dbacca0 460 # perl4 prints: a b
54310121 461 # perl5 prints: c d e
a0d0e21e 462
54310121 463=item * Discontinuance
a0d0e21e 464
6dbacca0 465You can't do a C<goto> into a block that is optimized away. Darn.
a0d0e21e 466
6dbacca0 467 goto marker1;
a0d0e21e 468
54310121 469 for(1){
6dbacca0
PP
470 marker1:
471 print "Here I is!\n";
54310121
PP
472 }
473
6dbacca0
PP
474 # perl4 prints: Here I is!
475 # perl5 dumps core (SEGV)
476
54310121 477=item * Discontinuance
6dbacca0
PP
478
479It is no longer syntactically legal to use whitespace as the name
480of a variable, or as a delimiter for any kind of quote construct.
54310121 481Double darn.
6dbacca0
PP
482
483 $a = ("foo bar");
484 $b = q baz ;
485 print "a is $a, b is $b\n";
54310121 486
6dbacca0 487 # perl4 prints: a is foo bar, b is baz
54310121 488 # perl5 errors: Bareword found where operator expected
5e378fdf 489
6dbacca0
PP
490=item * Discontinuance
491
492The archaic while/if BLOCK BLOCK syntax is no longer supported.
493
494 if { 1 } {
495 print "True!";
496 }
497 else {
498 print "False!";
499 }
54310121 500
6dbacca0
PP
501 # perl4 prints: True!
502 # perl5 errors: syntax error at test.pl line 1, near "if {"
503
504=item * BugFix
505
506The C<**> operator now binds more tightly than unary minus.
507It was documented to work this way before, but didn't.
508
509 print -4**2,"\n";
54310121 510
6dbacca0
PP
511 # perl4 prints: 16
512 # perl5 prints: -16
513
54310121 514=item * Discontinuance
6dbacca0
PP
515
516The meaning of C<foreach{}> has changed slightly when it is iterating over a
517list which is not an array. This used to assign the list to a
518temporary array, but no longer does so (for efficiency). This means
519that you'll now be iterating over the actual values, not over copies of
520the values. Modifications to the loop variable can change the original
521values.
522
523 @list = ('ab','abc','bcd','def');
524 foreach $var (grep(/ab/,@list)){
525 $var = 1;
526 }
527 print (join(':',@list));
54310121 528
6dbacca0
PP
529 # perl4 prints: ab:abc:bcd:def
530 # perl5 prints: 1:1:bcd:def
531
532To retain Perl4 semantics you need to assign your list
54310121 533explicitly to a temporary array and then iterate over that. For
6dbacca0
PP
534example, you might need to change
535
536 foreach $var (grep(/ab/,@list)){
537
538to
539
540 foreach $var (@tmp = grep(/ab/,@list)){
541
542Otherwise changing $var will clobber the values of @list. (This most often
543happens when you use C<$_> for the loop variable, and call subroutines in
544the loop that don't properly localize C<$_>.)
545
5e378fdf
PP
546=item * Discontinuance
547
548C<split> with no arguments now behaves like C<split ' '> (which doesn't
549return an initial null field if $_ starts with whitespace), it used to
550behave like C<split /\s+/> (which does).
551
552 $_ = ' hi mom';
553 print join(':', split);
554
555 # perl4 prints: :hi:mom
556 # perl5 prints: hi:mom
557
55497cff
PP
558=item * BugFix
559
9607fc9c 560Perl 4 would ignore any text which was attached to an B<-e> switch,
55497cff 561always taking the code snippet from the following arg. Additionally, it
9607fc9c 562would silently accept an B<-e> switch without a following arg. Both of
55497cff
PP
563these behaviors have been fixed.
564
565 perl -e'print "attached to -e"' 'print "separate arg"'
54310121 566
55497cff
PP
567 # perl4 prints: separate arg
568 # perl5 prints: attached to -e
54310121 569
55497cff
PP
570 perl -e
571
572 # perl4 prints:
573 # perl5 dies: No code specified for -e.
574
575=item * Discontinuance
576
577In Perl 4 the return value of C<push> was undocumented, but it was
578actually the last value being pushed onto the target list. In Perl 5
579the return value of C<push> is documented, but has changed, it is the
580number of elements in the resulting list.
581
582 @x = ('existing');
583 print push(@x, 'first new', 'second new');
54310121 584
55497cff
PP
585 # perl4 prints: second new
586 # perl5 prints: 3
587
68dc0745
PP
588=item * Discontinuance
589
590In Perl 4 (and versions of Perl 5 before 5.004), C<'\r'> characters in
591Perl code were silently allowed, although they could cause (mysterious!)
592failures in certain constructs, particularly here documents. Now,
593C<'\r'> characters cause an immediate fatal error. (Note: In this
594example, the notation B<\015> represents the incorrect line
595ending. Depending upon your text viewer, it will look different.)
596
597 print "foo";\015
598 print "bar";
599
600 # perl4 prints: foobar
601 # perl5.003 prints: foobar
602 # perl5.004 dies: Illegal character \015 (carriage return)
603
604See L<perldiag> for full details.
605
6dbacca0
PP
606=item * Deprecation
607
608Some error messages will be different.
609
54310121 610=item * Discontinuance
6dbacca0
PP
611
612Some bugs may have been inadvertently removed. :-)
613
614=back
615
616=head2 Parsing Traps
617
618Perl4-to-Perl5 traps from having to do with parsing.
619
620=over 4
621
622=item * Parsing
623
624Note the space between . and =
625
626 $string . = "more string";
627 print $string;
54310121 628
6dbacca0
PP
629 # perl4 prints: more string
630 # perl5 prints: syntax error at - line 1, near ". ="
631
632=item * Parsing
633
634Better parsing in perl 5
635
636 sub foo {}
637 &foo
638 print("hello, world\n");
54310121 639
6dbacca0
PP
640 # perl4 prints: hello, world
641 # perl5 prints: syntax error
642
643=item * Parsing
644
645"if it looks like a function, it is a function" rule.
646
647 print
648 ($foo == 1) ? "is one\n" : "is zero\n";
54310121 649
6dbacca0
PP
650 # perl4 prints: is zero
651 # perl5 warns: "Useless use of a constant in void context" if using -w
652
653=back
654
655=head2 Numerical Traps
656
657Perl4-to-Perl5 traps having to do with numerical operators,
658operands, or output from same.
659
660=over 5
661
662=item * Numerical
663
664Formatted output and significant digits
665
666 print 7.373504 - 0, "\n";
54310121
PP
667 printf "%20.18f\n", 7.373504 - 0;
668
6dbacca0
PP
669 # Perl4 prints:
670 7.375039999999996141
671 7.37503999999999614
54310121 672
6dbacca0
PP
673 # Perl5 prints:
674 7.373504
675 7.37503999999999614
676
677=item * Numerical
678
5f05dabc 679This specific item has been deleted. It demonstrated how the auto-increment
5e378fdf 680operator would not catch when a number went over the signed int limit. Fixed
a6006777
PP
681in version 5.003_04. But always be wary when using large integers.
682If in doubt:
6dbacca0 683
5e378fdf 684 use Math::BigInt;
6dbacca0 685
54310121 686=item * Numerical
6dbacca0
PP
687
688Assignment of return values from numeric equality tests
689does not work in perl5 when the test evaluates to false (0).
690Logical tests now return an null, instead of 0
a6006777 691
6dbacca0
PP
692 $p = ($test == 1);
693 print $p,"\n";
a6006777 694
6dbacca0
PP
695 # perl4 prints: 0
696 # perl5 prints:
697
dc848c6f
PP
698Also see L<"General Regular Expression Traps using s///, etc.">
699for another example of this new feature...
6dbacca0
PP
700
701=back
702
703=head2 General data type traps
704
705Perl4-to-Perl5 traps involving most data-types, and their usage
706within certain expressions and/or context.
707
708=over 5
709
710=item * (Arrays)
711
712Negative array subscripts now count from the end of the array.
713
714 @a = (1, 2, 3, 4, 5);
715 print "The third element of the array is $a[3] also expressed as $a[-2] \n";
54310121 716
6dbacca0
PP
717 # perl4 prints: The third element of the array is 4 also expressed as
718 # perl5 prints: The third element of the array is 4 also expressed as 4
719
720=item * (Arrays)
721
722Setting C<$#array> lower now discards array elements, and makes them
723impossible to recover.
724
54310121 725 @a = (a,b,c,d,e);
6dbacca0 726 print "Before: ",join('',@a);
54310121 727 $#a =1;
6dbacca0
PP
728 print ", After: ",join('',@a);
729 $#a =3;
730 print ", Recovered: ",join('',@a),"\n";
54310121 731
6dbacca0
PP
732 # perl4 prints: Before: abcde, After: ab, Recovered: abcd
733 # perl5 prints: Before: abcde, After: ab, Recovered: ab
734
735=item * (Hashes)
736
737Hashes get defined before use
738
54310121 739 local($s,@a,%h);
6dbacca0
PP
740 die "scalar \$s defined" if defined($s);
741 die "array \@a defined" if defined(@a);
742 die "hash \%h defined" if defined(%h);
54310121 743
6dbacca0
PP
744 # perl4 prints:
745 # perl5 dies: hash %h defined
746
747=item * (Globs)
748
749glob assignment from variable to variable will fail if the assigned
750variable is localized subsequent to the assignment
751
752 @a = ("This is Perl 4");
753 *b = *a;
754 local(@a);
755 print @b,"\n";
54310121 756
6dbacca0
PP
757 # perl4 prints: This is Perl 4
758 # perl5 prints:
54310121 759
6dbacca0 760 # Another example
54310121 761
6dbacca0
PP
762 *fred = *barney; # fred is aliased to barney
763 @barney = (1, 2, 4);
764 # @fred;
765 print "@fred"; # should print "1, 2, 4"
54310121 766
6dbacca0 767 # perl4 prints: 1 2 4
9607fc9c 768 # perl5 prints: In string, @fred now must be written as \@fred
5e378fdf 769
6dbacca0
PP
770=item * (Scalar String)
771
772Changes in unary negation (of strings)
773This change effects both the return value and what it
774does to auto(magic)increment.
775
776 $x = "aaa";
777 print ++$x," : ";
778 print -$x," : ";
779 print ++$x,"\n";
54310121 780
6dbacca0
PP
781 # perl4 prints: aab : -0 : 1
782 # perl5 prints: aab : -aab : aac
783
784=item * (Constants)
785
786perl 4 lets you modify constants:
787
788 $foo = "x";
789 &mod($foo);
790 for ($x = 0; $x < 3; $x++) {
791 &mod("a");
792 }
793 sub mod {
794 print "before: $_[0]";
795 $_[0] = "m";
796 print " after: $_[0]\n";
797 }
54310121 798
6dbacca0
PP
799 # perl4:
800 # before: x after: m
801 # before: a after: m
802 # before: m after: m
803 # before: m after: m
54310121 804
6dbacca0
PP
805 # Perl5:
806 # before: x after: m
807 # Modification of a read-only value attempted at foo.pl line 12.
808 # before: a
809
810=item * (Scalars)
811
812The behavior is slightly different for:
813
814 print "$x", defined $x
54310121 815
6dbacca0
PP
816 # perl 4: 1
817 # perl 5: <no output, $x is not called into existence>
818
819=item * (Variable Suicide)
820
821Variable suicide behavior is more consistent under Perl 5.
aa689395 822Perl5 exhibits the same behavior for hashes and scalars,
5f05dabc 823that perl4 exhibits for only scalars.
6dbacca0
PP
824
825 $aGlobal{ "aKey" } = "global value";
826 print "MAIN:", $aGlobal{"aKey"}, "\n";
827 $GlobalLevel = 0;
828 &test( *aGlobal );
829
830 sub test {
831 local( *theArgument ) = @_;
832 local( %aNewLocal ); # perl 4 != 5.001l,m
54310121 833 $aNewLocal{"aKey"} = "this should never appear";
6dbacca0
PP
834 print "SUB: ", $theArgument{"aKey"}, "\n";
835 $aNewLocal{"aKey"} = "level $GlobalLevel"; # what should print
836 $GlobalLevel++;
837 if( $GlobalLevel<4 ) {
838 &test( *aNewLocal );
839 }
840 }
54310121 841
6dbacca0
PP
842 # Perl4:
843 # MAIN:global value
844 # SUB: global value
845 # SUB: level 0
846 # SUB: level 1
847 # SUB: level 2
54310121 848
6dbacca0
PP
849 # Perl5:
850 # MAIN:global value
851 # SUB: global value
852 # SUB: this should never appear
853 # SUB: this should never appear
854 # SUB: this should never appear
855
84dc3c4d 856=back
6dbacca0
PP
857
858=head2 Context Traps - scalar, list contexts
859
860=over 5
861
862=item * (list context)
863
864The elements of argument lists for formats are now evaluated in list
865context. This means you can interpolate list values now.
866
867 @fmt = ("foo","bar","baz");
868 format STDOUT=
869 @<<<<< @||||| @>>>>>
870 @fmt;
871 .
54310121
PP
872 write;
873
6dbacca0
PP
874 # perl4 errors: Please use commas to separate fields in file
875 # perl5 prints: foo bar baz
876
877=item * (scalar context)
878
54310121
PP
879The C<caller()> function now returns a false value in a scalar context
880if there is no caller. This lets library files determine if they're
6dbacca0
PP
881being required.
882
883 caller() ? (print "You rang?\n") : (print "Got a 0\n");
54310121 884
6dbacca0
PP
885 # perl4 errors: There is no caller
886 # perl5 prints: Got a 0
5e378fdf 887
6dbacca0
PP
888=item * (scalar context)
889
890The comma operator in a scalar context is now guaranteed to give a
891scalar context to its arguments.
892
893 @y= ('a','b','c');
894 $x = (1, 2, @y);
895 print "x = $x\n";
54310121 896
6dbacca0
PP
897 # Perl4 prints: x = c # Thinks list context interpolates list
898 # Perl5 prints: x = 3 # Knows scalar uses length of list
899
900=item * (list, builtin)
901
902C<sprintf()> funkiness (array argument converted to scalar array count)
903This test could be added to t/op/sprintf.t
904
905 @z = ('%s%s', 'foo', 'bar');
906 $x = sprintf(@z);
907 if ($x eq 'foobar') {print "ok 2\n";} else {print "not ok 2 '$x'\n";}
54310121 908
6dbacca0
PP
909 # perl4 prints: ok 2
910 # perl5 prints: not ok 2
911
912C<printf()> works fine, though:
913
914 printf STDOUT (@z);
54310121
PP
915 print "\n";
916
6dbacca0
PP
917 # perl4 prints: foobar
918 # perl5 prints: foobar
919
920Probably a bug.
921
922=back
923
924=head2 Precedence Traps
925
926Perl4-to-Perl5 traps involving precedence order.
927
84dc3c4d
PP
928=over 5
929
5e378fdf
PP
930=item * Precedence
931
8dbef698
JM
932LHS vs. RHS of any assignment operator. LHS is evaluated first
933in perl4, second in perl5; this can affect the relationship
934between side-effects in sub-expressions.
5e378fdf
PP
935
936 @arr = ( 'left', 'right' );
937 $a{shift @arr} = shift @arr;
938 print join( ' ', keys %a );
939
940 # perl4 prints: left
941 # perl5 prints: right
942
943=item * Precedence
6dbacca0
PP
944
945These are now semantic errors because of precedence:
946
947 @list = (1,2,3,4,5);
948 %map = ("a",1,"b",2,"c",3,"d",4);
949 $n = shift @list + 2; # first item in list plus 2
950 print "n is $n, ";
951 $m = keys %map + 2; # number of items in hash plus 2
952 print "m is $m\n";
54310121 953
6dbacca0
PP
954 # perl4 prints: n is 3, m is 6
955 # perl5 errors and fails to compile
956
957=item * Precedence
a0d0e21e 958
4633a7c4
LW
959The precedence of assignment operators is now the same as the precedence
960of assignment. Perl 4 mistakenly gave them the precedence of the associated
961operator. So you now must parenthesize them in expressions like
962
963 /foo/ ? ($a += 2) : ($a -= 2);
a6006777 964
4633a7c4
LW
965Otherwise
966
6dbacca0 967 /foo/ ? $a += 2 : $a -= 2
4633a7c4
LW
968
969would be erroneously parsed as
970
971 (/foo/ ? $a += 2 : $a) -= 2;
972
973On the other hand,
974
54310121 975 $a += /foo/ ? 1 : 2;
4633a7c4
LW
976
977now works as a C programmer would expect.
978
6dbacca0 979=item * Precedence
4633a7c4 980
6dbacca0 981 open FOO || die;
a0d0e21e 982
5f05dabc
PP
983is now incorrect. You need parentheses around the filehandle.
984Otherwise, perl5 leaves the statement as its default precedence:
a0d0e21e 985
6dbacca0 986 open(FOO || die);
54310121 987
6dbacca0
PP
988 # perl4 opens or dies
989 # perl5 errors: Precedence problem: open FOO should be open(FOO)
a0d0e21e 990
6dbacca0 991=item * Precedence
a0d0e21e 992
6dbacca0
PP
993perl4 gives the special variable, C<$:> precedence, where perl5
994treats C<$::> as main C<package>
a0d0e21e 995
6dbacca0 996 $a = "x"; print "$::a";
54310121 997
6dbacca0
PP
998 # perl 4 prints: -:a
999 # perl 5 prints: x
5e378fdf 1000
6dbacca0 1001=item * Precedence
a0d0e21e 1002
54310121
PP
1003concatenation precedence over filetest operator?
1004
1005 -e $foo .= "q"
a0d0e21e 1006
6dbacca0
PP
1007 # perl4 prints: no output
1008 # perl5 prints: Can't modify -e in concatenation
a0d0e21e 1009
6dbacca0
PP
1010=back
1011
1012=head2 General Regular Expression Traps using s///, etc.
1013
1014All types of RE traps.
1015
1016=over 5
1017
1018=item * Regular Expression
1019
1020C<s'$lhs'$rhs'> now does no interpolation on either side. It used to
54310121 1021interpolate C<$lhs> but not C<$rhs>. (And still does not match a literal
6dbacca0
PP
1022'$' in string)
1023
1024 $a=1;$b=2;
1025 $string = '1 2 $a $b';
1026 $string =~ s'$a'$b';
1027 print $string,"\n";
54310121 1028
6dbacca0
PP
1029 # perl4 prints: $b 2 $a $b
1030 # perl5 prints: 1 2 $a $b
1031
1032=item * Regular Expression
a0d0e21e
LW
1033
1034C<m//g> now attaches its state to the searched string rather than the
6dbacca0
PP
1035regular expression. (Once the scope of a block is left for the sub, the
1036state of the searched string is lost)
1037
1038 $_ = "ababab";
1039 while(m/ab/g){
1040 &doit("blah");
1041 }
1042 sub doit{local($_) = shift; print "Got $_ "}
54310121 1043
6dbacca0
PP
1044 # perl4 prints: blah blah blah
1045 # perl5 prints: infinite loop blah...
1046
1047=item * Regular Expression
1048
68dc0745
PP
1049Currently, if you use the C<m//o> qualifier on a regular expression
1050within an anonymous sub, I<all> closures generated from that anonymous
1051sub will use the regular expression as it was compiled when it was used
1052the very first time in any such closure. For instance, if you say
1053
1054 sub build_match {
1055 my($left,$right) = @_;
1056 return sub { $_[0] =~ /$left stuff $right/o; };
1057 }
1058
1059build_match() will always return a sub which matches the contents of
1060C<$left> and C<$right> as they were the I<first> time that build_match()
1061was called, not as they are in the current call.
1062
1063This is probably a bug, and may change in future versions of Perl.
1064
1065=item * Regular Expression
1066
6dbacca0
PP
1067If no parentheses are used in a match, Perl4 sets C<$+> to
1068the whole match, just like C<$&>. Perl5 does not.
1069
1070 "abcdef" =~ /b.*e/;
1071 print "\$+ = $+\n";
54310121 1072
6dbacca0
PP
1073 # perl4 prints: bcde
1074 # perl5 prints:
1075
1076=item * Regular Expression
1077
1078substitution now returns the null string if it fails
1079
1080 $string = "test";
1081 $value = ($string =~ s/foo//);
1082 print $value, "\n";
54310121 1083
6dbacca0
PP
1084 # perl4 prints: 0
1085 # perl5 prints:
1086
1087Also see L<Numerical Traps> for another example of this new feature.
1088
1089=item * Regular Expression
1090
54310121
PP
1091C<s`lhs`rhs`> (using backticks) is now a normal substitution, with no
1092backtick expansion
6dbacca0
PP
1093
1094 $string = "";
1095 $string =~ s`^`hostname`;
1096 print $string, "\n";
54310121 1097
6dbacca0
PP
1098 # perl4 prints: <the local hostname>
1099 # perl5 prints: hostname
1100
1101=item * Regular Expression
1102
1103Stricter parsing of variables used in regular expressions
1104
1105 s/^([^$grpc]*$grpc[$opt$plus$rep]?)//o;
54310121 1106
6dbacca0
PP
1107 # perl4: compiles w/o error
1108 # perl5: with Scalar found where operator expected ..., near "$opt$plus"
1109
1110an added component of this example, apparently from the same script, is
1111the actual value of the s'd string after the substitution.
1112C<[$opt]> is a character class in perl4 and an array subscript in perl5
1113
54310121 1114 $grpc = 'a';
6dbacca0
PP
1115 $opt = 'r';
1116 $_ = 'bar';
1117 s/^([^$grpc]*$grpc[$opt]?)/foo/;
1118 print ;
54310121 1119
6dbacca0
PP
1120 # perl4 prints: foo
1121 # perl5 prints: foobar
1122
1123=item * Regular Expression
1124
1125Under perl5, C<m?x?> matches only once, like C<?x?>. Under perl4, it matched
1126repeatedly, like C</x/> or C<m!x!>.
1127
1128 $test = "once";
1129 sub match { $test =~ m?once?; }
1130 &match();
1131 if( &match() ) {
1132 # m?x? matches more then once
1133 print "perl4\n";
54310121 1134 } else {
6dbacca0 1135 # m?x? matches only once
54310121 1136 print "perl5\n";
6dbacca0 1137 }
54310121 1138
6dbacca0
PP
1139 # perl4 prints: perl4
1140 # perl5 prints: perl5
a0d0e21e 1141
a0d0e21e 1142
44a8e56a
PP
1143=item * Regular Expression
1144
1145Under perl4 and upto version 5.003, a failed C<m//g> match used to
1146reset the internal iterator, so that subsequent C<m//g> match attempts
1147began from the beginning of the string. In perl version 5.004 and later,
1148failed C<m//g> matches do not reset the iterator position (which can be
1149found using the C<pos()> function--see L<perlfunc/pos>).
1150
1151 $test = "foop";
1152 for (1..3) {
1153 print $1 while ($test =~ /(o)/g);
1154 # pos $test = 0; # to get old behavior
1155 }
54310121 1156
44a8e56a
PP
1157 # perl4 prints: oooooo
1158 # perl5.004 prints: oo
1159
1160You may always reset the iterator yourself as shown in the commented line
1161to get the old behavior.
1162
6dbacca0
PP
1163=back
1164
1165=head2 Subroutine, Signal, Sorting Traps
a0d0e21e 1166
6dbacca0
PP
1167The general group of Perl4-to-Perl5 traps having to do with
1168Signals, Sorting, and their related subroutines, as well as
1169general subroutine traps. Includes some OS-Specific traps.
a0d0e21e 1170
6dbacca0 1171=over 5
a0d0e21e 1172
6dbacca0 1173=item * (Signals)
a0d0e21e 1174
6dbacca0
PP
1175Barewords that used to look like strings to Perl will now look like subroutine
1176calls if a subroutine by that name is defined before the compiler sees them.
a0d0e21e 1177
6dbacca0
PP
1178 sub SeeYa { warn"Hasta la vista, baby!" }
1179 $SIG{'TERM'} = SeeYa;
1180 print "SIGTERM is now $SIG{'TERM'}\n";
54310121 1181
6dbacca0
PP
1182 # perl4 prints: SIGTERM is main'SeeYa
1183 # perl5 prints: SIGTERM is now main::1
a0d0e21e 1184
6dbacca0 1185Use B<-w> to catch this one
a0d0e21e 1186
6dbacca0 1187=item * (Sort Subroutine)
a0d0e21e 1188
6dbacca0 1189reverse is no longer allowed as the name of a sort subroutine.
a0d0e21e 1190
6dbacca0 1191 sub reverse{ print "yup "; $a <=> $b }
54310121
PP
1192 print sort reverse a,b,c;
1193
6dbacca0 1194 # perl4 prints: yup yup yup yup abc
54310121 1195 # perl5 prints: abc
a0d0e21e 1196
b996531f
PP
1197=item * warn() won't let you specify a filehandle.
1198
1199Although it _always_ printed to STDERR, warn() would let you specify a
1200filehandle in perl4. With perl5 it does not.
5e378fdf
PP
1201
1202 warn STDERR "Foo!";
1203
1204 # perl4 prints: Foo!
54310121 1205 # perl5 prints: String found where operator expected
5e378fdf 1206
6dbacca0 1207=back
a0d0e21e 1208
6dbacca0
PP
1209=head2 OS Traps
1210
1211=over 5
1212
1213=item * (SysV)
1214
54310121
PP
1215Under HPUX, and some other SysV OSes, one had to reset any signal handler,
1216within the signal handler function, each time a signal was handled with
1217perl4. With perl5, the reset is now done correctly. Any code relying
6dbacca0
PP
1218on the handler _not_ being reset will have to be reworked.
1219
a6006777 1220Since version 5.002, Perl uses sigaction() under SysV.
6dbacca0
PP
1221
1222 sub gotit {
54310121
PP
1223 print "Got @_... ";
1224 }
6dbacca0 1225 $SIG{'INT'} = 'gotit';
54310121 1226
6dbacca0
PP
1227 $| = 1;
1228 $pid = fork;
1229 if ($pid) {
1230 kill('INT', $pid);
1231 sleep(1);
1232 kill('INT', $pid);
54310121 1233 } else {
6dbacca0 1234 while (1) {sleep(10);}
54310121
PP
1235 }
1236
6dbacca0
PP
1237 # perl4 (HPUX) prints: Got INT...
1238 # perl5 (HPUX) prints: Got INT... Got INT...
1239
1240=item * (SysV)
1241
54310121
PP
1242Under SysV OSes, C<seek()> on a file opened to append C<E<gt>E<gt>> now does
1243the right thing w.r.t. the fopen() manpage. e.g., - When a file is opened
6dbacca0
PP
1244for append, it is impossible to overwrite information already in
1245the file.
1246
1247 open(TEST,">>seek.test");
54310121 1248 $start = tell TEST ;
6dbacca0
PP
1249 foreach(1 .. 9){
1250 print TEST "$_ ";
1251 }
1252 $end = tell TEST ;
1253 seek(TEST,$start,0);
1254 print TEST "18 characters here";
54310121 1255
6dbacca0
PP
1256 # perl4 (solaris) seek.test has: 18 characters here
1257 # perl5 (solaris) seek.test has: 1 2 3 4 5 6 7 8 9 18 characters here
a0d0e21e 1258
a0d0e21e 1259
a0d0e21e 1260
6dbacca0 1261=back
a0d0e21e 1262
6dbacca0 1263=head2 Interpolation Traps
a0d0e21e 1264
8b0a4b75
PP
1265Perl4-to-Perl5 traps having to do with how things get interpolated
1266within certain expressions, statements, contexts, or whatever.
1267
6dbacca0 1268=over 5
a0d0e21e 1269
6dbacca0 1270=item * Interpolation
a0d0e21e 1271
6dbacca0
PP
1272@ now always interpolates an array in double-quotish strings.
1273
54310121
PP
1274 print "To: someone@somewhere.com\n";
1275
6dbacca0 1276 # perl4 prints: To:someone@somewhere.com
9607fc9c 1277 # perl5 errors : In string, @somewhere now must be written as \@somewhere
6dbacca0
PP
1278
1279=item * Interpolation
1280
6dbacca0
PP
1281Double-quoted strings may no longer end with an unescaped $ or @.
1282
1283 $foo = "foo$";
1284 $bar = "bar@";
1285 print "foo is $foo, bar is $bar\n";
54310121 1286
6dbacca0
PP
1287 # perl4 prints: foo is foo$, bar is bar@
1288 # perl5 errors: Final $ should be \$ or $name
1289
1290Note: perl5 DOES NOT error on the terminating @ in $bar
1291
1292=item * Interpolation
a0d0e21e 1293
8b0a4b75
PP
1294Perl now sometimes evaluates arbitrary expressions inside braces that occur
1295within double quotes (usually when the opening brace is preceded by C<$>
1296or C<@>).
1297
1298 @www = "buz";
1299 $foo = "foo";
1300 $bar = "bar";
1301 sub foo { return "bar" };
1302 print "|@{w.w.w}|${main'foo}|";
1303
1304 # perl4 prints: |@{w.w.w}|foo|
1305 # perl5 prints: |buz|bar|
1306
1307Note that you can C<use strict;> to ward off such trappiness under perl5.
1308
1309=item * Interpolation
1310
748a9306 1311The construct "this is $$x" used to interpolate the pid at that
6dbacca0 1312point, but now apparently tries to dereference C<$x>. C<$$> by itself still
748a9306
LW
1313works fine, however.
1314
6dbacca0 1315 print "this is $$x\n";
748a9306 1316
6dbacca0
PP
1317 # perl4 prints: this is XXXx (XXX is the current pid)
1318 # perl5 prints: this is
1319
1320=item * Interpolation
1321
54310121
PP
1322Creation of hashes on the fly with C<eval "EXPR"> now requires either both
1323C<$>'s to be protected in the specification of the hash name, or both curlies
6dbacca0
PP
1324to be protected. If both curlies are protected, the result will be compatible
1325with perl4 and perl5. This is a very common practice, and should be changed
1326to use the block form of C<eval{}> if possible.
c07a80fd 1327
6dbacca0
PP
1328 $hashname = "foobar";
1329 $key = "baz";
1330 $value = 1234;
1331 eval "\$$hashname{'$key'} = q|$value|";
1332 (defined($foobar{'baz'})) ? (print "Yup") : (print "Nope");
1333
1334 # perl4 prints: Yup
1335 # perl5 prints: Nope
1336
1337Changing
1338
1339 eval "\$$hashname{'$key'} = q|$value|";
c07a80fd
PP
1340
1341to
1342
6dbacca0 1343 eval "\$\$hashname{'$key'} = q|$value|";
c07a80fd 1344
6dbacca0 1345causes the following result:
c07a80fd 1346
6dbacca0
PP
1347 # perl4 prints: Nope
1348 # perl5 prints: Yup
c07a80fd 1349
6dbacca0 1350or, changing to
a0d0e21e 1351
6dbacca0
PP
1352 eval "\$$hashname\{'$key'\} = q|$value|";
1353
1354causes the following result:
1355
1356 # perl4 prints: Yup
1357 # perl5 prints: Yup
1358 # and is compatible for both versions
1359
1360
1361=item * Interpolation
1362
1363perl4 programs which unconsciously rely on the bugs in earlier perl versions.
1364
1365 perl -e '$bar=q/not/; print "This is $foo{$bar} perl5"'
54310121 1366
6dbacca0
PP
1367 # perl4 prints: This is not perl5
1368 # perl5 prints: This is perl5
1369
1370=item * Interpolation
1371
54310121 1372You also have to be careful about array references.
6dbacca0
PP
1373
1374 print "$foo{"
1375
1376 perl 4 prints: {
1377 perl 5 prints: syntax error
1378
1379=item * Interpolation
1380
1381Similarly, watch out for:
1382
1383 $foo = "array";
1384 print "\$$foo{bar}\n";
54310121 1385
6dbacca0
PP
1386 # perl4 prints: $array{bar}
1387 # perl5 prints: $
1388
1389Perl 5 is looking for C<$array{bar}> which doesn't exist, but perl 4 is
1390happy just to expand $foo to "array" by itself. Watch out for this
1391especially in C<eval>'s.
1392
1393=item * Interpolation
1394
1395C<qq()> string passed to C<eval>
1396
1397 eval qq(
1398 foreach \$y (keys %\$x\) {
1399 \$count++;
1400 }
1401 );
54310121 1402
6dbacca0 1403 # perl4 runs this ok
54310121 1404 # perl5 prints: Can't find string terminator ")"
a0d0e21e 1405
6dbacca0
PP
1406=back
1407
1408=head2 DBM Traps
1409
1410General DBM traps.
1411
1412=over 5
1413
1414=item * DBM
1415
1416Existing dbm databases created under perl4 (or any other dbm/ndbm tool)
1417may cause the same script, run under perl5, to fail. The build of perl5
1418must have been linked with the same dbm/ndbm as the default for C<dbmopen()>
1419to function properly without C<tie>'ing to an extension dbm implementation.
1420
1421 dbmopen (%dbm, "file", undef);
1422 print "ok\n";
1423
1424 # perl4 prints: ok
1425 # perl5 prints: ok (IFF linked with -ldbm or -lndbm)
1426
1427
1428=item * DBM
1429
1430Existing dbm databases created under perl4 (or any other dbm/ndbm tool)
1431may cause the same script, run under perl5, to fail. The error generated
1432when exceeding the limit on the key/value size will cause perl5 to exit
1433immediately.
1434
1435 dbmopen(DB, "testdb",0600) || die "couldn't open db! $!";
1436 $DB{'trap'} = "x" x 1024; # value too large for most dbm/ndbm
1437 print "YUP\n";
1438
1439 # perl4 prints:
1440 dbm store returned -1, errno 28, key "trap" at - line 3.
1441 YUP
1442
1443 # perl5 prints:
1444 dbm store returned -1, errno 28, key "trap" at - line 3.
a0d0e21e
LW
1445
1446=back
6dbacca0
PP
1447
1448=head2 Unclassified Traps
1449
1450Everything else.
1451
84dc3c4d
PP
1452=over 5
1453
6dbacca0
PP
1454=item * Unclassified
1455
1456C<require>/C<do> trap using returned value
1457
1458If the file doit.pl has:
1459
1460 sub foo {
1461 $rc = do "./do.pl";
1462 return 8;
54310121 1463 }
6dbacca0
PP
1464 print &foo, "\n";
1465
1466And the do.pl file has the following single line:
1467
1468 return 3;
1469
1470Running doit.pl gives the following:
1471
1472 # perl 4 prints: 3 (aborts the subroutine early)
54310121 1473 # perl 5 prints: 8
6dbacca0
PP
1474
1475Same behavior if you replace C<do> with C<require>.
1476
1477=back
1478
54310121 1479As always, if any of these are ever officially declared as bugs,
6dbacca0
PP
1480they'll be fixed and removed.
1481