Les tableaux multidimentionnels pas trés clairs

**Lolo78** · 01/04/2016, 08h22

Envoyé par dedalios

pourquoi cette liste ce tableau début avec l'index 1 est non zero?

Je ne peux pas tester pour vérifier maintenant sur ma tablette dans le train, mais je pense que la ligne:

Code :

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

1
2
 
my @RT_FIC ="";

crée un premier élément contenant une chaîne vide dans le tableau. Du coup, le push vient ensuite ajouter un second élément, et ainsi de suite.

Tu ferais mieux de déclarer ton tableau comme suit:

Code :

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

1
2
 
my @RT_FIC = ();

Ou, mieux et plus simplement:

Code :

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

1
2
 
my @RT_FIC;

**Lolo78** · 01/04/2016, 19h39

Je viens de tester et je confirme que:

Code :

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

1
2
 
my @RT_FIC ="";

crée un tableau avec un élément:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
  DB<1> @a = "";
 
  DB<2> x \@a
0  ARRAY(0x600500e48)
   0  ''
  DB<3> push @a, "one";
 
  DB<4> x \@a;
0  ARRAY(0x600500e48)
   0  ''
   1  'one'
  DB<5>

Donc remplace par:

Code :

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

1
2
 
my @RT_FIC =();

ou

Code :

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

1
2
 
my @RT_FIC;

**dedalios** · 02/04/2016, 17h05

merci
c'est aussi la conclusion auquel j’étais arrivé a savoir qu'il existait un effet de bord du a l'une des instructions du code ayant généré ce premier élément mais n'ayant pas repris le code hier soir je n'avais pas encore identifier la cause merci

**dedalios** · 03/04/2016, 12h47

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
foreach my $name ( @T_fic1) {
  #debug mode
   #  print "$name\n";	
    my $line_count =  0 ;
  	$line_count = compteurdeligne_fichier($name);  
  	#print ("comp = $line_count \n");
 		my $taillefic  = -s $name;
 		my @deffic =Nomfic( $name);
	 #	print (" @deffic  \n");
 
	$files_hash_1{$name} = { taille => $taillefic , lignes => $line_count ,topvalide => "faux", nomfic => $deffic[1]  , nomrep => $deffic[2] };
}
 
 my $NbElem_1 = scalar(@T_fic1);
 print ("nombre d element 1: $NbElem_1 \n");

nombre d element 1: 4

Code :

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

1
2
 my $hashtaille_1 = scalar(%files_hash_1) ;
 print (" resultat $hashtaille_1 \n ");

resultat 4/8

Amusant ce que l'on obtient ici .
On a 4 éléments dans le tableaux de Hash files_hash_1 et pour chaque élément 5 sous éléments.
la commande

Code :

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

scalar(%files_hash_1)

retourne 4/8; je me demande a quoi 8 peux bien correspondre ?

**Lolo78** · 03/04/2016, 23h29

Le 8 est une donnée interne d'allocation pour le hash, aucun intérêt.

Pour connaître le nombre d'éléments d'un hash:

Code :

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

1
2
3
4
 
my $size = scalar keys %hash;
# ou, plus simplement:
my $size = keys %hash;

**dedalios** · 04/04/2016, 22h14

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
	open( my $fichierlog,'+>',$nomficlog) or die("open: $!");   
	print($fichierlog "Information des actions de ${nomficlog} \n \n" );
	print($fichierlog " Nombre des fichiers .dat .err :  $#T_fic1  \n" );


  foreach my $name ( @T_fic1) {
	#debug mode
	#  print "$name\n";	
	my $line_count =  0 ;
	$line_count = compteurdeligne_fichier($name);  
	#print ("comp = $line_count \n");
 	my $taillefic  = -s $name;
 	my @deffic =Nomfic( $name);
 	#	print (" @deffic  \n");
	$files_hash_1{$name} = { taille => $taillefic , lignes => $line_count ,topvalide => "faux", nomfic => $deffic[0]  , nomrep => $deffic[1] };
	$repert_1 = $deffic[1];
  	my $horodate_1 = substr ($repert_1 , 0 , 14);
	my $longeur = length($name); 
	#print ("longeur de $name \n  $longeur \n");
}

Use of uninitialized value $repert_1 in substr at lirefic.pl line 88.
Use of uninitialized value $repert_1 in substr at lirefic.pl line 88.
Use of uninitialized value $repert_1 in substr at lirefic.pl line 88.
Use of uninitialized value $repert_1 in substr at lirefic.pl line 88.

pourquoi 4 fois ce message

**Lolo78** · 05/04/2016, 15h44

Si $repert_1 n'est pas initialisé, cela veut dire que $deffic[1] lui-même n'était pas défini, donc, a priori, que la fonction Nomfic ne t'a rien retourné comme deuxième champ. Il faut que tu imprimes $name pour savoir que que cette variable contient à ce moment là. Ne voyant pas tes données, je ne peux pas t'en dire beaucoup plus.

