Structure pour stocker des variables

Version imprimable

Bonjour à tous,

encore une petite question existentielle ! :)

je suis en train de faire un petit programme un peu complexe (ça change des trucs qui font 20 lignes ^^) et je suis parti sur une table de hashage pour stocker tous mes paramètres.
Pour faire simple, mon programme se connecte à plusieurs environnements et réalise des comparaisons pour décrire ce qui est différent entre les environnements.
Mon idée était donc de stocker les informations nécessaires pour se connecter dans une table de hash dont le premier niveau serait l'environnement, le second, la variable et le troisième, la valeur, le libellé de la variable et 2/3 autres infos, ce qui doit ressembler à ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 $GP = { dev => { db_server => { value => '<dev_server>', label => 'Serveur BDD'}, db_port => { value => '<dev_port>', label => 'Port Serveur BDD'}, db_name => { value => '<dev_ame>', label => 'Nom BDD'}, }, test => { db_server => { value => '<test_server>', label => 'Serveur BDD'}, db_port => { value => '<test_port>', label => 'Port Serveur BDD'}, db_dbname => { value => '<test_dbname>', label => 'Nom BDD'}, } };
Ca marche niquel, sauf que j'ai un petit problème fonctionnel : je voulais faire une fonction d'initialisation qui boucle sur les clés du hash $GP{<env>} et qui demande à l'utilisateur de saisir la valeur souhaitée (et alimente $GP{<env>}{$clé}{value} en fonction).
Le hic, c'est que comme c'est un hash, il va me demander les trucs dans n'importe quel ordre, et ça fait pas très pro (c'est pas classe de demander un password avant un utilisateur ;))

J'avais contourné le problème une première fois en créant un tableau que j'alimente manuellement pour mettre les clés de mon hash dans l'ordre que je souhaitais, et ensuite, j'utilisais ce tableau pour parcourir mon hash.

Mais bon, côté propreté, c'est pas idéal... en plus, faut penser à le mettre à jour ce tableau.

Du coup, je suis parti sur un mix des deux avec un tableau de hash. Mais c'est quand même moins lisible :)

Exemple illustrant mes 3 solutions :
Code:

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 use Data::Dumper; use strict; use warnings; # ################### debut test gestion hash my %GP; my $env='default'; print "V1 : lecture simple du hash (désordre)\n"; $GP{$env} = { db_server => { value => '<db_server>', label => 'Serveur BDD'}, db_port => { value => '<db_port>', label => 'Port Serveur BDD'}, db_dbname => { value => '<db_dbname>', label => 'Nom BDD'}, }; foreach my $param (keys %{$GP{$env}}) { print $GP{$env}{$param}{label}," [",$GP{$env}{$param}{value},"] ?\n"; } print "\nV2 : hash + tableau (ordre ok)\n"; my @GP = qw (db_server db_port db_dbname); $GP{$env} = { db_server => { value => '<db_server>', label => 'Serveur BDD'}, db_port => { value => '<db_port>', label => 'Port Serveur BDD'}, db_dbname => { value => '<db_dbname>', label => 'Nom BDD'}, }; foreach my $param (@GP) { print $GP{$env}{$param}{label}," [",$GP{$env}{$param}{value},"] ?\n"; } print "\nV3 : tableau de hash (ordre ok)\n"; $GP{$env} = [ {db_server => { value => '<db_server>', label => 'Serveur BDD'}}, {db_port => { value => '<db_port>', label => 'Port Serveur BDD'}}, {db_dbname => { value => '<db_dbname>', label => 'Nom BDD'}}, ]; foreach (@{$GP{$env}}) { my ($var, $hash) = each(%$_); print $hash->{label}," [",$hash->{value},"] ?\n"; }
Ma question, comment feriez-vous ? ^^

Merci d'avance !

29/06/2012, 15h26
Dra_Gun
Hello,

j'utilise aussi un tableau pour classer la sortie...
Code:

1 2 3 4 my @order = ( 'nb_isp1', 'nb_isp2', 'nb_isp3' ); foreach (@order) { $output->{texte} .= "$_:$output->{$_} "; }
de toute façon, quand tu rajoutes une clé, tu la rajoutes aussi dans ce tableau..

peut etre la solution de nommer les clés avec un chiffre en premier (01db_server, 02db_port etc) et de faire un sort sur les keys... pas testé..

EDIT: enfin, si tu n'as pas besoin d'utiliser le nom de tes clés plus tard.. moi je les affiche, donc je ne pouvais pas utiliser cette hypothèse..
29/06/2012, 15h30
lennelei

ah ouais, la solution en préfixant peut être un autre moyen intermédiaire, ça fonctionne... merci :)

c'est pas joli joli dans le code, mais bon, c'est plus simple à gérer que le tableau de hash et que le tableau en plus je trouve :ccool:

Et un hash comme ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
$GP = {
	dev => {
		db_server	=>	{ id => 1, value => '<dev_server>', label => 'Serveur BDD'},
		db_port		=>	{ id => 2, value => '<dev_port>', label => 'Port Serveur BDD'},
		db_name		=>	{ id => 3, value => '<dev_ame>', label => 'Nom BDD'},
	},
	test => {
		db_server	=>	{ id => 1, value => '<test_server>', label => 'Serveur BDD'},
		db_port		=>	{ id => 2, value => '<test_port>', label => 'Port Serveur BDD'},
		db_dbname	=>	{ id => 3, value => '<test_dbname>', label => 'Nom BDD'},
	}
};

