sauver un hash de array dans un fichier

**Jasmine80** · 04/12/2015, 12h19

Bonjour à tous,

Y at-il moyen de sauver facilement un hash de array dans un fichier, en vue de le réimporter tel quel plus tard dans un autre programme ? Connaissez-vous des modules ?

D'avance merci.

**Jasmine80** · 04/12/2015, 13h00

J'ai maintenant transformé mon tableau en hash de hash de array. Mais, je suppose que la question reste la même. Merci.

**cmcmc** · 04/12/2015, 16h24

Le plus simple et portable est sans doute Data::Dumper. En moins portable mais dans le core il y a Storable. Après il y a aussi YAML et JSON...

**Jasmine80** · 04/12/2015, 16h48

Merci cmcmc, je vais y regarder et je reviens donner mon avis.

**Lolo78** · 04/12/2015, 18h42

Juste en complément, Data::Dumper fait aussi partie des modules core.

**cmcmc** · 06/12/2015, 19h08

Un petit exemple vite fait avec Data::Dumper :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
Taisha:~/perl/forum $ perl -E '
my $h = { b => { c => { foo => 1, bar => 2 }}, a => [0 .. 3], d => [4, 6, 8, 10]};
{
   use Data::Dumper;
   local ($Data::Dumper::Purity, $Data::Dumper::Terse) = (1,1);
   print Dumper($h);
}' > h.dat
Taisha:~/perl/forum $ cat h.dat
{
          'a' => [
                   0,
                   1,
                   2,
                   3
                 ],
          'b' => {
                   'c' => {
                            'bar' => 2,
                            'foo' => 1
                          }
                 },
          'd' => [
                   4,
                   6,
                   8,
                   10
                 ]
        }
Taisha:~/perl/forum $ perl -MData::Dump -e 'my $h = do "h.dat"; dd $h'
{ a => [0 .. 3], b => { c => { bar => 2, foo => 1 } }, d => [4, 6, 8, 10] }
Taisha:~/perl/forum $

note que l'utilisation de Data::Dump ci-dessus n'a rien à voir avec la sérialisation/désérialisation de $h: je l'utilise juste pour la fonction dd qui est pratique et compacte pour les impressions de debug. La sérialisation est faite par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

print Dumper($h)

et la désérialisation par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

$h = do "h.dat"

**Philou67430** · 07/12/2015, 14h41

