Making Variables Private to a Module (Perl Cookbook, 2nd Edition)

## 12.4. Making Variables Private to a Module

### 12.4.1. Problem

You want to make a variable private to a package.

### 12.4.2. Solution

You can't. But you can make them private to the file that the module sits in, which usually suffices.

### 12.4.3. Discussion

Remember that a package is just a way of grouping variables and functions together, conferring no privacy. Anything in a package is by definition global and accessible from anywhere. Packages only group; they don't hide.

For privacy, only lexical variables will do. A module is implemented in a Module.pm file, with all its globals in the package named Module. Because that whole file is by definition a scope and lexicals are private to a scope, creating file-scoped lexicals is effectively the same thing as a module-private variable.

If you alternate packages within a scope, though, you may be surprised that the scope's lexicals are still visible throughout that scope. That's because a package statement only sets a different prefix for a global identifier; it does not end the current scope, not does it begin a new one.

>     package Alpha;
>     my $aa = 10;
>        $x = "azure";

>     package Beta;
>     my $bb = 20;
>        $x = "blue";

>     package main;
>     print "$aa, $bb, $x, $Alpha::x, $Beta::x\n";
>     10, 20, , azure, blue

Was that the output you expected? The two lexicals, `$aa` and `$bb`, are still in scope because we haven't left the current block, file, or `eval`. You might think of globals and lexicals as existing in separate dimensions, forever unrelated to each other. Package statements have nothing to do with lexicals. By setting the current prefix, the first global variable `$x` is really `$Alpha::x`, whereas the second `$x` is now `$Beta::x` because of the intervening package statement changing the default prefix. Package identifiers, if fully qualified, can be accessed from anywhere, as we've done in the `print` statement.

So, packages can't have privacy—but modules can because they're in a file, which is always its own scope. Here's a simple module, placed in the file Flipper.pm, that exports two functions, `flip_words` and `flip_boundary`. The module provides code to reverse words in a line, and to change the definition of a word boundary.

>     # Flipper.pm
>     package Flipper;
>     use strict;

>     require Exporter;
>     use vars qw(@ISA @EXPORT $VERSION);
>     @ISA     = qw(Exporter);
>     @EXPORT  = qw(flip_words flip_boundary);
>     $VERSION = 1.0;

>     my $Separatrix = " ";  # default to blank; must precede functions

>     sub flip_boundary {
>         my $prev_sep = $Separatrix;
>         if (@_) { $Separatrix = $_[0] }
>         return $prev_sep;
>     }
>     sub flip_words {
>         my $line  = $_[0];
>         my @words = split($Separatrix, $line);
>         return join($Separatrix, reverse @words);
>     }
>     1;

This module sets three package variables needed by the Exporter and also initializes a lexical variable at file level called `$Separatrix`. Again, this variable is private to the file, not to the package. All code beneath its declaration in the same scope (or nested within that scope, as are the functions' blocks) can see `$Separatrix` perfectly. Even though they aren't exported, global variables could be accessed using the fully qualified name, as in `$Flipper::VERSION`.

A scope's lexicals cannot be examined or tinkered with from outside that scope, which in this case is the entire file below their point of declaration. You cannot fully qualify lexicals or export them either; only globals can be exported. If someone outside the module needs to look at or change the file's lexicals, they must ask the module itself. That's where the `flip_boundary` function comes into play, allowing indirect access to the module's private parts.

This module would work the same even if its `$Separatrix` variable were a package global rather than a file lexical. Someone from the outside could theoretically play with it without the module realizing this. On the other hand, if they really want to that badly, perhaps you should let them do so. Peppering your module with file-scoped lexicals is not necessary. You already have your own namespace (Flipper, in this case) where you can store any identifier you want. That's what it's there for, after all. Good Perl programming style nearly always avoids fully qualified identifiers.

Speaking of style, the case of identifiers used in the Flipper module was not random. Following the Perl style guide, identifiers in all capitals are reserved for those with special meaning to Perl itself. Functions and local variables are all lowercase. The module's persistent variables (either file lexicals or package globals) are capitalized. Identifiers with multiple words have each word separated by an underscore to make them easier to read. We advise against using mixed capitals without underscores—you wouldn't like reading this book without spaces, either.

### 12.4.4. See Also

The discussion on file-scoped lexicals in perlmod(1); the "Scoped Declarations" section in Chapter 4 of Programming Perl; the section on "Programming with Style" in Chapter 24 of Programming Perl or perlstyle(1); Recipe 10.2; Recipe 10.3

Copyright © 2003 O'Reilly & Associates. All rights reserved.