| [ Index ] |
PHP Cross Reference of Unnamed Project |
[Summary view] [Print] [Text view]
1 =head1 NAME 2 3 perlfaq7 - General Perl Language Issues ($Revision: 10100 $) 4 5 =head1 DESCRIPTION 6 7 This section deals with general Perl language issues that don't 8 clearly fit into any of the other sections. 9 10 =head2 Can I get a BNF/yacc/RE for the Perl language? 11 12 There is no BNF, but you can paw your way through the yacc grammar in 13 perly.y in the source distribution if you're particularly brave. The 14 grammar relies on very smart tokenizing code, so be prepared to 15 venture into toke.c as well. 16 17 In the words of Chaim Frenkel: "Perl's grammar can not be reduced to BNF. 18 The work of parsing perl is distributed between yacc, the lexer, smoke 19 and mirrors." 20 21 =head2 What are all these $@%&* punctuation signs, and how do I know when to use them? 22 23 They are type specifiers, as detailed in L<perldata>: 24 25 $ for scalar values (number, string or reference) 26 @ for arrays 27 % for hashes (associative arrays) 28 & for subroutines (aka functions, procedures, methods) 29 * for all types of that symbol name. In version 4 you used them like 30 pointers, but in modern perls you can just use references. 31 32 There are couple of other symbols that you're likely to encounter that aren't 33 really type specifiers: 34 35 <> are used for inputting a record from a filehandle. 36 \ takes a reference to something. 37 38 Note that <FILE> is I<neither> the type specifier for files 39 nor the name of the handle. It is the C<< <> >> operator applied 40 to the handle FILE. It reads one line (well, record--see 41 L<perlvar/$E<sol>>) from the handle FILE in scalar context, or I<all> lines 42 in list context. When performing open, close, or any other operation 43 besides C<< <> >> on files, or even when talking about the handle, do 44 I<not> use the brackets. These are correct: C<eof(FH)>, C<seek(FH, 0, 45 2)> and "copying from STDIN to FILE". 46 47 =head2 Do I always/never have to quote my strings or use semicolons and commas? 48 49 Normally, a bareword doesn't need to be quoted, but in most cases 50 probably should be (and must be under C<use strict>). But a hash key 51 consisting of a simple word (that isn't the name of a defined 52 subroutine) and the left-hand operand to the C<< => >> operator both 53 count as though they were quoted: 54 55 This is like this 56 ------------ --------------- 57 $foo{line} $foo{'line'} 58 bar => stuff 'bar' => stuff 59 60 The final semicolon in a block is optional, as is the final comma in a 61 list. Good style (see L<perlstyle>) says to put them in except for 62 one-liners: 63 64 if ($whoops) { exit 1 } 65 @nums = (1, 2, 3); 66 67 if ($whoops) { 68 exit 1; 69 } 70 71 @lines = ( 72 "There Beren came from mountains cold", 73 "And lost he wandered under leaves", 74 ); 75 76 =head2 How do I skip some return values? 77 78 One way is to treat the return values as a list and index into it: 79 80 $dir = (getpwnam($user))[7]; 81 82 Another way is to use undef as an element on the left-hand-side: 83 84 ($dev, $ino, undef, undef, $uid, $gid) = stat($file); 85 86 You can also use a list slice to select only the elements that 87 you need: 88 89 ($dev, $ino, $uid, $gid) = ( stat($file) )[0,1,4,5]; 90 91 =head2 How do I temporarily block warnings? 92 93 If you are running Perl 5.6.0 or better, the C<use warnings> pragma 94 allows fine control of what warning are produced. 95 See L<perllexwarn> for more details. 96 97 { 98 no warnings; # temporarily turn off warnings 99 $a = $b + $c; # I know these might be undef 100 } 101 102 Additionally, you can enable and disable categories of warnings. 103 You turn off the categories you want to ignore and you can still 104 get other categories of warnings. See L<perllexwarn> for the 105 complete details, including the category names and hierarchy. 106 107 { 108 no warnings 'uninitialized'; 109 $a = $b + $c; 110 } 111 112 If you have an older version of Perl, the C<$^W> variable (documented 113 in L<perlvar>) controls runtime warnings for a block: 114 115 { 116 local $^W = 0; # temporarily turn off warnings 117 $a = $b + $c; # I know these might be undef 118 } 119 120 Note that like all the punctuation variables, you cannot currently 121 use my() on C<$^W>, only local(). 122 123 =head2 What's an extension? 124 125 An extension is a way of calling compiled C code from Perl. Reading 126 L<perlxstut> is a good place to learn more about extensions. 127 128 =head2 Why do Perl operators have different precedence than C operators? 129 130 Actually, they don't. All C operators that Perl copies have the same 131 precedence in Perl as they do in C. The problem is with operators that C 132 doesn't have, especially functions that give a list context to everything 133 on their right, eg. print, chmod, exec, and so on. Such functions are 134 called "list operators" and appear as such in the precedence table in 135 L<perlop>. 136 137 A common mistake is to write: 138 139 unlink $file || die "snafu"; 140 141 This gets interpreted as: 142 143 unlink ($file || die "snafu"); 144 145 To avoid this problem, either put in extra parentheses or use the 146 super low precedence C<or> operator: 147 148 (unlink $file) || die "snafu"; 149 unlink $file or die "snafu"; 150 151 The "English" operators (C<and>, C<or>, C<xor>, and C<not>) 152 deliberately have precedence lower than that of list operators for 153 just such situations as the one above. 154 155 Another operator with surprising precedence is exponentiation. It 156 binds more tightly even than unary minus, making C<-2**2> product a 157 negative not a positive four. It is also right-associating, meaning 158 that C<2**3**2> is two raised to the ninth power, not eight squared. 159 160 Although it has the same precedence as in C, Perl's C<?:> operator 161 produces an lvalue. This assigns $x to either $a or $b, depending 162 on the trueness of $maybe: 163 164 ($maybe ? $a : $b) = $x; 165 166 =head2 How do I declare/create a structure? 167 168 In general, you don't "declare" a structure. Just use a (probably 169 anonymous) hash reference. See L<perlref> and L<perldsc> for details. 170 Here's an example: 171 172 $person = {}; # new anonymous hash 173 $person->{AGE} = 24; # set field AGE to 24 174 $person->{NAME} = "Nat"; # set field NAME to "Nat" 175 176 If you're looking for something a bit more rigorous, try L<perltoot>. 177 178 =head2 How do I create a module? 179 180 (contributed by brian d foy) 181 182 L<perlmod>, L<perlmodlib>, L<perlmodstyle> explain modules 183 in all the gory details. L<perlnewmod> gives a brief 184 overview of the process along with a couple of suggestions 185 about style. 186 187 If you need to include C code or C library interfaces in 188 your module, you'll need h2xs. h2xs will create the module 189 distribution structure and the initial interface files 190 you'll need. L<perlxs> and L<perlxstut> explain the details. 191 192 If you don't need to use C code, other tools such as 193 ExtUtils::ModuleMaker and Module::Starter, can help you 194 create a skeleton module distribution. 195 196 You may also want to see Sam Tregar's "Writing Perl Modules 197 for CPAN" ( http://apress.com/book/bookDisplay.html?bID=14 ) 198 which is the best hands-on guide to creating module 199 distributions. 200 201 =head2 How do I adopt or take over a module already on CPAN? 202 203 (contributed by brian d foy) 204 205 The easiest way to take over a module is to have the current 206 module maintainer either make you a co-maintainer or transfer 207 the module to you. 208 209 If you can't reach the author for some reason (e.g. email bounces), 210 the PAUSE admins at modules@perl.org can help. The PAUSE admins 211 treat each case individually. 212 213 =over 4 214 215 =item 216 217 Get a login for the Perl Authors Upload Server (PAUSE) if you don't 218 already have one: http://pause.perl.org 219 220 =item 221 222 Write to modules@perl.org explaining what you did to contact the 223 current maintainer. The PAUSE admins will also try to reach the 224 maintainer. 225 226 =item 227 228 Post a public message in a heavily trafficked site announcing your 229 intention to take over the module. 230 231 =item 232 233 Wait a bit. The PAUSE admins don't want to act too quickly in case 234 the current maintainer is on holiday. If there's no response to 235 private communication or the public post, a PAUSE admin can transfer 236 it to you. 237 238 =back 239 240 =head2 How do I create a class? 241 242 See L<perltoot> for an introduction to classes and objects, as well as 243 L<perlobj> and L<perlbot>. 244 245 =head2 How can I tell if a variable is tainted? 246 247 You can use the tainted() function of the Scalar::Util module, available 248 from CPAN (or included with Perl since release 5.8.0). 249 See also L<perlsec/"Laundering and Detecting Tainted Data">. 250 251 =head2 What's a closure? 252 253 Closures are documented in L<perlref>. 254 255 I<Closure> is a computer science term with a precise but 256 hard-to-explain meaning. Usually, closures are implemented in Perl as 257 anonymous subroutines with lasting references to lexical variables 258 outside their own scopes. These lexicals magically refer to the 259 variables that were around when the subroutine was defined (deep 260 binding). 261 262 Closures are most often used in programming languages where you can 263 have the return value of a function be itself a function, as you can 264 in Perl. Note that some languages provide anonymous functions but are 265 not capable of providing proper closures: the Python language, for 266 example. For more information on closures, check out any textbook on 267 functional programming. Scheme is a language that not only supports 268 but encourages closures. 269 270 Here's a classic non-closure function-generating function: 271 272 sub add_function_generator { 273 return sub { shift() + shift() }; 274 } 275 276 $add_sub = add_function_generator(); 277 $sum = $add_sub->(4,5); # $sum is 9 now. 278 279 The anonymous subroutine returned by add_function_generator() isn't 280 technically a closure because it refers to no lexicals outside its own 281 scope. Using a closure gives you a I<function template> with some 282 customization slots left out to be filled later. 283 284 Contrast this with the following make_adder() function, in which the 285 returned anonymous function contains a reference to a lexical variable 286 outside the scope of that function itself. Such a reference requires 287 that Perl return a proper closure, thus locking in for all time the 288 value that the lexical had when the function was created. 289 290 sub make_adder { 291 my $addpiece = shift; 292 return sub { shift() + $addpiece }; 293 } 294 295 $f1 = make_adder(20); 296 $f2 = make_adder(555); 297 298 Now C<&$f1($n)> is always 20 plus whatever $n you pass in, whereas 299 C<&$f2($n)> is always 555 plus whatever $n you pass in. The $addpiece 300 in the closure sticks around. 301 302 Closures are often used for less esoteric purposes. For example, when 303 you want to pass in a bit of code into a function: 304 305 my $line; 306 timeout( 30, sub { $line = <STDIN> } ); 307 308 If the code to execute had been passed in as a string, 309 C<< '$line = <STDIN>' >>, there would have been no way for the 310 hypothetical timeout() function to access the lexical variable 311 $line back in its caller's scope. 312 313 Another use for a closure is to make a variable I<private> to a 314 named subroutine, e.g. a counter that gets initialized at creation 315 time of the sub and can only be modified from within the sub. 316 This is sometimes used with a BEGIN block in package files to make 317 sure a variable doesn't get meddled with during the lifetime of the 318 package: 319 320 BEGIN { 321 my $id = 0; 322 sub next_id { ++$id } 323 } 324 325 This is discussed in more detail in L<perlsub>, see the entry on 326 I<Persistent Private Variables>. 327 328 =head2 What is variable suicide and how can I prevent it? 329 330 This problem was fixed in perl 5.004_05, so preventing it means upgrading 331 your version of perl. ;) 332 333 Variable suicide is when you (temporarily or permanently) lose the value 334 of a variable. It is caused by scoping through my() and local() 335 interacting with either closures or aliased foreach() iterator variables 336 and subroutine arguments. It used to be easy to inadvertently lose a 337 variable's value this way, but now it's much harder. Take this code: 338 339 my $f = 'foo'; 340 sub T { 341 while ($i++ < 3) { my $f = $f; $f .= "bar"; print $f, "\n" } 342 } 343 344 T; 345 print "Finally $f\n"; 346 347 If you are experiencing variable suicide, that C<my $f> in the subroutine 348 doesn't pick up a fresh copy of the C<$f> whose value is <foo>. The output 349 shows that inside the subroutine the value of C<$f> leaks through when it 350 shouldn't, as in this output: 351 352 foobar 353 foobarbar 354 foobarbarbar 355 Finally foo 356 357 The $f that has "bar" added to it three times should be a new C<$f> 358 C<my $f> should create a new lexical variable each time through the loop. 359 The expected output is: 360 361 foobar 362 foobar 363 foobar 364 Finally foo 365 366 =head2 How can I pass/return a {Function, FileHandle, Array, Hash, Method, Regex}? 367 368 With the exception of regexes, you need to pass references to these 369 objects. See L<perlsub/"Pass by Reference"> for this particular 370 question, and L<perlref> for information on references. 371 372 See "Passing Regexes", later in L<perlfaq7>, for information on 373 passing regular expressions. 374 375 =over 4 376 377 =item Passing Variables and Functions 378 379 Regular variables and functions are quite easy to pass: just pass in a 380 reference to an existing or anonymous variable or function: 381 382 func( \$some_scalar ); 383 384 func( \@some_array ); 385 func( [ 1 .. 10 ] ); 386 387 func( \%some_hash ); 388 func( { this => 10, that => 20 } ); 389 390 func( \&some_func ); 391 func( sub { $_[0] ** $_[1] } ); 392 393 =item Passing Filehandles 394 395 As of Perl 5.6, you can represent filehandles with scalar variables 396 which you treat as any other scalar. 397 398 open my $fh, $filename or die "Cannot open $filename! $!"; 399 func( $fh ); 400 401 sub func { 402 my $passed_fh = shift; 403 404 my $line = <$passed_fh>; 405 } 406 407 Before Perl 5.6, you had to use the C<*FH> or C<\*FH> notations. 408 These are "typeglobs"--see L<perldata/"Typeglobs and Filehandles"> 409 and especially L<perlsub/"Pass by Reference"> for more information. 410 411 =item Passing Regexes 412 413 To pass regexes around, you'll need to be using a release of Perl 414 sufficiently recent as to support the C<qr//> construct, pass around 415 strings and use an exception-trapping eval, or else be very, very clever. 416 417 Here's an example of how to pass in a string to be regex compared 418 using C<qr//>: 419 420 sub compare($$) { 421 my ($val1, $regex) = @_; 422 my $retval = $val1 =~ /$regex/; 423 return $retval; 424 } 425 $match = compare("old McDonald", qr/d.*D/i); 426 427 Notice how C<qr//> allows flags at the end. That pattern was compiled 428 at compile time, although it was executed later. The nifty C<qr//> 429 notation wasn't introduced until the 5.005 release. Before that, you 430 had to approach this problem much less intuitively. For example, here 431 it is again if you don't have C<qr//>: 432 433 sub compare($$) { 434 my ($val1, $regex) = @_; 435 my $retval = eval { $val1 =~ /$regex/ }; 436 die if $@; 437 return $retval; 438 } 439 440 $match = compare("old McDonald", q/($?i)d.*D/); 441 442 Make sure you never say something like this: 443 444 return eval "\$val =~ /$regex/"; # WRONG 445 446 or someone can sneak shell escapes into the regex due to the double 447 interpolation of the eval and the double-quoted string. For example: 448 449 $pattern_of_evil = 'danger ${ system("rm -rf * &") } danger'; 450 451 eval "\$string =~ /$pattern_of_evil/"; 452 453 Those preferring to be very, very clever might see the O'Reilly book, 454 I<Mastering Regular Expressions>, by Jeffrey Friedl. Page 273's 455 Build_MatchMany_Function() is particularly interesting. A complete 456 citation of this book is given in L<perlfaq2>. 457 458 =item Passing Methods 459 460 To pass an object method into a subroutine, you can do this: 461 462 call_a_lot(10, $some_obj, "methname") 463 sub call_a_lot { 464 my ($count, $widget, $trick) = @_; 465 for (my $i = 0; $i < $count; $i++) { 466 $widget->$trick(); 467 } 468 } 469 470 Or, you can use a closure to bundle up the object, its 471 method call, and arguments: 472 473 my $whatnot = sub { $some_obj->obfuscate(@args) }; 474 func($whatnot); 475 sub func { 476 my $code = shift; 477 &$code(); 478 } 479 480 You could also investigate the can() method in the UNIVERSAL class 481 (part of the standard perl distribution). 482 483 =back 484 485 =head2 How do I create a static variable? 486 487 (contributed by brian d foy) 488 489 Perl doesn't have "static" variables, which can only be accessed from 490 the function in which they are declared. You can get the same effect 491 with lexical variables, though. 492 493 You can fake a static variable by using a lexical variable which goes 494 out of scope. In this example, you define the subroutine C<counter>, and 495 it uses the lexical variable C<$count>. Since you wrap this in a BEGIN 496 block, C<$count> is defined at compile-time, but also goes out of 497 scope at the end of the BEGIN block. The BEGIN block also ensures that 498 the subroutine and the value it uses is defined at compile-time so the 499 subroutine is ready to use just like any other subroutine, and you can 500 put this code in the same place as other subroutines in the program 501 text (i.e. at the end of the code, typically). The subroutine 502 C<counter> still has a reference to the data, and is the only way you 503 can access the value (and each time you do, you increment the value). 504 The data in chunk of memory defined by C<$count> is private to 505 C<counter>. 506 507 BEGIN { 508 my $count = 1; 509 sub counter { $count++ } 510 } 511 512 my $start = counter(); 513 514 .... # code that calls counter(); 515 516 my $end = counter(); 517 518 In the previous example, you created a function-private variable 519 because only one function remembered its reference. You could define 520 multiple functions while the variable is in scope, and each function 521 can share the "private" variable. It's not really "static" because you 522 can access it outside the function while the lexical variable is in 523 scope, and even create references to it. In this example, 524 C<increment_count> and C<return_count> share the variable. One 525 function adds to the value and the other simply returns the value. 526 They can both access C<$count>, and since it has gone out of scope, 527 there is no other way to access it. 528 529 BEGIN { 530 my $count = 1; 531 sub increment_count { $count++ } 532 sub return_count { $count } 533 } 534 535 To declare a file-private variable, you still use a lexical variable. 536 A file is also a scope, so a lexical variable defined in the file 537 cannot be seen from any other file. 538 539 See L<perlsub/"Persistent Private Variables"> for more information. 540 The discussion of closures in L<perlref> may help you even though we 541 did not use anonymous subroutines in this answer. See 542 L<perlsub/"Persistent Private Variables"> for details. 543 544 =head2 What's the difference between dynamic and lexical (static) scoping? Between local() and my()? 545 546 C<local($x)> saves away the old value of the global variable C<$x> 547 and assigns a new value for the duration of the subroutine I<which is 548 visible in other functions called from that subroutine>. This is done 549 at run-time, so is called dynamic scoping. local() always affects global 550 variables, also called package variables or dynamic variables. 551 552 C<my($x)> creates a new variable that is only visible in the current 553 subroutine. This is done at compile-time, so it is called lexical or 554 static scoping. my() always affects private variables, also called 555 lexical variables or (improperly) static(ly scoped) variables. 556 557 For instance: 558 559 sub visible { 560 print "var has value $var\n"; 561 } 562 563 sub dynamic { 564 local $var = 'local'; # new temporary value for the still-global 565 visible(); # variable called $var 566 } 567 568 sub lexical { 569 my $var = 'private'; # new private variable, $var 570 visible(); # (invisible outside of sub scope) 571 } 572 573 $var = 'global'; 574 575 visible(); # prints global 576 dynamic(); # prints local 577 lexical(); # prints global 578 579 Notice how at no point does the value "private" get printed. That's 580 because $var only has that value within the block of the lexical() 581 function, and it is hidden from called subroutine. 582 583 In summary, local() doesn't make what you think of as private, local 584 variables. It gives a global variable a temporary value. my() is 585 what you're looking for if you want private variables. 586 587 See L<perlsub/"Private Variables via my()"> and 588 L<perlsub/"Temporary Values via local()"> for excruciating details. 589 590 =head2 How can I access a dynamic variable while a similarly named lexical is in scope? 591 592 If you know your package, you can just mention it explicitly, as in 593 $Some_Pack::var. Note that the notation $::var is B<not> the dynamic $var 594 in the current package, but rather the one in the "main" package, as 595 though you had written $main::var. 596 597 use vars '$var'; 598 local $var = "global"; 599 my $var = "lexical"; 600 601 print "lexical is $var\n"; 602 print "global is $main::var\n"; 603 604 Alternatively you can use the compiler directive our() to bring a 605 dynamic variable into the current lexical scope. 606 607 require 5.006; # our() did not exist before 5.6 608 use vars '$var'; 609 610 local $var = "global"; 611 my $var = "lexical"; 612 613 print "lexical is $var\n"; 614 615 { 616 our $var; 617 print "global is $var\n"; 618 } 619 620 =head2 What's the difference between deep and shallow binding? 621 622 In deep binding, lexical variables mentioned in anonymous subroutines 623 are the same ones that were in scope when the subroutine was created. 624 In shallow binding, they are whichever variables with the same names 625 happen to be in scope when the subroutine is called. Perl always uses 626 deep binding of lexical variables (i.e., those created with my()). 627 However, dynamic variables (aka global, local, or package variables) 628 are effectively shallowly bound. Consider this just one more reason 629 not to use them. See the answer to L<"What's a closure?">. 630 631 =head2 Why doesn't "my($foo) = E<lt>FILEE<gt>;" work right? 632 633 C<my()> and C<local()> give list context to the right hand side 634 of C<=>. The <FH> read operation, like so many of Perl's 635 functions and operators, can tell which context it was called in and 636 behaves appropriately. In general, the scalar() function can help. 637 This function does nothing to the data itself (contrary to popular myth) 638 but rather tells its argument to behave in whatever its scalar fashion is. 639 If that function doesn't have a defined scalar behavior, this of course 640 doesn't help you (such as with sort()). 641 642 To enforce scalar context in this particular case, however, you need 643 merely omit the parentheses: 644 645 local($foo) = <FILE>; # WRONG 646 local($foo) = scalar(<FILE>); # ok 647 local $foo = <FILE>; # right 648 649 You should probably be using lexical variables anyway, although the 650 issue is the same here: 651 652 my($foo) = <FILE>; # WRONG 653 my $foo = <FILE>; # right 654 655 =head2 How do I redefine a builtin function, operator, or method? 656 657 Why do you want to do that? :-) 658 659 If you want to override a predefined function, such as open(), 660 then you'll have to import the new definition from a different 661 module. See L<perlsub/"Overriding Built-in Functions">. There's 662 also an example in L<perltoot/"Class::Template">. 663 664 If you want to overload a Perl operator, such as C<+> or C<**>, 665 then you'll want to use the C<use overload> pragma, documented 666 in L<overload>. 667 668 If you're talking about obscuring method calls in parent classes, 669 see L<perltoot/"Overridden Methods">. 670 671 =head2 What's the difference between calling a function as &foo and foo()? 672 673 When you call a function as C<&foo>, you allow that function access to 674 your current @_ values, and you bypass prototypes. 675 The function doesn't get an empty @_--it gets yours! While not 676 strictly speaking a bug (it's documented that way in L<perlsub>), it 677 would be hard to consider this a feature in most cases. 678 679 When you call your function as C<&foo()>, then you I<do> get a new @_, 680 but prototyping is still circumvented. 681 682 Normally, you want to call a function using C<foo()>. You may only 683 omit the parentheses if the function is already known to the compiler 684 because it already saw the definition (C<use> but not C<require>), 685 or via a forward reference or C<use subs> declaration. Even in this 686 case, you get a clean @_ without any of the old values leaking through 687 where they don't belong. 688 689 =head2 How do I create a switch or case statement? 690 691 If one wants to use pure Perl and to be compatible with Perl versions 692 prior to 5.10, the general answer is to write a construct like this: 693 694 for ($variable_to_test) { 695 if (/pat1/) { } # do something 696 elsif (/pat2/) { } # do something else 697 elsif (/pat3/) { } # do something else 698 else { } # default 699 } 700 701 Here's a simple example of a switch based on pattern matching, 702 lined up in a way to make it look more like a switch statement. 703 We'll do a multiway conditional based on the type of reference stored 704 in $whatchamacallit: 705 706 SWITCH: for (ref $whatchamacallit) { 707 708 /^$/ && die "not a reference"; 709 710 /SCALAR/ && do { 711 print_scalar($$ref); 712 last SWITCH; 713 }; 714 715 /ARRAY/ && do { 716 print_array(@$ref); 717 last SWITCH; 718 }; 719 720 /HASH/ && do { 721 print_hash(%$ref); 722 last SWITCH; 723 }; 724 725 /CODE/ && do { 726 warn "can't print function ref"; 727 last SWITCH; 728 }; 729 730 # DEFAULT 731 732 warn "User defined type skipped"; 733 734 } 735 736 See L<perlsyn> for other examples in this style. 737 738 Sometimes you should change the positions of the constant and the variable. 739 For example, let's say you wanted to test which of many answers you were 740 given, but in a case-insensitive way that also allows abbreviations. 741 You can use the following technique if the strings all start with 742 different characters or if you want to arrange the matches so that 743 one takes precedence over another, as C<"SEND"> has precedence over 744 C<"STOP"> here: 745 746 chomp($answer = <>); 747 if ("SEND" =~ /^\Q$answer/i) { print "Action is send\n" } 748 elsif ("STOP" =~ /^\Q$answer/i) { print "Action is stop\n" } 749 elsif ("ABORT" =~ /^\Q$answer/i) { print "Action is abort\n" } 750 elsif ("LIST" =~ /^\Q$answer/i) { print "Action is list\n" } 751 elsif ("EDIT" =~ /^\Q$answer/i) { print "Action is edit\n" } 752 753 A totally different approach is to create a hash of function references. 754 755 my %commands = ( 756 "happy" => \&joy, 757 "sad", => \&sullen, 758 "done" => sub { die "See ya!" }, 759 "mad" => \&angry, 760 ); 761 762 print "How are you? "; 763 chomp($string = <STDIN>); 764 if ($commands{$string}) { 765 $commands{$string}->(); 766 } else { 767 print "No such command: $string\n"; 768 } 769 770 Note that starting from version 5.10, Perl has now a native switch 771 statement. See L<perlsyn>. 772 773 Starting from Perl 5.8, a source filter module, C<Switch>, can also be 774 used to get switch and case. Its use is now discouraged, because it's 775 not fully compatible with the native switch of Perl 5.10, and because, 776 as it's implemented as a source filter, it doesn't always work as intended 777 when complex syntax is involved. 778 779 =head2 How can I catch accesses to undefined variables, functions, or methods? 780 781 The AUTOLOAD method, discussed in L<perlsub/"Autoloading"> and 782 L<perltoot/"AUTOLOAD: Proxy Methods">, lets you capture calls to 783 undefined functions and methods. 784 785 When it comes to undefined variables that would trigger a warning 786 under C<use warnings>, you can promote the warning to an error. 787 788 use warnings FATAL => qw(uninitialized); 789 790 =head2 Why can't a method included in this same file be found? 791 792 Some possible reasons: your inheritance is getting confused, you've 793 misspelled the method name, or the object is of the wrong type. Check 794 out L<perltoot> for details about any of the above cases. You may 795 also use C<print ref($object)> to find out the class C<$object> was 796 blessed into. 797 798 Another possible reason for problems is because you've used the 799 indirect object syntax (eg, C<find Guru "Samy">) on a class name 800 before Perl has seen that such a package exists. It's wisest to make 801 sure your packages are all defined before you start using them, which 802 will be taken care of if you use the C<use> statement instead of 803 C<require>. If not, make sure to use arrow notation (eg., 804 C<< Guru->find("Samy") >>) instead. Object notation is explained in 805 L<perlobj>. 806 807 Make sure to read about creating modules in L<perlmod> and 808 the perils of indirect objects in L<perlobj/"Method Invocation">. 809 810 =head2 How can I find out my current package? 811 812 If you're just a random program, you can do this to find 813 out what the currently compiled package is: 814 815 my $packname = __PACKAGE__; 816 817 But, if you're a method and you want to print an error message 818 that includes the kind of object you were called on (which is 819 not necessarily the same as the one in which you were compiled): 820 821 sub amethod { 822 my $self = shift; 823 my $class = ref($self) || $self; 824 warn "called me from a $class object"; 825 } 826 827 =head2 How can I comment out a large block of perl code? 828 829 You can use embedded POD to discard it. Enclose the blocks you want 830 to comment out in POD markers. The <=begin> directive marks a section 831 for a specific formatter. Use the C<comment> format, which no formatter 832 should claim to understand (by policy). Mark the end of the block 833 with <=end>. 834 835 # program is here 836 837 =begin comment 838 839 all of this stuff 840 841 here will be ignored 842 by everyone 843 844 =end comment 845 846 =cut 847 848 # program continues 849 850 The pod directives cannot go just anywhere. You must put a 851 pod directive where the parser is expecting a new statement, 852 not just in the middle of an expression or some other 853 arbitrary grammar production. 854 855 See L<perlpod> for more details. 856 857 =head2 How do I clear a package? 858 859 Use this code, provided by Mark-Jason Dominus: 860 861 sub scrub_package { 862 no strict 'refs'; 863 my $pack = shift; 864 die "Shouldn't delete main package" 865 if $pack eq "" || $pack eq "main"; 866 my $stash = *{$pack . '::'}{HASH}; 867 my $name; 868 foreach $name (keys %$stash) { 869 my $fullname = $pack . '::' . $name; 870 # Get rid of everything with that name. 871 undef $$fullname; 872 undef @$fullname; 873 undef %$fullname; 874 undef &$fullname; 875 undef *$fullname; 876 } 877 } 878 879 Or, if you're using a recent release of Perl, you can 880 just use the Symbol::delete_package() function instead. 881 882 =head2 How can I use a variable as a variable name? 883 884 Beginners often think they want to have a variable contain the name 885 of a variable. 886 887 $fred = 23; 888 $varname = "fred"; 889 ++$$varname; # $fred now 24 890 891 This works I<sometimes>, but it is a very bad idea for two reasons. 892 893 The first reason is that this technique I<only works on global 894 variables>. That means that if $fred is a lexical variable created 895 with my() in the above example, the code wouldn't work at all: you'd 896 accidentally access the global and skip right over the private lexical 897 altogether. Global variables are bad because they can easily collide 898 accidentally and in general make for non-scalable and confusing code. 899 900 Symbolic references are forbidden under the C<use strict> pragma. 901 They are not true references and consequently are not reference counted 902 or garbage collected. 903 904 The other reason why using a variable to hold the name of another 905 variable is a bad idea is that the question often stems from a lack of 906 understanding of Perl data structures, particularly hashes. By using 907 symbolic references, you are just using the package's symbol-table hash 908 (like C<%main::>) instead of a user-defined hash. The solution is to 909 use your own hash or a real reference instead. 910 911 $USER_VARS{"fred"} = 23; 912 $varname = "fred"; 913 $USER_VARS{$varname}++; # not $$varname++ 914 915 There we're using the %USER_VARS hash instead of symbolic references. 916 Sometimes this comes up in reading strings from the user with variable 917 references and wanting to expand them to the values of your perl 918 program's variables. This is also a bad idea because it conflates the 919 program-addressable namespace and the user-addressable one. Instead of 920 reading a string and expanding it to the actual contents of your program's 921 own variables: 922 923 $str = 'this has a $fred and $barney in it'; 924 $str =~ s/(\$\w+)/$1/eeg; # need double eval 925 926 it would be better to keep a hash around like %USER_VARS and have 927 variable references actually refer to entries in that hash: 928 929 $str =~ s/\$(\w+)/$USER_VARS{$1}/g; # no /e here at all 930 931 That's faster, cleaner, and safer than the previous approach. Of course, 932 you don't need to use a dollar sign. You could use your own scheme to 933 make it less confusing, like bracketed percent symbols, etc. 934 935 $str = 'this has a %fred% and %barney% in it'; 936 $str =~ s/%(\w+)%/$USER_VARS{$1}/g; # no /e here at all 937 938 Another reason that folks sometimes think they want a variable to 939 contain the name of a variable is because they don't know how to build 940 proper data structures using hashes. For example, let's say they 941 wanted two hashes in their program: %fred and %barney, and that they 942 wanted to use another scalar variable to refer to those by name. 943 944 $name = "fred"; 945 $$name{WIFE} = "wilma"; # set %fred 946 947 $name = "barney"; 948 $$name{WIFE} = "betty"; # set %barney 949 950 This is still a symbolic reference, and is still saddled with the 951 problems enumerated above. It would be far better to write: 952 953 $folks{"fred"}{WIFE} = "wilma"; 954 $folks{"barney"}{WIFE} = "betty"; 955 956 And just use a multilevel hash to start with. 957 958 The only times that you absolutely I<must> use symbolic references are 959 when you really must refer to the symbol table. This may be because it's 960 something that can't take a real reference to, such as a format name. 961 Doing so may also be important for method calls, since these always go 962 through the symbol table for resolution. 963 964 In those cases, you would turn off C<strict 'refs'> temporarily so you 965 can play around with the symbol table. For example: 966 967 @colors = qw(red blue green yellow orange purple violet); 968 for my $name (@colors) { 969 no strict 'refs'; # renege for the block 970 *$name = sub { "<FONT COLOR='$name'>@_</FONT>" }; 971 } 972 973 All those functions (red(), blue(), green(), etc.) appear to be separate, 974 but the real code in the closure actually was compiled only once. 975 976 So, sometimes you might want to use symbolic references to directly 977 manipulate the symbol table. This doesn't matter for formats, handles, and 978 subroutines, because they are always global--you can't use my() on them. 979 For scalars, arrays, and hashes, though--and usually for subroutines-- 980 you probably only want to use hard references. 981 982 =head2 What does "bad interpreter" mean? 983 984 (contributed by brian d foy) 985 986 The "bad interpreter" message comes from the shell, not perl. The 987 actual message may vary depending on your platform, shell, and locale 988 settings. 989 990 If you see "bad interpreter - no such file or directory", the first 991 line in your perl script (the "shebang" line) does not contain the 992 right path to perl (or any other program capable of running scripts). 993 Sometimes this happens when you move the script from one machine to 994 another and each machine has a different path to perl--/usr/bin/perl 995 versus /usr/local/bin/perl for instance. It may also indicate 996 that the source machine has CRLF line terminators and the 997 destination machine has LF only: the shell tries to find 998 /usr/bin/perl<CR>, but can't. 999 1000 If you see "bad interpreter: Permission denied", you need to make your 1001 script executable. 1002 1003 In either case, you should still be able to run the scripts with perl 1004 explicitly: 1005 1006 % perl script.pl 1007 1008 If you get a message like "perl: command not found", perl is not in 1009 your PATH, which might also mean that the location of perl is not 1010 where you expect it so you need to adjust your shebang line. 1011 1012 =head1 REVISION 1013 1014 Revision: $Revision: 10100 $ 1015 1016 Date: $Date: 2007-10-21 20:59:30 +0200 (Sun, 21 Oct 2007) $ 1017 1018 See L<perlfaq> for source control details and availability. 1019 1020 =head1 AUTHOR AND COPYRIGHT 1021 1022 Copyright (c) 1997-2007 Tom Christiansen, Nathan Torkington, and 1023 other authors as noted. All rights reserved. 1024 1025 This documentation is free; you can redistribute it and/or modify it 1026 under the same terms as Perl itself. 1027 1028 Irrespective of its distribution, all code examples in this file 1029 are hereby placed into the public domain. You are permitted and 1030 encouraged to use this code in your own programs for fun 1031 or for profit as you see fit. A simple comment in the code giving 1032 credit would be courteous but is not required. 1033
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
| Generated: Tue Mar 17 22:47:18 2015 | Cross-referenced by PHPXref 0.7.1 |