Si ce n'est que je te conseilles vraiment de lire attentivement la FAQ sur le débogage dont je t'ai donné le lien et de mettre ses conseils en pratique pour examiner tes données au fur et à mesure du déroulement de ton algorithme.

**dedalios** · 05/04/2016, 22h54

Soit le code qui renseigne la table de hash

Code :

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

$files_hash_1{$name} = { taille => $taillefic , lignes => $line_count ,topvalide => "false",fictype => $typefic};

extrait de la table de hash

$VAR1 = {
'RFNP-Z-20160220041001.err' => {
'vacation' => './dev/SIM/R/20160220041004_w/RFNP-Z-20160220041001.err',
'taille' => 318135,
'topvalide' => 'faux',
'nomrep' => '20160220041004_w',
'lignes' => '2505'
}

...

close($fichierlog);

...
exit;

Code :

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

1
2
3
4
 
 
 $nomficlog="../Logs/fichier.log";
  	open( my $fichierlog,'+>',$nomficlog) or die("open: $!");

print( "recherche de $nomdufichier \n");

.....

if( $files_hash_1{$nomdufichier} = undef)
{
print($fichierlog " Absence du fichier $nomdufichier \n");
}
else {
print($fichierlog " Présent du fichier $nomdufichier \n");

my $lataille = $files_hash_1{$nomdufichier}{taille};
print(" taille $lataille \n");
}
}

...

[/CODE]

Résultat
recherche de RFNP-Z-20160220041001.err
Use of uninitialized value $lataille in concatenation (.) or string at lirefic.pl line 135.
taille

Code :

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

  	if(	$files_hash_1{$nomdufichier} = undef)

Si j'ai bien compris cette partie du code me permet de valider si l’indice

NB je ne retrouve pas le lien sur la FAQ de debug

**Lolo78** · 06/04/2016, 08h18

Bonjour,

Envoyé par dedalios

Code :

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

  	if(	$files_hash_1{$nomdufichier} = undef)

Si j'ai bien compris cette partie du code me permet de valider si l’indice

Surtout pas!

D'abord, un "=" simple est un opérateur d'affectation, pas de comparaison. Mais "==" ne serait guère meilleur car c'est un opérateur de comparaison numérique, et $files_hash_1{$nomdufichier} n'est pas un nombre. Et, de toute façon, il ne faut pas non plus faire de comparaison avec undef.

La bonne syntaxe pour vérifier si quelque chose est défini est la suivante:

Code :

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

1
2
 
  	if(	defined $files_hash_1{$nomdufichier})

Dans certains cas, il vaut mieux utiliser:

Code :

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

1
2
 
  	if(	exists $files_hash_1{$nomdufichier})

mais je ne pense pas que ça fasse de différence ici.

**dedalios** · 06/04/2016, 23h06

peut- on dans une fonction créer une table de hash est la retourner entiere à la variable appelante?

**Philou67430** · 07/04/2016, 11h51

Je n'ai pas parcouru la discussion pour voir si cette dernière question y est liée, mais oui, cela est tout à fait possible, de deux manière différentes :
- retourner une seule valeur qui est une référence vers ce tableau : return [ { toto => 1, tutu => 2 }, { toto => 10, tutu => 20 }];
- retourner la liste contenue dans le tableau (et récupérer le résultat de la fonction dans une variable tableau) : return {toto => 1, tutu => 2}, { toto => 10, tutu => 20 };

Je laisse Lolo compléter avec le contexte de la discussion, si nécessaire.

**Lolo78** · 07/04/2016, 15h25

@Philou: je pense que tu as mal compris la question de Dedalios et son emploi du terme "table de hachage". Il me semble qu'il veut retourner un simple hachage, pas un tab leau de plusieurs hachages.

@Dedalios: oui, on peut tout-à-fait retourner un hachage d'une fonction à son appelant.

Il y a en gros trois manières d'alimenter un hachage dans une fonction pour l'utiliser ailleurs dans le programme.

1. Utiliser une variable globale. Ce n'est généralement pas recommandé, mais ça peut à la limite se justifier pour un hachage de paramétrage qui n'évolue plus pendant la durée d'exécution du programme. Quelque chose dans ce genre;

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
my %params;
populate_params();
...
# utilisation du hachage
my $dir = $params{"dir"};
...
#ailleurs:
sub populate_params {
    # par exemple lecture d'un fichier de configuration et alimentation du hachage %params;
    $param{"dir"} = '/home/moi'; 
    # ...
}

2. Renvoyer le hachage en valeur de retour de la fonction

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
my %params = populate_params();
...
my $dir = $params{"dir"};
...
#ailleurs:
sub populate_params {
    # par exemple lecture d'un fichier de configuration et alimentation du hachage %local_params;
    my %local_params;
    $local_params{...} = ...;
    return %local_params;
}

