use - load in a module at compile time
use Module LIST
use Module
use Module VERSION LIST
use VERSION
Imports some semantics into the current package from the named module, generally by aliasing certain subroutine or variable names into your package. It is exactly equivalent to
BEGIN { require Module; import Module LIST; }
except that Module must be a bareword.
If the first argument to use is a number, it is treated as a version number instead of a module name. If the version of the Perl interpreter is less than VERSION, then an error message is printed and Perl exits immediately. This is often useful if you need to check the current Perl version before useing library modules that have changed in incompatible ways from older versions of Perl. (We try not to do this more than we have to.)
The BEGIN
forces the require and import() to happen at compile time. The
require makes sure the module is loaded into memory if it hasn't been yet. The import() is not a builtin--it's just an ordinary static method call into the ``Module
'' package to tell the module to import the list of features back into the
current package. The module can implement its
import() method any way it likes, though most modules just choose to derive their import() method via inheritance from the Exporter
class that is defined in the Exporter
module. See the Exporter manpage. If no import()
method can be found then the error is currently silently ignored. This may
change to a fatal error in a future version.
If you don't want your namespace altered, explicitly supply an empty list:
use Module ();
That is exactly equivalent to
BEGIN { require Module }
If the
VERSION argument is present between Module and
LIST, then the
use will call the
VERSION method in class Module with the given version as an argument. The default
VERSION method, inherited from the Universal class, croaks if the given version is larger than the value of the variable
$Module::VERSION
. (Note that there is not a comma after
VERSION!)
Because this is a wide-open interface, pragmas (compiler directives) are also implemented this way. Currently implemented pragmas are:
use integer; use diagnostics; use sigtrap qw(SEGV BUS); use strict qw(subs vars refs); use subs qw(afunc blurfl);
Some of these these pseudo-modules import semantics into the current block
scope (like strict
or integer
, unlike ordinary modules, which import symbols into the current package
(which are effective through the end of the file).
There's a corresponding ``no'' command that unimports meanings imported by use, i.e., it calls unimport Module LIST
instead of import().
no integer; no strict 'refs';
If no unimport()
method can be found the call fails with a fatal error.
See the perlmod manpage for a list of standard modules and pragmas.
If rather than formatting bugs, you encounter substantive content errors in these documents, such as mistakes in the explanations or code, please use the perlbug utility included with the Perl distribution.