Commit | Line | Data |
---|---|---|
a0d0e21e LW |
1 | =head1 NAME |
2 | ||
3 | perltrap - Perl traps for the unwary | |
4 | ||
5 | =head1 DESCRIPTION | |
6 | ||
9fda99eb DC |
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 LW |
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 MS |
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 LW |
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 LW |
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 LW |
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 LW |
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 LW |
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 LW |
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 LW |
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 LW |
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 LW |
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 LW |
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 MS |
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 LW |
170 | |
171 | =item * | |
172 | ||
6ec4bd10 MS |
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 LW |
175 | |
176 | =item * | |
177 | ||
5db417f7 | 178 | Variables begin with "$", "@" or "%" in Perl. |
a0d0e21e LW |
179 | |
180 | =item * | |
181 | ||
6014d0cb MS |
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 LW |
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 LW |
190 | |
191 | =item * | |
192 | ||
4633a7c4 LW |
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 LW |
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 LW |
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 MS |
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 LW |
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 LW |
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 LW |
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 LW |
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 | ||
8886331d NC |
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 | ||
a0d0e21e LW |
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 | ||
68dc0745 | 292 | Avoid barewords if you can, especially all lowercase ones. |
54310121 | 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 | |
5f05dabc | 295 | parentheses on function calls, you won't ever get them confused. |
a0d0e21e LW |
296 | |
297 | =item * | |
298 | ||
54310121 | 299 | You cannot discern from mere inspection which builtins |
300 | are unary operators (like chop() and chdir()) | |
a0d0e21e | 301 | and which are list operators (like print() and unlink()). |
9fda99eb DC |
302 | (Unless prototyped, user-defined subroutines can B<only> be list |
303 | operators, never unary ones.) See L<perlop> and L<perlsub>. | |
a0d0e21e LW |
304 | |
305 | =item * | |
306 | ||
748a9306 | 307 | People have a hard time remembering that some functions |
a0d0e21e | 308 | default to $_, or @ARGV, or whatever, but that others which |
54310121 | 309 | you might expect to do not. |
a0d0e21e | 310 | |
6dbacca0 | 311 | =item * |
a0d0e21e | 312 | |
c47ff5f1 | 313 | The <FH> construct is not the name of the filehandle, it is a readline |
5f05dabc | 314 | operation on that handle. The data read is assigned to $_ only if the |
748a9306 LW |
315 | file read is the sole condition in a while loop: |
316 | ||
317 | while (<FH>) { } | |
54310121 | 318 | while (defined($_ = <FH>)) { }.. |
748a9306 LW |
319 | <FH>; # data discarded! |
320 | ||
6dbacca0 | 321 | =item * |
748a9306 | 322 | |
19799a22 | 323 | Remember not to use C<=> when you need C<=~>; |
a0d0e21e LW |
324 | these two constructs are quite different: |
325 | ||
326 | $x = /foo/; | |
327 | $x =~ /foo/; | |
328 | ||
329 | =item * | |
330 | ||
54310121 | 331 | The C<do {}> construct isn't a real loop that you can use |
a0d0e21e LW |
332 | loop control on. |
333 | ||
334 | =item * | |
335 | ||
54310121 | 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 | |
a0d0e21e LW |
339 | variable, which leaves you open to unforeseen side-effects |
340 | of dynamic scoping. | |
341 | ||
c07a80fd | 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 | ||
a0d0e21e LW |
348 | =back |
349 | ||
5f05dabc | 350 | =head2 Perl4 to Perl5 Traps |
a0d0e21e | 351 | |
54310121 | 352 | Practicing Perl4 Programmers should take note of the following |
6dbacca0 | 353 | Perl4-to-Perl5 specific traps. |
354 | ||
355 | They're crudely ordered according to the following list: | |
a0d0e21e LW |
356 | |
357 | =over 4 | |
358 | ||
6dbacca0 | 359 | =item Discontinuance, Deprecation, and BugFix traps |
a0d0e21e | 360 | |
6dbacca0 | 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. | |
a0d0e21e | 364 | |
6dbacca0 | 365 | =item Parsing Traps |
748a9306 | 366 | |
6dbacca0 | 367 | Traps that appear to stem from the new parser. |
a0d0e21e | 368 | |
6dbacca0 | 369 | =item Numerical Traps |
a0d0e21e | 370 | |
6dbacca0 | 371 | Traps having to do with numerical or mathematical operators. |
a0d0e21e | 372 | |
6dbacca0 | 373 | =item General data type traps |
a0d0e21e | 374 | |
6dbacca0 | 375 | Traps involving perl standard data types. |
a0d0e21e | 376 | |
6dbacca0 | 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, | |
4375e838 | 410 | please submit it to <F<perlbug@perl.org>> for inclusion. |
9f1b1f2d GS |
411 | Also note that at least some of these can be caught with the |
412 | C<use warnings> pragma or the B<-w> switch. | |
6dbacca0 | 413 | |
414 | =head2 Discontinuance, Deprecation, and BugFix traps | |
415 | ||
416 | Anything that has been discontinued, deprecated, or fixed as | |
54310121 | 417 | a bug from perl4. |
a0d0e21e | 418 | |
6dbacca0 | 419 | =over 4 |
420 | ||
d52dc02a | 421 | =item * Symbols starting with "_" no longer forced into main |
6dbacca0 | 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; | |
cb1a09d0 | 428 | |
6dbacca0 | 429 | package main; |
430 | print "\$_legacy is ",$_legacy,"\n"; | |
54310121 | 431 | |
6dbacca0 | 432 | # perl4 prints: $_legacy is 1 |
433 | # perl5 prints: $_legacy is | |
434 | ||
d52dc02a | 435 | =item * Double-colon valid package separator in variable name |
6dbacca0 | 436 | |
437 | Double-colon is now a valid package separator in a variable name. Thus these | |
5f05dabc | 438 | behave differently in perl4 vs. perl5, because the packages don't exist. |
6dbacca0 | 439 | |
440 | $a=1;$b=2;$c=3;$var=4; | |
441 | print "$a::$b::$c "; | |
cb1a09d0 | 442 | print "$var::abc::xyz\n"; |
c47ff5f1 | 443 | |
6dbacca0 | 444 | # perl4 prints: 1::2::3 4::abc::xyz |
445 | # perl5 prints: 3 | |
cb1a09d0 | 446 | |
6dbacca0 | 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) | |
cb1a09d0 | 450 | |
4358a253 SS |
451 | $x = 10; |
452 | print "x=${'x}\n"; | |
54310121 | 453 | |
6dbacca0 | 454 | # perl4 prints: x=10 |
455 | # perl5 prints: Can't find string terminator "'" anywhere before EOF | |
a0d0e21e | 456 | |
5e77893f MG |
457 | You can avoid this problem, and remain compatible with perl4, if you |
458 | always explicitly include the package name: | |
459 | ||
4358a253 SS |
460 | $x = 10; |
461 | print "x=${main'x}\n"; | |
5e77893f | 462 | |
54310121 | 463 | Also see precedence traps, for parsing C<$:>. |
a0d0e21e | 464 | |
d52dc02a | 465 | =item * 2nd and 3rd args to C<splice()> are now in scalar context |
a0d0e21e | 466 | |
6dbacca0 | 467 | The second and third arguments of C<splice()> are now evaluated in scalar |
468 | context (as the Camel says) rather than list context. | |
a0d0e21e | 469 | |
1d2dff63 GS |
470 | sub sub1{return(0,2) } # return a 2-element list |
471 | sub sub2{ return(1,2,3)} # return a 3-element list | |
54310121 | 472 | @a1 = ("a","b","c","d","e"); |
6dbacca0 | 473 | @a2 = splice(@a1,&sub1,&sub2); |
474 | print join(' ',@a2),"\n"; | |
54310121 | 475 | |
6dbacca0 | 476 | # perl4 prints: a b |
54310121 | 477 | # perl5 prints: c d e |
a0d0e21e | 478 | |
d52dc02a | 479 | =item * Can't do C<goto> into a block that is optimized away |
a0d0e21e | 480 | |
6dbacca0 | 481 | You can't do a C<goto> into a block that is optimized away. Darn. |
a0d0e21e | 482 | |
6dbacca0 | 483 | goto marker1; |
a0d0e21e | 484 | |
54310121 | 485 | for(1){ |
6dbacca0 | 486 | marker1: |
487 | print "Here I is!\n"; | |
54310121 | 488 | } |
489 | ||
6dbacca0 | 490 | # perl4 prints: Here I is! |
9fda99eb | 491 | # perl5 errors: Can't "goto" into the middle of a foreach loop |
6dbacca0 | 492 | |
d52dc02a | 493 | =item * Can't use whitespace as variable name or quote delimiter |
6dbacca0 | 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. | |
54310121 | 497 | Double darn. |
6dbacca0 | 498 | |
499 | $a = ("foo bar"); | |
4358a253 | 500 | $b = q baz; |
6dbacca0 | 501 | print "a is $a, b is $b\n"; |
54310121 | 502 | |
6dbacca0 | 503 | # perl4 prints: a is foo bar, b is baz |
54310121 | 504 | # perl5 errors: Bareword found where operator expected |
5e378fdf | 505 | |
d52dc02a | 506 | =item * C<while/if BLOCK BLOCK> gone |
6dbacca0 | 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 | } | |
54310121 | 516 | |
6dbacca0 | 517 | # perl4 prints: True! |
518 | # perl5 errors: syntax error at test.pl line 1, near "if {" | |
519 | ||
d52dc02a | 520 | =item * C<**> binds tighter than unary minus |
6dbacca0 | 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"; | |
54310121 | 526 | |
6dbacca0 | 527 | # perl4 prints: 16 |
528 | # perl5 prints: -16 | |
529 | ||
d52dc02a | 530 | =item * C<foreach> changed when iterating over a list |
6dbacca0 | 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)); | |
54310121 | 544 | |
6dbacca0 | 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 | |
54310121 | 549 | explicitly to a temporary array and then iterate over that. For |
6dbacca0 | 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 | ||
d52dc02a | 562 | =item * C<split> with no args behavior changed |
5e378fdf | 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 | ||
d52dc02a | 574 | =item * B<-e> behavior fixed |
55497cff | 575 | |
9607fc9c | 576 | Perl 4 would ignore any text which was attached to an B<-e> switch, |
55497cff | 577 | always taking the code snippet from the following arg. Additionally, it |
9607fc9c | 578 | would silently accept an B<-e> switch without a following arg. Both of |
55497cff | 579 | these behaviors have been fixed. |
580 | ||
581 | perl -e'print "attached to -e"' 'print "separate arg"' | |
54310121 | 582 | |
55497cff | 583 | # perl4 prints: separate arg |
584 | # perl5 prints: attached to -e | |
54310121 | 585 | |
55497cff | 586 | perl -e |
587 | ||
588 | # perl4 prints: | |
589 | # perl5 dies: No code specified for -e. | |
590 | ||
d52dc02a | 591 | =item * C<push> returns number of elements in resulting list |
55497cff | 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'); | |
54310121 | 600 | |
55497cff | 601 | # perl4 prints: second new |
602 | # perl5 prints: 3 | |
603 | ||
d52dc02a | 604 | =item * Some error messages differ |
6dbacca0 | 605 | |
606 | Some error messages will be different. | |
607 | ||
d52dc02a | 608 | =item * C<split()> honors subroutine args |
6dbacca0 | 609 | |
46836f5c GS |
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 | ||
d52dc02a | 614 | =item * Bugs removed |
46836f5c | 615 | |
6dbacca0 | 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 | ||
d52dc02a | 626 | =item * Space between . and = triggers syntax error |
6dbacca0 | 627 | |
628 | Note the space between . and = | |
629 | ||
630 | $string . = "more string"; | |
631 | print $string; | |
54310121 | 632 | |
6dbacca0 | 633 | # perl4 prints: more string |
634 | # perl5 prints: syntax error at - line 1, near ". =" | |
635 | ||
d52dc02a | 636 | =item * Better parsing in perl 5 |
6dbacca0 | 637 | |
638 | Better parsing in perl 5 | |
639 | ||
640 | sub foo {} | |
641 | &foo | |
642 | print("hello, world\n"); | |
54310121 | 643 | |
6dbacca0 | 644 | # perl4 prints: hello, world |
645 | # perl5 prints: syntax error | |
646 | ||
d52dc02a | 647 | =item * Function parsing |
6dbacca0 | 648 | |
649 | "if it looks like a function, it is a function" rule. | |
650 | ||
651 | ||
652 | ($foo == 1) ? "is one\n" : "is zero\n"; | |
54310121 | 653 | |
6dbacca0 | 654 | # perl4 prints: is zero |
655 | # perl5 warns: "Useless use of a constant in void context" if using -w | |
656 | ||
d52dc02a | 657 | =item * String interpolation of C<$#array> differs |
c12982c8 GS |
658 | |
659 | String interpolation of the C<$#array> construct differs when braces | |
660 | are to used around the name. | |
661 | ||
9fda99eb | 662 | @a = (1..3); |
c12982c8 GS |
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 | ||
ba0dd969 | 674 | =item * Perl guesses on C<map>, C<grep> followed by C<{> if it starts BLOCK or hash ref |
bf1f8817 RB |
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 | ||
6dbacca0 | 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 | ||
d52dc02a | 693 | =item * Formatted output and significant digits |
6dbacca0 | 694 | |
a9709c40 AS |
695 | Formatted output and significant digits. In general, Perl 5 |
696 | tries to be more precise. For example, on a Solaris Sparc: | |
6dbacca0 | 697 | |
698 | print 7.373504 - 0, "\n"; | |
54310121 | 699 | printf "%20.18f\n", 7.373504 - 0; |
700 | ||
6dbacca0 | 701 | # Perl4 prints: |
a9709c40 AS |
702 | 7.3750399999999996141 |
703 | 7.375039999999999614 | |
54310121 | 704 | |
6dbacca0 | 705 | # Perl5 prints: |
706 | 7.373504 | |
a9709c40 AS |
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. | |
6dbacca0 | 713 | |
d52dc02a | 714 | =item * Auto-increment operator over signed int limit deleted |
6dbacca0 | 715 | |
5f05dabc | 716 | This specific item has been deleted. It demonstrated how the auto-increment |
5e378fdf | 717 | operator would not catch when a number went over the signed int limit. Fixed |
a6006777 | 718 | in version 5.003_04. But always be wary when using large integers. |
719 | If in doubt: | |
6dbacca0 | 720 | |
5e378fdf | 721 | use Math::BigInt; |
6dbacca0 | 722 | |
ba0dd969 | 723 | =item * Assignment of return values from numeric equality tests doesn't work |
6dbacca0 | 724 | |
725 | Assignment of return values from numeric equality tests | |
726 | does not work in perl5 when the test evaluates to false (0). | |
d1be9408 | 727 | Logical tests now return a null, instead of 0 |
a6006777 | 728 | |
6dbacca0 | 729 | $p = ($test == 1); |
730 | print $p,"\n"; | |
a6006777 | 731 | |
6dbacca0 | 732 | # perl4 prints: 0 |
733 | # perl5 prints: | |
734 | ||
dc848c6f | 735 | Also see L<"General Regular Expression Traps using s///, etc."> |
736 | for another example of this new feature... | |
6dbacca0 | 737 | |
651ad3b1 GS |
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 | ||
6dbacca0 | 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 | ||
d52dc02a | 771 | =item * Negative array subscripts now count from the end of array |
6dbacca0 | 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"; | |
54310121 | 777 | |
6dbacca0 | 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 | ||
d52dc02a | 781 | =item * Setting C<$#array> lower now discards array elements |
6dbacca0 | 782 | |
783 | Setting C<$#array> lower now discards array elements, and makes them | |
784 | impossible to recover. | |
785 | ||
54310121 | 786 | @a = (a,b,c,d,e); |
6dbacca0 | 787 | print "Before: ",join('',@a); |
54310121 | 788 | $#a =1; |
6dbacca0 | 789 | print ", After: ",join('',@a); |
790 | $#a =3; | |
791 | print ", Recovered: ",join('',@a),"\n"; | |
54310121 | 792 | |
6dbacca0 | 793 | # perl4 prints: Before: abcde, After: ab, Recovered: abcd |
794 | # perl5 prints: Before: abcde, After: ab, Recovered: ab | |
795 | ||
d52dc02a | 796 | =item * Hashes get defined before use |
6dbacca0 | 797 | |
798 | Hashes get defined before use | |
799 | ||
54310121 | 800 | local($s,@a,%h); |
6dbacca0 | 801 | die "scalar \$s defined" if defined($s); |
802 | die "array \@a defined" if defined(@a); | |
803 | die "hash \%h defined" if defined(%h); | |
54310121 | 804 | |
6dbacca0 | 805 | # perl4 prints: |
806 | # perl5 dies: hash %h defined | |
807 | ||
475342a6 GS |
808 | Perl will now generate a warning when it sees defined(@a) and |
809 | defined(%h). | |
810 | ||
d52dc02a | 811 | =item * Glob assignment from localized variable to variable |
6dbacca0 | 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"; | |
54310121 | 820 | |
6dbacca0 | 821 | # perl4 prints: This is Perl 4 |
822 | # perl5 prints: | |
54310121 | 823 | |
d52dc02a | 824 | =item * Assigning C<undef> to glob |
54310121 | 825 | |
a3cb178b GS |
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 | |
9fda99eb DC |
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 | |
5e378fdf | 841 | |
d52dc02a | 842 | =item * Changes in unary negation (of strings) |
6dbacca0 | 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"; | |
54310121 | 852 | |
6dbacca0 | 853 | # perl4 prints: aab : -0 : 1 |
854 | # perl5 prints: aab : -aab : aac | |
855 | ||
d52dc02a | 856 | =item * Modifying of constants prohibited |
6dbacca0 | 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 | } | |
54310121 | 870 | |
6dbacca0 | 871 | # perl4: |
872 | # before: x after: m | |
873 | # before: a after: m | |
874 | # before: m after: m | |
875 | # before: m after: m | |
54310121 | 876 | |
6dbacca0 | 877 | # Perl5: |
878 | # before: x after: m | |
879 | # Modification of a read-only value attempted at foo.pl line 12. | |
880 | # before: a | |
881 | ||
d52dc02a | 882 | =item * C<defined $var> behavior changed |
6dbacca0 | 883 | |
884 | The behavior is slightly different for: | |
885 | ||
886 | print "$x", defined $x | |
54310121 | 887 | |
6dbacca0 | 888 | # perl 4: 1 |
889 | # perl 5: <no output, $x is not called into existence> | |
890 | ||
d52dc02a | 891 | =item * Variable Suicide |
6dbacca0 | 892 | |
893 | Variable suicide behavior is more consistent under Perl 5. | |
aa689395 | 894 | Perl5 exhibits the same behavior for hashes and scalars, |
5f05dabc | 895 | that perl4 exhibits for only scalars. |
6dbacca0 | 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 | |
54310121 | 905 | $aNewLocal{"aKey"} = "this should never appear"; |
6dbacca0 | 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 | } | |
54310121 | 913 | |
6dbacca0 | 914 | # Perl4: |
915 | # MAIN:global value | |
916 | # SUB: global value | |
917 | # SUB: level 0 | |
918 | # SUB: level 1 | |
919 | # SUB: level 2 | |
54310121 | 920 | |
6dbacca0 | 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 | ||
84dc3c4d | 928 | =back |
6dbacca0 | 929 | |
930 | =head2 Context Traps - scalar, list contexts | |
931 | ||
932 | =over 5 | |
933 | ||
d52dc02a | 934 | =item * Elements of argument lists for formats evaluated in list context |
6dbacca0 | 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 | . | |
54310121 | 944 | write; |
945 | ||
6dbacca0 | 946 | # perl4 errors: Please use commas to separate fields in file |
947 | # perl5 prints: foo bar baz | |
948 | ||
d52dc02a | 949 | =item * C<caller()> returns false value in scalar context if no caller present |
6dbacca0 | 950 | |
54310121 | 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 | |
6dbacca0 | 953 | being required. |
954 | ||
955 | caller() ? (print "You rang?\n") : (print "Got a 0\n"); | |
54310121 | 956 | |
6dbacca0 | 957 | # perl4 errors: There is no caller |
958 | # perl5 prints: Got a 0 | |
5e378fdf | 959 | |
d52dc02a | 960 | =item * Comma operator in scalar context gives scalar context to args |
6dbacca0 | 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"; | |
54310121 | 968 | |
6dbacca0 | 969 | # Perl4 prints: x = c # Thinks list context interpolates list |
970 | # Perl5 prints: x = 3 # Knows scalar uses length of list | |
971 | ||
d52dc02a | 972 | =item * C<sprintf()> prototyped as C<($;@)> |
6dbacca0 | 973 | |
9fda99eb DC |
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: | |
6dbacca0 | 977 | |
978 | @z = ('%s%s', 'foo', 'bar'); | |
979 | $x = sprintf(@z); | |
9fda99eb | 980 | print $x; |
54310121 | 981 | |
9fda99eb DC |
982 | # perl4 prints: foobar |
983 | # perl5 prints: 3 | |
6dbacca0 | 984 | |
9fda99eb | 985 | C<printf()> works the same as it did in Perl 4, though: |
6dbacca0 | 986 | |
9fda99eb | 987 | @z = ('%s%s', 'foo', 'bar'); |
6dbacca0 | 988 | printf STDOUT (@z); |
54310121 | 989 | |
6dbacca0 | 990 | # perl4 prints: foobar |
991 | # perl5 prints: foobar | |
992 | ||
6dbacca0 | 993 | =back |
994 | ||
995 | =head2 Precedence Traps | |
996 | ||
997 | Perl4-to-Perl5 traps involving precedence order. | |
998 | ||
f4b17341 GS |
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 | ||
84dc3c4d | 1003 | =over 5 |
1004 | ||
d52dc02a | 1005 | =item * LHS vs. RHS of any assignment operator |
5e378fdf | 1006 | |
8dbef698 JM |
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. | |
5e378fdf | 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 | ||
d52dc02a | 1018 | =item * Semantic errors introduced due to precedence |
6dbacca0 | 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"; | |
54310121 | 1028 | |
6dbacca0 | 1029 | # perl4 prints: n is 3, m is 6 |
1030 | # perl5 errors and fails to compile | |
1031 | ||
d52dc02a | 1032 | =item * Precedence of assignment operators same as the precedence of assignment |
a0d0e21e | 1033 | |
4633a7c4 LW |
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); | |
a6006777 | 1039 | |
4633a7c4 LW |
1040 | Otherwise |
1041 | ||
6dbacca0 | 1042 | /foo/ ? $a += 2 : $a -= 2 |
4633a7c4 LW |
1043 | |
1044 | would be erroneously parsed as | |
1045 | ||
1046 | (/foo/ ? $a += 2 : $a) -= 2; | |
1047 | ||
1048 | On the other hand, | |
1049 | ||
54310121 | 1050 | $a += /foo/ ? 1 : 2; |
4633a7c4 LW |
1051 | |
1052 | now works as a C programmer would expect. | |
1053 | ||
d52dc02a | 1054 | =item * C<open> requires parentheses around filehandle |
4633a7c4 | 1055 | |
6dbacca0 | 1056 | open FOO || die; |
a0d0e21e | 1057 | |
5f05dabc | 1058 | is now incorrect. You need parentheses around the filehandle. |
1059 | Otherwise, perl5 leaves the statement as its default precedence: | |
a0d0e21e | 1060 | |
6dbacca0 | 1061 | open(FOO || die); |
54310121 | 1062 | |
6dbacca0 | 1063 | # perl4 opens or dies |
9fda99eb | 1064 | # perl5 opens FOO, dying only if 'FOO' is false, i.e. never |
a0d0e21e | 1065 | |
d52dc02a | 1066 | =item * C<$:> precedence over C<$::> gone |
a0d0e21e | 1067 | |
6dbacca0 | 1068 | perl4 gives the special variable, C<$:> precedence, where perl5 |
1069 | treats C<$::> as main C<package> | |
a0d0e21e | 1070 | |
6dbacca0 | 1071 | $a = "x"; print "$::a"; |
54310121 | 1072 | |
6dbacca0 | 1073 | # perl 4 prints: -:a |
1074 | # perl 5 prints: x | |
5e378fdf | 1075 | |
d52dc02a | 1076 | =item * Precedence of file test operators documented |
a0d0e21e | 1077 | |
f4b17341 GS |
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. | |
54310121 | 1083 | |
1084 | -e $foo .= "q" | |
a0d0e21e | 1085 | |
6dbacca0 | 1086 | # perl4 prints: no output |
1087 | # perl5 prints: Can't modify -e in concatenation | |
a0d0e21e | 1088 | |
d52dc02a | 1089 | =item * C<keys>, C<each>, C<values> are regular named unary operators |
f4b17341 GS |
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 | ||
6dbacca0 | 1106 | =back |
1107 | ||
1108 | =head2 General Regular Expression Traps using s///, etc. | |
1109 | ||
1110 | All types of RE traps. | |
1111 | ||
1112 | =over 5 | |
1113 | ||
d52dc02a | 1114 | =item * C<s'$lhs'$rhs'> interpolates on either side |
6dbacca0 | 1115 | |
1116 | C<s'$lhs'$rhs'> now does no interpolation on either side. It used to | |
19799a22 | 1117 | interpolate $lhs but not $rhs. (And still does not match a literal |
6dbacca0 | 1118 | '$' in string) |
1119 | ||
1120 | $a=1;$b=2; | |
1121 | $string = '1 2 $a $b'; | |
1122 | $string =~ s'$a'$b'; | |
1123 | print $string,"\n"; | |
54310121 | 1124 | |
6dbacca0 | 1125 | # perl4 prints: $b 2 $a $b |
1126 | # perl5 prints: 1 2 $a $b | |
1127 | ||
d52dc02a | 1128 | =item * C<m//g> attaches its state to the searched string |
a0d0e21e LW |
1129 | |
1130 | C<m//g> now attaches its state to the searched string rather than the | |
6dbacca0 | 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 $_ "} | |
54310121 | 1139 | |
9fda99eb | 1140 | # perl4 prints: Got blah Got blah Got blah Got blah |
6dbacca0 | 1141 | # perl5 prints: infinite loop blah... |
1142 | ||
d52dc02a | 1143 | =item * C<m//o> used within an anonymous sub |
6dbacca0 | 1144 | |
68dc0745 | 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 | } | |
9fda99eb DC |
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 | |
68dc0745 | 1164 | |
1165 | build_match() will always return a sub which matches the contents of | |
19799a22 | 1166 | $left and $right as they were the I<first> time that build_match() |
68dc0745 | 1167 | was called, not as they are in the current call. |
1168 | ||
d52dc02a | 1169 | =item * C<$+> isn't set to whole match |
68dc0745 | 1170 | |
6dbacca0 | 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"; | |
54310121 | 1176 | |
6dbacca0 | 1177 | # perl4 prints: bcde |
1178 | # perl5 prints: | |
1179 | ||
d52dc02a | 1180 | =item * Substitution now returns null string if it fails |
6dbacca0 | 1181 | |
1182 | substitution now returns the null string if it fails | |
1183 | ||
1184 | $string = "test"; | |
1185 | $value = ($string =~ s/foo//); | |
1186 | print $value, "\n"; | |
54310121 | 1187 | |
6dbacca0 | 1188 | # perl4 prints: 0 |
1189 | # perl5 prints: | |
1190 | ||
1191 | Also see L<Numerical Traps> for another example of this new feature. | |
1192 | ||
d52dc02a | 1193 | =item * C<s`lhs`rhs`> is now a normal substitution |
6dbacca0 | 1194 | |
54310121 | 1195 | C<s`lhs`rhs`> (using backticks) is now a normal substitution, with no |
1196 | backtick expansion | |
6dbacca0 | 1197 | |
1198 | $string = ""; | |
1199 | $string =~ s`^`hostname`; | |
1200 | print $string, "\n"; | |
54310121 | 1201 | |
6dbacca0 | 1202 | # perl4 prints: <the local hostname> |
1203 | # perl5 prints: hostname | |
1204 | ||
d52dc02a | 1205 | =item * Stricter parsing of variables in regular expressions |
6dbacca0 | 1206 | |
1207 | Stricter parsing of variables used in regular expressions | |
1208 | ||
1209 | s/^([^$grpc]*$grpc[$opt$plus$rep]?)//o; | |
54310121 | 1210 | |
6dbacca0 | 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 | ||
54310121 | 1218 | $grpc = 'a'; |
6dbacca0 | 1219 | $opt = 'r'; |
1220 | $_ = 'bar'; | |
1221 | s/^([^$grpc]*$grpc[$opt]?)/foo/; | |
4358a253 | 1222 | print; |
54310121 | 1223 | |
6dbacca0 | 1224 | # perl4 prints: foo |
1225 | # perl5 prints: foobar | |
1226 | ||
d52dc02a | 1227 | =item * C<m?x?> matches only once |
6dbacca0 | 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"; | |
54310121 | 1238 | } else { |
6dbacca0 | 1239 | # m?x? matches only once |
54310121 | 1240 | print "perl5\n"; |
6dbacca0 | 1241 | } |
54310121 | 1242 | |
6dbacca0 | 1243 | # perl4 prints: perl4 |
1244 | # perl5 prints: perl5 | |
a0d0e21e | 1245 | |
d52dc02a | 1246 | =item * Failed matches don't reset the match variables |
665e98b9 JH |
1247 | |
1248 | Unlike in Ruby, failed matches in Perl do not reset the match variables | |
1249 | ($1, $2, ..., C<$`>, ...). | |
a0d0e21e | 1250 | |
6dbacca0 | 1251 | =back |
1252 | ||
1253 | =head2 Subroutine, Signal, Sorting Traps | |
a0d0e21e | 1254 | |
6dbacca0 | 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. | |
a0d0e21e | 1258 | |
6dbacca0 | 1259 | =over 5 |
a0d0e21e | 1260 | |
ba0dd969 | 1261 | =item * Barewords that used to look like strings look like subroutine calls |
a0d0e21e | 1262 | |
6dbacca0 | 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. | |
a0d0e21e | 1265 | |
6dbacca0 | 1266 | sub SeeYa { warn"Hasta la vista, baby!" } |
1267 | $SIG{'TERM'} = SeeYa; | |
1268 | print "SIGTERM is now $SIG{'TERM'}\n"; | |
54310121 | 1269 | |
9fda99eb DC |
1270 | # perl4 prints: SIGTERM is now main'SeeYa |
1271 | # perl5 prints: SIGTERM is now main::1 (and warns "Hasta la vista, baby!") | |
a0d0e21e | 1272 | |
6dbacca0 | 1273 | Use B<-w> to catch this one |
a0d0e21e | 1274 | |
d52dc02a | 1275 | =item * Reverse is no longer allowed as the name of a sort subroutine |
a0d0e21e | 1276 | |
6dbacca0 | 1277 | reverse is no longer allowed as the name of a sort subroutine. |
a0d0e21e | 1278 | |
6dbacca0 | 1279 | sub reverse{ print "yup "; $a <=> $b } |
9fda99eb | 1280 | print sort reverse (2,1,3); |
54310121 | 1281 | |
9fda99eb DC |
1282 | # perl4 prints: yup yup 123 |
1283 | # perl5 prints: 123 | |
1284 | # perl5 warns (if using -w): Ambiguous call resolved as CORE::reverse() | |
a0d0e21e | 1285 | |
d52dc02a | 1286 | =item * C<warn()> won't let you specify a filehandle. |
b996531f | 1287 | |
1288 | Although it _always_ printed to STDERR, warn() would let you specify a | |
1289 | filehandle in perl4. With perl5 it does not. | |
5e378fdf | 1290 | |
1291 | warn STDERR "Foo!"; | |
1292 | ||
1293 | # perl4 prints: Foo! | |
54310121 | 1294 | # perl5 prints: String found where operator expected |
5e378fdf | 1295 | |
6dbacca0 | 1296 | =back |
a0d0e21e | 1297 | |
6dbacca0 | 1298 | =head2 OS Traps |
1299 | ||
1300 | =over 5 | |
1301 | ||
d52dc02a | 1302 | =item * SysV resets signal handler correctly |
6dbacca0 | 1303 | |
54310121 | 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 | |
6dbacca0 | 1307 | on the handler _not_ being reset will have to be reworked. |
1308 | ||
a6006777 | 1309 | Since version 5.002, Perl uses sigaction() under SysV. |
6dbacca0 | 1310 | |
1311 | sub gotit { | |
54310121 | 1312 | print "Got @_... "; |
1313 | } | |
6dbacca0 | 1314 | $SIG{'INT'} = 'gotit'; |
54310121 | 1315 | |
6dbacca0 | 1316 | $| = 1; |
1317 | $pid = fork; | |
1318 | if ($pid) { | |
1319 | kill('INT', $pid); | |
1320 | sleep(1); | |
1321 | kill('INT', $pid); | |
54310121 | 1322 | } else { |
6dbacca0 | 1323 | while (1) {sleep(10);} |
54310121 | 1324 | } |
1325 | ||
6dbacca0 | 1326 | # perl4 (HPUX) prints: Got INT... |
1327 | # perl5 (HPUX) prints: Got INT... Got INT... | |
1328 | ||
d52dc02a | 1329 | =item * SysV C<seek()> appends correctly |
6dbacca0 | 1330 | |
c47ff5f1 | 1331 | Under SysV OSes, C<seek()> on a file opened to append C<<< >> >>> now does |
54310121 | 1332 | the right thing w.r.t. the fopen() manpage. e.g., - When a file is opened |
6dbacca0 | 1333 | for append, it is impossible to overwrite information already in |
1334 | the file. | |
1335 | ||
1336 | open(TEST,">>seek.test"); | |
4358a253 | 1337 | $start = tell TEST; |
6dbacca0 | 1338 | foreach(1 .. 9){ |
1339 | print TEST "$_ "; | |
1340 | } | |
4358a253 | 1341 | $end = tell TEST; |
6dbacca0 | 1342 | seek(TEST,$start,0); |
1343 | print TEST "18 characters here"; | |
54310121 | 1344 | |
6dbacca0 | 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 | |
a0d0e21e | 1347 | |
a0d0e21e | 1348 | |
a0d0e21e | 1349 | |
6dbacca0 | 1350 | =back |
a0d0e21e | 1351 | |
6dbacca0 | 1352 | =head2 Interpolation Traps |
a0d0e21e | 1353 | |
8b0a4b75 | 1354 | Perl4-to-Perl5 traps having to do with how things get interpolated |
1355 | within certain expressions, statements, contexts, or whatever. | |
1356 | ||
6dbacca0 | 1357 | =over 5 |
a0d0e21e | 1358 | |
d52dc02a | 1359 | =item * C<@> always interpolates an array in double-quotish strings |
a0d0e21e | 1360 | |
6dbacca0 | 1361 | @ now always interpolates an array in double-quotish strings. |
1362 | ||
54310121 | 1363 | print "To: someone@somewhere.com\n"; |
1364 | ||
6dbacca0 | 1365 | # perl4 prints: To:someone@somewhere.com |
8593bda5 GS |
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 | |
6dbacca0 | 1368 | |
d52dc02a | 1369 | =item * Double-quoted strings may no longer end with an unescaped $ |
6dbacca0 | 1370 | |
1fa58bec | 1371 | Double-quoted strings may no longer end with an unescaped $. |
6dbacca0 | 1372 | |
1373 | $foo = "foo$"; | |
1fa58bec | 1374 | print "foo is $foo\n"; |
54310121 | 1375 | |
1fa58bec | 1376 | # perl4 prints: foo is foo$ |
6dbacca0 | 1377 | # perl5 errors: Final $ should be \$ or $name |
1378 | ||
1379 | Note: perl5 DOES NOT error on the terminating @ in $bar | |
1380 | ||
ba0dd969 | 1381 | =item * Arbitrary expressions are evaluated inside braces within double quotes |
a0d0e21e | 1382 | |
8b0a4b75 | 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 | ||
d52dc02a | 1398 | =item * C<$$x> now tries to dereference $x |
8b0a4b75 | 1399 | |
9fda99eb DC |
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. | |
748a9306 | 1402 | |
9fda99eb DC |
1403 | $s = "a reference"; |
1404 | $x = *s; | |
6dbacca0 | 1405 | print "this is $$x\n"; |
748a9306 | 1406 | |
6dbacca0 | 1407 | # perl4 prints: this is XXXx (XXX is the current pid) |
9fda99eb | 1408 | # perl5 prints: this is a reference |
6dbacca0 | 1409 | |
ba0dd969 | 1410 | =item * Creation of hashes on the fly with C<eval "EXPR"> requires protection |
6dbacca0 | 1411 | |
54310121 | 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 | |
6dbacca0 | 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. | |
c07a80fd | 1417 | |
6dbacca0 | 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|"; | |
c07a80fd | 1430 | |
1431 | to | |
1432 | ||
6dbacca0 | 1433 | eval "\$\$hashname{'$key'} = q|$value|"; |
c07a80fd | 1434 | |
6dbacca0 | 1435 | causes the following result: |
c07a80fd | 1436 | |
6dbacca0 | 1437 | # perl4 prints: Nope |
1438 | # perl5 prints: Yup | |
c07a80fd | 1439 | |
6dbacca0 | 1440 | or, changing to |
a0d0e21e | 1441 | |
6dbacca0 | 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 | ||
d52dc02a | 1451 | =item * Bugs in earlier perl versions |
6dbacca0 | 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"' | |
54310121 | 1456 | |
6dbacca0 | 1457 | # perl4 prints: This is not perl5 |
1458 | # perl5 prints: This is perl5 | |
1459 | ||
d52dc02a | 1460 | =item * Array and hash brackets during interpolation |
6dbacca0 | 1461 | |
418272e4 CW |
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 | |
6dbacca0 | 1469 | |
1470 | print "$foo{" | |
1471 | ||
1472 | perl 4 prints: { | |
1473 | perl 5 prints: syntax error | |
1474 | ||
418272e4 CW |
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 | ||
d52dc02a | 1482 | =item * Interpolation of C<\$$foo{bar}> |
6dbacca0 | 1483 | |
d52dc02a | 1484 | Similarly, watch out for: C<\$$foo{bar}> |
6dbacca0 | 1485 | |
9fda99eb | 1486 | $foo = "baz"; |
6dbacca0 | 1487 | print "\$$foo{bar}\n"; |
54310121 | 1488 | |
9fda99eb | 1489 | # perl4 prints: $baz{bar} |
6dbacca0 | 1490 | # perl5 prints: $ |
1491 | ||
9fda99eb DC |
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 | |
6dbacca0 | 1494 | especially in C<eval>'s. |
1495 | ||
d52dc02a | 1496 | =item * C<qq()> string passed to C<eval> will not find string terminator |
6dbacca0 | 1497 | |
1498 | C<qq()> string passed to C<eval> | |
1499 | ||
1500 | eval qq( | |
1501 | foreach \$y (keys %\$x\) { | |
1502 | \$count++; | |
1503 | } | |
1504 | ); | |
54310121 | 1505 | |
6dbacca0 | 1506 | # perl4 runs this ok |
54310121 | 1507 | # perl5 prints: Can't find string terminator ")" |
a0d0e21e | 1508 | |
6dbacca0 | 1509 | =back |
1510 | ||
1511 | =head2 DBM Traps | |
1512 | ||
1513 | General DBM traps. | |
1514 | ||
1515 | =over 5 | |
1516 | ||
ba0dd969 | 1517 | =item * Perl5 must have been linked with same dbm/ndbm as the default for C<dbmopen()> |
6dbacca0 | 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 | ||
ba0dd969 | 1531 | =item * DBM exceeding limit on the key/value size will cause perl5 to exit immediately |
6dbacca0 | 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. | |
a0d0e21e LW |
1548 | |
1549 | =back | |
6dbacca0 | 1550 | |
1551 | =head2 Unclassified Traps | |
1552 | ||
1553 | Everything else. | |
1554 | ||
84dc3c4d | 1555 | =over 5 |
1556 | ||
5db417f7 | 1557 | =item * C<require>/C<do> trap using returned value |
6dbacca0 | 1558 | |
1559 | If the file doit.pl has: | |
1560 | ||
1561 | sub foo { | |
1562 | $rc = do "./do.pl"; | |
1563 | return 8; | |
54310121 | 1564 | } |
6dbacca0 | 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) | |
54310121 | 1574 | # perl 5 prints: 8 |
6dbacca0 | 1575 | |
1576 | Same behavior if you replace C<do> with C<require>. | |
1577 | ||
5db417f7 TB |
1578 | =item * C<split> on empty string with LIMIT specified |
1579 | ||
9fda99eb | 1580 | $string = ''; |
5db417f7 TB |
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 | ||
6dbacca0 | 1586 | =back |
1587 | ||
54310121 | 1588 | As always, if any of these are ever officially declared as bugs, |
6dbacca0 | 1589 | they'll be fixed and removed. |
1590 |