summaryrefslogtreecommitdiff
path: root/Master/tlpkg/tlperl/lib/pods/perlfaq7.pod
diff options
context:
space:
mode:
Diffstat (limited to 'Master/tlpkg/tlperl/lib/pods/perlfaq7.pod')
-rw-r--r--Master/tlpkg/tlperl/lib/pods/perlfaq7.pod1061
1 files changed, 0 insertions, 1061 deletions
diff --git a/Master/tlpkg/tlperl/lib/pods/perlfaq7.pod b/Master/tlpkg/tlperl/lib/pods/perlfaq7.pod
deleted file mode 100644
index 35c9330f2dc..00000000000
--- a/Master/tlpkg/tlperl/lib/pods/perlfaq7.pod
+++ /dev/null
@@ -1,1061 +0,0 @@
-=head1 NAME
-
-perlfaq7 - General Perl Language Issues
-
-=head1 DESCRIPTION
-
-This section deals with general Perl language issues that don't
-clearly fit into any of the other sections.
-
-=head2 Can I get a BNF/yacc/RE for the Perl language?
-
-There is no BNF, but you can paw your way through the yacc grammar in
-perly.y in the source distribution if you're particularly brave. The
-grammar relies on very smart tokenizing code, so be prepared to
-venture into toke.c as well.
-
-In the words of Chaim Frenkel: "Perl's grammar can not be reduced to BNF.
-The work of parsing perl is distributed between yacc, the lexer, smoke
-and mirrors."
-
-=head2 What are all these $@%&* punctuation signs, and how do I know when to use them?
-
-They are type specifiers, as detailed in L<perldata>:
-
- $ for scalar values (number, string or reference)
- @ for arrays
- % for hashes (associative arrays)
- & for subroutines (aka functions, procedures, methods)
- * for all types of that symbol name. In version 4 you used them like
- pointers, but in modern perls you can just use references.
-
-There are a couple of other symbols that
-you're likely to encounter that aren't
-really type specifiers:
-
- <> are used for inputting a record from a filehandle.
- \ takes a reference to something.
-
-Note that <FILE> is I<neither> the type specifier for files
-nor the name of the handle. It is the C<< <> >> operator applied
-to the handle FILE. It reads one line (well, record--see
-L<perlvar/$E<sol>>) from the handle FILE in scalar context, or I<all> lines
-in list context. When performing open, close, or any other operation
-besides C<< <> >> on files, or even when talking about the handle, do
-I<not> use the brackets. These are correct: C<eof(FH)>, C<seek(FH, 0,
-2)> and "copying from STDIN to FILE".
-
-=head2 Do I always/never have to quote my strings or use semicolons and commas?
-
-Normally, a bareword doesn't need to be quoted, but in most cases
-probably should be (and must be under C<use strict>). But a hash key
-consisting of a simple word and the left-hand
-operand to the C<< => >> operator both
-count as though they were quoted:
-
- This is like this
- ------------ ---------------
- $foo{line} $foo{'line'}
- bar => stuff 'bar' => stuff
-
-The final semicolon in a block is optional, as is the final comma in a
-list. Good style (see L<perlstyle>) says to put them in except for
-one-liners:
-
- if ($whoops) { exit 1 }
- my @nums = (1, 2, 3);
-
- if ($whoops) {
- exit 1;
- }
-
- my @lines = (
- "There Beren came from mountains cold",
- "And lost he wandered under leaves",
- );
-
-=head2 How do I skip some return values?
-
-One way is to treat the return values as a list and index into it:
-
- $dir = (getpwnam($user))[7];
-
-Another way is to use undef as an element on the left-hand-side:
-
- ($dev, $ino, undef, undef, $uid, $gid) = stat($file);
-
-You can also use a list slice to select only the elements that
-you need:
-
- ($dev, $ino, $uid, $gid) = ( stat($file) )[0,1,4,5];
-
-=head2 How do I temporarily block warnings?
-
-If you are running Perl 5.6.0 or better, the C<use warnings> pragma
-allows fine control of what warnings are produced.
-See L<perllexwarn> for more details.
-
- {
- no warnings; # temporarily turn off warnings
- $x = $y + $z; # I know these might be undef
- }
-
-Additionally, you can enable and disable categories of warnings.
-You turn off the categories you want to ignore and you can still
-get other categories of warnings. See L<perllexwarn> for the
-complete details, including the category names and hierarchy.
-
- {
- no warnings 'uninitialized';
- $x = $y + $z;
- }
-
-If you have an older version of Perl, the C<$^W> variable (documented
-in L<perlvar>) controls runtime warnings for a block:
-
- {
- local $^W = 0; # temporarily turn off warnings
- $x = $y + $z; # I know these might be undef
- }
-
-Note that like all the punctuation variables, you cannot currently
-use my() on C<$^W>, only local().
-
-=head2 What's an extension?
-
-An extension is a way of calling compiled C code from Perl. Reading
-L<perlxstut> is a good place to learn more about extensions.
-
-=head2 Why do Perl operators have different precedence than C operators?
-
-Actually, they don't. All C operators that Perl copies have the same
-precedence in Perl as they do in C. The problem is with operators that C
-doesn't have, especially functions that give a list context to everything
-on their right, eg. print, chmod, exec, and so on. Such functions are
-called "list operators" and appear as such in the precedence table in
-L<perlop>.
-
-A common mistake is to write:
-
- unlink $file || die "snafu";
-
-This gets interpreted as:
-
- unlink ($file || die "snafu");
-
-To avoid this problem, either put in extra parentheses or use the
-super low precedence C<or> operator:
-
- (unlink $file) || die "snafu";
- unlink $file or die "snafu";
-
-The "English" operators (C<and>, C<or>, C<xor>, and C<not>)
-deliberately have precedence lower than that of list operators for
-just such situations as the one above.
-
-Another operator with surprising precedence is exponentiation. It
-binds more tightly even than unary minus, making C<-2**2> produce a
-negative four and not a positive one. It is also right-associating, meaning
-that C<2**3**2> is two raised to the ninth power, not eight squared.
-
-Although it has the same precedence as in C, Perl's C<?:> operator
-produces an lvalue. This assigns $x to either $if_true or $if_false, depending
-on the trueness of $maybe:
-
- ($maybe ? $if_true : $if_false) = $x;
-
-=head2 How do I declare/create a structure?
-
-In general, you don't "declare" a structure. Just use a (probably
-anonymous) hash reference. See L<perlref> and L<perldsc> for details.
-Here's an example:
-
- $person = {}; # new anonymous hash
- $person->{AGE} = 24; # set field AGE to 24
- $person->{NAME} = "Nat"; # set field NAME to "Nat"
-
-If you're looking for something a bit more rigorous, try L<perltoot>.
-
-=head2 How do I create a module?
-
-L<perlnewmod> is a good place to start, ignore the bits
-about uploading to CPAN if you don't want to make your
-module publicly available.
-
-L<ExtUtils::ModuleMaker> and L<Module::Starter> are also
-good places to start. Many CPAN authors now use L<Dist::Zilla>
-to automate as much as possible.
-
-Detailed documentation about modules can be found at:
-L<perlmod>, L<perlmodlib>, L<perlmodstyle>.
-
-If you need to include C code or C library interfaces
-use h2xs. h2xs will create the module distribution structure
-and the initial interface files.
-L<perlxs> and L<perlxstut> explain the details.
-
-=head2 How do I adopt or take over a module already on CPAN?
-
-Ask the current maintainer to make you a co-maintainer or
-transfer the module to you.
-
-If you can not reach the author for some reason contact
-the PAUSE admins at modules@perl.org who may be able to help,
-but each case it treated seperatly.
-
-=over 4
-
-=item *
-
-Get a login for the Perl Authors Upload Server (PAUSE) if you don't
-already have one: L<http://pause.perl.org>
-
-=item *
-
-Write to modules@perl.org explaining what you did to contact the
-current maintainer. The PAUSE admins will also try to reach the
-maintainer.
-
-=item *
-
-Post a public message in a heavily trafficked site announcing your
-intention to take over the module.
-
-=item *
-
-Wait a bit. The PAUSE admins don't want to act too quickly in case
-the current maintainer is on holiday. If there's no response to
-private communication or the public post, a PAUSE admin can transfer
-it to you.
-
-=back
-
-=head2 How do I create a class?
-X<class, creation> X<package>
-
-(contributed by brian d foy)
-
-In Perl, a class is just a package, and methods are just subroutines.
-Perl doesn't get more formal than that and lets you set up the package
-just the way that you like it (that is, it doesn't set up anything for
-you).
-
-The Perl documentation has several tutorials that cover class
-creation, including L<perlboot> (Barnyard Object Oriented Tutorial),
-L<perltoot> (Tom's Object Oriented Tutorial), L<perlbot> (Bag o'
-Object Tricks), and L<perlobj>.
-
-=head2 How can I tell if a variable is tainted?
-
-You can use the tainted() function of the Scalar::Util module, available
-from CPAN (or included with Perl since release 5.8.0).
-See also L<perlsec/"Laundering and Detecting Tainted Data">.
-
-=head2 What's a closure?
-
-Closures are documented in L<perlref>.
-
-I<Closure> is a computer science term with a precise but
-hard-to-explain meaning. Usually, closures are implemented in Perl as
-anonymous subroutines with lasting references to lexical variables
-outside their own scopes. These lexicals magically refer to the
-variables that were around when the subroutine was defined (deep
-binding).
-
-Closures are most often used in programming languages where you can
-have the return value of a function be itself a function, as you can
-in Perl. Note that some languages provide anonymous functions but are
-not capable of providing proper closures: the Python language, for
-example. For more information on closures, check out any textbook on
-functional programming. Scheme is a language that not only supports
-but encourages closures.
-
-Here's a classic non-closure function-generating function:
-
- sub add_function_generator {
- return sub { shift() + shift() };
- }
-
- my $add_sub = add_function_generator();
- my $sum = $add_sub->(4,5); # $sum is 9 now.
-
-The anonymous subroutine returned by add_function_generator() isn't
-technically a closure because it refers to no lexicals outside its own
-scope. Using a closure gives you a I<function template> with some
-customization slots left out to be filled later.
-
-Contrast this with the following make_adder() function, in which the
-returned anonymous function contains a reference to a lexical variable
-outside the scope of that function itself. Such a reference requires
-that Perl return a proper closure, thus locking in for all time the
-value that the lexical had when the function was created.
-
- sub make_adder {
- my $addpiece = shift;
- return sub { shift() + $addpiece };
- }
-
- my $f1 = make_adder(20);
- my $f2 = make_adder(555);
-
-Now C<< $f1->($n) >> is always 20 plus whatever $n you pass in, whereas
-C<< $f2->($n) >> is always 555 plus whatever $n you pass in. The $addpiece
-in the closure sticks around.
-
-Closures are often used for less esoteric purposes. For example, when
-you want to pass in a bit of code into a function:
-
- my $line;
- timeout( 30, sub { $line = <STDIN> } );
-
-If the code to execute had been passed in as a string,
-C<< '$line = <STDIN>' >>, there would have been no way for the
-hypothetical timeout() function to access the lexical variable
-$line back in its caller's scope.
-
-Another use for a closure is to make a variable I<private> to a
-named subroutine, e.g. a counter that gets initialized at creation
-time of the sub and can only be modified from within the sub.
-This is sometimes used with a BEGIN block in package files to make
-sure a variable doesn't get meddled with during the lifetime of the
-package:
-
- BEGIN {
- my $id = 0;
- sub next_id { ++$id }
- }
-
-This is discussed in more detail in L<perlsub>; see the entry on
-I<Persistent Private Variables>.
-
-=head2 What is variable suicide and how can I prevent it?
-
-This problem was fixed in perl 5.004_05, so preventing it means upgrading
-your version of perl. ;)
-
-Variable suicide is when you (temporarily or permanently) lose the value
-of a variable. It is caused by scoping through my() and local()
-interacting with either closures or aliased foreach() iterator variables
-and subroutine arguments. It used to be easy to inadvertently lose a
-variable's value this way, but now it's much harder. Take this code:
-
- my $f = 'foo';
- sub T {
- while ($i++ < 3) { my $f = $f; $f .= "bar"; print $f, "\n" }
- }
-
- T;
- print "Finally $f\n";
-
-If you are experiencing variable suicide, that C<my $f> in the subroutine
-doesn't pick up a fresh copy of the C<$f> whose value is C<'foo'>. The
-output shows that inside the subroutine the value of C<$f> leaks through
-when it shouldn't, as in this output:
-
- foobar
- foobarbar
- foobarbarbar
- Finally foo
-
-The $f that has "bar" added to it three times should be a new C<$f>
-C<my $f> should create a new lexical variable each time through the loop.
-The expected output is:
-
- foobar
- foobar
- foobar
- Finally foo
-
-=head2 How can I pass/return a {Function, FileHandle, Array, Hash, Method, Regex}?
-
-You need to pass references to these objects. See L<perlsub/"Pass by
-Reference"> for this particular question, and L<perlref> for
-information on references.
-
-=over 4
-
-=item Passing Variables and Functions
-
-Regular variables and functions are quite easy to pass: just pass in a
-reference to an existing or anonymous variable or function:
-
- func( \$some_scalar );
-
- func( \@some_array );
- func( [ 1 .. 10 ] );
-
- func( \%some_hash );
- func( { this => 10, that => 20 } );
-
- func( \&some_func );
- func( sub { $_[0] ** $_[1] } );
-
-=item Passing Filehandles
-
-As of Perl 5.6, you can represent filehandles with scalar variables
-which you treat as any other scalar.
-
- open my $fh, $filename or die "Cannot open $filename! $!";
- func( $fh );
-
- sub func {
- my $passed_fh = shift;
-
- my $line = <$passed_fh>;
- }
-
-Before Perl 5.6, you had to use the C<*FH> or C<\*FH> notations.
-These are "typeglobs"--see L<perldata/"Typeglobs and Filehandles">
-and especially L<perlsub/"Pass by Reference"> for more information.
-
-=item Passing Regexes
-
-Here's an example of how to pass in a string and a regular expression
-for it to match against. You construct the pattern with the C<qr//>
-operator:
-
- sub compare($$) {
- my ($val1, $regex) = @_;
- my $retval = $val1 =~ /$regex/;
- return $retval;
- }
- $match = compare("old McDonald", qr/d.*D/i);
-
-=item Passing Methods
-
-To pass an object method into a subroutine, you can do this:
-
- call_a_lot(10, $some_obj, "methname")
- sub call_a_lot {
- my ($count, $widget, $trick) = @_;
- for (my $i = 0; $i < $count; $i++) {
- $widget->$trick();
- }
- }
-
-Or, you can use a closure to bundle up the object, its
-method call, and arguments:
-
- my $whatnot = sub { $some_obj->obfuscate(@args) };
- func($whatnot);
- sub func {
- my $code = shift;
- &$code();
- }
-
-You could also investigate the can() method in the UNIVERSAL class
-(part of the standard perl distribution).
-
-=back
-
-=head2 How do I create a static variable?
-
-(contributed by brian d foy)
-
-In Perl 5.10, declare the variable with C<state>. The C<state>
-declaration creates the lexical variable that persists between calls
-to the subroutine:
-
- sub counter { state $count = 1; $count++ }
-
-You can fake a static variable by using a lexical variable which goes
-out of scope. In this example, you define the subroutine C<counter>, and
-it uses the lexical variable C<$count>. Since you wrap this in a BEGIN
-block, C<$count> is defined at compile-time, but also goes out of
-scope at the end of the BEGIN block. The BEGIN block also ensures that
-the subroutine and the value it uses is defined at compile-time so the
-subroutine is ready to use just like any other subroutine, and you can
-put this code in the same place as other subroutines in the program
-text (i.e. at the end of the code, typically). The subroutine
-C<counter> still has a reference to the data, and is the only way you
-can access the value (and each time you do, you increment the value).
-The data in chunk of memory defined by C<$count> is private to
-C<counter>.
-
- BEGIN {
- my $count = 1;
- sub counter { $count++ }
- }
-
- my $start = counter();
-
- .... # code that calls counter();
-
- my $end = counter();
-
-In the previous example, you created a function-private variable
-because only one function remembered its reference. You could define
-multiple functions while the variable is in scope, and each function
-can share the "private" variable. It's not really "static" because you
-can access it outside the function while the lexical variable is in
-scope, and even create references to it. In this example,
-C<increment_count> and C<return_count> share the variable. One
-function adds to the value and the other simply returns the value.
-They can both access C<$count>, and since it has gone out of scope,
-there is no other way to access it.
-
- BEGIN {
- my $count = 1;
- sub increment_count { $count++ }
- sub return_count { $count }
- }
-
-To declare a file-private variable, you still use a lexical variable.
-A file is also a scope, so a lexical variable defined in the file
-cannot be seen from any other file.
-
-See L<perlsub/"Persistent Private Variables"> for more information.
-The discussion of closures in L<perlref> may help you even though we
-did not use anonymous subroutines in this answer. See
-L<perlsub/"Persistent Private Variables"> for details.
-
-=head2 What's the difference between dynamic and lexical (static) scoping? Between local() and my()?
-
-C<local($x)> saves away the old value of the global variable C<$x>
-and assigns a new value for the duration of the subroutine I<which is
-visible in other functions called from that subroutine>. This is done
-at run-time, so is called dynamic scoping. local() always affects global
-variables, also called package variables or dynamic variables.
-
-C<my($x)> creates a new variable that is only visible in the current
-subroutine. This is done at compile-time, so it is called lexical or
-static scoping. my() always affects private variables, also called
-lexical variables or (improperly) static(ly scoped) variables.
-
-For instance:
-
- sub visible {
- print "var has value $var\n";
- }
-
- sub dynamic {
- local $var = 'local'; # new temporary value for the still-global
- visible(); # variable called $var
- }
-
- sub lexical {
- my $var = 'private'; # new private variable, $var
- visible(); # (invisible outside of sub scope)
- }
-
- $var = 'global';
-
- visible(); # prints global
- dynamic(); # prints local
- lexical(); # prints global
-
-Notice how at no point does the value "private" get printed. That's
-because $var only has that value within the block of the lexical()
-function, and it is hidden from the called subroutine.
-
-In summary, local() doesn't make what you think of as private, local
-variables. It gives a global variable a temporary value. my() is
-what you're looking for if you want private variables.
-
-See L<perlsub/"Private Variables via my()"> and
-L<perlsub/"Temporary Values via local()"> for excruciating details.
-
-=head2 How can I access a dynamic variable while a similarly named lexical is in scope?
-
-If you know your package, you can just mention it explicitly, as in
-$Some_Pack::var. Note that the notation $::var is B<not> the dynamic $var
-in the current package, but rather the one in the "main" package, as
-though you had written $main::var.
-
- use vars '$var';
- local $var = "global";
- my $var = "lexical";
-
- print "lexical is $var\n";
- print "global is $main::var\n";
-
-Alternatively you can use the compiler directive our() to bring a
-dynamic variable into the current lexical scope.
-
- require 5.006; # our() did not exist before 5.6
- use vars '$var';
-
- local $var = "global";
- my $var = "lexical";
-
- print "lexical is $var\n";
-
- {
- our $var;
- print "global is $var\n";
- }
-
-=head2 What's the difference between deep and shallow binding?
-
-In deep binding, lexical variables mentioned in anonymous subroutines
-are the same ones that were in scope when the subroutine was created.
-In shallow binding, they are whichever variables with the same names
-happen to be in scope when the subroutine is called. Perl always uses
-deep binding of lexical variables (i.e., those created with my()).
-However, dynamic variables (aka global, local, or package variables)
-are effectively shallowly bound. Consider this just one more reason
-not to use them. See the answer to L<"What's a closure?">.
-
-=head2 Why doesn't "my($foo) = E<lt>$fhE<gt>;" work right?
-
-C<my()> and C<local()> give list context to the right hand side
-of C<=>. The <$fh> read operation, like so many of Perl's
-functions and operators, can tell which context it was called in and
-behaves appropriately. In general, the scalar() function can help.
-This function does nothing to the data itself (contrary to popular myth)
-but rather tells its argument to behave in whatever its scalar fashion is.
-If that function doesn't have a defined scalar behavior, this of course
-doesn't help you (such as with sort()).
-
-To enforce scalar context in this particular case, however, you need
-merely omit the parentheses:
-
- local($foo) = <$fh>; # WRONG
- local($foo) = scalar(<$fh>); # ok
- local $foo = <$fh>; # right
-
-You should probably be using lexical variables anyway, although the
-issue is the same here:
-
- my($foo) = <$fh>; # WRONG
- my $foo = <$fh>; # right
-
-=head2 How do I redefine a builtin function, operator, or method?
-
-Why do you want to do that? :-)
-
-If you want to override a predefined function, such as open(),
-then you'll have to import the new definition from a different
-module. See L<perlsub/"Overriding Built-in Functions">.
-
-If you want to overload a Perl operator, such as C<+> or C<**>,
-then you'll want to use the C<use overload> pragma, documented
-in L<overload>.
-
-If you're talking about obscuring method calls in parent classes,
-see L<perltoot/"Overridden Methods">.
-
-=head2 What's the difference between calling a function as &foo and foo()?
-
-(contributed by brian d foy)
-
-Calling a subroutine as C<&foo> with no trailing parentheses ignores
-the prototype of C<foo> and passes it the current value of the argument
-list, C<@_>. Here's an example; the C<bar> subroutine calls C<&foo>,
-which prints its arguments list:
-
- sub bar { &foo }
-
- sub foo { print "Args in foo are: @_\n" }
-
- bar( qw( a b c ) );
-
-When you call C<bar> with arguments, you see that C<foo> got the same C<@_>:
-
- Args in foo are: a b c
-
-Calling the subroutine with trailing parentheses, with or without arguments,
-does not use the current C<@_> and respects the subroutine prototype. Changing
-the example to put parentheses after the call to C<foo> changes the program:
-
- sub bar { &foo() }
-
- sub foo { print "Args in foo are: @_\n" }
-
- bar( qw( a b c ) );
-
-Now the output shows that C<foo> doesn't get the C<@_> from its caller.
-
- Args in foo are:
-
-The main use of the C<@_> pass-through feature is to write subroutines
-whose main job it is to call other subroutines for you. For further
-details, see L<perlsub>.
-
-=head2 How do I create a switch or case statement?
-
-In Perl 5.10, use the C<given-when> construct described in L<perlsyn>:
-
- use 5.010;
-
- given ( $string ) {
- when( 'Fred' ) { say "I found Fred!" }
- when( 'Barney' ) { say "I found Barney!" }
- when( /Bamm-?Bamm/ ) { say "I found Bamm-Bamm!" }
- default { say "I don't recognize the name!" }
- };
-
-If one wants to use pure Perl and to be compatible with Perl versions
-prior to 5.10, the general answer is to use C<if-elsif-else>:
-
- for ($variable_to_test) {
- if (/pat1/) { } # do something
- elsif (/pat2/) { } # do something else
- elsif (/pat3/) { } # do something else
- else { } # default
- }
-
-Here's a simple example of a switch based on pattern matching,
-lined up in a way to make it look more like a switch statement.
-We'll do a multiway conditional based on the type of reference stored
-in $whatchamacallit:
-
- SWITCH: for (ref $whatchamacallit) {
-
- /^$/ && die "not a reference";
-
- /SCALAR/ && do {
- print_scalar($$ref);
- last SWITCH;
- };
-
- /ARRAY/ && do {
- print_array(@$ref);
- last SWITCH;
- };
-
- /HASH/ && do {
- print_hash(%$ref);
- last SWITCH;
- };
-
- /CODE/ && do {
- warn "can't print function ref";
- last SWITCH;
- };
-
- # DEFAULT
-
- warn "User defined type skipped";
-
- }
-
-See L<perlsyn> for other examples in this style.
-
-Sometimes you should change the positions of the constant and the variable.
-For example, let's say you wanted to test which of many answers you were
-given, but in a case-insensitive way that also allows abbreviations.
-You can use the following technique if the strings all start with
-different characters or if you want to arrange the matches so that
-one takes precedence over another, as C<"SEND"> has precedence over
-C<"STOP"> here:
-
- chomp($answer = <>);
- if ("SEND" =~ /^\Q$answer/i) { print "Action is send\n" }
- elsif ("STOP" =~ /^\Q$answer/i) { print "Action is stop\n" }
- elsif ("ABORT" =~ /^\Q$answer/i) { print "Action is abort\n" }
- elsif ("LIST" =~ /^\Q$answer/i) { print "Action is list\n" }
- elsif ("EDIT" =~ /^\Q$answer/i) { print "Action is edit\n" }
-
-A totally different approach is to create a hash of function references.
-
- my %commands = (
- "happy" => \&joy,
- "sad", => \&sullen,
- "done" => sub { die "See ya!" },
- "mad" => \&angry,
- );
-
- print "How are you? ";
- chomp($string = <STDIN>);
- if ($commands{$string}) {
- $commands{$string}->();
- } else {
- print "No such command: $string\n";
- }
-
-Starting from Perl 5.8, a source filter module, C<Switch>, can also be
-used to get switch and case. Its use is now discouraged, because it's
-not fully compatible with the native switch of Perl 5.10, and because,
-as it's implemented as a source filter, it doesn't always work as intended
-when complex syntax is involved.
-
-=head2 How can I catch accesses to undefined variables, functions, or methods?
-
-The AUTOLOAD method, discussed in L<perlsub/"Autoloading"> and
-L<perltoot/"AUTOLOAD: Proxy Methods">, lets you capture calls to
-undefined functions and methods.
-
-When it comes to undefined variables that would trigger a warning
-under C<use warnings>, you can promote the warning to an error.
-
- use warnings FATAL => qw(uninitialized);
-
-=head2 Why can't a method included in this same file be found?
-
-Some possible reasons: your inheritance is getting confused, you've
-misspelled the method name, or the object is of the wrong type. Check
-out L<perltoot> for details about any of the above cases. You may
-also use C<print ref($object)> to find out the class C<$object> was
-blessed into.
-
-Another possible reason for problems is that you've used the
-indirect object syntax (eg, C<find Guru "Samy">) on a class name
-before Perl has seen that such a package exists. It's wisest to make
-sure your packages are all defined before you start using them, which
-will be taken care of if you use the C<use> statement instead of
-C<require>. If not, make sure to use arrow notation (eg.,
-C<< Guru->find("Samy") >>) instead. Object notation is explained in
-L<perlobj>.
-
-Make sure to read about creating modules in L<perlmod> and
-the perils of indirect objects in L<perlobj/"Method Invocation">.
-
-=head2 How can I find out my current or calling package?
-
-(contributed by brian d foy)
-
-To find the package you are currently in, use the special literal
-C<__PACKAGE__>, as documented in L<perldata>. You can only use the
-special literals as separate tokens, so you can't interpolate them
-into strings like you can with variables:
-
- my $current_package = __PACKAGE__;
- print "I am in package $current_package\n";
-
-If you want to find the package calling your code, perhaps to give better
-diagnostics as L<Carp> does, use the C<caller> built-in:
-
- sub foo {
- my @args = ...;
- my( $package, $filename, $line ) = caller;
-
- print "I was called from package $package\n";
- );
-
-By default, your program starts in package C<main>, so you will
-always be in some package.
-
-This is different from finding out the package an object is blessed
-into, which might not be the current package. For that, use C<blessed>
-from L<Scalar::Util>, part of the Standard Library since Perl 5.8:
-
- use Scalar::Util qw(blessed);
- my $object_package = blessed( $object );
-
-Most of the time, you shouldn't care what package an object is blessed
-into, however, as long as it claims to inherit from that class:
-
- my $is_right_class = eval { $object->isa( $package ) }; # true or false
-
-And, with Perl 5.10 and later, you don't have to check for an
-inheritance to see if the object can handle a role. For that, you can
-use C<DOES>, which comes from C<UNIVERSAL>:
-
- my $class_does_it = eval { $object->DOES( $role ) }; # true or false
-
-You can safely replace C<isa> with C<DOES> (although the converse is not true).
-
-=head2 How can I comment out a large block of Perl code?
-
-(contributed by brian d foy)
-
-The quick-and-dirty way to comment out more than one line of Perl is
-to surround those lines with Pod directives. You have to put these
-directives at the beginning of the line and somewhere where Perl
-expects a new statement (so not in the middle of statements like the C<#>
-comments). You end the comment with C<=cut>, ending the Pod section:
-
- =pod
-
- my $object = NotGonnaHappen->new();
-
- ignored_sub();
-
- $wont_be_assigned = 37;
-
- =cut
-
-The quick-and-dirty method only works well when you don't plan to
-leave the commented code in the source. If a Pod parser comes along,
-you're multiline comment is going to show up in the Pod translation.
-A better way hides it from Pod parsers as well.
-
-The C<=begin> directive can mark a section for a particular purpose.
-If the Pod parser doesn't want to handle it, it just ignores it. Label
-the comments with C<comment>. End the comment using C<=end> with the
-same label. You still need the C<=cut> to go back to Perl code from
-the Pod comment:
-
- =begin comment
-
- my $object = NotGonnaHappen->new();
-
- ignored_sub();
-
- $wont_be_assigned = 37;
-
- =end comment
-
- =cut
-
-For more information on Pod, check out L<perlpod> and L<perlpodspec>.
-
-=head2 How do I clear a package?
-
-Use this code, provided by Mark-Jason Dominus:
-
- sub scrub_package {
- no strict 'refs';
- my $pack = shift;
- die "Shouldn't delete main package"
- if $pack eq "" || $pack eq "main";
- my $stash = *{$pack . '::'}{HASH};
- my $name;
- foreach $name (keys %$stash) {
- my $fullname = $pack . '::' . $name;
- # Get rid of everything with that name.
- undef $$fullname;
- undef @$fullname;
- undef %$fullname;
- undef &$fullname;
- undef *$fullname;
- }
- }
-
-Or, if you're using a recent release of Perl, you can
-just use the Symbol::delete_package() function instead.
-
-=head2 How can I use a variable as a variable name?
-
-Beginners often think they want to have a variable contain the name
-of a variable.
-
- $fred = 23;
- $varname = "fred";
- ++$$varname; # $fred now 24
-
-This works I<sometimes>, but it is a very bad idea for two reasons.
-
-The first reason is that this technique I<only works on global
-variables>. That means that if $fred is a lexical variable created
-with my() in the above example, the code wouldn't work at all: you'd
-accidentally access the global and skip right over the private lexical
-altogether. Global variables are bad because they can easily collide
-accidentally and in general make for non-scalable and confusing code.
-
-Symbolic references are forbidden under the C<use strict> pragma.
-They are not true references and consequently are not reference-counted
-or garbage-collected.
-
-The other reason why using a variable to hold the name of another
-variable is a bad idea is that the question often stems from a lack of
-understanding of Perl data structures, particularly hashes. By using
-symbolic references, you are just using the package's symbol-table hash
-(like C<%main::>) instead of a user-defined hash. The solution is to
-use your own hash or a real reference instead.
-
- $USER_VARS{"fred"} = 23;
- my $varname = "fred";
- $USER_VARS{$varname}++; # not $$varname++
-
-There we're using the %USER_VARS hash instead of symbolic references.
-Sometimes this comes up in reading strings from the user with variable
-references and wanting to expand them to the values of your perl
-program's variables. This is also a bad idea because it conflates the
-program-addressable namespace and the user-addressable one. Instead of
-reading a string and expanding it to the actual contents of your program's
-own variables:
-
- $str = 'this has a $fred and $barney in it';
- $str =~ s/(\$\w+)/$1/eeg; # need double eval
-
-it would be better to keep a hash around like %USER_VARS and have
-variable references actually refer to entries in that hash:
-
- $str =~ s/\$(\w+)/$USER_VARS{$1}/g; # no /e here at all
-
-That's faster, cleaner, and safer than the previous approach. Of course,
-you don't need to use a dollar sign. You could use your own scheme to
-make it less confusing, like bracketed percent symbols, etc.
-
- $str = 'this has a %fred% and %barney% in it';
- $str =~ s/%(\w+)%/$USER_VARS{$1}/g; # no /e here at all
-
-Another reason that folks sometimes think they want a variable to
-contain the name of a variable is that they don't know how to build
-proper data structures using hashes. For example, let's say they
-wanted two hashes in their program: %fred and %barney, and that they
-wanted to use another scalar variable to refer to those by name.
-
- $name = "fred";
- $$name{WIFE} = "wilma"; # set %fred
-
- $name = "barney";
- $$name{WIFE} = "betty"; # set %barney
-
-This is still a symbolic reference, and is still saddled with the
-problems enumerated above. It would be far better to write:
-
- $folks{"fred"}{WIFE} = "wilma";
- $folks{"barney"}{WIFE} = "betty";
-
-And just use a multilevel hash to start with.
-
-The only times that you absolutely I<must> use symbolic references are
-when you really must refer to the symbol table. This may be because it's
-something that one can't take a real reference to, such as a format name.
-Doing so may also be important for method calls, since these always go
-through the symbol table for resolution.
-
-In those cases, you would turn off C<strict 'refs'> temporarily so you
-can play around with the symbol table. For example:
-
- @colors = qw(red blue green yellow orange purple violet);
- for my $name (@colors) {
- no strict 'refs'; # renege for the block
- *$name = sub { "<FONT COLOR='$name'>@_</FONT>" };
- }
-
-All those functions (red(), blue(), green(), etc.) appear to be separate,
-but the real code in the closure actually was compiled only once.
-
-So, sometimes you might want to use symbolic references to manipulate
-the symbol table directly. This doesn't matter for formats, handles, and
-subroutines, because they are always global--you can't use my() on them.
-For scalars, arrays, and hashes, though--and usually for subroutines--
-you probably only want to use hard references.
-
-=head2 What does "bad interpreter" mean?
-
-(contributed by brian d foy)
-
-The "bad interpreter" message comes from the shell, not perl. The
-actual message may vary depending on your platform, shell, and locale
-settings.
-
-If you see "bad interpreter - no such file or directory", the first
-line in your perl script (the "shebang" line) does not contain the
-right path to perl (or any other program capable of running scripts).
-Sometimes this happens when you move the script from one machine to
-another and each machine has a different path to perl--/usr/bin/perl
-versus /usr/local/bin/perl for instance. It may also indicate
-that the source machine has CRLF line terminators and the
-destination machine has LF only: the shell tries to find
-/usr/bin/perl<CR>, but can't.
-
-If you see "bad interpreter: Permission denied", you need to make your
-script executable.
-
-In either case, you should still be able to run the scripts with perl
-explicitly:
-
- % perl script.pl
-
-If you get a message like "perl: command not found", perl is not in
-your PATH, which might also mean that the location of perl is not
-where you expect it so you need to adjust your shebang line.
-
-=head1 AUTHOR AND COPYRIGHT
-
-Copyright (c) 1997-2010 Tom Christiansen, Nathan Torkington, and
-other authors as noted. All rights reserved.
-
-This documentation is free; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-
-Irrespective of its distribution, all code examples in this file
-are hereby placed into the public domain. You are permitted and
-encouraged to use this code in your own programs for fun
-or for profit as you see fit. A simple comment in the code giving
-credit would be courteous but is not required.