use happens at compile time, so before the if gets checked.

Yes, I know you've put it in a BEGIN { ... } block, so the if also happens at compile time, but the use is happening at a compile-time within compile-time, if you see what I mean.

One solution is to not use use and use require;import instead.

BEGIN {
  if ($ENV{USE_XYZ} == 1) {
    require XYZ;
    XYZ->import();
  }
}
[download]

Another option is to take advantage of the core module if (if.pm).

use if $ENV{USE_XYZ}, "XYZ";
[download]

In rare cases, if you're loading something that does weird funky stuff at compile time, the first option won't work well. The second option should generally be okay.

Keep in mind that for non-trivial code an optional dependency can cause spaghetti-like code with conditionals peppered throughout the code base:

if(exists $INC{'Example/Module.pm'}) {...}
[download]

...or...

if (__PACKAGE__->can('example')) {...}
[download]

...or any of a number of other strategies for detecting if the optional module got loaded. This is a situation where it's usually better to encapsulate the optional dependency so that the calling code doesn't have to care whether it was available or not:

package SomeThing;

use Exporter;

BEGIN {
    if (eval "require MyOptional; 1;") {
        MyOptional->import('foo');
    }
    else {
        *foo = sub { # fallback code here. };
    }
}

use parent 'Exporter';
our @EXPORT = qw(foo);

1;

package main;

use SomeThing;

foo();
[download]

Now everywhere you wanted foo() you can just call it and not worry about whether or not it got loaded at startup by an external dependency, or by a fallback sub that you created yourself. This is just one of many ways to do it. An encapsulating OO class might work better, or dependency injection into a consuming object could be better; it depends a lot on your use case. But the goal is to reduce the pervasiveness of conditional logic in your code to only the one place.

See use. use Foo::Bar; is basically BEGIN { require Foo::Bar; }. If you want some conditional logic, you can put that into the BEGIN block as well:

BEGIN {
    if( $ENV{USE_XYZ}) {
        require Foo::Bar;
        Foo::Bar->import();
    }
}
[download]

The if module wraps that simple case already:

use if $ENV{USE_XYZ}, 'Foo::Bar';
[download]

In my experience, conditionally loading a module (like Corion and tobyink already showed) isn't always the only thing going on, since later on in your code you might want to use functions from that module conditionally, based on whether it was loaded in the first place. Personally, I prefer to set a global variable, something like this:

our $HAVE_XYZ;
BEGIN { $HAVE_XYZ = !!$ENV{USE_XYZ} }
use if $HAVE_XYZ, 'XYZ';
...
if ( $HAVE_XYZ ) {
    XYZ::foo(...)
}
[download]

Also, note that BEGIN is uppercase, not begin {...}.

A constant is usually better than a variable:

use constant HAVE_XYZ => !!$ENV{USE_XYZ};
use if HAVE_XYZ, 'XYZ';
...
if ( HAVE_XYZ ) {
    XYZ::foo(...)
}
[download]

At it means that the if (...) stuff will be optimized away entirely when it's false. Also it will protect against $HAVE_XYZ being accidentally changed half way through running the process. (Of course, sometimes you do wish to start using XYZ later on by changing the variable, but that's probably less common.)

toby döt ink

Heh perlcritic knows about this

See perlrun for ways to environmentally load a module

perl -MXYZ ./myprogram.pl

export PERL5OPT=-MXYZ
set PERL5OPT=-MXYZ
./myprogram.pl
[download]

The if module has been core since Perl 5.6.2.