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