Voici la procédure de création du hash
$handle,le numéro du média
$id , identifiant
$file, nom du fichier média
$note, note attachée au média
#####################################
# ajoute un élément au hash objects #
#####################################
sub add_object
{
my($handle,$id,$file,$note)=@_;
my @users=();
my $tab=[$id,$file,$note,@users];
$h_objects{$handle}=$tab;
}
Dans un deuxième temps, le programme explore le fichier par personne,
famille, évènement, lieu et entre-autre met à jour le hash des objets.
Voici la routine de mise à jour du hash, l'idée est d'ajouter un tableau
[type d'utilisateur, utilisateur] dans la liste des utilisateurs du médium.
####################################################
# ajoute un utilisateur a un objet du hash objects #
####################################################
$handle , numero du média
$type , type d'utilisateur (personne, famille, evenement, lieux)
$id , id de l'utilisateur
sub add_object_user
{
my($handle,$type,$id)=@_;
my $user=[$type,$id];
my $object=$h_objects{$handle};
print "Ajout de l'utilisateur $id type $type à l'objet $object->[1]n";
my @users=@$object->[3];
print "Avant :n";
print "@users n";
push(@users,$user);
print "Après :n";
print "Utilisateurs: @users n";
}
Voici la procédure de création du hash
$handle,le numéro du média
$id , identifiant
$file, nom du fichier média
$note, note attachée au média
#####################################
# ajoute un élément au hash objects #
#####################################
sub add_object
{
my($handle,$id,$file,$note)=@_;
my @users=();
my $tab=[$id,$file,$note,@users];
$h_objects{$handle}=$tab;
}
Dans un deuxième temps, le programme explore le fichier par personne,
famille, évènement, lieu et entre-autre met à jour le hash des objets.
Voici la routine de mise à jour du hash, l'idée est d'ajouter un tableau
[type d'utilisateur, utilisateur] dans la liste des utilisateurs du médium.
####################################################
# ajoute un utilisateur a un objet du hash objects #
####################################################
$handle , numero du média
$type , type d'utilisateur (personne, famille, evenement, lieux)
$id , id de l'utilisateur
sub add_object_user
{
my($handle,$type,$id)=@_;
my $user=[$type,$id];
my $object=$h_objects{$handle};
print "Ajout de l'utilisateur $id type $type à l'objet $object->[1]n";
my @users=@$object->[3];
print "Avant :n";
print "@users n";
push(@users,$user);
print "Après :n";
print "Utilisateurs: @users n";
}
Voici la procédure de création du hash
$handle,le numéro du média
$id , identifiant
$file, nom du fichier média
$note, note attachée au média
#####################################
# ajoute un élément au hash objects #
#####################################
sub add_object
{
my($handle,$id,$file,$note)=@_;
my @users=();
my $tab=[$id,$file,$note,@users];
$h_objects{$handle}=$tab;
}
Dans un deuxième temps, le programme explore le fichier par personne,
famille, évènement, lieu et entre-autre met à jour le hash des objets.
Voici la routine de mise à jour du hash, l'idée est d'ajouter un tableau
[type d'utilisateur, utilisateur] dans la liste des utilisateurs du médium.
####################################################
# ajoute un utilisateur a un objet du hash objects #
####################################################
$handle , numero du média
$type , type d'utilisateur (personne, famille, evenement, lieux)
$id , id de l'utilisateur
sub add_object_user
{
my($handle,$type,$id)=@_;
my $user=[$type,$id];
my $object=$h_objects{$handle};
print "Ajout de l'utilisateur $id type $type à l'objet $object->[1]n";
my @users=@$object->[3];
print "Avant :n";
print "@users n";
push(@users,$user);
print "Après :n";
print "Utilisateurs: @users n";
}
Cette procédure pourrait dont s'écrire de manière plus perlienne :
sub add_object {
my ($handle, $id, $file, $note) = @_;
# on avertit si l'objet est déjà défini
warn "$handle is already defined in h_object !"
if defined $h_objects{$handle};
# on place les trois valeurs plus une référence à un
# tableau (vide) d'utilisateurs en les associant à la clé $handle
# dans %h_object
$h_objects{$handle} = [$id, $file, $note, []];
}
Dernière remarque : plutôt que d'utiliser des tableaux pour stocker
les différentes informations, j'utiliserais plutôt des tables de
hachages pour rendre les chose plus claires (sauf pour les 'users' qui
sont effectivement dans une liste).
Cela donnerait alors :
sub add_object {
my ($handle, $id, $file, $note) = @_;
warn "$handle already defined in %h_object !"
if defined $h_objects{$handle};
$h_objects{$handle} = {
id => $id,
file => $file,
note => $note,
users => [],
};
}
sub show_array_type_id {
my $ref = shift;
warn "nb users : ", scalar(@$ref), "n";
foreach my $user (@$ref) {
warn "ttype $user->{type}, id $user->{id}n";
}
}
sub add_object_user {
my($handle,$type,$id)=@_;
warn "Ajout de l'utilisateur $id type $type à l'objet
$h_objects{$handle}{file}n";
warn "Avantn";
show_array_type_id($h_objects{$handle}{users});
push @{$h_objects{$handle}{users}}, {type => $type, id => $id};
warn "Aprèsn";
show_array_type_id($h_objects{$handle}{users});
}
Cette procédure pourrait dont s'écrire de manière plus perlienne :
sub add_object {
my ($handle, $id, $file, $note) = @_;
# on avertit si l'objet est déjà défini
warn "$handle is already defined in h_object !"
if defined $h_objects{$handle};
# on place les trois valeurs plus une référence à un
# tableau (vide) d'utilisateurs en les associant à la clé $handle
# dans %h_object
$h_objects{$handle} = [$id, $file, $note, []];
}
Dernière remarque : plutôt que d'utiliser des tableaux pour stocker
les différentes informations, j'utiliserais plutôt des tables de
hachages pour rendre les chose plus claires (sauf pour les 'users' qui
sont effectivement dans une liste).
Cela donnerait alors :
sub add_object {
my ($handle, $id, $file, $note) = @_;
warn "$handle already defined in %h_object !"
if defined $h_objects{$handle};
$h_objects{$handle} = {
id => $id,
file => $file,
note => $note,
users => [],
};
}
sub show_array_type_id {
my $ref = shift;
warn "nb users : ", scalar(@$ref), "n";
foreach my $user (@$ref) {
warn "ttype $user->{type}, id $user->{id}n";
}
}
sub add_object_user {
my($handle,$type,$id)=@_;
warn "Ajout de l'utilisateur $id type $type à l'objet
$h_objects{$handle}{file}n";
warn "Avantn";
show_array_type_id($h_objects{$handle}{users});
push @{$h_objects{$handle}{users}}, {type => $type, id => $id};
warn "Aprèsn";
show_array_type_id($h_objects{$handle}{users});
}
Cette procédure pourrait dont s'écrire de manière plus perlienne :
sub add_object {
my ($handle, $id, $file, $note) = @_;
# on avertit si l'objet est déjà défini
warn "$handle is already defined in h_object !"
if defined $h_objects{$handle};
# on place les trois valeurs plus une référence à un
# tableau (vide) d'utilisateurs en les associant à la clé $handle
# dans %h_object
$h_objects{$handle} = [$id, $file, $note, []];
}
Dernière remarque : plutôt que d'utiliser des tableaux pour stocker
les différentes informations, j'utiliserais plutôt des tables de
hachages pour rendre les chose plus claires (sauf pour les 'users' qui
sont effectivement dans une liste).
Cela donnerait alors :
sub add_object {
my ($handle, $id, $file, $note) = @_;
warn "$handle already defined in %h_object !"
if defined $h_objects{$handle};
$h_objects{$handle} = {
id => $id,
file => $file,
note => $note,
users => [],
};
}
sub show_array_type_id {
my $ref = shift;
warn "nb users : ", scalar(@$ref), "n";
foreach my $user (@$ref) {
warn "ttype $user->{type}, id $user->{id}n";
}
}
sub add_object_user {
my($handle,$type,$id)=@_;
warn "Ajout de l'utilisateur $id type $type à l'objet
$h_objects{$handle}{file}n";
warn "Avantn";
show_array_type_id($h_objects{$handle}{users});
push @{$h_objects{$handle}{users}}, {type => $type, id => $id};
warn "Aprèsn";
show_array_type_id($h_objects{$handle}{users});
}
Pratiquant Perl de manière épisodique, je ne connaissais pas ce type de
construction.
Le programme semble fonctionner parfaitement.
Apparemment, je sais lire Perl mais ne le parle pas couramment. :-)
Pratiquant Perl de manière épisodique, je ne connaissais pas ce type de
construction.
Le programme semble fonctionner parfaitement.
Apparemment, je sais lire Perl mais ne le parle pas couramment. :-)
Pratiquant Perl de manière épisodique, je ne connaissais pas ce type de
construction.
Le programme semble fonctionner parfaitement.
Apparemment, je sais lire Perl mais ne le parle pas couramment. :-)
C'est comme ça pour tout le monde et pour tous les langages : on écrit
toujours avec un sous-ensemble de ce qu'on sait lire (l'inverse serait
carrément surprenant). Mais c'est aussi en regardant comment les
autres écrivent qu'on peut améliorer son style et augmenter son
vocabulaire. ;-)
C'est comme ça pour tout le monde et pour tous les langages : on écrit
toujours avec un sous-ensemble de ce qu'on sait lire (l'inverse serait
carrément surprenant). Mais c'est aussi en regardant comment les
autres écrivent qu'on peut améliorer son style et augmenter son
vocabulaire. ;-)
C'est comme ça pour tout le monde et pour tous les langages : on écrit
toujours avec un sous-ensemble de ce qu'on sait lire (l'inverse serait
carrément surprenant). Mais c'est aussi en regardant comment les
autres écrivent qu'on peut améliorer son style et augmenter son
vocabulaire. ;-)
Ah tiens, moi j'ai deja ete surpris alors. Pour certains, la programmation
se rapproche de la magie noire. C'est aussi la technique shadock: on essaie
des trucs sans bien comprendre jusqu'a avoir le resultat attendu.
(bon je dis pas que ca donne des programmes lisibles et maintenables...)
Ah tiens, moi j'ai deja ete surpris alors. Pour certains, la programmation
se rapproche de la magie noire. C'est aussi la technique shadock: on essaie
des trucs sans bien comprendre jusqu'a avoir le resultat attendu.
(bon je dis pas que ca donne des programmes lisibles et maintenables...)
Ah tiens, moi j'ai deja ete surpris alors. Pour certains, la programmation
se rapproche de la magie noire. C'est aussi la technique shadock: on essaie
des trucs sans bien comprendre jusqu'a avoir le resultat attendu.
(bon je dis pas que ca donne des programmes lisibles et maintenables...)
À (at) Mon, 28 Sep 2009 18:08:58 +0200,
JB écrivait (wrote):Pratiquant Perl de manière épisodique, je ne connaissais pas ce type de
construction.
Ce sont que de simples tables de hachage anonymes qui sont aux tables
de hachage ce que sont les tableaux anonymes aux tableaux. Les objets
anonymes (tables de hachage, tableaux ou scalaires) se manipulent via
des références.
Tout cela est très bien expliqué dans perlreftut et perlref :
<http://perl.enstimac.fr/DocFr/perlreftut.html>
<http://perl.enstimac.fr/DocFr/perlref.html>
On trouve aussi quelques bons exemples dans perldsc :
<http://perl.enstimac.fr/DocFr/perldsc.html>
Et pour une lecture hors-ligne (mais en anglais) :
% perldoc perlreftut
% perldoc perlref
% perldoc perldscLe programme semble fonctionner parfaitement.
Ouf... Je n'avais rien vérifié.Apparemment, je sais lire Perl mais ne le parle pas couramment. :-)
C'est comme ça pour tout le monde et pour tous les langages : on écrit
toujours avec un sous-ensemble de ce qu'on sait lire (l'inverse serait
carrément surprenant). Mais c'est aussi en regardant comment les
autres écrivent qu'on peut améliorer son style et augmenter son
vocabulaire. ;-)
À (at) Mon, 28 Sep 2009 18:08:58 +0200,
JB <jb.invalid@invalid.tjinvalid> écrivait (wrote):
Pratiquant Perl de manière épisodique, je ne connaissais pas ce type de
construction.
Ce sont que de simples tables de hachage anonymes qui sont aux tables
de hachage ce que sont les tableaux anonymes aux tableaux. Les objets
anonymes (tables de hachage, tableaux ou scalaires) se manipulent via
des références.
Tout cela est très bien expliqué dans perlreftut et perlref :
<http://perl.enstimac.fr/DocFr/perlreftut.html>
<http://perl.enstimac.fr/DocFr/perlref.html>
On trouve aussi quelques bons exemples dans perldsc :
<http://perl.enstimac.fr/DocFr/perldsc.html>
Et pour une lecture hors-ligne (mais en anglais) :
% perldoc perlreftut
% perldoc perlref
% perldoc perldsc
Le programme semble fonctionner parfaitement.
Ouf... Je n'avais rien vérifié.
Apparemment, je sais lire Perl mais ne le parle pas couramment. :-)
C'est comme ça pour tout le monde et pour tous les langages : on écrit
toujours avec un sous-ensemble de ce qu'on sait lire (l'inverse serait
carrément surprenant). Mais c'est aussi en regardant comment les
autres écrivent qu'on peut améliorer son style et augmenter son
vocabulaire. ;-)
À (at) Mon, 28 Sep 2009 18:08:58 +0200,
JB écrivait (wrote):Pratiquant Perl de manière épisodique, je ne connaissais pas ce type de
construction.
Ce sont que de simples tables de hachage anonymes qui sont aux tables
de hachage ce que sont les tableaux anonymes aux tableaux. Les objets
anonymes (tables de hachage, tableaux ou scalaires) se manipulent via
des références.
Tout cela est très bien expliqué dans perlreftut et perlref :
<http://perl.enstimac.fr/DocFr/perlreftut.html>
<http://perl.enstimac.fr/DocFr/perlref.html>
On trouve aussi quelques bons exemples dans perldsc :
<http://perl.enstimac.fr/DocFr/perldsc.html>
Et pour une lecture hors-ligne (mais en anglais) :
% perldoc perlreftut
% perldoc perlref
% perldoc perldscLe programme semble fonctionner parfaitement.
Ouf... Je n'avais rien vérifié.Apparemment, je sais lire Perl mais ne le parle pas couramment. :-)
C'est comme ça pour tout le monde et pour tous les langages : on écrit
toujours avec un sous-ensemble de ce qu'on sait lire (l'inverse serait
carrément surprenant). Mais c'est aussi en regardant comment les
autres écrivent qu'on peut améliorer son style et augmenter son
vocabulaire. ;-)
J'en suis persuadé mais je pense qu'il faut acquérir une culture perlienne.
À la différence de langage de type C ou Pascal, Perl a un gros moteur sous
le capot ce qui lui permet de faire magiquement des choses intéressantes,
encore faut-il connaître ces possibilités.
Je vais essayer de revoir le programme que j'avais démarré il y a un peu
plus d'un an et que je reprend parfois quand je veux un nouveau rapport.
Ceci m'amène à la question suivante : J'ai utilisée la solution avec des
hash, est-ce que celle-ci est plus gourmande en mémoire que la solution
avec des tableaux. Je pense que oui mais je peux me tromper.
J'en suis persuadé mais je pense qu'il faut acquérir une culture perlienne.
À la différence de langage de type C ou Pascal, Perl a un gros moteur sous
le capot ce qui lui permet de faire magiquement des choses intéressantes,
encore faut-il connaître ces possibilités.
Je vais essayer de revoir le programme que j'avais démarré il y a un peu
plus d'un an et que je reprend parfois quand je veux un nouveau rapport.
Ceci m'amène à la question suivante : J'ai utilisée la solution avec des
hash, est-ce que celle-ci est plus gourmande en mémoire que la solution
avec des tableaux. Je pense que oui mais je peux me tromper.
J'en suis persuadé mais je pense qu'il faut acquérir une culture perlienne.
À la différence de langage de type C ou Pascal, Perl a un gros moteur sous
le capot ce qui lui permet de faire magiquement des choses intéressantes,
encore faut-il connaître ces possibilités.
Je vais essayer de revoir le programme que j'avais démarré il y a un peu
plus d'un an et que je reprend parfois quand je veux un nouveau rapport.
Ceci m'amène à la question suivante : J'ai utilisée la solution avec des
hash, est-ce que celle-ci est plus gourmande en mémoire que la solution
avec des tableaux. Je pense que oui mais je peux me tromper.
Ceci m'amène à la question suivante : J'ai utilisée la solution avec des
hash, est-ce que celle-ci est plus gourmande en mémoire que la solution
avec des tableaux. Je pense que oui mais je peux me tromper.
Tu peux en avoir le coeur net: je t'enjoins a jouer avec Devel::Size.
Ceci m'amène à la question suivante : J'ai utilisée la solution avec des
hash, est-ce que celle-ci est plus gourmande en mémoire que la solution
avec des tableaux. Je pense que oui mais je peux me tromper.
Tu peux en avoir le coeur net: je t'enjoins a jouer avec Devel::Size.
Ceci m'amène à la question suivante : J'ai utilisée la solution avec des
hash, est-ce que celle-ci est plus gourmande en mémoire que la solution
avec des tableaux. Je pense que oui mais je peux me tromper.
Tu peux en avoir le coeur net: je t'enjoins a jouer avec Devel::Size.
Ceci m'amène à la question suivante : J'ai utilisée la solution avec des
hash, est-ce que celle-ci est plus gourmande en mémoire que la solution
avec des tableaux. Je pense que oui mais je peux me tromper.
Ceci m'amène à la question suivante : J'ai utilisée la solution avec des
hash, est-ce que celle-ci est plus gourmande en mémoire que la solution
avec des tableaux. Je pense que oui mais je peux me tromper.
Ceci m'amène à la question suivante : J'ai utilisée la solution avec des
hash, est-ce que celle-ci est plus gourmande en mémoire que la solution
avec des tableaux. Je pense que oui mais je peux me tromper.
À (at) Mon, 28 Sep 2009 21:02:10 +0200,
JB écrivait (wrote):Ceci m'amène à la question suivante : J'ai utilisée la solution avec des
hash, est-ce que celle-ci est plus gourmande en mémoire que la solution
avec des tableaux. Je pense que oui mais je peux me tromper.
La réponse simple est oui. Mais pour une réponse plus éclairante, je
préfère vous citer un extrait de 'perltoot' :
Vous pourriez penser que l'accès au tableau est plus rapide que
l'accès à la table de hachage, mais ils sont en fait
comparables. Le tableau est un tout petit peu plus rapide, mais pas
plus de 10 ou 15%[...]. La plus grande différence entre les deux
approches est l'utilisation de la mémoire. La représentation par
table de hachage prend plus de mémoire que la représentation par
tableau parce qu'il faut allouer de la mémoire pour stocker les
clés d'accès en plus des valeurs. Par contre, ce n'est pas vraiment
mauvais puisque, depuis la version 5.004, le mémoire n'est allouée
qu'une seule fois pour une clé donnée indépendamment du nombre de
tables de hachage qui utilisent cette clé.[...]
(cf.
À (at) Mon, 28 Sep 2009 21:02:10 +0200,
JB <jb.invalid@invalid.tjinvalid> écrivait (wrote):
Ceci m'amène à la question suivante : J'ai utilisée la solution avec des
hash, est-ce que celle-ci est plus gourmande en mémoire que la solution
avec des tableaux. Je pense que oui mais je peux me tromper.
La réponse simple est oui. Mais pour une réponse plus éclairante, je
préfère vous citer un extrait de 'perltoot' :
Vous pourriez penser que l'accès au tableau est plus rapide que
l'accès à la table de hachage, mais ils sont en fait
comparables. Le tableau est un tout petit peu plus rapide, mais pas
plus de 10 ou 15%[...]. La plus grande différence entre les deux
approches est l'utilisation de la mémoire. La représentation par
table de hachage prend plus de mémoire que la représentation par
tableau parce qu'il faut allouer de la mémoire pour stocker les
clés d'accès en plus des valeurs. Par contre, ce n'est pas vraiment
mauvais puisque, depuis la version 5.004, le mémoire n'est allouée
qu'une seule fois pour une clé donnée indépendamment du nombre de
tables de hachage qui utilisent cette clé.[...]
(cf.
À (at) Mon, 28 Sep 2009 21:02:10 +0200,
JB écrivait (wrote):Ceci m'amène à la question suivante : J'ai utilisée la solution avec des
hash, est-ce que celle-ci est plus gourmande en mémoire que la solution
avec des tableaux. Je pense que oui mais je peux me tromper.
La réponse simple est oui. Mais pour une réponse plus éclairante, je
préfère vous citer un extrait de 'perltoot' :
Vous pourriez penser que l'accès au tableau est plus rapide que
l'accès à la table de hachage, mais ils sont en fait
comparables. Le tableau est un tout petit peu plus rapide, mais pas
plus de 10 ou 15%[...]. La plus grande différence entre les deux
approches est l'utilisation de la mémoire. La représentation par
table de hachage prend plus de mémoire que la représentation par
tableau parce qu'il faut allouer de la mémoire pour stocker les
clés d'accès en plus des valeurs. Par contre, ce n'est pas vraiment
mauvais puisque, depuis la version 5.004, le mémoire n'est allouée
qu'une seule fois pour une clé donnée indépendamment du nombre de
tables de hachage qui utilisent cette clé.[...]
(cf.