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