tableau 2 dimensions

Version imprimable

Voir 40 message(s) de cette discussion en une page

pour JAsmine!

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
sub switch
{
    my $lign;
    my ($switch_name,$switch_ip,$user_login,$user_password);
 
    $#switchs_database;
 
## La variable $var prend successivement toutes les valeurs scalaires contenues dans $switchs_database                      
    foreach $lign (1 .. $#switchs_database)
    {
        foreach my $var (@{$switchs_database[$lign]})
        {
            $switch_name = $switchs_database[$lign]->[0];
            $switch_ip = $switchs_database[$lign]->[1];
            $user_login = $switchs_database[$lign]->[2];
            $user_password = $switchs_database[$lign]->[3];                                           
        }
        print "$switch_name\t$switch_ip\t$user_login\t$user_password\n";
    }
&backup ($switch_name,$switch_ip,$user_login,$user_password);
}

oui je les déclares en haut de ma fonction!
oui j'utilise warnings et strict

et ca me met des petites erreurs
"Use of uninitialized value in concatenation (.) or string at ./script_backup2.pl line 132.
Use of uninitialized value in concatenation (.) or string at ./script_backup2.pl line 153."

voila

@danathane :

Dans les exemples, il n'y a pas de tableau de hash (ce qui serait tout aussi simple, vois l'exemple 3) mais un hash de tableau.

@parisien91 :

Je pense que le hash de hash est le plus adapté à ton besoin. (1) L'accès à tes données est alors beaucoup plus clair:

Code:

$data{SWO1}{ip} ;

(2) tu peux trier sur le critère que tu veux (exemple, trie les clés sur les logins):

Code:

sort { $data{$a}{login} cmp $data{$b}{login} } keys %data;

(3) tu peux extraire juste une donnée très facilement :
Code:

1 2 3 4 5 6 # retourne une liste des passwords (avec doublons) map { $data{$_}{mdp} } keys %data ; # retourne une liste sans doublons des IP my %ip = map { $data{$_}{ip} => 1 } keys %data ; my @unique_ips = keys %ip;

21/01/2009, 15h40
Jasmine80

Le premier à avoir suggéré un hash, fut Djibril

Citation:

Envoyé par djibril

pourquoi ne pas utiliser les hashs avec en clé SWO1 SWO2, etc vu qu'ils sont unique ?

Ce à quoi Parisien à répondu :

Citation:

Envoyé par parisien91

Mais, j'en ai parler avec un proche du projet, et ma dit de le faire avec un tableau 2 dimensions pas en hash!! En plus il faut que je comprenne ce que je fais vue que c'est noté!

... faudrait savoir ce que tu veux! :aie:
21/01/2009, 15h49
iblis

Autres choses.

(1) Si tu en restes au tableau de tableaux, je te suggère d'utiliser la façon de faire que je t'ai indiqué cela t'évitera d'avoir à jongler avec les numéros de ligne lu et d'avoir un premier accès direct et le deuxième en référence (non que je pense avoir raison bien sûr, mais Jasmine c'est évertuée à résoudre tes problèmes au coup pas coup, ce qui est le plus difficile car il faut sans cesse deviner où celui qui a le problème, toi en l'occurrence, veut en venir).

(2) Quand tu passes tes données à une fonction, pourquoi ne pas passer la référence sur ton tableau : backup($switch_database[$ligne]) puisque $switch_database[$ligne] est une référence vers un tableau de valeurs.
21/01/2009, 15h55
parisien91

Jasmine, pour te répondre mon tuteur quand je lui ai demander si il voulait que je le fasse avec du hash ou tableau 2 dim, il ma répondu comme tu veux mais tableau 2 dimensions c'est plus facile... oui sachant que je commence dans le perl!

Donc je suis partis sur l'autre solution! sachant que ce que djibril avais dis j'avais chercher et rien trouver de bien pour m'expliquer... je suis surment bete de pas comprendre les explications des sites!
Donc avec toi mem JAsmine nous avons pas mal avancé! et je continue a dire que je finis deja avec cette méthode et apres je verrais si j'ai le tps de modifier mon script je verrais!!
Sachant que je dois TOUS comprendre a se que je fais!!et je dois savoir tous réexpliquer devant des examinateurs!