Ensuite, tu tries en fonction de l'id, non ?

ouais, j'ai pensé aussi au coup d'ajouter un id dans la table mais le seul truc de l'id, c'est que si je veux ajouter une variable au milieu, c'est galère :p

Edit: ah, en fait si, il suffit d'utiliser une variable pour cet <id>
Code:

1 2 3 4 5 6 7 8 9 10 11 print "\nV4 : hash avec id\n"; my $id=0; $GP{$env} = { '01db_server' => { id => $id++, value => '<db_server>', label => 'Serveur BDD'}, '02db_port' => { id => $id++, value => '<db_port>', label => 'Port Serveur BDD'}, '03db_dbname' => { id => $id++, value => '<db_dbname>', label => 'Nom BDD'}, }; foreach my $param (sort {$GP{$env}{$a}{id} cmp $GP{$env}{$b}{id}} keys %{$GP{$env}}) { print $GP{$env}{$param}{label}," [",$GP{$env}{$param}{value},"] ?\n"; }
:ccool: c'est pas extraordinaire, mais je pense que c'est le meilleur compris simplicité / relecture / évolution !

ps. Dra_Gun: en fait, ça va pas le faire le numéro devant la clé. Parce que j'ai une commande set <variable> <valeur> et que je me vois pas faire set 01trumuche <valeur> :p

bon, si djibril a répondu, y a peu de chance que je trouve mieux ^^ merci à tous !

29/06/2012, 16h12
djibril

Ta problématique est que même si tu pouvais ordonner, tout dépend de ce qu'il y a dans le hash. Le classement alphabétique ne correspond pas toujours à celui que tu souhaites pour l'utilisateur. Donc le meilleur moyen est que tu puisses imposer l'ordre avec par exemple un id.
Maintenant si tu dois rajouter une nouvelle valeur, bah faut déjà que tu saches où tu souhaites la mettre, donc ce n'est pas un souci perl, mais d'abord d'algo.
29/06/2012, 16h36
Dra_Gun

Citation:

Envoyé par Alek-C

ps. Dra_Gun: en fait, ça va pas le faire le numéro devant la clé. Parce que j'ai une commande set <variable> <valeur> et que je me vois pas faire set 01trumuche <valeur> :p

d'où mon edit :p

J'avais zappé les réponses !

Citation:

Envoyé par djibril

Le classement alphabétique ne correspond pas toujours à celui que tu souhaites pour l'utilisateur. Donc le meilleur moyen est que tu puisses imposer l'ordre avec par exemple un id.

Exactement, c'est pour ça que j'étais parti sur un tableau de hashs anonymes :) un tableau, c'est ordonné en fonction de la création ! Mais bon, à l'usage, je n'étais pas fan :s

Citation:

Envoyé par djibril

Maintenant si tu dois rajouter une nouvelle valeur, bah faut déjà que tu saches où tu souhaites la mettre, donc ce n'est pas un souci perl, mais d'abord d'algo.

En fait, ce que je voulais dire, c'est que dans une solution type :
Code:

1 2 3 4 5 6 7 8 $GP = { dev => { db_server => { id => 1, value => '<dev_server>', label => 'Serveur BDD'}, db_port => { id => 2, value => '<dev_port>', label => 'Port Serveur BDD'}, db_name => { id => 3, value => '<dev_ame>', label => 'Nom BDD'}, .... x 25 }... };
Si je veux ajouter db_ip par exemple après db_server (et que j'ai encore 25 clés après db_dbname), je suis potentiellement obligé de modifier à la mimine les 25 ids des clés pour que tout soit bien ordonné :
Code:

1 2 3 4 5 6 7 8 9 $GP = { dev => { db_server => { id => 1, value => '<dev_server>', label => 'Serveur BDD'}, db_ip => { id => 2, value => '<ip_server>', label => 'IP Serveur BDD'}, db_port => { id => 3, value => '<dev_port>', label => 'Port Serveur BDD'}, db_name => { id => 4, value => '<dev_ame>', label => 'Nom BDD'}, .... x 25 }... };
Mais en utilisant une variable pour l'incrémenter, ça permet d'insérer une nouvelle variable au milieu des autres si besoin sans se retaper les 36 variables suivantes pour modifier leur id !
Code:

1 2 3 4 5 6 7 8 9 10 $id=1; $GP = { dev => { db_server => { id => $id++, value => '<dev_server>', label => 'Serveur BDD'}, db_ip => { id => $id++, value => '<ip_server>', label => 'IP Serveur BDD'}, db_port => { id => $id++, value => '<dev_port>', label => 'Port Serveur BDD'}, db_name => { id => $id++, value => '<dev_ame>', label => 'Nom BDD'}, .... x 25 }... };
Et en utilisant un tableau de hash, c'est facile aussi (suffit de mettre la ligne où on veut qu'elle soit).

Bref, c'est cool :ccool: et j'ai fait comme ça finalement :)

@Dra_Gun: yes, j'avais pas vu ;)