Exporter Module

1. usage                                                                                                                                             implements an import method which allows a module to export functions and variables to its users' namespaces.

package YourModule;
require Exporter;
@ISA = qw(Exporter);
@EXPORT_OK = qw(munge frobnicate);  # symbols to export on request

package YourModule;
use Exporter 'import'; # gives you Exporter's import() method directly
@EXPORT_OK = qw(munge frobnicate);  # symbols to export on request

Perl automatically calls the import method when processing a use statement for a module.

use YourModule qw(frobnicate);      # import listed symbols
frobnicate ($left, $right)          # calls YourModule::frobnicate

@ISA, @EXPORT, @EXPORT_OK, %EXPORT_TAGS

 @ISA：Within each package a special array called @ISA tells Perl where else to look for a method if it can't find the method in that package. This is how Perl implements inheritance.

Each element of the @ISA array is just the name of another package that happens to be used as a class. The packages are recursively searched (depth first) for missing methods, in the order that packages are mentioned in @ISA.

This means that if you have two different packages (say, Mom and Dad) in a class's @ISA, Perl would first look for missing methods in Mom and all of her ancestor classes before going on to search through Dad and his ancestors. Classes accessible through @ISA are known as base classes of the current class, which is itself called the derived class.

@EXPORT contains list of symbols (subroutines and variables) of the module to be exported into the caller namespace.

@EXPORT = qw(...); 
Symbols to export by default

@EXPORT_OK this array stores the subroutins to be exported only on request.
@EXPORT_OK = qw(...); 
Symbols to export on request.

%EXPORT_TAGS = (tag => [...]); 
Define names for sets of symbols
Since the symbols listed within %EXPORT_TAGS must also appear in either @EXPORT or EXPORT_OK,
two utility functions are provided that allow you to easily add tagged sets of symbols to @EXPORT or @EXPORT_OK:
%EXPORT_TAGS = (Bactrian => [qw(aa bb cc)], Dromedary => [qw(aa cc dd)]);
Exporter::export_tags('Bactrian'); # add aa, bb and cc to @EXPORT
Exporter::export_ok_tags('Dromedary'); # add aa, cc and dd to @EXPORT_OK

How to EXPORT

The arrays  @EXPORT  and  @EXPORT_OK   in a module hold lists of symbols that are going to be exported into the users name space by default, or which they can request to be exported, respectively. The symbols can represent functions, scalars, arrays, hashes, or typeglobs.

How to import

In other files which wish to use your module there are three basic ways for them to load your module and import its symbols:

1. use YourModule;                                                                                                                                            This imports all the symbols from YourModule's @EXPORT into the namespace of the use statement.
2. use YourModule ();                                                                                                                                   This causes perl to load your module but does not import any symbols.
3. use YourModule qw(...);                                                                                                                             This imports only the symbols listed by the caller into their namespace. All listed symbols must be in your @EXPORT or @EXPORT_OK, else an error occurs. The advanced export features of Exporter are accessed like this, but with list entries that are syntactically distinct from symbol names.

@INC

@INC is a special Perl variable which is the equivalent of the shell's PATH variable. Whereas PATH contains a list of directories to search for executables, @INC contains a list of directories from which Perl modules and libraries can be loaded.

When you use(), require() or do() a filename or a module, Perl gets a list of directories from the @INC variable and searches them for the file it was requested to load. If the file that you want to load is not located in one of the listed directories, you have to tell Perl where to find the file. You can either provide a path relative to one of the directories in @INC, or you can provide the full path to the file.

%INC

%INC is another special Perl variable that is used to cache the names of the files and the modules that were successfully loaded and compiled by use(), require() or do() statements.Before attempting to load a file or a module with use() or require(), Perl checks whether it's already in the %INC hash. If it's there, the loading and therefore the compilation are not performed at all. Otherwise the file is loaded into memory and an attempt is made to compile it.do() does unconditional loading--no lookup in the %INC hash is made.

If the file is successfully loaded and compiled, a new key-value pair is added to %INC. The key is the name of the file or module as it was passed to the one of the three functions we have just mentioned, and if it was found in any of the @INC directories except "." the value is the full path to it in the file system.

% perl -e 'print join "\n", @INC'/usr/lib/perl5/5.00503/i386-linux/usr/lib/perl5/5.00503/usr/lib/perl5/site_perl/5.005/i386-linux/usr/lib/perl5/site_perl/5.005.

Notice the . (current directory) is the last directory in the list.

% perl -e 'use strict; print map {"$_ => $INC{$_}\n"} keys %INC'strict.pm => /usr/lib/perl5/5.00503/strict.pm

Now let's create the simplest module in /tmp/test.pm:

test.pm-------1;

It does nothing, but returns a true value when loaded. Now let's load it in different ways:

% cd /tmp% perl -e 'use test; print map {"$_ => $INC{$_}\n"} keys %INC'test.pm => test.pm

Since the file was found relative to . (the current directory), the relative path is inserted as the value. If we alter @INC, by adding /tmp to the end:

% cd /tmp% perl -e 'BEGIN{push @INC, "/tmp"} use test; \print map {"$_ => $INC{$_}\n"} keys %INC'test.pm => test.pm

require

require() reads a file containing Perl code and compiles it.Before attempting to load the file it looks up the argument in %INC to see whether it has already been loaded. If it has, require() just returns without doing a thing. Otherwise an attempt will be made to load and compile the file.

This differs from use in that included files effectively become additional text for the current script. Functions, variables, and other objects are not imported into the current name space, so if the specified file includes a package definition, then objects will require fully qualified names.

The specified module is searched for in the directories defined in @INC, looking for a file with the specified name and an extension of .pm.

1、require用于载入module或perl程序(.pm后缀可以省略，但.pl必须有)
2、require在运行时载入(验证)module

require htolib::test
这条语句相当于：require “htolib/test.pm”；

如果使用require 'filename'或者require "filename"来包含文件的话，使用方法和do完全近似；

1. 如果不加单引号或者双引号的话，后面的Module将被解析为Perl的模块即.pm文件，然后根据@INC Array中搜索Module.pm文件。首先在当前目录下搜索Module.pm的文件（用户自定义的），如果找不到再去Perl的 (@INC contains: C:/Perl/site/lib C:/Perl/lib .)寻找。

use

use(), just like require(), loads and compiles files containing Perl code, but it works with modules only and is executed at compile time.

The only way to pass a module to load is by its module name and not its filename. If the module is located in MyCode.pm, the correct way to use() it is:

use MyCode

and not:

use "MyCode.pm"

use() translates the passed argument into a file name replacing :: with the operating system's path separator (normally /) and appending .pm at the end. So My::Module becomes My/Module.pm.

use() is exactly equivalent to:

BEGIN { require Module; Module->import(LIST); }

Internally it calls require() to do the loading and compilation chores. When require() finishes its job, import() is called unless () is the second argument. The following pairs are equivalent:

use MyModule;BEGIN {require MyModule; MyModule->import; }use MyModule qw(foo bar);BEGIN {require MyModule; MyModule->import("foo","bar"); }use MyModule ();BEGIN {require MyModule; }

do

While do() behaves almost identically to require(), it reloads the file unconditionally. It doesn't check %INC to see whether the file was already loaded.

If do() cannot read the file, it returns undef and sets $! to report the error. If do() can read the file but cannot compile it, it returns undef and puts an error message in $@. If the file is successfully compiled, do() returns the value of the last expression evaluated.