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