Il existe bien le module Storable, mais j'avoue également utiliser les facilités de Data::Dumper, qui en outre, permet d'avoir accès, offline, au contenu de la structure à l'aide d'un simple éditeur de texte. La manipulation d'exportation est très simple, celle d'importation un peu moins (si l'on intègre la gestion des exceptions avec les tests de $@, $! et le retour de la fonction do), mais bien documentée dans l'aide de la fonction do (avec notamment un exemple de programme).

**Jasmine80** · 07/12/2015, 17h34

Bonjour à vous deux,

Merci pour vos réponses :

Voila, j'ai adapté ... ça fonctionne vraiment bien, un grand merci.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#!/usr/bin/perl
 
use strict;
use warnings;
 
use Data::Dumper;
local ($Data::Dumper::Purity, $Data::Dumper::Terse) = (1,1);
 
 
my $h = { b => { c => { foo => 1, bar => 2 }}, a => [0 .. 3], d => [4, 6, 8, 10]};
 
my $file = 'test.txt';
open(my $fh, ">", $file)  or die "cannot create file : $!";	
print $fh Dumper($h);
close $fh;
 
 
open(my $fh2, "<", $file)  or die "cannot open file : $!";	
my $h2 = do "test.txt";
close $fh2;
 
print Dumper($h2);

Comment choisir de mettre 1 ou de laisser le défaut ?

$Data::Dumper::Purity or $OBJ->Purity([NEWVAL]) : Controls the degree to which the output can be evaled to recreate the supplied reference structures. Setting it to 1 will output additional perl statements that will correctly recreate nested references. The default is 0.

$Data::Dumper::Terse or $OBJ->Terse([NEWVAL]) : When set, Data::Dumper will emit single, non-self-referential values as atoms/terms rather than statements. This means that the $VARn names will be avoided where possible, but be advised that such output may not always be parseable by eval.

Bonne fin de journée,

**cmcmc** · 07/12/2015, 19h43

Envoyé par Jasmine80

Comment choisir de mettre 1 ou de laisser le défaut ?

Je l'utilise personnellement comme ci dessus sans état d'âme sachant que je ne m'en sers que pour des structures potentiellement complexes mais pas auto-référentes... Donc purity est probablement overkill mais terse permet de ne pas utiliser de variables globales.

**Jasmine80** · 08/12/2015, 10h31

Merci, j'ai encore quelques questions.
Quelle est l'utilité d'une variable autoréférente ?
A partir de quelle complexité de structure vaut-il mieux mettre purity à 1 ?
Est-ce que la taille du tableau compte aussi dans cette complexité ?

Bonne journée.

**cmcmc** · 08/12/2015, 11h52

Envoyé par Jasmine80

Merci, j'ai encore quelques questions.
Quelle est l'utilité d'une variable autoréférente ?

Je voulais parler d'une structure dont certains membres pointent sur d'autres de la structure, par exemple un arbre ou un graphe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
Taisha:~/perl/forum $ perl -E '
my $a = { name => "alice" };
my $b = { name => "bob", parent => $a };
push @{$a->{children}}, $b;
my $c = { name => "charles", parent => $b};
push @{$b->{children}}, $c;
my $d = { name => "dave", parent => $b};
push @{$b->{children}}, $d;
push @{$c->{siblings}}, $d;
push @{$d->{siblings}}, $c;
use Data::Dumper; print Dumper($a);
say+"-"x50;
use Data::Dump; dd $a'
$VAR1 = {
          'name' => 'alice',
          'children' => [
                          {
                            'parent' => $VAR1,
                            'children' => [
                                            {
                                              'name' => 'charles',
                                              'parent' => $VAR1->{'children'}[0],
                                              'siblings' => [
                                                              {
                                                                'parent' => $VAR1->{'children'}[0],
                                                                'siblings' => [
                                                                                $VAR1->{'children'}[0]{'children'}[0]
                                                                              ],
                                                                'name' => 'dave'
                                                              }
                                                            ]
                                            },
                                            $VAR1->{'children'}[0]{'children'}[0]{'siblings'}[0]
                                          ],
                            'name' => 'bob'
                          }
                        ]
        };
--------------------------------------------------
do {
  my $a = {
    children => [
      {
        children => [
          {
            name => "charles",
            parent => 'fix',
            siblings => [{ name => "dave", parent => 'fix', siblings => ['fix'] }],
          },
          'fix',
        ],
        name => "bob",
        parent => 'fix',
      },
    ],
    name => "alice",
  };
  $a->{children}[0]{children}[0]{parent} = $a->{children}[0];
  $a->{children}[0]{children}[0]{siblings}[0]{parent} = $a->{children}[0];
  $a->{children}[0]{children}[0]{siblings}[0]{siblings}[0] = $a->{children}[0]{children}[0];
  $a->{children}[0]{children}[1] = $a->{children}[0]{children}[0]{siblings}[0];
  $a->{children}[0]{parent} = $a;
  $a;
}
Taisha:~/perl/forum $

On voit que Data::Dumper et Data::Dump utilisent des méthodes différentes pour reconstituer la structure. $Data::Dumper::Terse = 1 ne fonctionnerait probablement pas dans ce cas.

A partir de quelle complexité de structure vaut-il mieux mettre purity à 1 ?

Aucune idée car je ne m'en sers pas pour des structures autoréférentes.

Est-ce que la taille du tableau compte aussi dans cette complexité ?

Pour des structures complexes mais pas autoréférentes je n'ai pas rencontré de limitation de taille.