Cette méthode fonctionne bien, mais est à éviter si le hachage est susceptible d'être gros ou très gros, car cela implique une copie complète des données et donc une altération possible des performances. En réalité, la fonction renvoie une liste de clefs-valeurs et l'appelant reconstitue un hachage à l'arrivée à partir de cette liste, mais ce processus est en principe transparent pour l'utilisateur.

3. Utiliser des références vers un hachage

On a aussi un hachage global, mais on y accède par des références locales. Par exemple:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
my %params;
populate_params(\%params);  # passage d'une référence au hachage
...
my $dir = $params{"dir"};
...
#ailleurs:
sub populate_params {
    my $param_ref = shift;
    # par exemple lecture d'un fichier de configuration et alimentation du hachage pointé par $param_ref;
    $param_ref->{"dir"} = '/home/moi';   # alimentation du hachage par l'intermédiaire de la référence
    # ...
}

Dès que tu utilises des références comme ici, il y a plusieurs variations possibles. Par exemple, on peut aussi alimenter un hachage dans la fonction et utiliser une référence dans l'appelant.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
my $param_ref = populate_params(\%params); 
...
my $dir = $param_ref->{"dir"};
...
#ailleurs:
sub populate_params {
    my %params;
    # par exemple lecture d'un fichier de configuration et alimentation du hachage
    $params{"dir"} = '/home/moi';   # alimentation du hachage
    # ...
    return \%params;  # renvoi d'une référence au hachage
}

Bien sûr, les bouts de code ci-dessus sont incomplets, ils n'ont bien sûr pas pu être testés.

**dedalios** · 07/04/2016, 23h19

VOici la modification du code original en prenant compte des remarques.

version N1

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
 
use strict; # controle
use warnings; 
use Data::Dumper;
 
 
#strict et warnings : sont deux modules internes à Perl permettant de vérifier la syntaxe de votre code et de vous alerter à la compilation du programme ;
require "./Fonctions/FonctionFichiers.pl";
 
# ------------------------------------------------------------------------------------
# fonctions internes
# ------------------------------------------------------------------------------------
 
sub hashfichier{
 
	my %retourne_hash; # table de hash
	my $extention="";
	my $line_nbr=0; 
	my $taillefic=0;
	my $repert ="";
	my $nomdufichier;
	my $horodate="";
    my @deffic;	
    my @T_fic = $_[0];
 
    foreach my $name ( @T_fic) {
 
		#debug mode
		#  print "$name\n";	
		$line_nbr = compteurdeligne_fichier($name);  
		$taillefic  = -s $name;
		@deffic = Nomfic( $name);
		$repert = $deffic[1];
		$nomdufichier =  $deffic[0];
		$horodate = substr($repert , 0 , 14);
		if ( $nomdufichier =~ m/.err/ )  { 
			$extention ='.err';
			}
		elsif ( $nomdufichier =~ m/.dat/ )  { 
			$extention ='.dat';
			}
			else {
			$extention ='autre';
			}
		}
	}
	$retourne_hash{$nomdufichier} = { Vacation => $name, Taille => $taillefic, NBRLigne => $line_nbr, Rep =>$repert, HoroD =>$horodate, Ext =>$extention, top => "faux"};
	return  %retourne_hash;
}
 
 
# variable global
my $fichier_1 = $ARGV[0];
my $fichier_2 = $ARGV[1];
my @T_fic1=undef;
my @T_fic2=undef;
my %files_hash_1 = hashfichier();
my %files_hash_2 = hashfichier();
 
my $nmfic_1;
my $header_fic_log = "";
 
 
 
# debut code    
# doit contenir : nom du fichier + longueur. 
# print " $ARGV[0] \n";   
# print " $ARGV[1] \n";  
 
# liste les fichiers *.dat des répertoire
# print "Appel aux fonctions \n";  
@T_fic1 = listedesfichiers( $ARGV[0], "*.dat" );
push( @T_fic1,listedesfichiers( $ARGV[0], "*.err" ));
 
@T_fic2 = listedesfichiers( $ARGV[1], "*.dat" ); 
push( @T_fic2,listedesfichiers( $ARGV[1], "*.err" ));
 
 
 
######################
# MAIN               #
######################
 
