Learning Perl Objects, References amp;amp; Modules [Electronic resources] نسخه متنی

5.3 Storing Complex Data with Storable

You can take the output of
Data::Dumper's
Dumper routine, place it into a file, and then
load the file to a different program, evaluating the code as Perl
code, and you'd end up with two package variables,
$VAR1 and $VAR2, that are
equivalent to the original data. This is called
marshaling the data: converting complex data
into a form that can be written to a file as a stream of bytes for
later reconstruction.

However, another Perl core module is much better suited for
marshaling: Storable. It's better
suited because compared to Data::Dumper,
Storable produces smaller and faster-to-process
files. (The Storable module is standard in recent
versions of Perl, but you can always install it from the CPAN if
it's missing.)

The interface is similar to using Data::Dumper,
except you must put everything into one reference. For example,
let's store the mutually referencing data
structures:

use Storable;
my @data1 = qw(one won);
my @data2 = qw(two too to);
push @data2, \@data1;
push @data1, \@data2;
store [\@data1, \@data2], 'some_file';

The file produced by this step was 68 bytes on this system, which was
quite a bit shorter than the equivalent
Data::Dumper output. It's also
much less readable for humans. It's easy for
Storable to read, as you'll soon
see.[1]

[1] The format used by Storable
is architecture byte-order dependent by default. The manpage shows
how to create byte-order-independent storage files.

Next, fetch the data, again using the Storable
module. The result will be a single array reference. Dump the result
to see if it stored the right values:

use Storable;
my $result = retrieve 'some_file';
use Data::Dumper;
$Data::Dumper::Purity = 1;
print Dumper($result);

Here's the result:

$VAR1 = [
[
'one',
'won',
[
'two',
'too',
'to',
[  ]
]
],
[  ]
];
$VAR1->[0][2][3] = $VAR1->[0];
$VAR1->[1] = $VAR1->[0][2];

This is functionally the same as the original data structure.
You're now looking at the two array references
within one top-level array. To get something closer to what you saw
before, you can be more explicit about the return value:

use Storable;
my ($arr1, $arr2) = @{ retrieve 'some_file' };
use Data::Dumper;
$Data::Dumper::Purity = 1;
print Dumper($arr1, $arr2);

or equivalently:

use Storable;
my $result = retrieve 'some_file';
use Data::Dumper;
$Data::Dumper::Purity = 1;
print Dumper(@$result);

and you'll get:

$VAR1 = [
'one',
'won',
[
'two',
'too',
'to',
[  ]
]
];
$VAR1->[2][3] = $VAR1;
$VAR2 = $VAR1->[2];

just as you did in the original program. With
Storable, you can store data and retrieve it
later. More information on Storable can be found
in perldoc Storable, as always.