3 perlfaq7 - General Perl Language Issues ($Revision: 1.23 $, $Date: 2005/04/07 21:39:34 $)
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 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. Closures are implemented in Perl as anonymous
217 subroutines with lasting references to lexical variables outside their
218 own scopes. These lexicals magically refer to the variables that were
219 around when the subroutine was defined (deep binding).
221 Closures make sense in any programming language where you can have the
222 return value of a function be itself a function, as you can in Perl.
223 Note that some languages provide anonymous functions but are not
224 capable of providing proper closures: the Python language, for
225 example. For more information on closures, check out any textbook on
226 functional programming. Scheme is a language that not only supports
227 but encourages closures.
229 Here's a classic function-generating function:
231 sub add_function_generator {
232 return sub { shift() + shift() };
235 $add_sub = add_function_generator();
236 $sum = $add_sub->(4,5); # $sum is 9 now.
238 The closure works as a I<function template> with some customization
239 slots left out to be filled later. The anonymous subroutine returned
240 by add_function_generator() isn't technically a closure because it
241 refers to no lexicals outside its own scope.
243 Contrast this with the following make_adder() function, in which the
244 returned anonymous function contains a reference to a lexical variable
245 outside the scope of that function itself. Such a reference requires
246 that Perl return a proper closure, thus locking in for all time the
247 value that the lexical had when the function was created.
250 my $addpiece = shift;
251 return sub { shift() + $addpiece };
254 $f1 = make_adder(20);
255 $f2 = make_adder(555);
257 Now C<&$f1($n)> is always 20 plus whatever $n you pass in, whereas
258 C<&$f2($n)> is always 555 plus whatever $n you pass in. The $addpiece
259 in the closure sticks around.
261 Closures are often used for less esoteric purposes. For example, when
262 you want to pass in a bit of code into a function:
265 timeout( 30, sub { $line = <STDIN> } );
267 If the code to execute had been passed in as a string,
268 C<< '$line = <STDIN>' >>, there would have been no way for the
269 hypothetical timeout() function to access the lexical variable
270 $line back in its caller's scope.
272 =head2 What is variable suicide and how can I prevent it?
274 Variable suicide is when you (temporarily or permanently) lose the
275 value of a variable. It is caused by scoping through my() and local()
276 interacting with either closures or aliased foreach() iterator
277 variables and subroutine arguments. It used to be easy to
278 inadvertently lose a variable's value this way, but now it's much
279 harder. Take this code:
283 while ($i++ < 3) { my $f = $f; $f .= "bar"; print $f, "\n" }
286 print "Finally $f\n";
288 The $f that has "bar" added to it three times should be a new C<$f>
289 (C<my $f> should create a new local variable each time through the loop).
290 It isn't, however. This was a bug, now fixed in the latest releases
291 (tested against 5.004_05, 5.005_03, and 5.005_56).
293 =head2 How can I pass/return a {Function, FileHandle, Array, Hash, Method, Regex}?
295 With the exception of regexes, you need to pass references to these
296 objects. See L<perlsub/"Pass by Reference"> for this particular
297 question, and L<perlref> for information on references.
299 See "Passing Regexes", below, for information on passing regular
304 =item Passing Variables and Functions
306 Regular variables and functions are quite easy to pass: just pass in a
307 reference to an existing or anonymous variable or function:
309 func( \$some_scalar );
311 func( \@some_array );
315 func( { this => 10, that => 20 } );
318 func( sub { $_[0] ** $_[1] } );
320 =item Passing Filehandles
322 As of Perl 5.6, you can represent filehandles with scalar variables
323 which you treat as any other scalar.
325 open my $fh, $filename or die "Cannot open $filename! $!";
329 my $passed_fh = shift;
334 Before Perl 5.6, you had to use the C<*FH> or C<\*FH> notations.
335 These are "typeglobs"--see L<perldata/"Typeglobs and Filehandles">
336 and especially L<perlsub/"Pass by Reference"> for more information.
338 =item Passing Regexes
340 To pass regexes around, you'll need to be using a release of Perl
341 sufficiently recent as to support the C<qr//> construct, pass around
342 strings and use an exception-trapping eval, or else be very, very clever.
344 Here's an example of how to pass in a string to be regex compared
348 my ($val1, $regex) = @_;
349 my $retval = $val1 =~ /$regex/;
352 $match = compare("old McDonald", qr/d.*D/i);
354 Notice how C<qr//> allows flags at the end. That pattern was compiled
355 at compile time, although it was executed later. The nifty C<qr//>
356 notation wasn't introduced until the 5.005 release. Before that, you
357 had to approach this problem much less intuitively. For example, here
358 it is again if you don't have C<qr//>:
361 my ($val1, $regex) = @_;
362 my $retval = eval { $val1 =~ /$regex/ };
367 $match = compare("old McDonald", q/($?i)d.*D/);
369 Make sure you never say something like this:
371 return eval "\$val =~ /$regex/"; # WRONG
373 or someone can sneak shell escapes into the regex due to the double
374 interpolation of the eval and the double-quoted string. For example:
376 $pattern_of_evil = 'danger ${ system("rm -rf * &") } danger';
378 eval "\$string =~ /$pattern_of_evil/";
380 Those preferring to be very, very clever might see the O'Reilly book,
381 I<Mastering Regular Expressions>, by Jeffrey Friedl. Page 273's
382 Build_MatchMany_Function() is particularly interesting. A complete
383 citation of this book is given in L<perlfaq2>.
385 =item Passing Methods
387 To pass an object method into a subroutine, you can do this:
389 call_a_lot(10, $some_obj, "methname")
391 my ($count, $widget, $trick) = @_;
392 for (my $i = 0; $i < $count; $i++) {
397 Or, you can use a closure to bundle up the object, its
398 method call, and arguments:
400 my $whatnot = sub { $some_obj->obfuscate(@args) };
407 You could also investigate the can() method in the UNIVERSAL class
408 (part of the standard perl distribution).
412 =head2 How do I create a static variable?
414 (contributed by brian d foy)
416 Perl doesn't have "static" variables, which can only be accessed from
417 the function in which they are declared. You can get the same effect
418 with lexical variables, though.
420 You can fake a static variable by using a lexical variable which goes
421 of scope. In this example, you define the subroutine C<counter>, and
422 it uses the lexical variable C<$count>. Since you wrap this in a BEGIN
423 block, C<$count> is defined at compile-time, but also goes out of
424 scope at the end of the BEGIN block. The BEGIN block also ensures that
425 the subroutine and the value it uses is defined at compile-time so the
426 subroutine is ready to use just like any other subroutine, and you can
427 put this code in the same place as other subroutines in the program
428 text (i.e. at the end of the code, typically). The subroutine
429 C<counter> still has a reference to the data, and is the only way you
430 can access the value (and each time you do, you increment the value).
431 The data in chunk of memory defined by C<$count> is private to
436 sub counter { $count++ }
441 .... # code that calls count();
445 In the previous example, you created a function-private variable
446 because only one function remembered its reference. You could define
447 multiple functions while the variable is in scope, and each function
448 can share the "private" variable. It's not really "static" because you
449 can access it outside the function while the lexical variable is in
450 scope, and even create references to it. In this example,
451 C<increment_count> and C<return_count> share the variable. One
452 function adds to the value and the other simply returns the value.
453 They can both access C<$count>, and since it has gone out of scope,
454 there is no other way to access it.
458 sub increment_count { $count++ }
459 sub return_count { $count }
462 To declare a file-private variable, you still use a lexical variable.
463 A file is also a scope, so a lexical variable defined in the file
464 cannot be seen from any other file.
466 See L<perlsub/"Persistent Private Variables"> for more information.
467 The discussion of closures in L<perlref> may help you even though we
468 did not use anonymous subroutines in this answer. See
469 L<perlsub/"Persistent Private Variables"> for details.
471 =head2 What's the difference between dynamic and lexical (static) scoping? Between local() and my()?
473 C<local($x)> saves away the old value of the global variable C<$x>
474 and assigns a new value for the duration of the subroutine I<which is
475 visible in other functions called from that subroutine>. This is done
476 at run-time, so is called dynamic scoping. local() always affects global
477 variables, also called package variables or dynamic variables.
479 C<my($x)> creates a new variable that is only visible in the current
480 subroutine. This is done at compile-time, so it is called lexical or
481 static scoping. my() always affects private variables, also called
482 lexical variables or (improperly) static(ly scoped) variables.
487 print "var has value $var\n";
491 local $var = 'local'; # new temporary value for the still-global
492 visible(); # variable called $var
496 my $var = 'private'; # new private variable, $var
497 visible(); # (invisible outside of sub scope)
502 visible(); # prints global
503 dynamic(); # prints local
504 lexical(); # prints global
506 Notice how at no point does the value "private" get printed. That's
507 because $var only has that value within the block of the lexical()
508 function, and it is hidden from called subroutine.
510 In summary, local() doesn't make what you think of as private, local
511 variables. It gives a global variable a temporary value. my() is
512 what you're looking for if you want private variables.
514 See L<perlsub/"Private Variables via my()"> and
515 L<perlsub/"Temporary Values via local()"> for excruciating details.
517 =head2 How can I access a dynamic variable while a similarly named lexical is in scope?
519 If you know your package, you can just mention it explicitly, as in
520 $Some_Pack::var. Note that the notation $::var is B<not> the dynamic $var
521 in the current package, but rather the one in the "main" package, as
522 though you had written $main::var.
525 local $var = "global";
528 print "lexical is $var\n";
529 print "global is $main::var\n";
531 Alternatively you can use the compiler directive our() to bring a
532 dynamic variable into the current lexical scope.
534 require 5.006; # our() did not exist before 5.6
537 local $var = "global";
540 print "lexical is $var\n";
544 print "global is $var\n";
547 =head2 What's the difference between deep and shallow binding?
549 In deep binding, lexical variables mentioned in anonymous subroutines
550 are the same ones that were in scope when the subroutine was created.
551 In shallow binding, they are whichever variables with the same names
552 happen to be in scope when the subroutine is called. Perl always uses
553 deep binding of lexical variables (i.e., those created with my()).
554 However, dynamic variables (aka global, local, or package variables)
555 are effectively shallowly bound. Consider this just one more reason
556 not to use them. See the answer to L<"What's a closure?">.
558 =head2 Why doesn't "my($foo) = E<lt>FILEE<gt>;" work right?
560 C<my()> and C<local()> give list context to the right hand side
561 of C<=>. The <FH> read operation, like so many of Perl's
562 functions and operators, can tell which context it was called in and
563 behaves appropriately. In general, the scalar() function can help.
564 This function does nothing to the data itself (contrary to popular myth)
565 but rather tells its argument to behave in whatever its scalar fashion is.
566 If that function doesn't have a defined scalar behavior, this of course
567 doesn't help you (such as with sort()).
569 To enforce scalar context in this particular case, however, you need
570 merely omit the parentheses:
572 local($foo) = <FILE>; # WRONG
573 local($foo) = scalar(<FILE>); # ok
574 local $foo = <FILE>; # right
576 You should probably be using lexical variables anyway, although the
577 issue is the same here:
579 my($foo) = <FILE>; # WRONG
580 my $foo = <FILE>; # right
582 =head2 How do I redefine a builtin function, operator, or method?
584 Why do you want to do that? :-)
586 If you want to override a predefined function, such as open(),
587 then you'll have to import the new definition from a different
588 module. See L<perlsub/"Overriding Built-in Functions">. There's
589 also an example in L<perltoot/"Class::Template">.
591 If you want to overload a Perl operator, such as C<+> or C<**>,
592 then you'll want to use the C<use overload> pragma, documented
595 If you're talking about obscuring method calls in parent classes,
596 see L<perltoot/"Overridden Methods">.
598 =head2 What's the difference between calling a function as &foo and foo()?
600 When you call a function as C<&foo>, you allow that function access to
601 your current @_ values, and you bypass prototypes.
602 The function doesn't get an empty @_--it gets yours! While not
603 strictly speaking a bug (it's documented that way in L<perlsub>), it
604 would be hard to consider this a feature in most cases.
606 When you call your function as C<&foo()>, then you I<do> get a new @_,
607 but prototyping is still circumvented.
609 Normally, you want to call a function using C<foo()>. You may only
610 omit the parentheses if the function is already known to the compiler
611 because it already saw the definition (C<use> but not C<require>),
612 or via a forward reference or C<use subs> declaration. Even in this
613 case, you get a clean @_ without any of the old values leaking through
614 where they don't belong.
616 =head2 How do I create a switch or case statement?
618 This is explained in more depth in the L<perlsyn>. Briefly, there's
619 no official case statement, because of the variety of tests possible
620 in Perl (numeric comparison, string comparison, glob comparison,
621 regex matching, overloaded comparisons, ...).
622 Larry couldn't decide how best to do this, so he left it out, even
623 though it's been on the wish list since perl1.
625 Starting from Perl 5.8 to get switch and case one can use the
626 Switch extension and say:
630 after which one has switch and case. It is not as fast as it could be
631 because it's not really part of the language (it's done using source
632 filters) but it is available, and it's very flexible.
634 But if one wants to use pure Perl, the general answer is to write a
637 for ($variable_to_test) {
638 if (/pat1/) { } # do something
639 elsif (/pat2/) { } # do something else
640 elsif (/pat3/) { } # do something else
644 Here's a simple example of a switch based on pattern matching, this
645 time lined up in a way to make it look more like a switch statement.
646 We'll do a multiway conditional based on the type of reference stored
649 SWITCH: for (ref $whatchamacallit) {
651 /^$/ && die "not a reference";
669 warn "can't print function ref";
675 warn "User defined type skipped";
679 See C<perlsyn/"Basic BLOCKs and Switch Statements"> for many other
680 examples in this style.
682 Sometimes you should change the positions of the constant and the variable.
683 For example, let's say you wanted to test which of many answers you were
684 given, but in a case-insensitive way that also allows abbreviations.
685 You can use the following technique if the strings all start with
686 different characters or if you want to arrange the matches so that
687 one takes precedence over another, as C<"SEND"> has precedence over
691 if ("SEND" =~ /^\Q$answer/i) { print "Action is send\n" }
692 elsif ("STOP" =~ /^\Q$answer/i) { print "Action is stop\n" }
693 elsif ("ABORT" =~ /^\Q$answer/i) { print "Action is abort\n" }
694 elsif ("LIST" =~ /^\Q$answer/i) { print "Action is list\n" }
695 elsif ("EDIT" =~ /^\Q$answer/i) { print "Action is edit\n" }
697 A totally different approach is to create a hash of function references.
702 "done" => sub { die "See ya!" },
706 print "How are you? ";
707 chomp($string = <STDIN>);
708 if ($commands{$string}) {
709 $commands{$string}->();
711 print "No such command: $string\n";
714 =head2 How can I catch accesses to undefined variables, functions, or methods?
716 The AUTOLOAD method, discussed in L<perlsub/"Autoloading"> and
717 L<perltoot/"AUTOLOAD: Proxy Methods">, lets you capture calls to
718 undefined functions and methods.
720 When it comes to undefined variables that would trigger a warning
721 under C<use warnings>, you can promote the warning to an error.
723 use warnings FATAL => qw(uninitialized);
725 =head2 Why can't a method included in this same file be found?
727 Some possible reasons: your inheritance is getting confused, you've
728 misspelled the method name, or the object is of the wrong type. Check
729 out L<perltoot> for details about any of the above cases. You may
730 also use C<print ref($object)> to find out the class C<$object> was
733 Another possible reason for problems is because you've used the
734 indirect object syntax (eg, C<find Guru "Samy">) on a class name
735 before Perl has seen that such a package exists. It's wisest to make
736 sure your packages are all defined before you start using them, which
737 will be taken care of if you use the C<use> statement instead of
738 C<require>. If not, make sure to use arrow notation (eg.,
739 C<< Guru->find("Samy") >>) instead. Object notation is explained in
742 Make sure to read about creating modules in L<perlmod> and
743 the perils of indirect objects in L<perlobj/"Method Invocation">.
745 =head2 How can I find out my current package?
747 If you're just a random program, you can do this to find
748 out what the currently compiled package is:
750 my $packname = __PACKAGE__;
752 But, if you're a method and you want to print an error message
753 that includes the kind of object you were called on (which is
754 not necessarily the same as the one in which you were compiled):
758 my $class = ref($self) || $self;
759 warn "called me from a $class object";
762 =head2 How can I comment out a large block of perl code?
764 You can use embedded POD to discard it. Enclose the blocks you want
765 to comment out in POD markers. The <=begin> directive marks a section
766 for a specific formatter. Use the C<comment> format, which no formatter
767 should claim to understand (by policy). Mark the end of the block
785 The pod directives cannot go just anywhere. You must put a
786 pod directive where the parser is expecting a new statement,
787 not just in the middle of an expression or some other
788 arbitrary grammar production.
790 See L<perlpod> for more details.
792 =head2 How do I clear a package?
794 Use this code, provided by Mark-Jason Dominus:
799 die "Shouldn't delete main package"
800 if $pack eq "" || $pack eq "main";
801 my $stash = *{$pack . '::'}{HASH};
803 foreach $name (keys %$stash) {
804 my $fullname = $pack . '::' . $name;
805 # Get rid of everything with that name.
814 Or, if you're using a recent release of Perl, you can
815 just use the Symbol::delete_package() function instead.
817 =head2 How can I use a variable as a variable name?
819 Beginners often think they want to have a variable contain the name
824 ++$$varname; # $fred now 24
826 This works I<sometimes>, but it is a very bad idea for two reasons.
828 The first reason is that this technique I<only works on global
829 variables>. That means that if $fred is a lexical variable created
830 with my() in the above example, the code wouldn't work at all: you'd
831 accidentally access the global and skip right over the private lexical
832 altogether. Global variables are bad because they can easily collide
833 accidentally and in general make for non-scalable and confusing code.
835 Symbolic references are forbidden under the C<use strict> pragma.
836 They are not true references and consequently are not reference counted
837 or garbage collected.
839 The other reason why using a variable to hold the name of another
840 variable is a bad idea is that the question often stems from a lack of
841 understanding of Perl data structures, particularly hashes. By using
842 symbolic references, you are just using the package's symbol-table hash
843 (like C<%main::>) instead of a user-defined hash. The solution is to
844 use your own hash or a real reference instead.
846 $USER_VARS{"fred"} = 23;
848 $USER_VARS{$varname}++; # not $$varname++
850 There we're using the %USER_VARS hash instead of symbolic references.
851 Sometimes this comes up in reading strings from the user with variable
852 references and wanting to expand them to the values of your perl
853 program's variables. This is also a bad idea because it conflates the
854 program-addressable namespace and the user-addressable one. Instead of
855 reading a string and expanding it to the actual contents of your program's
858 $str = 'this has a $fred and $barney in it';
859 $str =~ s/(\$\w+)/$1/eeg; # need double eval
861 it would be better to keep a hash around like %USER_VARS and have
862 variable references actually refer to entries in that hash:
864 $str =~ s/\$(\w+)/$USER_VARS{$1}/g; # no /e here at all
866 That's faster, cleaner, and safer than the previous approach. Of course,
867 you don't need to use a dollar sign. You could use your own scheme to
868 make it less confusing, like bracketed percent symbols, etc.
870 $str = 'this has a %fred% and %barney% in it';
871 $str =~ s/%(\w+)%/$USER_VARS{$1}/g; # no /e here at all
873 Another reason that folks sometimes think they want a variable to
874 contain the name of a variable is because they don't know how to build
875 proper data structures using hashes. For example, let's say they
876 wanted two hashes in their program: %fred and %barney, and that they
877 wanted to use another scalar variable to refer to those by name.
880 $$name{WIFE} = "wilma"; # set %fred
883 $$name{WIFE} = "betty"; # set %barney
885 This is still a symbolic reference, and is still saddled with the
886 problems enumerated above. It would be far better to write:
888 $folks{"fred"}{WIFE} = "wilma";
889 $folks{"barney"}{WIFE} = "betty";
891 And just use a multilevel hash to start with.
893 The only times that you absolutely I<must> use symbolic references are
894 when you really must refer to the symbol table. This may be because it's
895 something that can't take a real reference to, such as a format name.
896 Doing so may also be important for method calls, since these always go
897 through the symbol table for resolution.
899 In those cases, you would turn off C<strict 'refs'> temporarily so you
900 can play around with the symbol table. For example:
902 @colors = qw(red blue green yellow orange purple violet);
903 for my $name (@colors) {
904 no strict 'refs'; # renege for the block
905 *$name = sub { "<FONT COLOR='$name'>@_</FONT>" };
908 All those functions (red(), blue(), green(), etc.) appear to be separate,
909 but the real code in the closure actually was compiled only once.
911 So, sometimes you might want to use symbolic references to directly
912 manipulate the symbol table. This doesn't matter for formats, handles, and
913 subroutines, because they are always global--you can't use my() on them.
914 For scalars, arrays, and hashes, though--and usually for subroutines--
915 you probably only want to use hard references.
917 =head2 What does "bad interpreter" mean?
919 (contributed by brian d foy)
921 The "bad interpreter" message comes from the shell, not perl. The
922 actual message may vary depending on your platform, shell, and locale
925 If you see "bad interpreter - no such file or directory", the first
926 line in your perl script (the "shebang" line) does not contain the
927 right path to perl (or any other program capable of running scripts).
928 Sometimes this happens when you move the script from one machine to
929 another and each machine has a different path to perl---/usr/bin/perl
930 versus /usr/local/bin/perl for instance. It may also indicate
931 that the source machine has CRLF line terminators and the
932 destination machine has LF only: the shell tries to find
933 /usr/bin/perl<CR>, but can't.
935 If you see "bad interpreter: Permission denied", you need to make your
938 In either case, you should still be able to run the scripts with perl
943 If you get a message like "perl: command not found", perl is not in
944 your PATH, which might also mean that the location of perl is not
945 where you expect it so you need to adjust your shebang line.
947 =head1 AUTHOR AND COPYRIGHT
949 Copyright (c) 1997-2005 Tom Christiansen, Nathan Torkington, and
950 other authors as noted. All rights reserved.
952 This documentation is free; you can redistribute it and/or modify it
953 under the same terms as Perl itself.
955 Irrespective of its distribution, all code examples in this file
956 are hereby placed into the public domain. You are permitted and
957 encouraged to use this code in your own programs for fun
958 or for profit as you see fit. A simple comment in the code giving
959 credit would be courteous but is not required.