=head1 NAME
-perlfaq7 - General Perl Language Issues ($Revision: 9309 $)
+perlfaq7 - General Perl Language Issues ($Revision: 9620 $)
=head1 DESCRIPTION
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.
+ $ 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 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.
+ <> 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
subroutine) 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
+ 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 }
- @nums = (1, 2, 3);
+ if ($whoops) { exit 1 }
+ @nums = (1, 2, 3);
+
+ if ($whoops) {
+ exit 1;
+ }
- if ($whoops) {
- exit 1;
- }
- @lines = (
+ @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];
+ $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);
+ ($dev, $ino, undef, undef, $uid, $gid) = stat($file);
You can also use a list slice to select only the elements that
you need:
allows fine control of what warning are produced.
See L<perllexwarn> for more details.
- {
+ {
no warnings; # temporarily turn off warnings
$a = $b + $c; # 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
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
$a = $b + $c; # I know these might be undef
- }
+ }
Note that like all the punctuation variables, you cannot currently
use my() on C<$^W>, only local().
A common mistake is to write:
- unlink $file || die "snafu";
+ unlink $file || die "snafu";
This gets interpreted as:
- unlink ($file || die "snafu");
+ 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";
+ (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
produces an lvalue. This assigns $x to either $a or $b, depending
on the trueness of $maybe:
- ($maybe ? $a : $b) = $x;
+ ($maybe ? $a : $b) = $x;
=head2 How do I declare/create a structure?
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"
-
+ $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?
Here's a classic non-closure function-generating function:
- sub add_function_generator {
- return sub { shift() + shift() };
- }
+ sub add_function_generator {
+ return sub { shift() + shift() };
+ }
- $add_sub = add_function_generator();
- $sum = $add_sub->(4,5); # $sum is 9 now.
+ $add_sub = add_function_generator();
+ $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
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 };
- }
-
- $f1 = make_adder(20);
- $f2 = make_adder(555);
+ sub make_adder {
+ my $addpiece = shift;
+ return sub { shift() + $addpiece };
+ }
+
+ $f1 = make_adder(20);
+ $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
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> } );
+ 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
sure a variable doesn't get meddled with during the lifetime of the
package:
- BEGIN {
- my $id = 0;
- sub next_id { ++$id }
- }
+ 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>.
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";
+ 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 <foo>. The output
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_scalar );
- func( \@some_array );
- func( [ 1 .. 10 ] );
+ func( \@some_array );
+ func( [ 1 .. 10 ] );
- func( \%some_hash );
- func( { this => 10, that => 20 } );
+ func( \%some_hash );
+ func( { this => 10, that => 20 } );
- func( \&some_func );
- func( sub { $_[0] ** $_[1] } );
+ func( \&some_func );
+ func( sub { $_[0] ** $_[1] } );
=item Passing Filehandles
sub func {
my $passed_fh = shift;
- my $line = <$fh>;
+ my $line = <$passed_fh>;
}
Before Perl 5.6, you had to use the C<*FH> or C<\*FH> notations.
Here's an example of how to pass in a string to be regex compared
using C<qr//>:
- sub compare($$) {
- my ($val1, $regex) = @_;
- my $retval = $val1 =~ /$regex/;
+ sub compare($$) {
+ my ($val1, $regex) = @_;
+ my $retval = $val1 =~ /$regex/;
return $retval;
- }
- $match = compare("old McDonald", qr/d.*D/i);
+ }
+ $match = compare("old McDonald", qr/d.*D/i);
Notice how C<qr//> allows flags at the end. That pattern was compiled
at compile time, although it was executed later. The nifty C<qr//>
had to approach this problem much less intuitively. For example, here
it is again if you don't have C<qr//>:
- sub compare($$) {
- my ($val1, $regex) = @_;
- my $retval = eval { $val1 =~ /$regex/ };
+ sub compare($$) {
+ my ($val1, $regex) = @_;
+ my $retval = eval { $val1 =~ /$regex/ };
die if $@;
return $retval;
- }
+ }
- $match = compare("old McDonald", q/($?i)d.*D/);
+ $match = compare("old McDonald", q/($?i)d.*D/);
Make sure you never say something like this:
- return eval "\$val =~ /$regex/"; # WRONG
+ return eval "\$val =~ /$regex/"; # WRONG
or someone can sneak shell escapes into the regex due to the double
interpolation of the eval and the double-quoted string. For example:
- $pattern_of_evil = 'danger ${ system("rm -rf * &") } danger';
+ $pattern_of_evil = 'danger ${ system("rm -rf * &") } danger';
- eval "\$string =~ /$pattern_of_evil/";
+ eval "\$string =~ /$pattern_of_evil/";
Those preferring to be very, very clever might see the O'Reilly book,
I<Mastering Regular Expressions>, by Jeffrey Friedl. Page 273's
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();
- }
- }
+ 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();
- }
+ 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).
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();
+ 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
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 }
- }
+ 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
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
+ 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()
print "lexical is $var\n";
{
- our $var;
- print "global is $var\n";
+ our $var;
+ print "global is $var\n";
}
=head2 What's the difference between deep and shallow binding?
To enforce scalar context in this particular case, however, you need
merely omit the parentheses:
- local($foo) = <FILE>; # WRONG
- local($foo) = scalar(<FILE>); # ok
- local $foo = <FILE>; # right
+ local($foo) = <FILE>; # WRONG
+ local($foo) = scalar(<FILE>); # ok
+ local $foo = <FILE>; # right
You should probably be using lexical variables anyway, although the
issue is the same here:
- my($foo) = <FILE>; # WRONG
- my $foo = <FILE>; # right
+ my($foo) = <FILE>; # WRONG
+ my $foo = <FILE>; # right
=head2 How do I redefine a builtin function, operator, or method?
If one wants to use pure Perl and to be compatible with Perl versions
prior to 5.10, the general answer is to write a construct like this:
- for ($variable_to_test) {
- if (/pat1/) { } # do something
- elsif (/pat2/) { } # do something else
- elsif (/pat3/) { } # do something else
- else { } # default
- }
+ 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.
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" }
+ 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";
- }
+ 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";
+ }
Note that starting from version 5.10, Perl has now a native switch
statement. See L<perlsyn>.
If you're just a random program, you can do this to find
out what the currently compiled package is:
- my $packname = __PACKAGE__;
+ my $packname = __PACKAGE__;
But, if you're a method and you want to print an error message
that includes the kind of object you were called on (which is
not 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";
- }
+ sub amethod {
+ my $self = shift;
+ my $class = ref($self) || $self;
+ warn "called me from a $class object";
+ }
=head2 How can I comment out a large block of perl code?
should claim to understand (by policy). Mark the end of the block
with <=end>.
- # program is here
-
- =begin comment
-
- all of this stuff
-
- here will be ignored
- by everyone
-
+ # program is here
+
+ =begin comment
+
+ all of this stuff
+
+ here will be ignored
+ by everyone
+
=end comment
-
- =cut
-
- # program continues
+
+ =cut
+
+ # program continues
The pod directives cannot go just anywhere. You must put a
pod directive where the parser is expecting a new statement,
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;
+ 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.
Beginners often think they want to have a variable contain the name
of a variable.
- $fred = 23;
- $varname = "fred";
- ++$$varname; # $fred now 24
+ $fred = 23;
+ $varname = "fred";
+ ++$$varname; # $fred now 24
This works I<sometimes>, but it is a very bad idea for two reasons.
(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;
- $varname = "fred";
- $USER_VARS{$varname}++; # not $$varname++
+ $USER_VARS{"fred"} = 23;
+ $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
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
+ $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
+ $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
+ $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 because they don't know how to build
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 = "fred";
+ $$name{WIFE} = "wilma"; # set %fred
- $name = "barney";
- $$name{WIFE} = "betty"; # set %barney
+ $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";
+ $folks{"fred"}{WIFE} = "wilma";
+ $folks{"barney"}{WIFE} = "betty";
And just use a multilevel hash to start with.
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>" };
- }
+ @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.
=head1 REVISION
-Revision: $Revision: 9309 $
+Revision: $Revision: 9620 $
-Date: $Date: 2007-03-23 15:28:16 +0100 (Fri, 23 Mar 2007) $
+Date: $Date: 2007-05-29 19:57:58 +0200 (Tue, 29 May 2007) $
See L<perlfaq> for source control details and availability.
=head1 NAME
-perlfaq8 - System Interaction ($Revision: 8539 $)
+perlfaq8 - System Interaction ($Revision: 9667 $)
=head1 DESCRIPTION
bound to get you talked about.
Seriously, you can't if they are Unix password files--the Unix
-password system employs one-way encryption. It's more like hashing than
-encryption. The best you can check is whether something else hashes to
-the same string. You can't turn a hash back into the original string.
-Programs like Crack
-can forcibly (and intelligently) try to guess passwords, but don't
-(can't) guarantee quick success.
+password system employs one-way encryption. It's more like hashing
+than encryption. The best you can do is check whether something else
+hashes to the same string. You can't turn a hash back into the
+original string. Programs like Crack can forcibly (and intelligently)
+try to guess passwords, but don't (can't) guarantee quick success.
If you're worried about users selecting bad passwords, you should
proactively check when they try to change their password (by modifying
@ok = `grep @opts '$search_string' @filenames`;
-As of Perl 5.8.0, you can use open() with multiple arguments.
-Just like the list forms of system() and exec(), no shell
+As of Perl 5.8.0, you can use C<open()> with multiple arguments.
+Just like the list forms of C<system()> and C<exec()>, no shell
escapes happen.
open( GREP, "-|", 'grep', @opts, $search_string, @filenames );
while (<GREP>) {
chomp;
push(@ok, $_);
- }
- close GREP;
+ }
+ close GREP;
} else {
exec 'grep', @opts, $search_string, @filenames;
}
-Just as with system(), no shell escapes happen when you exec() a list.
-Further examples of this can be found in L<perlipc/"Safe Pipe Opens">.
+Just as with C<system()>, no shell escapes happen when you C<exec()> a
+list. Further examples of this can be found in L<perlipc/"Safe Pipe
+Opens">.
-Note that if you're use Microsoft, no solution to this vexing issue
-is even possible. Even if Perl were to emulate fork(), you'd still
-be stuck, because Microsoft does not have a argc/argv-style API.
+Note that if you're using Windows, no solution to this vexing issue is
+even possible. Even if Perl were to emulate C<fork()>, you'd still be
+stuck, because Windows does not have an argc/argv-style API.
=head2 Why can't my script read from STDIN after I gave it EOF (^D on Unix, ^Z on MS-DOS)?
=head2 How do I tell the difference between errors from the shell and perl?
-(answer contributed by brian d foy, C<< <bdfoy@cpan.org> >>
+(answer contributed by brian d foy)
When you run a Perl script, something else is running the script for you,
and that something else may output error messages. The script might
=head2 How do I keep my own module/library directory?
-When you build modules, use the PREFIX and LIB options when generating
-Makefiles:
+When you build modules, tell Perl where to install the modules.
+
+For C<Makefile.PL>-based distributions, use the PREFIX and LIB options
+when generating Makefiles:
perl Makefile.PL PREFIX=/mydir/perl LIB=/mydir/perl/lib
-then either set the PERL5LIB environment variable before you run
-scripts that use the modules/libraries (see L<perlrun>) or say
+You can set this in your CPAN.pm configuration so modules automatically install
+in your private library directory when you use the CPAN.pm shell:
- use lib '/mydir/perl/lib';
+ % cpan
+ cpan> o conf makepl_arg PREFIX=/mydir/perl,LIB=/mydir/perl/lib
+ cpan> o conf commit
-This is almost the same as
+For C<Build.PL>-based distributions, use the --install_base option:
- BEGIN {
- unshift(@INC, '/mydir/perl/lib');
- }
+ perl Build.PL --install_base /mydir/perl
+
+You can configure CPAN.pm to automatically use this option too:
-except that the lib module checks for machine-dependent subdirectories.
-See Perl's L<lib> for more information.
+ % cpan
+ cpan> o conf mbuild_arg --install_base /mydir/perl
+ cpan> o conf commit
=head2 How do I add the directory my program lives in to the module/library search path?
+(contributed by brian d foy)
+
+If you know the directory already, you can add it to C<@INC> as you would
+for any other directory. You might <use lib> if you know the directory
+at compile time:
+
+ use lib $directory;
+
+The trick in this task is to find the directory. Before your script does
+anything else (such as a C<chdir>), you can get the current working
+directory with the C<Cwd> module, which comes with Perl:
+
+ BEGIN {
+ use Cwd;
+ our $directory = cwd;
+ }
+
+ use lib $directory;
+
+You can do a similar thing with the value of C<$0>, which holds the
+script name. That might hold a relative path, but C<rel2abs> can turn
+it into an absolute path. Once you have the
+
+ BEGIN {
+ use File::Spec::Functions qw(rel2abs);
+ use File::Basename qw(dirname);
+
+ my $path = rel2abs( $0 );
+ our $directory = dirname( $path );
+ }
+
+ use lib $directory;
+
+The C<FindBin> module, which comes with Perl, might work. It searches
+through C<$ENV{PATH}> (so your script has to be in one of those
+directories). You can then use that directory (in C<$FindBin::Bin>)
+to locate nearby directories you want to add:
+
use FindBin;
- use lib "$FindBin::Bin";
- use your_own_modules;
+ use lib "$FindBin::Bin/../lib";
=head2 How do I add a directory to my include path (@INC) at runtime?
-Here are the suggested ways of modifying your include path:
+Here are the suggested ways of modifying your include path, including
+environment variables, run-time switches, and in-code statements:
+
+=over 4
+
+=item the PERLLIB environment variable
+
+ $ export PERLLIB=/path/to/my/dir
+ $ perl program.pl
+
+=item the PERL5LIB environment variable
- the PERLLIB environment variable
- the PERL5LIB environment variable
- the perl -Idir command line flag
- the use lib pragma, as in
- use lib "$ENV{HOME}/myown_perllib";
+ $ export PERL5LIB=/path/to/my/dir
+ $ perl program.pl
+
+=item the perl -Idir command line flag
+
+ $ perl -I/path/to/my/dir program.pl
+
+=item the use lib pragma:
+
+ use lib "$ENV{HOME}/myown_perllib";
+
+=back
-The latter is particularly useful because it knows about machine
+The last is particularly useful because it knows about machine
dependent architectures. The lib.pm pragmatic module was first
included with the 5.002 release of Perl.
=head1 REVISION
-Revision: $Revision: 8539 $
+Revision: $Revision: 9667 $
-Date: $Date: 2007-01-11 00:07:14 +0100 (Thu, 11 Jan 2007) $
+Date: $Date: 2007-06-20 06:13:55 +0200 (Wed, 20 Jun 2007) $
See L<perlfaq> for source control details and availability.
projects / p5sagit/p5-mst-13.2.git / commitdiff