# Recipe 1.21 Constant Variables

#### 1.21.1 Problem

You want a variable whose value cannot be modified once set.

#### 1.21.2 Solution

If you don't need it to be a scalar variable that can interpolate, the use constant pragma will work:

```use constant AVOGADRO => 6.02252e23;

printf "You need %g of those for guac\n", AVOGADRO;```

If it does have to be a variable, assign to the typeglob a reference to a literal string or number, then use the scalar variable:

```*AVOGADRO = \6.02252e23;
print "You need \$AVOGADRO of those for guac\n";```

But the most foolproof way is via a small tie class whose STORE method raises an exception:

```package Tie::Constvar;
use Carp;
sub TIESCALAR {
my (\$class, \$initval) = @_;
my \$var = \$initval;
return bless \\$var => \$class;
}
sub FETCH {
my \$selfref = shift;
return \$\$selfref;
}
sub STORE {
confess "Meddle not with the constants of the universe";
}```

#### 1.21.3 Discussion

The use constant pragma is the easiest to use, but has a few drawbacks. The biggest one is that it doesn't give you a variable that you can expand in double-quoted strings. Another is that it isn't scoped; it puts a subroutine of that name into the package namespace.

The way the pragma really works is to create a subroutine of that name that takes no arguments and always returns the same value (or values if a list is provided). That means it goes into the current package's namespace and isn't scoped. You could do the same thing yourself this way:

`sub AVOGADRO( ) { 6.02252e23 }`

If you wanted it scoped to the current block, you could make a temporary subroutine by assigning an anonymous subroutine to the typeglob of that name:

```use subs qw(AVOGADRO);
local *AVOGADRO = sub ( ) { 6.02252e23 };```

But that's pretty magical, so you should comment the code if you don't plan to use the pragma.

If instead of assigning to the typeglob a reference to a subroutine, you assign to it a reference to a constant scalar, then you'll be able to use the variable of that name. That's the second technique given in the Solution. Its disadvantage is that typeglobs are available only for package variables, not for lexicals created via my. Under the recommended use strict pragma, an undeclared package variable will get you into trouble, too, but you can declare the variable using our:

```our \$AVOGADRO;

The third solution provided, that of creating your own little tie class, might appear the most complicated, but it provides the most flexibility. Plus you get to declare it as a lexical if you want.

`tie my \$AVOGADRO, Tie::Constvar, 6.02252e23;`

After which this is okay:

`print "You need \$AVOGADRO of those for guac\n";`

But this will get you in trouble:

`\$AVOGADRO = 6.6256e-34;   # sorry, Max`

Recipe 1.15; Recipe 5.3; the discussion on folding constant subroutines toward the end of the section on "Compiling Your Code" in Chapter 18 of Programming Perl; the CPAN module Tie::Scalar::RestrictUpdates might give you some other ideas

 Chapter 2. Numbers
 Chapter 3. Dates and Times
 Chapter 4. Arrays
 Chapter 5. Hashes
 Chapter 6. Pattern Matching
 Chapter 7. File Access
 Chapter 8. File Contents
 Chapter 9. Directories
 Chapter 10. Subroutines
 Chapter 11. References and Records
 Chapter 12. Packages, Libraries, and Modules
 Chapter 13. Classes, Objects, and Ties
 Chapter 14. Database Access
 Chapter 15. Interactivity
 Chapter 16. Process Management and Communication
 Chapter 17. Sockets
 Chapter 18. Internet Services
 Chapter 19. CGI Programming
 Chapter 20. Web Automation
 Chapter 21. mod_perl
 Chapter 22. XML