3 perlfaq7 - General Perl Language Issues ($Revision: 9620 $)
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 }
72 "There Beren came from mountains cold",
73 "And lost he wandered under leaves",
76 =head2 How do I skip some return values?
78 One way is to treat the return values as a list and index into it:
80 $dir = (getpwnam($user))[7];
82 Another way is to use undef as an element on the left-hand-side:
84 ($dev, $ino, undef, undef, $uid, $gid) = stat($file);
86 You can also use a list slice to select only the elements that
89 ($dev, $ino, $uid, $gid) = ( stat($file) )[0,1,4,5];
91 =head2 How do I temporarily block warnings?
93 If you are running Perl 5.6.0 or better, the C<use warnings> pragma
94 allows fine control of what warning are produced.
95 See L<perllexwarn> for more details.
98 no warnings; # temporarily turn off warnings
99 $a = $b + $c; # I know these might be undef
102 Additionally, you can enable and disable categories of warnings.
103 You turn off the categories you want to ignore and you can still
104 get other categories of warnings. See L<perllexwarn> for the
105 complete details, including the category names and hierarchy.
108 no warnings 'uninitialized';
112 If you have an older version of Perl, the C<$^W> variable (documented
113 in L<perlvar>) controls runtime warnings for a block:
116 local $^W = 0; # temporarily turn off warnings
117 $a = $b + $c; # I know these might be undef
120 Note that like all the punctuation variables, you cannot currently
121 use my() on C<$^W>, only local().
123 =head2 What's an extension?
125 An extension is a way of calling compiled C code from Perl. Reading
126 L<perlxstut> is a good place to learn more about extensions.
128 =head2 Why do Perl operators have different precedence than C operators?
130 Actually, they don't. All C operators that Perl copies have the same
131 precedence in Perl as they do in C. The problem is with operators that C
132 doesn't have, especially functions that give a list context to everything
133 on their right, eg. print, chmod, exec, and so on. Such functions are
134 called "list operators" and appear as such in the precedence table in
137 A common mistake is to write:
139 unlink $file || die "snafu";
141 This gets interpreted as:
143 unlink ($file || die "snafu");
145 To avoid this problem, either put in extra parentheses or use the
146 super low precedence C<or> operator:
148 (unlink $file) || die "snafu";
149 unlink $file or die "snafu";
151 The "English" operators (C<and>, C<or>, C<xor>, and C<not>)
152 deliberately have precedence lower than that of list operators for
153 just such situations as the one above.
155 Another operator with surprising precedence is exponentiation. It
156 binds more tightly even than unary minus, making C<-2**2> product a
157 negative not a positive four. It is also right-associating, meaning
158 that C<2**3**2> is two raised to the ninth power, not eight squared.
160 Although it has the same precedence as in C, Perl's C<?:> operator
161 produces an lvalue. This assigns $x to either $a or $b, depending
162 on the trueness of $maybe:
164 ($maybe ? $a : $b) = $x;
166 =head2 How do I declare/create a structure?
168 In general, you don't "declare" a structure. Just use a (probably
169 anonymous) hash reference. See L<perlref> and L<perldsc> for details.
172 $person = {}; # new anonymous hash
173 $person->{AGE} = 24; # set field AGE to 24
174 $person->{NAME} = "Nat"; # set field NAME to "Nat"
176 If you're looking for something a bit more rigorous, try L<perltoot>.
178 =head2 How do I create a module?
180 (contributed by brian d foy)
182 L<perlmod>, L<perlmodlib>, L<perlmodstyle> explain modules
183 in all the gory details. L<perlnewmod> gives a brief
184 overview of the process along with a couple of suggestions
187 If you need to include C code or C library interfaces in
188 your module, you'll need h2xs. h2xs will create the module
189 distribution structure and the initial interface files
190 you'll need. L<perlxs> and L<perlxstut> explain the details.
192 If you don't need to use C code, other tools such as
193 ExtUtils::ModuleMaker and Module::Starter, can help you
194 create a skeleton module distribution.
196 You may also want to see Sam Tregar's "Writing Perl Modules
197 for CPAN" ( http://apress.com/book/bookDisplay.html?bID=14 )
198 which is the best hands-on guide to creating module
201 =head2 How do I create a class?
203 See L<perltoot> for an introduction to classes and objects, as well as
204 L<perlobj> and L<perlbot>.
206 =head2 How can I tell if a variable is tainted?
208 You can use the tainted() function of the Scalar::Util module, available
209 from CPAN (or included with Perl since release 5.8.0).
210 See also L<perlsec/"Laundering and Detecting Tainted Data">.
212 =head2 What's a closure?
214 Closures are documented in L<perlref>.
216 I<Closure> is a computer science term with a precise but
217 hard-to-explain meaning. Usually, closures are implemented in Perl as
218 anonymous subroutines with lasting references to lexical variables
219 outside their own scopes. These lexicals magically refer to the
220 variables that were around when the subroutine was defined (deep
223 Closures are most often used in programming languages where you can
224 have the return value of a function be itself a function, as you can
225 in Perl. Note that some languages provide anonymous functions but are
226 not capable of providing proper closures: the Python language, for
227 example. For more information on closures, check out any textbook on
228 functional programming. Scheme is a language that not only supports
229 but encourages closures.
231 Here's a classic non-closure function-generating function:
233 sub add_function_generator {
234 return sub { shift() + shift() };
237 $add_sub = add_function_generator();
238 $sum = $add_sub->(4,5); # $sum is 9 now.
240 The anonymous subroutine returned by add_function_generator() isn't
241 technically a closure because it refers to no lexicals outside its own
242 scope. Using a closure gives you a I<function template> with some
243 customization slots left out to be filled later.
245 Contrast this with the following make_adder() function, in which the
246 returned anonymous function contains a reference to a lexical variable
247 outside the scope of that function itself. Such a reference requires
248 that Perl return a proper closure, thus locking in for all time the
249 value that the lexical had when the function was created.
252 my $addpiece = shift;
253 return sub { shift() + $addpiece };
256 $f1 = make_adder(20);
257 $f2 = make_adder(555);
259 Now C<&$f1($n)> is always 20 plus whatever $n you pass in, whereas
260 C<&$f2($n)> is always 555 plus whatever $n you pass in. The $addpiece
261 in the closure sticks around.
263 Closures are often used for less esoteric purposes. For example, when
264 you want to pass in a bit of code into a function:
267 timeout( 30, sub { $line = <STDIN> } );
269 If the code to execute had been passed in as a string,
270 C<< '$line = <STDIN>' >>, there would have been no way for the
271 hypothetical timeout() function to access the lexical variable
272 $line back in its caller's scope.
274 Another use for a closure is to make a variable I<private> to a
275 named subroutine, e.g. a counter that gets initialized at creation
276 time of the sub and can only be modified from within the sub.
277 This is sometimes used with a BEGIN block in package files to make
278 sure a variable doesn't get meddled with during the lifetime of the
283 sub next_id { ++$id }
286 This is discussed in more detail in L<perlsub>, see the entry on
287 I<Persistent Private Variables>.
289 =head2 What is variable suicide and how can I prevent it?
291 This problem was fixed in perl 5.004_05, so preventing it means upgrading
292 your version of perl. ;)
294 Variable suicide is when you (temporarily or permanently) lose the value
295 of a variable. It is caused by scoping through my() and local()
296 interacting with either closures or aliased foreach() iterator variables
297 and subroutine arguments. It used to be easy to inadvertently lose a
298 variable's value this way, but now it's much harder. Take this code:
302 while ($i++ < 3) { my $f = $f; $f .= "bar"; print $f, "\n" }
306 print "Finally $f\n";
308 If you are experiencing variable suicide, that C<my $f> in the subroutine
309 doesn't pick up a fresh copy of the C<$f> whose value is <foo>. The output
310 shows that inside the subroutine the value of C<$f> leaks through when it
311 shouldn't, as in this output:
318 The $f that has "bar" added to it three times should be a new C<$f>
319 C<my $f> should create a new lexical variable each time through the loop.
320 The expected output is:
327 =head2 How can I pass/return a {Function, FileHandle, Array, Hash, Method, Regex}?
329 With the exception of regexes, you need to pass references to these
330 objects. See L<perlsub/"Pass by Reference"> for this particular
331 question, and L<perlref> for information on references.
333 See "Passing Regexes", later in L<perlfaq7>, for information on
334 passing regular expressions.
338 =item Passing Variables and Functions
340 Regular variables and functions are quite easy to pass: just pass in a
341 reference to an existing or anonymous variable or function:
343 func( \$some_scalar );
345 func( \@some_array );
349 func( { this => 10, that => 20 } );
352 func( sub { $_[0] ** $_[1] } );
354 =item Passing Filehandles
356 As of Perl 5.6, you can represent filehandles with scalar variables
357 which you treat as any other scalar.
359 open my $fh, $filename or die "Cannot open $filename! $!";
363 my $passed_fh = shift;
365 my $line = <$passed_fh>;
368 Before Perl 5.6, you had to use the C<*FH> or C<\*FH> notations.
369 These are "typeglobs"--see L<perldata/"Typeglobs and Filehandles">
370 and especially L<perlsub/"Pass by Reference"> for more information.
372 =item Passing Regexes
374 To pass regexes around, you'll need to be using a release of Perl
375 sufficiently recent as to support the C<qr//> construct, pass around
376 strings and use an exception-trapping eval, or else be very, very clever.
378 Here's an example of how to pass in a string to be regex compared
382 my ($val1, $regex) = @_;
383 my $retval = $val1 =~ /$regex/;
386 $match = compare("old McDonald", qr/d.*D/i);
388 Notice how C<qr//> allows flags at the end. That pattern was compiled
389 at compile time, although it was executed later. The nifty C<qr//>
390 notation wasn't introduced until the 5.005 release. Before that, you
391 had to approach this problem much less intuitively. For example, here
392 it is again if you don't have C<qr//>:
395 my ($val1, $regex) = @_;
396 my $retval = eval { $val1 =~ /$regex/ };
401 $match = compare("old McDonald", q/($?i)d.*D/);
403 Make sure you never say something like this:
405 return eval "\$val =~ /$regex/"; # WRONG
407 or someone can sneak shell escapes into the regex due to the double
408 interpolation of the eval and the double-quoted string. For example:
410 $pattern_of_evil = 'danger ${ system("rm -rf * &") } danger';
412 eval "\$string =~ /$pattern_of_evil/";
414 Those preferring to be very, very clever might see the O'Reilly book,
415 I<Mastering Regular Expressions>, by Jeffrey Friedl. Page 273's
416 Build_MatchMany_Function() is particularly interesting. A complete
417 citation of this book is given in L<perlfaq2>.
419 =item Passing Methods
421 To pass an object method into a subroutine, you can do this:
423 call_a_lot(10, $some_obj, "methname")
425 my ($count, $widget, $trick) = @_;
426 for (my $i = 0; $i < $count; $i++) {
431 Or, you can use a closure to bundle up the object, its
432 method call, and arguments:
434 my $whatnot = sub { $some_obj->obfuscate(@args) };
441 You could also investigate the can() method in the UNIVERSAL class
442 (part of the standard perl distribution).
446 =head2 How do I create a static variable?
448 (contributed by brian d foy)
450 Perl doesn't have "static" variables, which can only be accessed from
451 the function in which they are declared. You can get the same effect
452 with lexical variables, though.
454 You can fake a static variable by using a lexical variable which goes
455 out of scope. In this example, you define the subroutine C<counter>, and
456 it uses the lexical variable C<$count>. Since you wrap this in a BEGIN
457 block, C<$count> is defined at compile-time, but also goes out of
458 scope at the end of the BEGIN block. The BEGIN block also ensures that
459 the subroutine and the value it uses is defined at compile-time so the
460 subroutine is ready to use just like any other subroutine, and you can
461 put this code in the same place as other subroutines in the program
462 text (i.e. at the end of the code, typically). The subroutine
463 C<counter> still has a reference to the data, and is the only way you
464 can access the value (and each time you do, you increment the value).
465 The data in chunk of memory defined by C<$count> is private to
470 sub counter { $count++ }
473 my $start = counter();
475 .... # code that calls counter();
479 In the previous example, you created a function-private variable
480 because only one function remembered its reference. You could define
481 multiple functions while the variable is in scope, and each function
482 can share the "private" variable. It's not really "static" because you
483 can access it outside the function while the lexical variable is in
484 scope, and even create references to it. In this example,
485 C<increment_count> and C<return_count> share the variable. One
486 function adds to the value and the other simply returns the value.
487 They can both access C<$count>, and since it has gone out of scope,
488 there is no other way to access it.
492 sub increment_count { $count++ }
493 sub return_count { $count }
496 To declare a file-private variable, you still use a lexical variable.
497 A file is also a scope, so a lexical variable defined in the file
498 cannot be seen from any other file.
500 See L<perlsub/"Persistent Private Variables"> for more information.
501 The discussion of closures in L<perlref> may help you even though we
502 did not use anonymous subroutines in this answer. See
503 L<perlsub/"Persistent Private Variables"> for details.
505 =head2 What's the difference between dynamic and lexical (static) scoping? Between local() and my()?
507 C<local($x)> saves away the old value of the global variable C<$x>
508 and assigns a new value for the duration of the subroutine I<which is
509 visible in other functions called from that subroutine>. This is done
510 at run-time, so is called dynamic scoping. local() always affects global
511 variables, also called package variables or dynamic variables.
513 C<my($x)> creates a new variable that is only visible in the current
514 subroutine. This is done at compile-time, so it is called lexical or
515 static scoping. my() always affects private variables, also called
516 lexical variables or (improperly) static(ly scoped) variables.
521 print "var has value $var\n";
525 local $var = 'local'; # new temporary value for the still-global
526 visible(); # variable called $var
530 my $var = 'private'; # new private variable, $var
531 visible(); # (invisible outside of sub scope)
536 visible(); # prints global
537 dynamic(); # prints local
538 lexical(); # prints global
540 Notice how at no point does the value "private" get printed. That's
541 because $var only has that value within the block of the lexical()
542 function, and it is hidden from called subroutine.
544 In summary, local() doesn't make what you think of as private, local
545 variables. It gives a global variable a temporary value. my() is
546 what you're looking for if you want private variables.
548 See L<perlsub/"Private Variables via my()"> and
549 L<perlsub/"Temporary Values via local()"> for excruciating details.
551 =head2 How can I access a dynamic variable while a similarly named lexical is in scope?
553 If you know your package, you can just mention it explicitly, as in
554 $Some_Pack::var. Note that the notation $::var is B<not> the dynamic $var
555 in the current package, but rather the one in the "main" package, as
556 though you had written $main::var.
559 local $var = "global";
562 print "lexical is $var\n";
563 print "global is $main::var\n";
565 Alternatively you can use the compiler directive our() to bring a
566 dynamic variable into the current lexical scope.
568 require 5.006; # our() did not exist before 5.6
571 local $var = "global";
574 print "lexical is $var\n";
578 print "global is $var\n";
581 =head2 What's the difference between deep and shallow binding?
583 In deep binding, lexical variables mentioned in anonymous subroutines
584 are the same ones that were in scope when the subroutine was created.
585 In shallow binding, they are whichever variables with the same names
586 happen to be in scope when the subroutine is called. Perl always uses
587 deep binding of lexical variables (i.e., those created with my()).
588 However, dynamic variables (aka global, local, or package variables)
589 are effectively shallowly bound. Consider this just one more reason
590 not to use them. See the answer to L<"What's a closure?">.
592 =head2 Why doesn't "my($foo) = E<lt>FILEE<gt>;" work right?
594 C<my()> and C<local()> give list context to the right hand side
595 of C<=>. The <FH> read operation, like so many of Perl's
596 functions and operators, can tell which context it was called in and
597 behaves appropriately. In general, the scalar() function can help.
598 This function does nothing to the data itself (contrary to popular myth)
599 but rather tells its argument to behave in whatever its scalar fashion is.
600 If that function doesn't have a defined scalar behavior, this of course
601 doesn't help you (such as with sort()).
603 To enforce scalar context in this particular case, however, you need
604 merely omit the parentheses:
606 local($foo) = <FILE>; # WRONG
607 local($foo) = scalar(<FILE>); # ok
608 local $foo = <FILE>; # right
610 You should probably be using lexical variables anyway, although the
611 issue is the same here:
613 my($foo) = <FILE>; # WRONG
614 my $foo = <FILE>; # right
616 =head2 How do I redefine a builtin function, operator, or method?
618 Why do you want to do that? :-)
620 If you want to override a predefined function, such as open(),
621 then you'll have to import the new definition from a different
622 module. See L<perlsub/"Overriding Built-in Functions">. There's
623 also an example in L<perltoot/"Class::Template">.
625 If you want to overload a Perl operator, such as C<+> or C<**>,
626 then you'll want to use the C<use overload> pragma, documented
629 If you're talking about obscuring method calls in parent classes,
630 see L<perltoot/"Overridden Methods">.
632 =head2 What's the difference between calling a function as &foo and foo()?
634 When you call a function as C<&foo>, you allow that function access to
635 your current @_ values, and you bypass prototypes.
636 The function doesn't get an empty @_--it gets yours! While not
637 strictly speaking a bug (it's documented that way in L<perlsub>), it
638 would be hard to consider this a feature in most cases.
640 When you call your function as C<&foo()>, then you I<do> get a new @_,
641 but prototyping is still circumvented.
643 Normally, you want to call a function using C<foo()>. You may only
644 omit the parentheses if the function is already known to the compiler
645 because it already saw the definition (C<use> but not C<require>),
646 or via a forward reference or C<use subs> declaration. Even in this
647 case, you get a clean @_ without any of the old values leaking through
648 where they don't belong.
650 =head2 How do I create a switch or case statement?
652 If one wants to use pure Perl and to be compatible with Perl versions
653 prior to 5.10, the general answer is to write a construct like this:
655 for ($variable_to_test) {
656 if (/pat1/) { } # do something
657 elsif (/pat2/) { } # do something else
658 elsif (/pat3/) { } # do something else
662 Here's a simple example of a switch based on pattern matching,
663 lined up in a way to make it look more like a switch statement.
664 We'll do a multiway conditional based on the type of reference stored
667 SWITCH: for (ref $whatchamacallit) {
669 /^$/ && die "not a reference";
687 warn "can't print function ref";
693 warn "User defined type skipped";
697 See L<perlsyn> for other examples in this style.
699 Sometimes you should change the positions of the constant and the variable.
700 For example, let's say you wanted to test which of many answers you were
701 given, but in a case-insensitive way that also allows abbreviations.
702 You can use the following technique if the strings all start with
703 different characters or if you want to arrange the matches so that
704 one takes precedence over another, as C<"SEND"> has precedence over
708 if ("SEND" =~ /^\Q$answer/i) { print "Action is send\n" }
709 elsif ("STOP" =~ /^\Q$answer/i) { print "Action is stop\n" }
710 elsif ("ABORT" =~ /^\Q$answer/i) { print "Action is abort\n" }
711 elsif ("LIST" =~ /^\Q$answer/i) { print "Action is list\n" }
712 elsif ("EDIT" =~ /^\Q$answer/i) { print "Action is edit\n" }
714 A totally different approach is to create a hash of function references.
719 "done" => sub { die "See ya!" },
723 print "How are you? ";
724 chomp($string = <STDIN>);
725 if ($commands{$string}) {
726 $commands{$string}->();
728 print "No such command: $string\n";
731 Note that starting from version 5.10, Perl has now a native switch
732 statement. See L<perlsyn>.
734 Starting from Perl 5.8, a source filter module, C<Switch>, can also be
735 used to get switch and case. Its use is now discouraged, because it's
736 not fully compatible with the native switch of Perl 5.10, and because,
737 as it's implemented as a source filter, it doesn't always work as intended
738 when complex syntax is involved.
740 =head2 How can I catch accesses to undefined variables, functions, or methods?
742 The AUTOLOAD method, discussed in L<perlsub/"Autoloading"> and
743 L<perltoot/"AUTOLOAD: Proxy Methods">, lets you capture calls to
744 undefined functions and methods.
746 When it comes to undefined variables that would trigger a warning
747 under C<use warnings>, you can promote the warning to an error.
749 use warnings FATAL => qw(uninitialized);
751 =head2 Why can't a method included in this same file be found?
753 Some possible reasons: your inheritance is getting confused, you've
754 misspelled the method name, or the object is of the wrong type. Check
755 out L<perltoot> for details about any of the above cases. You may
756 also use C<print ref($object)> to find out the class C<$object> was
759 Another possible reason for problems is because you've used the
760 indirect object syntax (eg, C<find Guru "Samy">) on a class name
761 before Perl has seen that such a package exists. It's wisest to make
762 sure your packages are all defined before you start using them, which
763 will be taken care of if you use the C<use> statement instead of
764 C<require>. If not, make sure to use arrow notation (eg.,
765 C<< Guru->find("Samy") >>) instead. Object notation is explained in
768 Make sure to read about creating modules in L<perlmod> and
769 the perils of indirect objects in L<perlobj/"Method Invocation">.
771 =head2 How can I find out my current package?
773 If you're just a random program, you can do this to find
774 out what the currently compiled package is:
776 my $packname = __PACKAGE__;
778 But, if you're a method and you want to print an error message
779 that includes the kind of object you were called on (which is
780 not necessarily the same as the one in which you were compiled):
784 my $class = ref($self) || $self;
785 warn "called me from a $class object";
788 =head2 How can I comment out a large block of perl code?
790 You can use embedded POD to discard it. Enclose the blocks you want
791 to comment out in POD markers. The <=begin> directive marks a section
792 for a specific formatter. Use the C<comment> format, which no formatter
793 should claim to understand (by policy). Mark the end of the block
811 The pod directives cannot go just anywhere. You must put a
812 pod directive where the parser is expecting a new statement,
813 not just in the middle of an expression or some other
814 arbitrary grammar production.
816 See L<perlpod> for more details.
818 =head2 How do I clear a package?
820 Use this code, provided by Mark-Jason Dominus:
825 die "Shouldn't delete main package"
826 if $pack eq "" || $pack eq "main";
827 my $stash = *{$pack . '::'}{HASH};
829 foreach $name (keys %$stash) {
830 my $fullname = $pack . '::' . $name;
831 # Get rid of everything with that name.
840 Or, if you're using a recent release of Perl, you can
841 just use the Symbol::delete_package() function instead.
843 =head2 How can I use a variable as a variable name?
845 Beginners often think they want to have a variable contain the name
850 ++$$varname; # $fred now 24
852 This works I<sometimes>, but it is a very bad idea for two reasons.
854 The first reason is that this technique I<only works on global
855 variables>. That means that if $fred is a lexical variable created
856 with my() in the above example, the code wouldn't work at all: you'd
857 accidentally access the global and skip right over the private lexical
858 altogether. Global variables are bad because they can easily collide
859 accidentally and in general make for non-scalable and confusing code.
861 Symbolic references are forbidden under the C<use strict> pragma.
862 They are not true references and consequently are not reference counted
863 or garbage collected.
865 The other reason why using a variable to hold the name of another
866 variable is a bad idea is that the question often stems from a lack of
867 understanding of Perl data structures, particularly hashes. By using
868 symbolic 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
870 use your own hash or a real reference instead.
872 $USER_VARS{"fred"} = 23;
874 $USER_VARS{$varname}++; # not $$varname++
876 There we're using the %USER_VARS hash instead of symbolic references.
877 Sometimes this comes up in reading strings from the user with variable
878 references and wanting to expand them to the values of your perl
879 program's variables. This is also a bad idea because it conflates the
880 program-addressable namespace and the user-addressable one. Instead of
881 reading a string and expanding it to the actual contents of your program's
884 $str = 'this has a $fred and $barney in it';
885 $str =~ s/(\$\w+)/$1/eeg; # need double eval
887 it would be better to keep a hash around like %USER_VARS and have
888 variable references actually refer to entries in that hash:
890 $str =~ s/\$(\w+)/$USER_VARS{$1}/g; # no /e here at all
892 That's faster, cleaner, and safer than the previous approach. Of course,
893 you don't need to use a dollar sign. You could use your own scheme to
894 make it less confusing, like bracketed percent symbols, etc.
896 $str = 'this has a %fred% and %barney% in it';
897 $str =~ s/%(\w+)%/$USER_VARS{$1}/g; # no /e here at all
899 Another reason that folks sometimes think they want a variable to
900 contain the name of a variable is because they don't know how to build
901 proper data structures using hashes. For example, let's say they
902 wanted two hashes in their program: %fred and %barney, and that they
903 wanted to use another scalar variable to refer to those by name.
906 $$name{WIFE} = "wilma"; # set %fred
909 $$name{WIFE} = "betty"; # set %barney
911 This is still a symbolic reference, and is still saddled with the
912 problems enumerated above. It would be far better to write:
914 $folks{"fred"}{WIFE} = "wilma";
915 $folks{"barney"}{WIFE} = "betty";
917 And just use a multilevel hash to start with.
919 The only times that you absolutely I<must> use symbolic references are
920 when you really must refer to the symbol table. This may be because it's
921 something that can't take a real reference to, such as a format name.
922 Doing so may also be important for method calls, since these always go
923 through the symbol table for resolution.
925 In those cases, you would turn off C<strict 'refs'> temporarily so you
926 can play around with the symbol table. For example:
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>" };
934 All those functions (red(), blue(), green(), etc.) appear to be separate,
935 but the real code in the closure actually was compiled only once.
937 So, sometimes you might want to use symbolic references to directly
938 manipulate the symbol table. This doesn't matter for formats, handles, and
939 subroutines, because they are always global--you can't use my() on them.
940 For scalars, arrays, and hashes, though--and usually for subroutines--
941 you probably only want to use hard references.
943 =head2 What does "bad interpreter" mean?
945 (contributed by brian d foy)
947 The "bad interpreter" message comes from the shell, not perl. The
948 actual message may vary depending on your platform, shell, and locale
951 If you see "bad interpreter - no such file or directory", the first
952 line in your perl script (the "shebang" line) does not contain the
953 right path to perl (or any other program capable of running scripts).
954 Sometimes this happens when you move the script from one machine to
955 another and each machine has a different path to perl--/usr/bin/perl
956 versus /usr/local/bin/perl for instance. It may also indicate
957 that the source machine has CRLF line terminators and the
958 destination machine has LF only: the shell tries to find
959 /usr/bin/perl<CR>, but can't.
961 If you see "bad interpreter: Permission denied", you need to make your
964 In either case, you should still be able to run the scripts with perl
969 If you get a message like "perl: command not found", perl is not in
970 your PATH, which might also mean that the location of perl is not
971 where you expect it so you need to adjust your shebang line.
975 Revision: $Revision: 9620 $
977 Date: $Date: 2007-05-29 19:57:58 +0200 (Tue, 29 May 2007) $
979 See L<perlfaq> for source control details and availability.
981 =head1 AUTHOR AND COPYRIGHT
983 Copyright (c) 1997-2007 Tom Christiansen, Nathan Torkington, and
984 other authors as noted. All rights reserved.
986 This documentation is free; you can redistribute it and/or modify it
987 under the same terms as Perl itself.
989 Irrespective of its distribution, all code examples in this file
990 are hereby placed into the public domain. You are permitted and
991 encouraged to use this code in your own programs for fun
992 or for profit as you see fit. A simple comment in the code giving
993 credit would be courteous but is not required.