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