3 perlfaq7 - General Perl Language Issues ($Revision: 8539 $)
7 This section deals with general Perl language issues that don't
8 clearly fit into any of the other sections.
10 =head2 Can I get a BNF/yacc/RE for the Perl language?
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.
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
21 =head2 What are all these $@%&* punctuation signs, and how do I know when to use them?
23 They are type specifiers, as detailed in L<perldata>:
25 $ for scalar values (number, string or reference)
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.
32 There are couple of other symbols that you're likely to encounter that aren't
33 really type specifiers:
35 <> are used for inputting a record from a filehandle.
36 \ takes a reference to something.
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".
47 =head2 Do I always/never have to quote my strings or use semicolons and commas?
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:
56 ------------ ---------------
57 $foo{line} $foo{'line'}
58 bar => stuff 'bar' => stuff
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
64 if ($whoops) { exit 1 }
71 "There Beren came from mountains cold",
72 "And lost he wandered under leaves",
75 =head2 How do I skip some return values?
77 One way is to treat the return values as a list and index into it:
79 $dir = (getpwnam($user))[7];
81 Another way is to use undef as an element on the left-hand-side:
83 ($dev, $ino, undef, undef, $uid, $gid) = stat($file);
85 You can also use a list slice to select only the elements that
88 ($dev, $ino, $uid, $gid) = ( stat($file) )[0,1,4,5];
90 =head2 How do I temporarily block warnings?
92 If you are running Perl 5.6.0 or better, the C<use warnings> pragma
93 allows fine control of what warning are produced.
94 See L<perllexwarn> for more details.
97 no warnings; # temporarily turn off warnings
98 $a = $b + $c; # I know these might be undef
101 Additionally, you can enable and disable categories of warnings.
102 You turn off the categories you want to ignore and you can still
103 get other categories of warnings. See L<perllexwarn> for the
104 complete details, including the category names and hierarchy.
107 no warnings 'uninitialized';
111 If you have an older version of Perl, the C<$^W> variable (documented
112 in L<perlvar>) controls runtime warnings for a block:
115 local $^W = 0; # temporarily turn off warnings
116 $a = $b + $c; # I know these might be undef
119 Note that like all the punctuation variables, you cannot currently
120 use my() on C<$^W>, only local().
122 =head2 What's an extension?
124 An extension is a way of calling compiled C code from Perl. Reading
125 L<perlxstut> is a good place to learn more about extensions.
127 =head2 Why do Perl operators have different precedence than C operators?
129 Actually, they don't. All C operators that Perl copies have the same
130 precedence in Perl as they do in C. The problem is with operators that C
131 doesn't have, especially functions that give a list context to everything
132 on their right, eg. print, chmod, exec, and so on. Such functions are
133 called "list operators" and appear as such in the precedence table in
136 A common mistake is to write:
138 unlink $file || die "snafu";
140 This gets interpreted as:
142 unlink ($file || die "snafu");
144 To avoid this problem, either put in extra parentheses or use the
145 super low precedence C<or> operator:
147 (unlink $file) || die "snafu";
148 unlink $file or die "snafu";
150 The "English" operators (C<and>, C<or>, C<xor>, and C<not>)
151 deliberately have precedence lower than that of list operators for
152 just such situations as the one above.
154 Another operator with surprising precedence is exponentiation. It
155 binds more tightly even than unary minus, making C<-2**2> product a
156 negative not a positive four. It is also right-associating, meaning
157 that C<2**3**2> is two raised to the ninth power, not eight squared.
159 Although it has the same precedence as in C, Perl's C<?:> operator
160 produces an lvalue. This assigns $x to either $a or $b, depending
161 on the trueness of $maybe:
163 ($maybe ? $a : $b) = $x;
165 =head2 How do I declare/create a structure?
167 In general, you don't "declare" a structure. Just use a (probably
168 anonymous) hash reference. See L<perlref> and L<perldsc> for details.
171 $person = {}; # new anonymous hash
172 $person->{AGE} = 24; # set field AGE to 24
173 $person->{NAME} = "Nat"; # set field NAME to "Nat"
175 If you're looking for something a bit more rigorous, try L<perltoot>.
177 =head2 How do I create a module?
179 (contributed by brian d foy)
181 L<perlmod>, L<perlmodlib>, L<perlmodstyle> explain modules
182 in all the gory details. L<perlnewmod> gives a brief
183 overview of the process along with a couple of suggestions
186 If you need to include C code or C library interfaces in
187 your module, you'll need h2xs. h2xs will create the module
188 distribution structure and the initial interface files
189 you'll need. L<perlxs> and L<perlxstut> explain the details.
191 If you don't need to use C code, other tools such as
192 ExtUtils::ModuleMaker and Module::Starter, can help you
193 create a skeleton module distribution.
195 You may also want to see Sam Tregar's "Writing Perl Modules
196 for CPAN" ( http://apress.com/book/bookDisplay.html?bID=14 )
197 which is the best hands-on guide to creating module
200 =head2 How do I create a class?
202 See L<perltoot> for an introduction to classes and objects, as well as
203 L<perlobj> and L<perlbot>.
205 =head2 How can I tell if a variable is tainted?
207 You can use the tainted() function of the Scalar::Util module, available
208 from CPAN (or included with Perl since release 5.8.0).
209 See also L<perlsec/"Laundering and Detecting Tainted Data">.
211 =head2 What's a closure?
213 Closures are documented in L<perlref>.
215 I<Closure> is a computer science term with a precise but
216 hard-to-explain meaning. Usually, closures are implemented in Perl as
217 anonymous subroutines with lasting references to lexical variables
218 outside their own scopes. These lexicals magically refer to the
219 variables that were around when the subroutine was defined (deep
222 Closures are most often used in programming languages where you can
223 have the return value of a function be itself a function, as you can
224 in Perl. Note that some languages provide anonymous functions but are
225 not capable of providing proper closures: the Python language, for
226 example. For more information on closures, check out any textbook on
227 functional programming. Scheme is a language that not only supports
228 but encourages closures.
230 Here's a classic non-closure function-generating function:
232 sub add_function_generator {
233 return sub { shift() + shift() };
236 $add_sub = add_function_generator();
237 $sum = $add_sub->(4,5); # $sum is 9 now.
239 The anonymous subroutine returned by add_function_generator() isn't
240 technically a closure because it refers to no lexicals outside its own
241 scope. Using a closure gives you a I<function template> with some
242 customization slots left out to be filled later.
244 Contrast this with the following make_adder() function, in which the
245 returned anonymous function contains a reference to a lexical variable
246 outside the scope of that function itself. Such a reference requires
247 that Perl return a proper closure, thus locking in for all time the
248 value that the lexical had when the function was created.
251 my $addpiece = shift;
252 return sub { shift() + $addpiece };
255 $f1 = make_adder(20);
256 $f2 = make_adder(555);
258 Now C<&$f1($n)> is always 20 plus whatever $n you pass in, whereas
259 C<&$f2($n)> is always 555 plus whatever $n you pass in. The $addpiece
260 in the closure sticks around.
262 Closures are often used for less esoteric purposes. For example, when
263 you want to pass in a bit of code into a function:
266 timeout( 30, sub { $line = <STDIN> } );
268 If the code to execute had been passed in as a string,
269 C<< '$line = <STDIN>' >>, there would have been no way for the
270 hypothetical timeout() function to access the lexical variable
271 $line back in its caller's scope.
273 Another use for a closure is to make a variable I<private> to a
274 named subroutine, e.g. a counter that gets initialized at creation
275 time of the sub and can only be modified from within the sub.
276 This is sometimes used with a BEGIN block in package files to make
277 sure a variable doesn't get meddled with during the lifetime of the
282 sub next_id { ++$id }
285 This is discussed in more detail in L<perlsub>, see the entry on
286 I<Persistent Private Variables>.
288 =head2 What is variable suicide and how can I prevent it?
290 This problem was fixed in perl 5.004_05, so preventing it means upgrading
291 your version of perl. ;)
293 Variable suicide is when you (temporarily or permanently) lose the value
294 of a variable. It is caused by scoping through my() and local()
295 interacting with either closures or aliased foreach() iterator variables
296 and subroutine arguments. It used to be easy to inadvertently lose a
297 variable's value this way, but now it's much harder. Take this code:
301 while ($i++ < 3) { my $f = $f; $f .= "bar"; print $f, "\n" }
304 print "Finally $f\n";
306 If you are experiencing variable suicide, that C<my $f> in the subroutine
307 doesn't pick up a fresh copy of the C<$f> whose value is <foo>. The output
308 shows that inside the subroutine the value of C<$f> leaks through when it
309 shouldn't, as in this output:
316 The $f that has "bar" added to it three times should be a new C<$f>
317 C<my $f> should create a new lexical variable each time through the loop.
318 The expected output is:
325 =head2 How can I pass/return a {Function, FileHandle, Array, Hash, Method, Regex}?
327 With the exception of regexes, you need to pass references to these
328 objects. See L<perlsub/"Pass by Reference"> for this particular
329 question, and L<perlref> for information on references.
331 See "Passing Regexes", later in L<perlfaq7>, for information on
332 passing regular expressions.
336 =item Passing Variables and Functions
338 Regular variables and functions are quite easy to pass: just pass in a
339 reference to an existing or anonymous variable or function:
341 func( \$some_scalar );
343 func( \@some_array );
347 func( { this => 10, that => 20 } );
350 func( sub { $_[0] ** $_[1] } );
352 =item Passing Filehandles
354 As of Perl 5.6, you can represent filehandles with scalar variables
355 which you treat as any other scalar.
357 open my $fh, $filename or die "Cannot open $filename! $!";
361 my $passed_fh = shift;
366 Before Perl 5.6, you had to use the C<*FH> or C<\*FH> notations.
367 These are "typeglobs"--see L<perldata/"Typeglobs and Filehandles">
368 and especially L<perlsub/"Pass by Reference"> for more information.
370 =item Passing Regexes
372 To pass regexes around, you'll need to be using a release of Perl
373 sufficiently recent as to support the C<qr//> construct, pass around
374 strings and use an exception-trapping eval, or else be very, very clever.
376 Here's an example of how to pass in a string to be regex compared
380 my ($val1, $regex) = @_;
381 my $retval = $val1 =~ /$regex/;
384 $match = compare("old McDonald", qr/d.*D/i);
386 Notice how C<qr//> allows flags at the end. That pattern was compiled
387 at compile time, although it was executed later. The nifty C<qr//>
388 notation wasn't introduced until the 5.005 release. Before that, you
389 had to approach this problem much less intuitively. For example, here
390 it is again if you don't have C<qr//>:
393 my ($val1, $regex) = @_;
394 my $retval = eval { $val1 =~ /$regex/ };
399 $match = compare("old McDonald", q/($?i)d.*D/);
401 Make sure you never say something like this:
403 return eval "\$val =~ /$regex/"; # WRONG
405 or someone can sneak shell escapes into the regex due to the double
406 interpolation of the eval and the double-quoted string. For example:
408 $pattern_of_evil = 'danger ${ system("rm -rf * &") } danger';
410 eval "\$string =~ /$pattern_of_evil/";
412 Those preferring to be very, very clever might see the O'Reilly book,
413 I<Mastering Regular Expressions>, by Jeffrey Friedl. Page 273's
414 Build_MatchMany_Function() is particularly interesting. A complete
415 citation of this book is given in L<perlfaq2>.
417 =item Passing Methods
419 To pass an object method into a subroutine, you can do this:
421 call_a_lot(10, $some_obj, "methname")
423 my ($count, $widget, $trick) = @_;
424 for (my $i = 0; $i < $count; $i++) {
429 Or, you can use a closure to bundle up the object, its
430 method call, and arguments:
432 my $whatnot = sub { $some_obj->obfuscate(@args) };
439 You could also investigate the can() method in the UNIVERSAL class
440 (part of the standard perl distribution).
444 =head2 How do I create a static variable?
446 (contributed by brian d foy)
448 Perl doesn't have "static" variables, which can only be accessed from
449 the function in which they are declared. You can get the same effect
450 with lexical variables, though.
452 You can fake a static variable by using a lexical variable which goes
453 out of scope. In this example, you define the subroutine C<counter>, and
454 it uses the lexical variable C<$count>. Since you wrap this in a BEGIN
455 block, C<$count> is defined at compile-time, but also goes out of
456 scope at the end of the BEGIN block. The BEGIN block also ensures that
457 the subroutine and the value it uses is defined at compile-time so the
458 subroutine is ready to use just like any other subroutine, and you can
459 put this code in the same place as other subroutines in the program
460 text (i.e. at the end of the code, typically). The subroutine
461 C<counter> still has a reference to the data, and is the only way you
462 can access the value (and each time you do, you increment the value).
463 The data in chunk of memory defined by C<$count> is private to
468 sub counter { $count++ }
471 my $start = counter();
473 .... # code that calls counter();
477 In the previous example, you created a function-private variable
478 because only one function remembered its reference. You could define
479 multiple functions while the variable is in scope, and each function
480 can share the "private" variable. It's not really "static" because you
481 can access it outside the function while the lexical variable is in
482 scope, and even create references to it. In this example,
483 C<increment_count> and C<return_count> share the variable. One
484 function adds to the value and the other simply returns the value.
485 They can both access C<$count>, and since it has gone out of scope,
486 there is no other way to access it.
490 sub increment_count { $count++ }
491 sub return_count { $count }
494 To declare a file-private variable, you still use a lexical variable.
495 A file is also a scope, so a lexical variable defined in the file
496 cannot be seen from any other file.
498 See L<perlsub/"Persistent Private Variables"> for more information.
499 The discussion of closures in L<perlref> may help you even though we
500 did not use anonymous subroutines in this answer. See
501 L<perlsub/"Persistent Private Variables"> for details.
503 =head2 What's the difference between dynamic and lexical (static) scoping? Between local() and my()?
505 C<local($x)> saves away the old value of the global variable C<$x>
506 and assigns a new value for the duration of the subroutine I<which is
507 visible in other functions called from that subroutine>. This is done
508 at run-time, so is called dynamic scoping. local() always affects global
509 variables, also called package variables or dynamic variables.
511 C<my($x)> creates a new variable that is only visible in the current
512 subroutine. This is done at compile-time, so it is called lexical or
513 static scoping. my() always affects private variables, also called
514 lexical variables or (improperly) static(ly scoped) variables.
519 print "var has value $var\n";
523 local $var = 'local'; # new temporary value for the still-global
524 visible(); # variable called $var
528 my $var = 'private'; # new private variable, $var
529 visible(); # (invisible outside of sub scope)
534 visible(); # prints global
535 dynamic(); # prints local
536 lexical(); # prints global
538 Notice how at no point does the value "private" get printed. That's
539 because $var only has that value within the block of the lexical()
540 function, and it is hidden from called subroutine.
542 In summary, local() doesn't make what you think of as private, local
543 variables. It gives a global variable a temporary value. my() is
544 what you're looking for if you want private variables.
546 See L<perlsub/"Private Variables via my()"> and
547 L<perlsub/"Temporary Values via local()"> for excruciating details.
549 =head2 How can I access a dynamic variable while a similarly named lexical is in scope?
551 If you know your package, you can just mention it explicitly, as in
552 $Some_Pack::var. Note that the notation $::var is B<not> the dynamic $var
553 in the current package, but rather the one in the "main" package, as
554 though you had written $main::var.
557 local $var = "global";
560 print "lexical is $var\n";
561 print "global is $main::var\n";
563 Alternatively you can use the compiler directive our() to bring a
564 dynamic variable into the current lexical scope.
566 require 5.006; # our() did not exist before 5.6
569 local $var = "global";
572 print "lexical is $var\n";
576 print "global is $var\n";
579 =head2 What's the difference between deep and shallow binding?
581 In deep binding, lexical variables mentioned in anonymous subroutines
582 are the same ones that were in scope when the subroutine was created.
583 In shallow binding, they are whichever variables with the same names
584 happen to be in scope when the subroutine is called. Perl always uses
585 deep binding of lexical variables (i.e., those created with my()).
586 However, dynamic variables (aka global, local, or package variables)
587 are effectively shallowly bound. Consider this just one more reason
588 not to use them. See the answer to L<"What's a closure?">.
590 =head2 Why doesn't "my($foo) = E<lt>FILEE<gt>;" work right?
592 C<my()> and C<local()> give list context to the right hand side
593 of C<=>. The <FH> read operation, like so many of Perl's
594 functions and operators, can tell which context it was called in and
595 behaves appropriately. In general, the scalar() function can help.
596 This function does nothing to the data itself (contrary to popular myth)
597 but rather tells its argument to behave in whatever its scalar fashion is.
598 If that function doesn't have a defined scalar behavior, this of course
599 doesn't help you (such as with sort()).
601 To enforce scalar context in this particular case, however, you need
602 merely omit the parentheses:
604 local($foo) = <FILE>; # WRONG
605 local($foo) = scalar(<FILE>); # ok
606 local $foo = <FILE>; # right
608 You should probably be using lexical variables anyway, although the
609 issue is the same here:
611 my($foo) = <FILE>; # WRONG
612 my $foo = <FILE>; # right
614 =head2 How do I redefine a builtin function, operator, or method?
616 Why do you want to do that? :-)
618 If you want to override a predefined function, such as open(),
619 then you'll have to import the new definition from a different
620 module. See L<perlsub/"Overriding Built-in Functions">. There's
621 also an example in L<perltoot/"Class::Template">.
623 If you want to overload a Perl operator, such as C<+> or C<**>,
624 then you'll want to use the C<use overload> pragma, documented
627 If you're talking about obscuring method calls in parent classes,
628 see L<perltoot/"Overridden Methods">.
630 =head2 What's the difference between calling a function as &foo and foo()?
632 When you call a function as C<&foo>, you allow that function access to
633 your current @_ values, and you bypass prototypes.
634 The function doesn't get an empty @_--it gets yours! While not
635 strictly speaking a bug (it's documented that way in L<perlsub>), it
636 would be hard to consider this a feature in most cases.
638 When you call your function as C<&foo()>, then you I<do> get a new @_,
639 but prototyping is still circumvented.
641 Normally, you want to call a function using C<foo()>. You may only
642 omit the parentheses if the function is already known to the compiler
643 because it already saw the definition (C<use> but not C<require>),
644 or via a forward reference or C<use subs> declaration. Even in this
645 case, you get a clean @_ without any of the old values leaking through
646 where they don't belong.
648 =head2 How do I create a switch or case statement?
650 This is explained in more depth in the L<perlsyn>. Briefly, there's
651 no official case statement, because of the variety of tests possible
652 in Perl (numeric comparison, string comparison, glob comparison,
653 regex matching, overloaded comparisons, ...). Larry couldn't decide
654 how best to do this, so he left it out, even though it's been on the
655 wish list since perl1.
657 Starting from Perl 5.8 to get switch and case one can use the
658 Switch extension and say:
662 after which one has switch and case. It is not as fast as it could be
663 because it's not really part of the language (it's done using source
664 filters) but it is available, and it's very flexible.
666 But if one wants to use pure Perl, the general answer is to write a
669 for ($variable_to_test) {
670 if (/pat1/) { } # do something
671 elsif (/pat2/) { } # do something else
672 elsif (/pat3/) { } # do something else
676 Here's a simple example of a switch based on pattern matching, this
677 time lined up in a way to make it look more like a switch statement.
678 We'll do a multiway conditional based on the type of reference stored
681 SWITCH: for (ref $whatchamacallit) {
683 /^$/ && die "not a reference";
701 warn "can't print function ref";
707 warn "User defined type skipped";
711 See C<perlsyn/"Basic BLOCKs and Switch Statements"> for many other
712 examples in this style.
714 Sometimes you should change the positions of the constant and the variable.
715 For example, let's say you wanted to test which of many answers you were
716 given, but in a case-insensitive way that also allows abbreviations.
717 You can use the following technique if the strings all start with
718 different characters or if you want to arrange the matches so that
719 one takes precedence over another, as C<"SEND"> has precedence over
723 if ("SEND" =~ /^\Q$answer/i) { print "Action is send\n" }
724 elsif ("STOP" =~ /^\Q$answer/i) { print "Action is stop\n" }
725 elsif ("ABORT" =~ /^\Q$answer/i) { print "Action is abort\n" }
726 elsif ("LIST" =~ /^\Q$answer/i) { print "Action is list\n" }
727 elsif ("EDIT" =~ /^\Q$answer/i) { print "Action is edit\n" }
729 A totally different approach is to create a hash of function references.
734 "done" => sub { die "See ya!" },
738 print "How are you? ";
739 chomp($string = <STDIN>);
740 if ($commands{$string}) {
741 $commands{$string}->();
743 print "No such command: $string\n";
746 =head2 How can I catch accesses to undefined variables, functions, or methods?
748 The AUTOLOAD method, discussed in L<perlsub/"Autoloading"> and
749 L<perltoot/"AUTOLOAD: Proxy Methods">, lets you capture calls to
750 undefined functions and methods.
752 When it comes to undefined variables that would trigger a warning
753 under C<use warnings>, you can promote the warning to an error.
755 use warnings FATAL => qw(uninitialized);
757 =head2 Why can't a method included in this same file be found?
759 Some possible reasons: your inheritance is getting confused, you've
760 misspelled the method name, or the object is of the wrong type. Check
761 out L<perltoot> for details about any of the above cases. You may
762 also use C<print ref($object)> to find out the class C<$object> was
765 Another possible reason for problems is because you've used the
766 indirect object syntax (eg, C<find Guru "Samy">) on a class name
767 before Perl has seen that such a package exists. It's wisest to make
768 sure your packages are all defined before you start using them, which
769 will be taken care of if you use the C<use> statement instead of
770 C<require>. If not, make sure to use arrow notation (eg.,
771 C<< Guru->find("Samy") >>) instead. Object notation is explained in
774 Make sure to read about creating modules in L<perlmod> and
775 the perils of indirect objects in L<perlobj/"Method Invocation">.
777 =head2 How can I find out my current package?
779 If you're just a random program, you can do this to find
780 out what the currently compiled package is:
782 my $packname = __PACKAGE__;
784 But, if you're a method and you want to print an error message
785 that includes the kind of object you were called on (which is
786 not necessarily the same as the one in which you were compiled):
790 my $class = ref($self) || $self;
791 warn "called me from a $class object";
794 =head2 How can I comment out a large block of perl code?
796 You can use embedded POD to discard it. Enclose the blocks you want
797 to comment out in POD markers. The <=begin> directive marks a section
798 for a specific formatter. Use the C<comment> format, which no formatter
799 should claim to understand (by policy). Mark the end of the block
817 The pod directives cannot go just anywhere. You must put a
818 pod directive where the parser is expecting a new statement,
819 not just in the middle of an expression or some other
820 arbitrary grammar production.
822 See L<perlpod> for more details.
824 =head2 How do I clear a package?
826 Use this code, provided by Mark-Jason Dominus:
831 die "Shouldn't delete main package"
832 if $pack eq "" || $pack eq "main";
833 my $stash = *{$pack . '::'}{HASH};
835 foreach $name (keys %$stash) {
836 my $fullname = $pack . '::' . $name;
837 # Get rid of everything with that name.
846 Or, if you're using a recent release of Perl, you can
847 just use the Symbol::delete_package() function instead.
849 =head2 How can I use a variable as a variable name?
851 Beginners often think they want to have a variable contain the name
856 ++$$varname; # $fred now 24
858 This works I<sometimes>, but it is a very bad idea for two reasons.
860 The first reason is that this technique I<only works on global
861 variables>. That means that if $fred is a lexical variable created
862 with my() in the above example, the code wouldn't work at all: you'd
863 accidentally access the global and skip right over the private lexical
864 altogether. Global variables are bad because they can easily collide
865 accidentally and in general make for non-scalable and confusing code.
867 Symbolic references are forbidden under the C<use strict> pragma.
868 They are not true references and consequently are not reference counted
869 or garbage collected.
871 The other reason why using a variable to hold the name of another
872 variable is a bad idea is that the question often stems from a lack of
873 understanding of Perl data structures, particularly hashes. By using
874 symbolic references, you are just using the package's symbol-table hash
875 (like C<%main::>) instead of a user-defined hash. The solution is to
876 use your own hash or a real reference instead.
878 $USER_VARS{"fred"} = 23;
880 $USER_VARS{$varname}++; # not $$varname++
882 There we're using the %USER_VARS hash instead of symbolic references.
883 Sometimes this comes up in reading strings from the user with variable
884 references and wanting to expand them to the values of your perl
885 program's variables. This is also a bad idea because it conflates the
886 program-addressable namespace and the user-addressable one. Instead of
887 reading a string and expanding it to the actual contents of your program's
890 $str = 'this has a $fred and $barney in it';
891 $str =~ s/(\$\w+)/$1/eeg; # need double eval
893 it would be better to keep a hash around like %USER_VARS and have
894 variable references actually refer to entries in that hash:
896 $str =~ s/\$(\w+)/$USER_VARS{$1}/g; # no /e here at all
898 That's faster, cleaner, and safer than the previous approach. Of course,
899 you don't need to use a dollar sign. You could use your own scheme to
900 make it less confusing, like bracketed percent symbols, etc.
902 $str = 'this has a %fred% and %barney% in it';
903 $str =~ s/%(\w+)%/$USER_VARS{$1}/g; # no /e here at all
905 Another reason that folks sometimes think they want a variable to
906 contain the name of a variable is because they don't know how to build
907 proper data structures using hashes. For example, let's say they
908 wanted two hashes in their program: %fred and %barney, and that they
909 wanted to use another scalar variable to refer to those by name.
912 $$name{WIFE} = "wilma"; # set %fred
915 $$name{WIFE} = "betty"; # set %barney
917 This is still a symbolic reference, and is still saddled with the
918 problems enumerated above. It would be far better to write:
920 $folks{"fred"}{WIFE} = "wilma";
921 $folks{"barney"}{WIFE} = "betty";
923 And just use a multilevel hash to start with.
925 The only times that you absolutely I<must> use symbolic references are
926 when you really must refer to the symbol table. This may be because it's
927 something that can't take a real reference to, such as a format name.
928 Doing so may also be important for method calls, since these always go
929 through the symbol table for resolution.
931 In those cases, you would turn off C<strict 'refs'> temporarily so you
932 can play around with the symbol table. For example:
934 @colors = qw(red blue green yellow orange purple violet);
935 for my $name (@colors) {
936 no strict 'refs'; # renege for the block
937 *$name = sub { "<FONT COLOR='$name'>@_</FONT>" };
940 All those functions (red(), blue(), green(), etc.) appear to be separate,
941 but the real code in the closure actually was compiled only once.
943 So, sometimes you might want to use symbolic references to directly
944 manipulate the symbol table. This doesn't matter for formats, handles, and
945 subroutines, because they are always global--you can't use my() on them.
946 For scalars, arrays, and hashes, though--and usually for subroutines--
947 you probably only want to use hard references.
949 =head2 What does "bad interpreter" mean?
951 (contributed by brian d foy)
953 The "bad interpreter" message comes from the shell, not perl. The
954 actual message may vary depending on your platform, shell, and locale
957 If you see "bad interpreter - no such file or directory", the first
958 line in your perl script (the "shebang" line) does not contain the
959 right path to perl (or any other program capable of running scripts).
960 Sometimes this happens when you move the script from one machine to
961 another and each machine has a different path to perl--/usr/bin/perl
962 versus /usr/local/bin/perl for instance. It may also indicate
963 that the source machine has CRLF line terminators and the
964 destination machine has LF only: the shell tries to find
965 /usr/bin/perl<CR>, but can't.
967 If you see "bad interpreter: Permission denied", you need to make your
970 In either case, you should still be able to run the scripts with perl
975 If you get a message like "perl: command not found", perl is not in
976 your PATH, which might also mean that the location of perl is not
977 where you expect it so you need to adjust your shebang line.
981 Revision: $Revision: 8539 $
983 Date: $Date: 2007-01-11 00:07:14 +0100 (jeu, 11 jan 2007) $
985 See L<perlfaq> for source control details and availability.
987 =head1 AUTHOR AND COPYRIGHT
989 Copyright (c) 1997-2007 Tom Christiansen, Nathan Torkington, and
990 other authors as noted. All rights reserved.
992 This documentation is free; you can redistribute it and/or modify it
993 under the same terms as Perl itself.
995 Irrespective of its distribution, all code examples in this file
996 are hereby placed into the public domain. You are permitted and
997 encouraged to use this code in your own programs for fun
998 or for profit as you see fit. A simple comment in the code giving
999 credit would be courteous but is not required.