categorized answer
QandAEditors
data_structure
<p>Yes. In the spirit of TMTOWTDI, there are several ways to
represent your data structure. Which you choose is largely up to
you. The information provided below should serve as an overview
only; always consult a module's complete documentation for usage,
bugs, and caveats.</p>
<blockquote>
<ol>
<li>[cpan://Dumpvalue]</li>
</ol>
<blockquote>
<p>More of a [jargon://prettyprint]er than a serializer, this
method provides the view of your data structure that is most like
the output from Perl's debugger. The output format may be modified
by setting numerous options. [cpan://Dumpvalue] can even dump the
symbol tables of whole packages.</p>
<code>
use strict;
use warnings;
use Dumpvalue;
my $ref = {
a => [ 1, 2, 3 ],
b => [
{ X => 1, Y=> 2 },
{
X => [ 1, 2, 3 ],
Y => [ 4, 5, 6 ],
Z => [ 7, 8, 9 ]
},
],
};
print "Dumpvalue:\n";
Dumpvalue->new->dumpValue( $ref );
</code>
<p>Output:</p>
<code>
Dumpvalue:
'a' => ARRAY(0x460ee8)
0 1
1 2
2 3
'b' => ARRAY(0x4e3e50)
0 HASH(0x4d964c)
'X' => 1
'Y' => 2
1 HASH(0x4e3e14)
'X' => ARRAY(0x4d967c)
0 1
1 2
2 3
'Y' => ARRAY(0x4e3d9c)
0 4
1 5
2 6
'Z' => ARRAY(0x4e3dd8)
0 7
1 8
2 9
</code></blockquote>
<ol start="2">
<li>[cpan://Data::Dumper]</li>
</ol>
<blockquote>
<p>Possibly the most popular choice, [cpan://Data::Dumper] outputs
actual Perl code. As such, it is both a [jargon://prettyprint]er
<i>and</i> a serializer. [cpan://Data::Dumper] can handle
self-referential data structures, and <code>eval</code>ing
[cpan://Data::Dumper]'s output reconstitutes an exact copy of the
original data structure. This module is useful both for saving data
structures to disk and DBM files and for passing them to other
processes. As with [cpan://Dumpvalue], [cpan://Data::Dumper]'s
output is configurable.</p>
<code>
use strict;
use warnings;
use Data::Dumper;
my $ref = {
a => [ 1, 2, 3 ],
b => [
{ X => 1, Y=> 2 },
{
X => [ 1, 2, 3 ],
Y => [ 4, 5, 6 ],
Z => [ 7, 8, 9 ]
},
],
};
print "Data::Dumper:\n";
print Dumper( $ref );
</code>
<p>Output:</p>
<code>
Data::Dumper:
$VAR1 = {
'a' => [
1,
2,
3
],
'b' => [
{
'X' => 1,
'Y' => 2
},
{
'Z' => [
7,
8,
9
],
'X' => [
1,
2,
3
],
'Y' => [
4,
5,
6
]
}
]
};
</code></blockquote>
<ol start="3">
<li>[cpan://YAML]'s Dump</li>
</ol>
<blockquote>
<p>Another [jargon://prettyprint]er/serializer combo.
[cpan://YAML]'s output format is also controllable and hash keys
are sorted by default. Since [cpan://YAML] does not <code>eval</code> to de-serialize, it is safer than
[cpan://Data::Dumper] when you're not sure who else might have
access to your files. Data structures serialized from Perl using
[cpan://YAML] can be accurately read and processed using
[cpan://YAML] in Java, Javascript, PHP, Python, Ruby, and Tcl (and
of course, Perl). Likewise, data structures may be serialized in
any of these languages and be usable by Perl.</p>
<code>
use strict;
use warnings;
use YAML;
my $ref = {
a => [ 1, 2, 3 ],
b => [
{ X => 1, Y=> 2 },
{
X => [ 1, 2, 3 ],
Y => [ 4, 5, 6 ],
Z => [ 7, 8, 9 ]
},
],
};
print "YAML::Dump:\n";
print Dump( $ref );
</code>
<p>Output:</p>
<code>
YAML::Dump:
---
a:
- 1
- 2
- 3
b:
- X: 1
Y: 2
- X:
- 1
- 2
- 3
Y:
- 4
- 5
- 6
Z:
- 7
- 8
- 9
</code></blockquote>
<ol start="4">
<li>[cpan://Data::Dump::Streamer], by [demerphq]</li>
</ol>
<blockquote>
<p>If it's by our very own [demerphq], it <i>must</i> be good.</p>
<p>[cpan://Data::Dump::Streamer] offers more accurate and more
readable output, and uses less memory, than does
[cpan://Data::Dumper]. Hash keys are sorted and the sort order is
configurable. [cpan://Data::Dump::Streamer]'s output, like that of
[cpan://Data::Dumper], may be <code>eval</code>ed back to
its original form.</p>
<code>
use strict;
use warnings;
use Data::Dump::Streamer;
my $ref = {
a => [ 1, 2, 3 ],
b => [
{ X => 1, Y=> 2 },
{
X => [ 1, 2, 3 ],
Y => [ 4, 5, 6 ],
Z => [ 7, 8, 9 ]
},
],
};
print "Data::Dump::Streamer:\n";
print Dump( $ref );
</code>
<p>Output:</p>
<code>
Data::Dump::Streamer:
$HASH1 = {
a => [
1,
2,
3
],
b => [
{
X => 1,
Y => 2
},
{
X => [
1,
2,
3
],
Y => [
4,
5,
6
],
Z => [
7,
8,
9
]
}
]
};
</code>
See also: [cpan://Test::Struct]</blockquote>
<ol start="5">
<li>[cpan://GraphViz::Data::Structure] is one of two modules I know
of that literally draw you a picture of your data structure. Great
for the visually-oriented, but none of the de-serializing or
multi-lingual features of the above alternatives.</li>
</ol>
<blockquote>
<code>
use strict;
use warnings;
use GraphViz::Data::Structure;
my $data_structure = {
a => [ 1, 2, 3 ],
b => [
{ X => 1, Y => 2 },
{
X => [ 1, 2, 3 ],
Y => [ 4, 5, 6 ],
Z => [ 7, 8, 9 ]
},
],
};
my $gvds =
GraphViz::Data::Structure->new( $data_structure, Orientation => 'vertical' );
print $gvds->graph()->as_png("gvds.png");
</code>
<p><a href="http://planetscape.perlmonk.org/gvds.png">Output</a></p>
</blockquote>
<ol start="6">
<li>[cpan://GraphViz::Data::Grapher] is the other of the two, and
happens to be my personal favorite. No reconstituting original
structures or sharing them with other languages such as Python or
Ruby; but this does create very nice illustrations of complex data
structures for documentation or perhaps teaching purposes.</li>
</ol>
<blockquote>
<code>
use strict;
use warnings;
use GraphViz::Data::Grapher;
my $structure = {
a => [ 1, 2, 3 ],
b => [
{ X => 1, Y => 2 },
{
X => [ 1, 2, 3 ],
Y => [ 4, 5, 6 ],
Z => [ 7, 8, 9 ]
},
],
};
my $graph = GraphViz::Data::Grapher->new($structure);
print $graph->as_png("gvdg.png");
</code>
<p><a href="http://planetscape.perlmonk.org/gvdg.png">Output</a></p>
</blockquote>
<p> </p>
<p><b><i>For more on visualizing hash structure, please see: [id://471590]</i></b></p>
<p> </p>
<p><b>References</b> <font size="2">(incomplete and in no
particular order)</font><b>:</b></p>
<ul>
<li>[id://30275]</li>
<li>[id://390153]</li>
<li>[id://433537]</li>
<li>[id://439530]</li>
<li>[id://472337]</li>
<li>[id://474783]</li>
<li>[id://476435]</li>
<li>[id://476806]</li>
<li>[id://478513]</li>
</ul>
</blockquote>
481745