#debug mode
#  print  ("@T_fic1 \n ");
#  print  ("@T_fic2 \n ");
 
 	my $valeur = "/";
	my @T_FIC  =  split(/${valeur}/,$ARGV[0]);    	
	my $nomficlog =  $T_FIC[$#T_FIC]  ;
 	$nomficlog="../Logs/${nomficlog}.log";
	print("$nomficlog \n");
	open( my $fichierlog,'+>',$nomficlog) or die("open: $!");   
	print($fichierlog "Information des actions de ${nomficlog} \n \n" );
	my $nbfic1 = $#T_fic1 +1; # compte le nombre de fichier
	print($fichierlog " Nombre des fichiers  .dat  .err :  $nbfic1   \n" );
 
    %files_hash_1 = %hashfichier( @T_fic1);
    %files_hash_2 = %hashfichier( @T_fic2);
    print Dumper \%files_hash_1;
    print Dumper \%files_hash_2;
#  print Dumper \%files_hash_1;
 
# traitement 2 pass
    @T_FIC  =  split(/${valeur}/,$ARGV[1]);    	
    $nomficlog =  $T_FIC[$#T_FIC]  ;
	$nomficlog="${nomficlog}.log";
	print($fichierlog "\n \n Comparaison avec ${nomficlog} \n " );
	my $nbfic2=$#T_fic2 + 1; # compte le nombre de fichier
    close($fichierlog); 
 
 
 exit;

Mais bon le résultat me laisse perplexe

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
Global symbol "%retourne_hash" requires explicit package name (did you forget to declare "my %retourne_hash"?) at /cygdrive/g/CodeSources/CodePerl/lirefic-v1.pl line 66.
Global symbol "$nomdufichier" requires explicit package name (did you forget to declare "my $nomdufichier"?) at /cygdrive/g/CodeSources/CodePerl/lirefic-v1.pl line 66.
Global symbol "$name" requires explicit package name (did you forget to declare "my $name"?) at /cygdrive/g/CodeSources/CodePerl/lirefic-v1.pl line 66.
Global symbol "$taillefic" requires explicit package name (did you forget to declare "my $taillefic"?) at /cygdrive/g/CodeSources/CodePerl/lirefic-v1.pl line 66.
Global symbol "$line_nbr" requires explicit package name (did you forget to declare "my $line_nbr"?) at /cygdrive/g/CodeSources/CodePerl/lirefic-v1.pl line 66.
Global symbol "$repert" requires explicit package name (did you forget to declare "my $repert"?) at /cygdrive/g/CodeSources/CodePerl/lirefic-v1.pl line 66.
Global symbol "$horodate" requires explicit package name (did you forget to declare "my $horodate"?) at /cygdrive/g/CodeSources/CodePerl/lirefic-v1.pl line 66.
Global symbol "$extention" requires explicit package name (did you forget to declare "my $extention"?) at /cygdrive/g/CodeSources/CodePerl/lirefic-v1.pl line 66.
Global symbol "%retourne_hash" requires explicit package name (did you forget to declare "my %retourne_hash"?) at /cygdrive/g/CodeSources/CodePerl/lirefic-v1.pl line 67.
Unmatched right curly bracket at /cygdrive/g/CodeSources/CodePerl/lirefic-v1.pl line 68, at end of line
/cygdrive/g/CodeSources/CodePerl/lirefic-v1.pl has too many errors.

version N°2

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
use strict; # controle
use warnings; 
use Data::Dumper;
 
 
#strict et warnings : sont deux modules internes à Perl permettant de vérifier la syntaxe de votre code et de vous alerter à la compilation du programme ;
require "./Fonctions/FonctionFichiers.pl";
 
# ------------------------------------------------------------------------------------
# fonctions internes
# ------------------------------------------------------------------------------------
 
 
 
sub hashfichier{
 
	my %retourne_hash= shift; # table de hash
	my $extention="";
	my $line_nbr=0; 
	my $taillefic=0;
	my $repert ="";
	my $nomdufichier;
	my $horodate="";
    my @deffic;	
	my @T_fic = $_[1];
 
    foreach my $name ( @T_fic) {
 
		#debug mode
		#  print "$name\n";	
		$line_nbr = compteurdeligne_fichier($name);  
		$taillefic  = -s $name;
		@deffic = Nomfic( $name);
		$repert = $deffic[1];
		$nomdufichier =  $deffic[0];
		$horodate = substr($repert , 0 , 14);
		if ( $nomdufichier =~ m/.err/ )  { 
			$extention ='.err';
			}
		elsif ( $nomdufichier =~ m/.dat/ )  { 
			$extention ='.dat';
			}
			else {
			$extention ='autre';
			}
		}
	}
	$retourne_hash->{$nomdufichier} = { Vacation => $name, Taille => $taillefic, NBRLigne => $line_nbr, Rep =>$repert, HoroD =>$horodate, Ext =>$extention, top => "faux"};
	return  \%retourne_hash;# renvoi d'une référence au hachage
}
 
 
# variable global
my $fichier_1 = $ARGV[0];
my $fichier_2 = $ARGV[1];
my @T_fic1=undef;
my @T_fic2=undef;
 
my $nmfic_1;
my $header_fic_log = "";
 
 
 
# debut code    
# doit contenir : nom du fichier + longueur. 
# print " $ARGV[0] \n";   
# print " $ARGV[1] \n";  
 
# liste les fichiers *.dat des répertoire
# print "Appel aux fonctions \n";  
@T_fic1 = listedesfichiers( $ARGV[0], "*.dat" );
push( @T_fic1,listedesfichiers( $ARGV[0], "*.err" ));
 
@T_fic2 = listedesfichiers( $ARGV[1], "*.dat" ); 
push( @T_fic2,listedesfichiers( $ARGV[1], "*.err" ));
 
 
 
######################
# MAIN               #
######################
 
#debug mode
#  print  ("@T_fic1 \n ");
#  print  ("@T_fic2 \n ");
 
 	my $valeur = "/";
	my @T_FIC  =  split(/${valeur}/,$ARGV[0]);    	
	my $nomficlog =  $T_FIC[$#T_FIC]  ;
 	$nomficlog="../Logs/${nomficlog}.log";
	print("$nomficlog \n");
	open( my $fichierlog,'+>',$nomficlog) or die("open: $!");   
	print($fichierlog "Information des actions de ${nomficlog} \n \n" );
	my $nbfic1 = $#T_fic1 +1; # compte le nombre de fichier
	print($fichierlog " Nombre des fichiers  .dat  .err :  $nbfic1   \n" );
 
    my %files_hash_1;
    my %files_hash_1;
	my %P_files_hash_1 = %hashfichier( \%files_hash_1,\@T_fic1);
    my %P_files_hash_2 = %hashfichier( \%files_hash_2,\@T_fic2);
 
 
    print Dumper \%files_hash_1;
    print Dumper \%files_hash_2;
#  print Dumper \%files_hash_1;
 
# traitement 2 pass
    @T_FIC  =  split(/${valeur}/,$ARGV[1]);    	
    $nomficlog =  $T_FIC[$#T_FIC]  ;
	$nomficlog="${nomficlog}.log";
	print($fichierlog "\n \n Comparaison avec ${nomficlog} \n " );
	my $nbfic2=$#T_fic2 + 1; # compte le nombre de fichier
    close($fichierlog); 
 
 
 exit;

pas mieux

Code :

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

1
2
3
4
5
6
7
8
9
10
Global symbol "$retourne_hash" requires explicit package name (did you forget to declare "my $retourne_hash"?) at lirefic-v2.pl line 66.
Global symbol "$nomdufichier" requires explicit package name (did you forget to declare "my $nomdufichier"?) at lirefic-v2.pl line 66.
Global symbol "$name" requires explicit package name (did you forget to declare "my $name"?) at lirefic-v2.pl line 66.
Global symbol "$taillefic" requires explicit package name (did you forget to declare "my $taillefic"?) at lirefic-v2.pl line 66.
Global symbol "$line_nbr" requires explicit package name (did you forget to declare "my $line_nbr"?) at lirefic-v2.pl line 66.
Global symbol "$repert" requires explicit package name (did you forget to declare "my $repert"?) at lirefic-v2.pl line 66.
Global symbol "$horodate" requires explicit package name (did you forget to declare "my $horodate"?) at lirefic-v2.pl line 66.
Global symbol "$extention" requires explicit package name (did you forget to declare "my $extention"?) at lirefic-v2.pl line 66.
Global symbol "%retourne_hash" requires explicit package name (did you forget to declare "my %retourne_hash"?) at lirefic-v2.pl line 67.
Unmatched right curly bracket at lirefic-v2.pl line 68, at end of line

**Lolo78** · 08/04/2016, 08h18

Quand tu as une série d'erreurs de ce genre, c'est généralement une erreur unique, par exemple qu'il manque un point-virgule, une accolade fermante, un crochet fermant ou un guillemet fermant quelque part dans le code avant la ligne indiquée par le compilateur (parfois plusieurs dizaines de lignes plus haut).

Là, je suis dans le train et n'ai pas de compilateur sur ma tablette, je ne peux donc pas tester, mais essaie déjà de mettre ta fonction hashfichier dans un fichier séparé et essaie de la compiler (perl -c fichier.pl). Fais pareil pour les autres fonctions et d'autres bouts de ton programme, tu devrais trouver assez facilement l'erreur.

**Lolo78** · 08/04/2016, 15h17

Bonjour,

je viens de tester la compilation, en fait tu as une accolade fermante en trop (sans doute l'avant-dernière) dans cette partie de code:

Code :

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

1
2
3
4
5
6
7
8
9
 
        elsif ( $nomdufichier =~ m/.dat/ )  { 
            $extention ='.dat';
            }
            else {
            $extention ='autre';
            }
        }
    }

En fait, si tu indentais ton code plus soigneusement, tu t'en serais rendu compte:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
        if ( $nomdufichier =~ m/.err/ )  { 
            $extention ='.err';
        }
        elsif ( $nomdufichier =~ m/.dat/ )  { 
            $extention ='.dat';
        }
        else {
            $extention ='autre';
        }
    }
    }

