How do I use constants from a Perl module?

Question

If I define a constant in a Perl module, how do I use that constant in my main program? (Or how do I call that constant in the main program?)

Answer 1

Constants can be exported just like other package symbols. Using the standard Exporter module, you can export constants from a package like this:

package Foo;
use strict;
use warnings;

use base 'Exporter';

use constant CONST => 42;

our @EXPORT_OK = ('CONST');

1;

Then, in a client script (or other module)

use Foo 'CONST';
print CONST;

You can use the %EXPORT_TAGS hash (see the Exporter documentation) to define groups of constants that can be exported with a single import argument.

Update: Here's an example of how to use the %EXPORT_TAGS feature if you have multiple constants.

use constant LARRY => 42;
use constant CURLY => 43;
use constant MOE   => 44;

our @EXPORT_OK = ('LARRY', 'CURLY', 'MOE');
our %EXPORT_TAGS = ( stooges => [ 'LARRY', 'CURLY', 'MOE' ] );

Then you can say

use Foo ':stooges';
print "$_\n" for LARRY, CURLY, MOE;

Answer 2

Constants are just subs with empty prototype, so they can be exported like any other sub.

# file Foo.pm
package Foo;
use constant BAR => 123;
use Exporter qw(import);
our @EXPORT_OK = qw(BAR);


# file main.pl:
use Foo qw(BAR);
print BAR;

Answer 3

To expand on the earlier answers, since constants are really just subs, you can also call them directly:

use Foo;
print Foo::BAR;

Answer 4

您可能想要考虑使用Readonly而不是常量。

Answer 5

package Foo;
use Readonly;
Readonly my  $C1 => 'const1';
Readonly our $C2 => 'const2';
sub get_c1 { return $C1 }
1;

perl -MFoo -e 'print "$_\n" for Foo->get_c1, $Foo::C2'

Answer 6

To add to the bag of tricks, since a constant is just a subroutine you can even call it as a class method.

package Foo;
use constant PI => 3.14;

print Foo->PI;

If you have lots of constants it's a nice way to get at the occasional one without having to export them all. However, unlike Foo::PI or exporting PI , Perl will not compile out Foo->PI so you incur the cost of a method call (which probably doesn't matter).