"use base" or @ISA

[uwevoelker]

use base 'Exporter';
and
@ISA = qw(Exporter);
seem to be the same thing. I was thinking 'use base' was introduced later and should be prefered. But even never code often uses @ISA.

Which one should be prefered and why?

Thanks, Uwe

[davido]

Not exactly the same thing. @ISA = qw/Exporter/; doesn't perform a 'require Exporter;'.

From the base POD: use base; "is rougly similar to":

BEGIN {
    require Foo;
    require Bar;
    push @ISA, qw(Foo Bar);
}

I like use base; also because it runs under strictures without explicitly calling "use vars qw/@ISA/;", or declaring "our @ISA...". ...just a minor improvement, IMHO, but I prefer to use it.

[ikegami]

As an aside, I hate inhererting from Exporter. My class does NOT have an ISA relationship with Exporter! (And inheriting an autoload? ouch!) Below is an alternative.

Instead of:

use vars qw( @ISA @EXPORT_OK %EXPORT_TAGS );
BEGIN {
    @ISA = qw( Exporter );
    @EXPORT_OK   = qw( ... );
    %EXPORT_TAGS = ( ... );  # if necessary
    use Exporter;
}

try:

use vars qw( @EXPORT_OK %EXPORT_TAGS );
BEGIN {
    @EXPORT_OK   = qw( ... );
    %EXPORT_TAGS = ( ... );  # if necessary
    require Exporter;
    *import = \&Exporter::import;
}

Update: s/module/class/;

[kscaldef]

My module does NOT have an ISA relationship with Exporter!

Really? So, how would you explain the relationship? Your module exports; it is an exporter.

[simonm]

My module does NOT have an ISA relationship with Exporter!

Really? So, how would you explain the relationship? Your module exports; it is an exporter.

I would say that the module "delegates to Exporter", or "uses Exporter".

Delegation and composition are perfectly valid implementation mechanisms, and there's no reason to view inheritance as the one true way of sharing functionality.

[ikegami]

oops, that was a typo or a freudian slip or something. I meant to say my class isn't an exporter. A dog (for example) is an animal, but a dog isn't an exporter (although the package in which dog is defined might be). That's just my way of looking at things, so use the style you like the most.

[Aristotle]

I use Exporter::Lite. It is much lighter and has a clean interface (its import() is simply exported). It doesn't support tags, but then I never needed them anyway.

Exporter::Tidy is another alternative if you need advanced features (some of which Exporter doesn't even offer.)

[Prior Nacre V]

Exporter has:

package YourModule;
use Exporter qw( import );

under the heading Exporting without inheriting from Exporter.

[borisz]

I use both from time to time. A difference is that use base 'Exporter'; is like

require Exporter;
push @ISA, 'Exporter';

so you may save a line. For all the differences read perldoc base.

[dragonchild]

There is a subtle difference between the following:

use base 'Foo';

----

use Foo;
our @ISA = qw( Foo );

I always use the latter, because 'use base' does a require, not a use. This means that Foo's import() isn't called. Most people would consider this to be a good thing, but I don't like limiting the options for the modules I work with. This is Perl, after all.

[adrianh]

Which one should be prefered and why?

I prefer use base for three reasons:

• To me, it expresses my intent more clearly. I am using this module as a base class. When I have separate use/require and @ISA and have to expend that little bit more effort to associate the two.
• Less typing.
• Since use base does not die if the specified module cannot be required I don't have to change my code when I move between inlined packages and external modules