On voit plus clairement que l'une des deux dernières accolade fermante est de trop.

Par ailleurs, autre erreur à la compilation, tu utilises dans la dernière ligne de cette fonction la variable $name non déclarée et non initialisée.

NB: il y a d'autres erreurs de compilation plus loin (variables non déclarées), mais je pense que tu les trouveras toi-même facilement.

**dedalios** · 08/04/2016, 22h35

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
#!/usr/bin/perl
# ------------------------------------------------------------------------------------
# Ce programme doit decompte le nombre de ligne de 2 fichiers et les comparer
# ------------------------------------------------------------------------------------
 
# Argument d'entree
# $ARGV[0] : Chemin sur environement T
# $ARGV[1] : Chemin sur environement D
# ------------------------------------------------------------------------------------
# Argument de Sortie
# Fichier log  format Speudo csv avec entete
#   "Nomfichier1;Nombre d'enregistrement F1;Nomfichier2;Nombre d'enregistrement F2;Test de coherence";
# ------------------------------------------------------------------------------------
#
 
# version 1.0 2016-03-22 ESE
# ------------------------------------------------------------------------------------
 
use strict;    # controle
use warnings;
use Data::Dumper;
 
#strict et warnings : sont deux modules internes a Perl permettant de verifier la syntaxe de votre code et de vous alerter a la compilation du programme ;
require "./Fonctions/FonctionFichiers.pl";
 
