use module if condition is met

[Grygonos]

Felllow Monks,

Here is the basic idea of what I'm attempting, I want to use a different module depending on what client my script runs for. Secondly,there are some functions that exist in one client module that may not exist in another. I would like to check for the existance of a sub before I call it.

if($type eq 'x')
{
     use Some::Module;
}

#*pseudo*
if(subExists('mysubtocheck'))
{ 
    mysubtocheck();
}

Is this possible, or a good idea? Can you suggest some alternatives?

Thanks again monks,

[tcf22]

Perhaps something like this:

if($type eq 'x'){
     eval "use Some::Module";
}

eval { mysubtocheck(); };
if($@){ 
    #Sub ran
}else{
    #Sub not present or died
}

[broquaint]

For conditional a use statement, see the if module. But if you're happy to include your modules at runtime then a simple require will be be. Finally, to check for the existence of a subroutine you can simply use defined e.g

defined &mysubtocheck && mysubtocheck();

Although make sure you use parens when calling a dynamically defined subroutine otherwise you'll get a compile-time error under strict 'subs'.

[cfreak]

[perrin]

Not that it really matters, but require is not slower than use. If anything, it would be faster, since it does less.

[Abigail-II]

use if $type eq 'x', Some::Module;

Of course, that requires the value of $type to be known at compile time. Otherwise, do something like:

if ($type eq 'x') {
    require Some::Module;
    Some::Module -> import if Some::Module -> can ("import");
}

Abigail

[ysth]

If $type is known when your script is compiling (e.g. based on operating system or information in @ARGV), use the if module for this:

use if $type eq 'x', "Some::Module";

(Your try at if ($type eq 'x') { use Some::Module } doesn't work because the use will be performed at compilation time, before the check of $type even happens.)
Otherwise, use some form like eval "use $module" or eval { require $module; $module->import; } (but not eval { use $module }, because there the use is again performed at compilation time).

Having the use happen at run-time is not ideal, because there can be differences in how your code will compile; e.g.:

$perl -we'eval "use Errno qw/EINVAL/"; print EINVAL'
Name "main::EINVAL" used only once: possible typo at -e line 1.
print() on unopened filehandle EINVAL at -e line 1.

$perl -we'use Errno qw/EINVAL/; print EINVAL'
22

To detect if a subroutine exists, use exists(&subname). This will not detect subs that would be AUTOLOADed, unless they have a forward declaration (e.g. sub Foo;). defined(&subname) is slightly different and probably not what you want; see perldoc defined and exists.

[Grygonos]

Thanks monks, the if module worked perfectly. I simply passed my client name as $ARGV[0] and it works.