MAN page from Old RedHat 5.X perl-5.004-4.i386.rpm
PERLFAQ7
Section: Perl Programmers Reference Guide (1)
Updated: perl 5.004, patch 04
Index NAME
perlfaq7 - Perl Language Issues ($Revision: 1.18 $,
$Date: 1997/04/24 22:44:14 $)
DESCRIPTION
This section deals with general Perl language issues that don'tclearly fit into any of the other sections.
Can I get a BNF/yacc/RE for the Perl language?
No, in the words of Chaim Frenkel: ``Perl's grammar can not be reducedto
BNF. The work of parsing perl is distributed between yacc, thelexer, smoke and mirrors.''
What are all these $@%* punctuation signs, and how do I know when to use them?
They are type specifiers, as detailed in the
perldata manpage:
$ for scalar values (number, string or reference) @ for arrays % for hashes (associative arrays) * for all types of that symbol name. In version 4 you used them like pointers, but in modern perls you can just use references.
While there are a few places where you don't actually need these typespecifiers, you should always use them.
A couple of others that you're likely to encounter that aren'treally type specifiers are:
<> are used for inputting a record from a filehandle. \ takes a reference to something.
Note that <
FILE> is
neither the type specifier for filesnor the name of the handle. It is the
<> operator appliedto the handle
FILE. It reads one line (well, record - seethe section on
$/ in the
perlvar manpage) from the handle
FILE in scalar context, or
all linesin list context. When performing open, close, or any other operationbesides
<> on files, or even talking about the handle, do
not use the brackets. These are correct:
eof(FH),
seek(FH, 0,2) and ``copying from
STDIN to
FILE''.
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 casesprobably should be (and must be under
use strict). But a hash keyconsisting of a simple word (that isn't the name of a definedsubroutine) and the left-hand operand to the
=> operator bothcount as though they were quoted:
This is like this ------------ --------------- $foo{line} $foo{"line"} bar => stuff "bar" => stuffThe final semicolon in a block is optional, as is the final comma in alist. Good style (see the
perlstyle manpage) says to put them in except forone-liners:
if ($whoops) { exit 1 } @nums = (1, 2, 3); if ($whoops) { exit 1; } @lines = ( "There Beren came from mountains cold", "And lost he wandered under leaves", ); 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);
How do I temporarily block warnings?
The
$^W variable (documented in the
perlvar manpage) controlsruntime warnings for a block:
{ local $^W = 0; # temporarily turn off warnings $a = $b + $c; # I know these might be undef }Note that like all the punctuation variables, you cannot currentlyuse
my() on
$^W, only
local().
A new use warnings pragma is in the works to provide finer controlover all this. The curious should check the perl5-porters mailing listarchives for details.
What's an extension?
A way of calling compiled C code from Perl. Reading the
perlxstut manpageis a good place to learn more about extensions.
Why do Perl operators have different precedence than C operators?
Actually, they don't. All C operators that Perl copies have the sameprecedence in Perl as they do in C. The problem is with operators that Cdoesn't have, especially functions that give a list context to everythingon their right, eg print, chmod, exec, and so on. Such functions arecalled ``list operators'' and appear as such in the precedence table inthe
perlop manpage.
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 thesuper low precedence
or operator:
(unlink $file) || die "snafu"; unlink $file or die "snafu";
The ``English'' operators (
and,
or,
xor, and
not)deliberately have precedence lower than that of list operators forjust such situations as the one above.
Another operator with surprising precedence is exponentiation. Itbinds more tightly even than unary minus, making -2**2 product anegative not a positive four. It is also right-associating, meaningthat 2**3**2 is two raised to the ninth power, not eight squared.
How do I declare/create a structure?
In general, you don't ``declare'' a structure. Just use a (probablyanonymous) hash reference. See the
perlref manpage and the
perldsc manpage 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 the
perltoot manpage.
How do I create a module?
A module is a package that lives in a file of the same name. Forexample, the Hello::There module would live in Hello/There.pm. Fordetails, read the
perlmod manpage. You'll also find the
Exporter manpage helpful. Ifyou're writing a C or mixed-language module with both C and Perl, thenyou should study the
perlxstut manpage.
Here's a convenient template you might wish you use when starting yourown module. Make sure to change the names appropriately.
package Some::Module; # assumes Some/Module.pm
use strict;
BEGIN { use Exporter (); use vars qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS); ## set the version for version checking; uncomment to use ## $VERSION = 1.00;
# if using RCS/CVS, this next line may be preferred, # but beware two-digit versions. $VERSION = do{my@r=q$Revision: 1.18 $=~/\d+/g;sprintf '%d.'.'%02d'x$#r,@r}; @ISA = qw(Exporter); @EXPORT = qw(&func1 &func2 &func3); %EXPORT_TAGS = ( ); # eg: TAG => [ qw!name1 name2! ],
# your exported package globals go here, # as well as any optionally exported functions @EXPORT_OK = qw($Var1 %Hashit); } use vars @EXPORT_OK;
# non-exported package globals go here use vars qw( @more $stuff );
# initialize package globals, first exported ones $Var1 = ''; %Hashit = ();
# then the others (which are still accessible as $Some::Module::stuff) $stuff = ''; @more = ();
# all file-scoped lexicals must be created before # the functions below that use them.
# file-private lexicals go here my $priv_var = ''; my %secret_hash = ();
# here's a file-private function as a closure, # callable as &$priv_func; it cannot be prototyped. my $priv_func = sub { # stuff goes here. }; # make all your functions, whether exported or not; # remember to put something interesting in the {} stubs sub func1 {} # no prototype sub func2() {} # proto'd void sub func3($$) {} # proto'd to 2 scalars # this one isn't exported, but could be called! sub func4(\%) {} # proto'd to 1 hash ref END { } # module clean-up code here (global destructor) 1; # modules must return true
How do I create a class?
See the
perltoot manpage for an introduction to classes and objects, as well asthe
perlobj manpage and the
perlbot manpage.
How can I tell if a variable is tainted?
See the section on
Laundering and Detecting Tainted Data in the
perlsec manpage. Here's anexample (which doesn't use any system calls, because the
kill()is given no processes to signal):
sub is_tainted { return ! eval { join('',@_), kill 0; 1; }; }This is not
-w clean, however. There is no
-w clean way todetect taintedness - take this as a hint that you should untaintall possibly-tainted data.
What's a closure?
Closures are documented in the
perlref manpage.
Closure is a computer science term with a precise buthard-to-explain meaning. Closures are implemented in Perl as anonymoussubroutines with lasting references to lexical variables outside theirown scopes. These lexicals magically refer to the variables that werearound when the subroutine was defined (deep binding).
Closures make sense in any programming language where you can have thereturn value of a function be itself a function, as you can in Perl.Note that some languages provide anonymous functions but are notcapable of providing proper closures; the Python language, forexample. For more information on closures, check out any textbook onfunctional programming. Scheme is a language that not only supportsbut encourages closures.
Here's a classic function-generating function:
sub add_function_generator { return sub { shift + shift }; } $add_sub = add_function_generator(); $sum = &$add_sub(4,5); # $sum is 9 now.
The closure works as a
function template with some customizationslots left out to be filled later. The anonymous subroutine returnedby
add_function_generator() isn't technically a closure because itrefers to no lexicals outside its own scope.
Contrast this with the following make_adder() function, in which thereturned anonymous function contains a reference to a lexical variableoutside the scope of that function itself. Such a reference requiresthat Perl return a proper closure, thus locking in for all time thevalue that the lexical had when the function was created.
sub make_adder { my $addpiece = shift; return sub { shift + $addpiece }; } $f1 = make_adder(20); $f2 = make_adder(555);
Now
&$f1($n) is always 20 plus whatever
$n you pass in, whereas
&$f2($n) is always 555 plus whatever
$n you pass in. The
$addpiecein the closure sticks around.
Closures are often used for less esoteric purposes. For example, whenyou 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,
'$line =<STDIN>', there would have been no way for the hypothetical
timeout() function to access the lexical variable
$line back in itscaller's scope.
What is variable suicide and how can I prevent it?
Variable suicide is when you (temporarily or permanently) lose thevalue of a variable. It is caused by scoping through
my() and
local()interacting with either closures or aliased
foreach() interatorvariables and subroutine arguments. It used to be easy toinadvertently lose a variable's value this way, but now it's muchharder. Take this code:
my $f = "foo"; sub T { while ($i++ < 3) { my $f = $f; $f .= "bar"; print $f, "\n" } } T; print "Finally $f\n";The
$f that has ``bar'' added to it three times should be a new
$f(
my $f should create a new local variable each time through theloop). It isn't, however. This is a bug, and will be fixed.
How can I pass/return a {Function, FileHandle, Array, Hash, Method, Regexp}?
With the exception of regexps, you need to pass references to theseobjects. See the section on
Pass by Reference in the
perlsub manpage for this particularquestion, and the
perlref manpage for information on references.
- Passing Variables and Functions
- Regular variables and functions are quite easy: just pass in areference 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] } );
- Passing Filehandles
- To create filehandles you can pass to subroutines, you can use *FHor \*FH notation ("typeglobs'' - see the perldata manpage for more information),or create filehandles dynamically using the old FileHandle or the newIO::File modules, both part of the standard Perl distribution.
use Fcntl; use IO::File; my $fh = new IO::File $filename, O_WRONLY|O_APPEND; or die "Can't append to $filename: $!"; func($fh);
- Passing Regexps
- To pass regexps around, you'll need to either use one of the highlyexperimental regular expression modules from CPAN (Nick Ing-Simmons'sRegexp or Ilya Zakharevich's Devel::Regexp), pass around stringsand use an exception-trapping eval, or else be be very, very clever.Here's an example of how to pass in a string to be regexp compared:
sub compare($$) { my ($val1, $regexp) = @_; my $retval = eval { $val =~ /$regexp/ }; die if $@; return $retval; } $match = compare("old McDonald", q/d.*D/);Make sure you never say something like this: return eval "\$val =~ /$regexp/"; # WRONG
or someone can sneak shell escapes into the regexp due to the doubleinterpolation of the eval and the double-quoted string. For example: $pattern_of_evil = 'danger ${ system("rm -rf * &") } danger'; eval "\$string =~ /$pattern_of_evil/";
Those preferring to be very, very clever might see the O'Reilly book,Mastering Regular Expressions, by Jeffrey Friedl. Page 273'sBuild_MatchMany_Function() is particularly interesting. A completecitation of this book is given in the perlfaq2 manpage.
- 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 and its method calland 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).
How do I create a static variable?
As with most things in Perl,
TMTOWTDI. What is a ``static variable'' inother languages could be either a function-private variable (visibleonly within a single function, retaining its value between calls tothat function), or a file-private variable (visible only to functionswithin the file it was declared in) in Perl.
Here's code to implement a function-private variable:
BEGIN { my $counter = 42; sub prev_counter { return --$counter } sub next_counter { return $counter++ } }Now
prev_counter() and
next_counter() share a private variable
$counterthat was initialized at compile time.
To declare a file-private variable, you'll still use a my(), puttingit at the outer scope level at the top of the file. Assume this is infile Pax.pm:
package Pax; my $started = scalar(localtime(time()));
sub begun { return $started }When
use Pax or
require Pax loads this module, the variable willbe initialized. It won't get garbage-collected the way most variablesgoing out of scope do, because the
begun() function cares about it,but no one else can get it. It is not called
$Pax::started becauseits scope is unrelated to the package. It's scoped to the file. Youcould conceivably have several packages in that same file allaccessing the same private variable, but another file with the samepackage couldn't get to it.
What's the difference between dynamic and lexical (static) scoping? Between local() and my()?
local($x) saves away the old value of the global variable
$x,and assigns a new value for the duration of the subroutine,
which isvisible in other functions called from that subroutine. This is doneat run-time, so is called dynamic scoping.
local() always affects globalvariables, also called package variables or dynamic variables.
my($x) creates a new variable that is only visible in the currentsubroutine. This is done at compile-time, so is called lexical orstatic scoping. my() always affects private variables, also calledlexical 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'sbecause
$var only has that value within the block of the
lexical()function, and it is hidden from called subroutine.
In summary, local() doesn't make what you think of as private, localvariables. It gives a global variable a temporary value. my() iswhat you're looking for if you want private variables.
See also the perlsub manpage, which explains this all in more detail.
How can I access a dynamic variable while a similarly named lexical is in scope?
You can do this via symbolic references, provided you haven't set
use strict "refs". So instead of
$var, use
${'var'}.
local $var = "global"; my $var = "lexical";
print "lexical is $var\n";
no strict 'refs'; print "global is ${'var'}\n";If you know your package, you can just mention it explicitly, as in
$Some_Pack::var. Note that the notation
$::var is
not the dynamic
$var in the current package, but rather the one in the
mainpackage, as though you had written
$main::var. Specifying the packagedirectly makes you hard-code its name, but it executes faster andavoids running afoul of
use strict "refs".
What's the difference between deep and shallow binding?
In deep binding, lexical variables mentioned in anonymous subroutinesare the same ones that were in scope when the subroutine was created.In shallow binding, they are whichever variables with the same nameshappen to be in scope when the subroutine is called. Perl always usesdeep 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 reasonnot to use them. See the answer to the section on
What's a closure?.
Why doesn't local($foo) = <FILE>; work right?
local() gives list context to the right hand side of
=. The<
FH> read operation, like so many of Perl's functions andoperators, can tell which context it was called in and behavesappropriately. In general, the
scalar() function can help. Thisfunction does nothing to the data itself (contrary to popular myth)but rather tells its argument to behave in whatever its scalar fashionis. If that function doesn't have a defined scalar behavior, this ofcourse doesn't help you (such as with
sort()).
To enforce scalar context in this particular case, however, you needmerely omit the parentheses:
local($foo) = <FILE>; # WRONG local($foo) = scalar(<FILE>); # ok local $foo = <FILE>; # right
You should probably be using lexical variables anyway, although theissue is the same here:
my($foo) = <FILE>; # WRONG my $foo = <FILE>; # right
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 differentmodule. See the section on Overriding Builtin Functions in the perlsub manpage. There'salso an example in the section on Class::Template in the perltoot manpage.
If you want to overload a Perl operator, such as + or **,then you'll want to use the use overload pragma, documentedin the overload manpage.
If you're talking about obscuring method calls in parent classes,see the section on Overridden Methods in the perltoot manpage.
What's the difference between calling a function as &foo and foo()?
When you call a function as
&foo, you allow that function access toyour current
@_ values, and you by-pass prototypes. That means thatthe function doesn't get an empty
@_, it gets yours! While notstrictly speaking a bug (it's documented that way in the
perlsub manpage), itwould be hard to consider this a feature in most cases.
When you call your function as &foo(), then you do get a new @_,but prototyping is still circumvented.
Normally, you want to call a function using foo(). You may onlyomit the parentheses if the function is already known to the compilerbecause it already saw the definition (use but not require),or via a forward reference or use subs declaration. Even in thiscase, you get a clean @_ without any of the old values leaking throughwhere they don't belong.
How do I create a switch or case statement?
This is explained in more depth in the the
perlsyn manpage. Briefly, there'sno official case statement, because of the variety of tests possiblein Perl (numeric comparison, string comparison, glob comparison,regexp matching, overloaded comparisons, ...). Larry couldn't decidehow best to do this, so he left it out, even though it's been on thewish list since perl1.
Here's a simple example of a switch based on pattern matching. We'lldo a multi-way 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";
}
How can I catch accesses to undefined variables/functions/methods?
The
AUTOLOAD method, discussed in the section on
Autoloading in the
perlsub manpage andthe section on
AUTOLOAD: Proxy Methods in the
perltoot manpage, lets you capture calls toundefined functions and methods.
When it comes to undefined variables that would trigger a warningunder -w, you can use a handler to trap the pseudo-signal__WARN__ like this:
$SIG{__WARN__} = sub { for ( $_[0] ) { /Use of uninitialized value/ && do { # promote warning to a fatal die $_; }; # other warning cases to catch could go here;
warn $_; }
};
Why can't a method included in this same file be found?
Some possible reasons: your inheritance is getting confused, you'vemisspelled the method name, or the object is of the wrong type. Checkout the
perltoot manpage for details on these. You may also use
printref($object) to find out the class
$object was blessed into.
Another possible reason for problems is because you've used theindirect object syntax (eg, find Guru "Samy") on a class namebefore Perl has seen that such a package exists. It's wisest to makesure your packages are all defined before you start using them, whichwill be taken care of if you use the use statement instead ofrequire. If not, make sure to use arrow notation (eg,Guru-find("Samy")>) instead. Object notation is explained inthe perlobj manpage.
How can I find out my current package?
If you're just a random program, you can do this to findout what the currently compiled package is:
my $packname = ref bless [];
But if you're a method and you want to print an error messagethat includes the kind of object you were called on (which isnot necessarily the same as the one in which you were compiled):
sub amethod { my $self = shift; my $class = ref($self) || $self; warn "called me from a $class object"; } How can I comment out a large block of perl code?
Use embedded
POD to discard it:
# program is here
=for nobody This paragraph is commented out
# program continues
=begin comment text
all of this stuff
here will be ignored by everyone
=end comment text
=cut
AUTHOR AND COPYRIGHT
Copyright (c) 1997 Tom Christiansen and Nathan Torkington.All rights reserved. See the
perlfaq manpage for distribution information.
Index
- NAME
- DESCRIPTION
- Can I get a BNF/yacc/RE for the Perl language?
- What are all these $@%* punctuation signs, and how do I know when to use them?
- Do I always/never have to quote my strings or use semicolons and commas?
- How do I skip some return values?
- How do I temporarily block warnings?
- What's an extension?
- Why do Perl operators have different precedence than C operators?
- How do I declare/create a structure?
- How do I create a module?
- How do I create a class?
- How can I tell if a variable is tainted?
- What's a closure?
- What is variable suicide and how can I prevent it?
- How can I pass/return a {Function, FileHandle, Array, Hash, Method, Regexp}?
- How do I create a static variable?
- What's the difference between dynamic and lexical (static) scoping? Between local() and my()?
- How can I access a dynamic variable while a similarly named lexical is in scope?
- What's the difference between deep and shallow binding?
- Why doesn't local($foo) = <FILE>; work right?
- How do I redefine a builtin function, operator, or method?
- What's the difference between calling a function as &foo and foo()?
- How do I create a switch or case statement?
- How can I catch accesses to undefined variables/functions/methods?
- Why can't a method included in this same file be found?
- How can I find out my current package?
- How can I comment out a large block of perl code?
- AUTHOR AND COPYRIGHT
This document was created byman2html,using the manual pages.