# ------------------------------------------------------------------------------------
# fonctions internes
# ------------------------------------------------------------------------------------
 
sub hashfichier {
 
	my %retourne_hash = shift;    # table de hash
	my $extention     = "";
	my $line_nbr      = 0;
	my $taillefic     = 0;
	my $repert        = "";
	my $nomdufichier;
	my $horodate = "";
	my @deffic;
	my @T_fic = $_[1];
 
	foreach my $name (@T_fic) {
 
		#debug mode
		#  print "$name\n";
		$line_nbr     = compteurdeligne_fichier($name);
		$taillefic    = -s $name;
		@deffic       = Nomfic($name);
		$repert       = $deffic[1];
		$nomdufichier = $deffic[0];
		$horodate     = substr( $repert, 0, 14 );
		if ( $nomdufichier =~ m/.err/ ) {
			$extention = '.err';
		}
		elsif ( $nomdufichier =~ m/.dat/ ) {
			$extention = '.dat';
		}
		else {
			$extention = 'autre';
		}
		$retourne_hash{$nomdufichier} = {
			Vacation => $name,
			Taille   => $taillefic,
			NBRLigne => $line_nbr,
			Rep      => $repert,
			HoroD    => $horodate,
			Ext      => $extention,
			top      => "faux"
		};
	}
	return \%retourne_hash;    # renvoi d'une reference au hachage
}
 
# variable global
my $fichier_1 = $ARGV[0];
my $fichier_2 = $ARGV[1];
my @T_fic1    = undef;
my @T_fic2    = undef;
 
my $nmfic_1;
my $header_fic_log = "";
 
# debut code
# doit contenir : nom du fichier + longueur.
# print " $ARGV[0] \n";
# print " $ARGV[1] \n";
 
# liste les fichiers *.dat des repertoire
# print "Appel aux fonctions \n";
@T_fic1 = listedesfichiers( $ARGV[0], "*.dat" );
push( @T_fic1, listedesfichiers( $ARGV[0], "*.err" ) );
 
@T_fic2 = listedesfichiers( $ARGV[1], "*.dat" );
push( @T_fic2, listedesfichiers( $ARGV[1], "*.err" ) );
 
######################
# MAIN               #
######################
 
#debug mode
#  print  ("@T_fic1 \n ");
#  print  ("@T_fic2 \n ");
 