donc je t'affirme que je continue la méthode que l'on a commencé, Jasmine.
Pour le hash de tableau je verrais a la fin avec les exemples que iblis ma donnée.

mais le passage des arguments ne fonctionnes pas...
21/01/2009, 16h39
djibril

Moi je te conseillerais sincèrement plutôt d'utiliser les hashs .
C'est beaucoup plus simple d'utilisation et de compréhension que les tableaux à plusieurs dimensions surtout quand on débute.

De plus, c'est plus facilement maintenable.

On peut t'aider, donc c'est pas un souci.

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
 
 
$VAR1 = {
          'SWO4' => [
                      '10.42.78.4',
                      'user4',
                      'mdp4'
                    ],
          'SWO2' => [
                      '10.42.78.2',
                      'user2',
                      'mdp2'
                    ],
          'SWO1' => [
                      '10.42.78.1',
                      'user1',
                      'mdp1'
                    ],
          'SWO3' => [
                      '10.42.78.3',
                      'user3',
                      'mdp3'
                    ]
        };

est ce que quelqu'un pourrait me dire comment faire pour lire le contenu des tableau de ce hash?

je vois pas trop...

Code:

1
2
3
foreach my $cle ( keys  %hash ) {
  print "$cle : $hash{$cle}->[0]\n";
}

21/01/2009, 17h48
danathane

donc ce que j'ai mis, c'est l'exemple du dessus. J'aimerais savoir comment lire le contenu des tableau. Par exemple les IP contenues dans les case 0 des tableaux.
21/01/2009, 18h00
iblis

Djibril t'a répondu, on ne peut pas être plus clair.

Code:

1
2
3
4
5
6
foreach my $cle ( keys  %hash ) {
  print "$cle : \n";
  foreach $valeur ( @{ $hash{$cle} } ) {
    print "\t- $valeur\n";
  }  
}

22/01/2009, 10h10
Jasmine80

Citation:

Envoyé par Parisien91

Jasmine, pour te répondre mon tuteur quand je lui ai demander si il voulait que je le fasse avec du hash ou tableau 2 dim, il ma répondu comme tu veux mais tableau 2 dimensions c'est plus facile... oui sachant que je commence dans le perl!

Peut-être ton promoteur voulait-il dire de ne pas utiliser un hash simple mais un hash de hash ... qui est d'une certaine façon un tableau à deux dimensions.

As-tu regardé le lien que je t'ai donné? tout y est vraiment bien expliqué

Les structures de données complexes
http://perso.univ-rennes1.fr/francoi...ERLnode15.html
22/01/2009, 10h51
parisien91

SAlut Jasmine j'espere va sa aujourd'hui!
Oui j'ai regardé le lien que tu m'as donné, j'ai surtout bien aimé le "14.2 Les hashes de hashes". Mais pour le moment j'ai fais marché tout mon script en bricolant un peu dessus ce matin donc, maintenant j'attends d'avoir la réaction de mon tuteur pour apporter les modifs.Donc je vous recontacte dans la journée je pense pour vous tenir au courant!

Voila! En tout cas merci a vous tous!!
A tout a l'heure;)
22/01/2009, 16h46
parisien91

Re bon bah ce que j'ai fais lui convient, donc comme je disais si j'ai le tps je fairais du hash sinon je laisse comme ca!!
J'ai encore des messages d'erreurs mais du a mon passages d'arguments!!

Donc voila
Merci bcp a vous tous!!!!

Donc au final, j'ai opter pour ca, j'ai diminuer le code et ca marche tjs aussi bien vue que maintenant j'ai pas la boucle qui parcourt les 4 objets de ma ligne! Elle les prends direct dans la premiere boucle, et elle initialise les 4 variables!!! pile poil!!!!
Code:

