[ Index ]

PHP Cross Reference of Unnamed Project

title

Body

[close]

/se3-unattended/var/se3/unattended/install/linuxaux/opt/perl/lib/5.10.0/pod/ -> perlfaq7.pod (source)

   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  


Generated: Tue Mar 17 22:47:18 2015 Cross-referenced by PHPXref 0.7.1