# definir le nom du fichier log
my $valeur    = "/";
my @T_FIC     = split( /${valeur}/, $ARGV[0] );
my $nomficlog = $T_FIC[$#T_FIC];
$nomficlog = "../Logs/${nomficlog}.log";    # Fichier de log
 
open( my $fichierlog, '+>', $nomficlog ) or die("open: $!");
print( $fichierlog "Information des actions de ${nomficlog} \n \n" );
 
my $nbfic1 = $#T_fic1 + 1;                  # compte le nombre de fichier
print( $fichierlog " Nombre des fichiers  .dat  .err :  $nbfic1   \n" );
 
 print ("avant \n");
 
my %files_hash_1;
my %files_hash_2;
my %P_files_hash_1 = hashfichier( \%files_hash_1, @T_fic1 );
my %P_files_hash_2 = hashfichier( \%files_hash_2, @T_fic2 );
 
print Dumper \%P_files_hash_1;
print Dumper \%P_files_hash_2;
 
 print "fin";
 
# traitement 2 pass
@T_FIC     = split( /${valeur}/, $ARGV[1] );
$nomficlog = $T_FIC[$#T_FIC];
$nomficlog = "${nomficlog}.log";
print( $fichierlog "\n \n Comparaison avec ${nomficlog} \n " );
my $nbfic2 = $#T_fic2 + 1;    # compte le nombre de fichier
 
close($fichierlog);
exit;

le code ne donne rien les print n'affcihe rien

Code :

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

1
2
3
print ("avant \n");
 
 print "fin";

je vins de voir que eclipseepic est pas mal comme editeur pour Perl

**Lolo78** · 09/04/2016, 10h46

Bonjour,

je n'ai pas pris le temps de tout regarder en détail et encore moins de tester le code, mais je constate au moins une erreur importante dans ta fonction hashfichier:

Code :

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

1
2
 
	return \%retourne_hash;    # renvoi d'une reference au hachage

Tu renvoies une référence vers un hachage, alors que ton code appelant s'attend à recevoir un hachage:

Code :

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

1
2
3
 
my %P_files_hash_1 = hashfichier( \%files_hash_1, @T_fic1 );
my %P_files_hash_2 = hashfichier( \%files_hash_2, @T_fic2 );

Pour que le code utilisateur fonctionne, ta fonction doit renvoyer un hachage:

Code :

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

1
2
 
	return %retourne_hash;    # renvoi d'un hachage

ou alors, inversement, que ton code utilisateur attende une référence et l'utilise comme telle:

Code :

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

1
2
3
 
my $P_files_hash_1_ref = hashfichier( \%files_hash_1, @T_fic1 );
my $P_files_hash_2_ref = hashfichier( \%files_hash_2, @T_fic2 );

Mais je te conseille plutôt la première solution (renvoi du hachage), elle sera plus simple à mettre en œuvre pour toi.

Par ailleurs, ce code:

Code :

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

1
2
3
4
 
	my %retourne_hash = shift;    # table de hash
        # ...
	my @T_fic = $_[1];

est sans doute faux sur deux points:
- Tu passes une référence à un hachage et tu affectes cette référence à un hachage, il faut déréférencer la référence pour obtenir un hachage;
- Le shift dépile le premier argument (la référence au hachage), si bien que la liste des arguments après cela contient les éléments du tableau.

Il faut donc avoir à cet endroit:

Code :

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

1
2
3
4
 
	my $retourne_hash_ref = shift;    # référence vers table de hash
        # ...
	my @T_fic = @_;

Note que je ne parle que de la cohérence syntaxique du programme, je n'ai pas cherché à comprendre ton algorithme qui me paraît sans doute plus compliqué que nécessaire.

**Lolo78** · 09/04/2016, 10h54

Bonjour,

voici une version de ta fonction hashfichier (un autre nom serait sans doute meilleur) plus conforme aux "bonnes pratiques" parce qu'elle déclare les variables là où elles doivent l'être, et non toutes au début.

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
 
sub hashfichier {
	my $retourne_hash_ref = shift;    # référence à une table de hash
	my %retourne_hash = %{$retourne_hash_ref);
	my @T_fic = @_;
 
	foreach my $name (@T_fic) {
 
		my $extension;
		my $line_nbr     = compteurdeligne_fichier($name);
		my $taillefic    = -s $name;
		my @deffic       = Nomfic($name);
		my ($nomdufichier, $repert)       = $deffic[0,1];
		my $horodate     = substr( $repert, 0, 14 );
		if ( $nomdufichier =~ m/.err/ ) {
			$extention = '.err';
		}
		elsif ( $nomdufichier =~ m/.dat/ ) {
			$extention = '.dat';
		}
		else {
			$extention = 'autre';
		}
		$retourne_hash{$nomdufichier} = {
			Vacation => $name,
			Taille   => $taillefic,
			NBRLigne => $line_nbr,
			Rep      => $repert,
			HoroD    => $horodate,
			Ext      => $extention,
			top      => "faux"
		};
	}
	return %retourne_hash;    # renvoi d'un hachage
}

Encore une fois, je n'ai regardé que la cohérence syntaxique de la fonction, je n'ai pas cherché à comprendre la logique globale de ton algo.

**dedalios** · 10/04/2016, 15h20

Voici le code fonctionnel

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
use strict;    # controle
use warnings;
use Data::Dumper;
 
#strict et warnings : sont deux modules internes a Perl permettant de verifier la syntaxe de votre code et de vous alerter a la compilation du programme ;
require "./Fonctions/FonctionFichiers.pl";
 
# ------------------------------------------------------------------------------------
# fonctions internes
# ------------------------------------------------------------------------------------
 
sub hashfichier {
 
	my %retourne_hash = shift;                   # table de hash
#	my %retourne_hash = %{$retourne_hash_ref};
 
	my @T_fic         = @_;
 
	foreach my $name (@T_fic) {
		my $extention;
 
		#debug mode
		print "$name\n";
		my $line_nbr     = compteurdeligne_fichier($name);
		my $taillefic    = -s $name;
		my @deffic       = Nomfic($name);
		my $repert       = $deffic[1];
		my $nomdufichier = $deffic[0];
		my $horodate     = substr( $repert, 0, 14 );
		if ( $nomdufichier =~ m/.err/ ) {
			$extention = '.err';
		}
		elsif ( $nomdufichier =~ m/.dat/ ) {
			$extention = '.dat';
		}
		else {
			$extention = 'autre';
		}
		$retourne_hash{$nomdufichier} = {
			Vacation => $name,
			Taille   => $taillefic,
			NBRLigne => $line_nbr,
			Rep      => $repert,
			HoroD    => $horodate,
			Ext      => $extention,
			top      => "faux"
		};
	}
 
	 	 return %retourne_hash;
}
 
# variable global
my $fichier_1 = $ARGV[0];
my $fichier_2 = $ARGV[1];
my @T_fic1    = undef;
my @T_fic2    = undef;
 
my $nmfic_1;
my $header_fic_log = "";
 
# debut code
# doit contenir : nom du fichier + longueur.
# print " $ARGV[0] \n";
# print " $ARGV[1] \n";
 
# liste les fichiers *.dat des repertoire
# print "Appel aux fonctions \n";
@T_fic1 = listedesfichiers( $ARGV[0], "*.dat" );
push( @T_fic1, listedesfichiers( $ARGV[0], "*.err" ) );
 
@T_fic2 = listedesfichiers( $ARGV[1], "*.dat" );
push( @T_fic2, listedesfichiers( $ARGV[1], "*.err" ) );
 
######################
# MAIN               #
######################
 
#debug mode
#  print  ("@T_fic1 \n ");
#  print  ("@T_fic2 \n ");
 
# definir le nom du fichier log
my $valeur    = "/";
my @T_FIC     = split( /${valeur}/, $ARGV[0] );
my $nomficlog = $T_FIC[$#T_FIC];
$nomficlog = "../Logs/${nomficlog}.log";    # Fichier de log
 
open( my $fichierlog, '+>', $nomficlog ) or die("open: $!");
print( $fichierlog "Information des actions de ${nomficlog} \n \n" );
 
my $nbfic1 = $#T_fic1 + 1;                  # compte le nombre de fichier
print( $fichierlog " Nombre des fichiers  .dat  .err :  $nbfic1   \n" );
 
print("FICHIER Ã€ LIRE $nomficlog \n");
 
my %files_hash_1;
my %files_hash_2;
my %P_files_hash_1 = hashfichier(@T_fic1 );
my %P_files_hash_2 = hashfichier(@T_fic2 );
 
print Dumper \%P_files_hash_1;
print Dumper \%P_files_hash_2;
 
print "fin";
 
# traitement 2 pass
@T_FIC     = split( /${valeur}/, $ARGV[1] );
$nomficlog = $T_FIC[$#T_FIC];
$nomficlog = "${nomficlog}.log";
print( $fichierlog "\n \n Comparaison avec ${nomficlog} \n " );
my $nbfic2 = $#T_fic2 + 1;    # compte le nombre de fichier
 
close($fichierlog);
exit;

je supprime

Code :

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

my %retourne_hash = %{$retourne_hash_ref};

car il renvoi

"my" variable %retourne_hash masks earlier declaration in same scope
Global symbol "$retourne_hash_ref" requires explicit package name (did you forget
to declare "my $retourne_hash_ref"?)

**Lolo78** · 10/04/2016, 15h46

Bonjour,

étant donné que tu appelles ta fonction hashfichier comme ceci:

Code :

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

1
2
3
 
my %P_files_hash_1 = hashfichier(@T_fic1 );
my %P_files_hash_2 = hashfichier(@T_fic2 );

ceci ne va pas marcher correctement:

Code :

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

1
2
3
4
5
 
sub hashfichier {
 
	my %retourne_hash = shift;                   # table de hash
        # ...

Car tu passes un tableau à ta fonction et, dans la fonction l'interprète comme un hachage. Cela ne va pas générer d'erreur de syntaxe à la compilation, parce que Perl passe de toute façon la structure de donnée comme une simple liste, mais la logique n'est pas bonne: la fonction s'attend à recevoir des paires clef-valeur et ce n'est pas ce que tu lui passes.

Les tableaux multidimentionnels pas trés clairs

Langage Perl

Discussions similaires

Partager

Partager