1 2 3 4 5 6 7 8 9 10 11 foreach $lign (1 .. $switchs_number) { ## Initialise les variables $switch_name = $switchs_database[$lign]->[0]; $switch_ip = $switchs_database[$lign]->[1]; $user_login = $switchs_database[$lign]->[2]; $user_password = $switchs_database[$lign]->[3]; print("$switch_name,$switch_ip,$user_login,$user_password\n"); &backup ($switch_name,$switch_ip,$user_login,$user_password); }
Donc voila MERCI BEAUCOUP

Citation:

Envoyé par parisien91

j'ai mis dans ma sub main my ($switch_name,$switch_ip,$user_login,$user_password)
et pour ma focntion sub backup($$$$)

Je ne sais pas si tu utilises des prototypes mais apparemment, il ne faudrait pas en utiliser (selon le livre 'Perl Best Practices', O'Reilly).
Utilisé des prototypes rend impossible la déduction du comportement du passage d'arguments de ton sous-programme en ne regardant que l'appel de celui-ci. Cela rend également impossible de déduire le contexte dans lequel des arguments particuliers sont évalués.

L'exemple donné est que quand tu écris par exemple un sous-programme :

Code:

sub swap_arrays(\@\@)

Cela oblige ceux qui vont utiliser ce code de savoir qu'en faisant swap_array(@array1, @array2), les 2 array ne vont pas fusionner (comme elles le feraient sans les prototypes).

Mais bon, je ne suis pas certaine qu'il faille suivre tous les conseils donnés dans 'Perl Best Practices' car je sais que les prototypes sont décrits en long et en large dans 'Programming Perl' , Third Edition, O'Reilly)

Demande à ton promoteur ce qu'il en pense, j'ai rencontrés des gens contre et des gens pour ... apparemment les avis sont très partagés.

Avant tu avais écrit
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 my $lign; my ($switch_name,$switch_ip,$user_login,$user_password); $#switchs_database; ## La variable $var prend successivement toutes les valeurs scalaires contenues dans $switchs_database foreach $lign (1 .. $#switchs_database) { foreach my $var (@{$switchs_database[$lign]}) { $switch_name = $switchs_database[$lign]->[0]; $switch_ip = $switchs_database[$lign]->[1]; $user_login = $switchs_database[$lign]->[2]; $user_password = $switchs_database[$lign]->[3]; } print "$switch_name\t$switch_ip\t$user_login\t$user_password\n"; }
Tu peux déclarer $lign dans le foreach : foreach my $lign (1 .. $#switchs_database)
Et ton '$#switchs_database;' perdu tout seul au milieu du code ... on se demande à quoi sert-il. Au cas où il trainerait toujours dans ton code actuel, tu peux le supprimer.

23/01/2009, 10h27
Jedai

Citation:

Envoyé par Jasmine80

Je ne sais pas si tu utilises des prototypes mais apparemment, il ne faudrait pas en utiliser (selon le livre 'Perl Best Practices', O'Reilly).
Utilisé des prototypes rend impossible la déduction du comportement du passage d'arguments de ton sous-programme en ne regardant que l'appel de celui-ci. Cela rend également impossible de déduire le contexte dans lequel des arguments particuliers sont évalués.
Mais bon, je ne suis pas certaine qu'il faille suivre tous les conseils donnés dans 'Perl Best Practices' car je sais que les prototypes sont décrits en long et en large dans 'Programming Perl' , Third Edition, O'Reilly)

Quoiqu'il en soit, cette utilisation particulière des prototypes est à déconseiller : les prototypes sont fait pour modifier la syntaxe d'un appel de fonction si on veut donner un aspect un peu plus builtin à ses fonctions, utiliser un prototype pour compter le nombre d'argument est une erreur.
De plus lorsqu'on utilise & avant un appel de fonction cela désactive les prototypes, les prototypes ne marchent également pas avec les méthodes (POO)...
A mon avis, il faut éviter d'utiliser les prototypes tant qu'on n'a pas une bonne connaissance de Perl sous le bras. Et même après c'est contestable (ça ne m'empêche pas d'en mettre de temps en temps, surtout lorsqu'il y a une subroutine en argument).

--
Jedaï

Voir 40 message(s) de cette discussion en une page