Comparaison du contenu de 2 fichiers

**ecniv** · 10/08/2006, 07h52

Bonjour,
j'ecris actuellement un script qui liste le contenu d'un repertoire donné, il enregistre ces données dans un fichier texte et vient comparer le contenu de ce fichier texte ( jour J) avec le contenu du meme fichier texte du jour precedent (jour J-1)

Pour la comparaison je passe par une fonction. En fait, je recupere les données de chaque fichiers ( J et J-1) dans 2 hashs puis je les passe a la fonction par reference.

Code :

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

1
2
3
4
 
	#comparaison des 2 fichiers
	print "je rentre ds la fonction comparaison\n";
	my @tableau = &comparaison(\%datas, \%datas1);

une fois dans ma fonction, je teste la taille des 2 hashs (et j'aimerai aussi tester le contenu mais il y a encore du boulot), et suivant la difference de taille entre les deux, je dit si des elements ont ete ajoutés, supprimé ou si rien n'a changé. Ensuite j'indique les valeurs ajoutées ou supprimées. Je renvoi ces valeurs dans un tableau pour les ajouter a mon fichier texte (jour J) et les envoyer par mail.
Le soucis c'est que je m'embrouille un peu dans l'ecriture de ma fonction et que j'ai ecrit un premier jet qui ne fonctionne pas completement et je ne trouve pas l'erreur. de plus peu etre aurez vous d'autres solutions a me proposer (plus optimisées, etc). J'aimerais si possible ne pas passer par une fonction existante de perl qui effectuerai le meme travail.

la dite fonction

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
 
sub comparaison
{
	my ($datas,$datas1)= @_; #recuperation des references ds la fonction que des scalaires ici.
	my $i=0;
	my $diff = 0;
 
	print "datas contient :\n";
	#foreach (sort keys %{$datas}) #trié
	foreach (keys %{$datas})
	{
		print "$_ -> $datas->{$_}\n";
	}
 
	print "datas1 contient :\n";
	foreach (keys %{$datas1})
	{
		print "$_ -> $datas1->{$_}\n";
	}
 
	print "je suis ds fonction comparaison\n";
	print "Comparaisons des tailles :\n";
	my $size_datas = scalar(keys %{$datas}); #renvoi le nbre d'entree ds datas
	my $size_datas1 = scalar(keys %{$datas1}); #renvoi le nbre d'entree ds datas1
 
	print ($size_datas,"\n");
	print ($size_datas1,"\n");
	print "comparaison des 2 fichiers\n";
	if($size_datas != $size_datas1)
	{
		my $diff = ($size_datas-$size_datas1);
		if ($diff>0)
		{
			print"Il y a $diff entree(s) a rajouter.\n";
			for ($i=$size_datas1; $i<$size_datas1+$diff; $i++)
			{
				print "Nouvel élément : $datas{$i}\n"; #LINE 144
			}
		}
 
		if ($diff==0)
		{print"Il n'y rien de nouveau.\n";}
 
		if ($diff<0)
		{
			print"Il y a $diff entrée(s) enlevé rajouter.\n";
			for ($i=$size_datas1; $i<$size_datas1+$diff; $i++)
			{
				print "Elément supprimé : $datas{$i}\n"; #LINE 156
			}
		}
	}
}

une autre solution que l'on ma proposée, consisté a comparer mes deux fichiers (via 2tableaux) lignes par lignes mais j'aimerai mieux opter pour l'option des hash et des references avec lesquel je lutte un peu il est vrai.
D'avance merci pr votre aide.

J'avais poublié de preciser le message d'erreur
Global symbol "%datas" requires explicit package name at C:\Vincent\Scripts\Perl\test\liste_rep.pl. line144
Global symbol "%datas" requires explicit package name at C:\Vincent\Scripts\Perl\test\liste_rep.pl. line156

**ecniv** · 11/08/2006, 07h16

Je relit ma fonction avec plus de recul sur le forum et je repere deja quelques enormes coquilles.

Fonction corrigée mais qui bug tjs

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
 
sub comparaison
{
	my ($datas,$datas1)= @_; #recuperation des references ds la fonction que des scalaires ici.
                                             #$datas=fic J-1, $datas1=fic J
	my $i=0;
	my $diff = 0;
 
         print "je suis ds fonction comparaison\n"; #test pour debug
 
	#foreach (sort keys %{$datas}) #test de tri
	print "datas contient :\n";
        foreach (keys %{$datas}) { print "$_ -> $datas->{$_}\n"; }
	print "datas1 contient :\n";
	foreach (keys %{$datas1}) { print "$_ -> $datas1->{$_}\n"; }
 
	print "Comparaisons des tailles :\n";
	my $size_datas = scalar(keys %{$datas}); #renvoi le nbre d'entree ds datas
	my $size_datas1 = scalar(keys %{$datas1}); #renvoi le nbre d'entree ds datas1
 
	print ($size_datas,"\n"); #test pour debug
	print ($size_datas1,"\n"); #test pour debug
	print "comparaison des 2 fichiers\n";
	if($size_datas != $size_datas1)
	{
		my $diff = ($size_datas-$size_datas1);
		if ($diff>0)
		{
			print"Il y a $diff entree(s) enlevee(s).\n";
			for ($i=$size_datas1; $i<$size_datas1+$diff; $i++)
			{
				print "Elément supprimé : $datas{$i}\n"; #line 144
			}
		}
		if ($diff<0)
		{
			print"Il y a $diff entree(s) ajoutee(s).\n";
			for ($i=$size_datas; $i<$size_datas1; $i++)
			{
				print "Nouvel élément : $datas{$i}\n"; #line 152
			}
		}
	}
	else {print"Il n'y rien de nouveau.\n";}
}

Les 2 bugs line 144 et 152 (anciennement 156) persistent. J'imagine que l'expression $datas{$i} ne lui convient pas mais je ne saisit pas pourquoi.

**ecniv** · 11/08/2006, 08h03

nouvelle modif sur les test de diff (evite une imbrication de boucle)

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
 
sub comparaison
{
	my ($datas,$datas1)= @_; #recuperation des references ds la fonction que des scalaires ici.
                                             #$datas=fic J-1, $datas1=fic J
	my $i=0;
	my $diff = 0;
 
         print "je suis ds fonction comparaison\n"; #test pour debug
 
	#foreach (sort keys %{$datas}) #test de tri
	print "datas contient :\n";
        foreach (keys %{$datas}) { print "$_ -> $datas->{$_}\n"; }
	print "datas1 contient :\n";
	foreach (keys %{$datas1}) { print "$_ -> $datas1->{$_}\n"; }
 
	print "Comparaisons des tailles :\n";
	my $size_datas = scalar(keys %{$datas}); #renvoi le nbre d'entree ds datas
	my $size_datas1 = scalar(keys %{$datas1}); #renvoi le nbre d'entree ds datas1
 
	print ($size_datas,"\n"); #test pour debug
	print ($size_datas1,"\n"); #test pour debug
	print "comparaison des 2 fichiers\n";
 
        my $diff = ($size_datas-$size_datas1);
	if ($diff>0)
	{
		print"Il y a $diff entree(s) enlevee(s).\n";
		for ($i=$size_datas1; $i<$size_datas1+$diff; $i++)
		{
			print "Elément supprimé : $datas{$i}\n"; #line 144
		}
	}
	elsif ($diff<0)
	{
		print"Il y a $diff entree(s) ajoutee(s).\n";
		for ($i=$size_datas; $i<$size_datas1; $i++)
		{
			print "Nouvel élément : $datas{$i}\n"; #line 152
		}
	}
	else {print"Il n'y rien de nouveau.\n";}
}

J'approche, mais la je suis bloqué, je repotasse le camelbook sans comprendre mon erreur erf :/.

**Jedai** · 11/08/2006, 13h11

Moi ce que je ne comprend pas, c'est pourquoi tu utilises des hashs comme des tableaux (les clés sont des nombres, et en plus c'est même pas un tableau creux parqu'a priori ces nombres sont les numéro de ligne...). Plus je ne comprend pas comment tu décides quels éléments ont été supprimés, et lesquels sont nouveaux (d'autant que les nouveaux semblent être un sous-ensemble de supprimés

).
Voici une fonction de comparaison qui prend deux références de tableaux contenant les lignes de chacun des fichiers, et donne les éléments supprimés et nouveaux :

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
 
package Changes;
require Exporter;
our @ISA = qw(Exporter);
our @EXPORT = qw(compare);
 
sub compare {
    my ($old, $new) = @_;
    my (%old_lines, %new_lines);
    @old_lines{@$old} = ();
    @new_lines{@$new} = ();
 
    my $deleted;
    foreach my $line ( @$old ){
        push @$deleted, $line if not exists $new_lines{$line};
    }
 
    my $added;
    foreach my $line ( @$new ){
        push @$added, $line if not exists $old_lines{$line};
    }
 
    return $deleted, $added;
}

Ca s'utilise comme ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#! /usr/bin/perl
use strict;
use warnings;
 
use Changes;
 
my @old = (1, 2, 3, 4, 5);
my @new = (2, 3, 5, 7, 8);
 
my ($deleted, $added) = compare( \@old, \@new );
 
print "@$deleted\n@$added\n";

Mais je pense que ce que tu cherches vraiment, c'est plutôt Algorithm:: Diff par exemple.

--
Jedaï

**ecniv** · 12/08/2006, 12h13

Merci pour ta reponse. Je me rend compte avec le recul que l'utilisation des hash n'est pas appropriée, tu as raison, je vais utiliser des tableaux. Du fait qu'ils soient ordonnés, ils se pretent mieux aux comparaisons (on m'avez deja proposé cette methode et je m'apercois que c'est finalement la meilleure ^^)

Le code de ta fonction est tres interessant.Te serait il possible de le commenter en details stp. Je me permet de modifier le nom des variables en fonction de leur nature. cette petite manip que je conseil fortement au debutant en perl aide grandement lors du debug du code.

"sdata" s pour scalaire,
"hdatas" h pour hash,
"tdatas" t pour tableau,
"rtdatas" rt pour reference tableau
"rhdatas" rh reference hash

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
 
package Changes;
require Exporter;
our @ISA = qw(Exporter);
our @EXPORT = qw(compare);
 
sub compare {
    my ($rtold, $rtnew) = @_;
    my (%hold_lines, %hnew_lines);
    @hold_lines{@$sold} = ();
    @hnew_lines{@$snew} = ();
 
    my $sdeleted;
    foreach my $sline ( @$rtold )
    {
        push (@$sdeleted, $sline) if not exists $hnew_lines{$sline};
    }
 
    my $sadded;
    foreach my $sline ( @$rtnew )
    {
        push (@$sadded, $sline) if not exists $hold_lines{$sline};
    }
 
    return $sdeleted, $sadded;
}

Mais je pense que ce que tu cherches vraiment, c'est plutôt Algorithm:: Diff par exemple.

J'ai regardé, ca correspond a ce que je veux. Mais, "normalement" je n'aurais pas a traité les cas de redondances dans un meme fichiers car aucunes lignes nesera en doublons ds ce fichier.

**ecniv** · 14/08/2006, 21h53

up

**Woufeil** · 15/08/2006, 18h23

Bonjour,

Hum, je trouve que ta méthode pour nommer les variables peut induire en erreur. D'ailleurs, tu t'es trompé

$deleted et $added sont des références à des tableaux. Bon, OK, ce sont tout de même des scalaires, mais tu aurait du les nommer $rtadded et $rtdeleted.

Bien que ce ne soit pas mon code, je pense arriver à te le commenter

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
package Changes;
#sert à utiliser le mdule Exporter
require Exporter;
our @ISA = qw(Exporter);
our @EXPORT = qw(compare);
 
sub compare {
    my ($old, $new) = @_;
    my (%old_lines, %new_lines);#on créé ici deux tables de hachage
    #dans la première, chaque ligne de @$old est une clé vers un element undef
    @old_lines{@$old} = (); 
    #dans la seconde, chaque ligne de @$new est une clé vers un element undef
    @new_lines{@$new} = ();
 
    #référence vers un tableau qui contiendra les lignes supprimées
    my $deleted;
    #on parcourt le tableau des anciennes lignes
    foreach my $line ( @$old ){
        #on ajoute l'élément au tableau @$deleted si il n'est pas une clé du hash %new_lines
       #qui contient toutes les lignes de @$new
        push @$deleted, $line if not exists $new_lines{$line};
    }    
 
    #référence vers un tableau qui contiendra les lignes supprimées
    my $added;
    #on parcourt le tableau des nouvelles lignes
    foreach my $line ( @$new ){
        #on ajoute l'élément au tableau si il n'est pas une clé du hash %old_lines
       #qui contient toutes les lignes de @$old
        push @$added, $line if not exists $old_lines{$line};
    }
 
    #on retourne les lignes supprimées et ajoutées dans deux ref à des tableaux
    return $deleted, $added;
}

C'est assez clair ou je détaille plus ?

**ecniv** · 16/08/2006, 18h35

merci pr les details

. Pourrez tu me dire l'utilité de

Code :

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

1
2
3
4
5
6
 
package Changes;
#sert à utiliser le mdule Exporter
require Exporter;
our @ISA = qw(Exporter);
our @EXPORT = qw(compare);

et

Code :

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

1
2
3
4
5
 
#dans la première, chaque ligne de @$old est une clé vers un element undef
    @old_lines{@$old} = (); 
    #dans la seconde, chaque ligne de @$new est une clé vers un element undef
    @new_lines{@$new} = ();

il y un truc que je ne saisit pas dans cette ecriture (c'est un hash de tableau?).

Et je ne savais pas que l'on pouvez declarer des references sans leur affecter de contenu (my $deleted, my $added). Peu tu m'en dire un peu plus.

d'avance merci.

**Woufeil** · 16/08/2006, 18h46

Le premier code sert à pouvoir utiliser la fonction compare dans le programme principal.

Dans la seconde écriture, on obtient en fait un hash unidimensionnel. C'est comme si on écrivait :

Code :

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

1
2
3
my $old_lines{$old->[0]} = "";
my $old_lines{$old->[1]} = "";
...

Et pour $deleted et $added, elles deviennent toutes les deux des références dans le foreach au moment du push.

Voilà, j'espère t'avoir éclairé !

**Jedai** · 16/08/2006, 22h57

Envoyé par Woufeil

Dans la seconde écriture, on obtient en fait un hash unidimensionnel. C'est comme si on écrivait :

Code :

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

1
2
3
my $old_lines{$old->[0]} = "";
my $old_lines{$old->[1]} = "";
...

Pas exactement, c'est plutôt un undef qu'une chaîne vide :

Code :

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

1
2
 
$old_lines{$_} = undef  foreach (@$old);

C'est ce qu'on appelle une tranche (slice) de tableau ou de hash : on affecte en fait une liste de valeur à une liste de clé du tableau (index numérique) ou du hash (chaîne de caractère).
Un exemple un peu plus explicite :

Code :

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

1
2
3
4
 
my @tab = (1, 2, 3, 4);
@tab[1,3] = (3, 5);
#@tab = (1, 3, 3, 5);

(Tu remarqueras que le sigil de la tranche est "@", puisqu'il s'agit bien d'une liste, et pas d'un élément unique)
(Si la liste qu'on affecte est plus petite que la liste des clés, elle est complétée par des undef comme ici, si elle est trop grande les valeurs surnuméraires sont ignorées)

Envoyé par Woufeil

Et pour $deleted et $added, elles deviennent toutes les deux des références dans le foreach au moment du push.

Lorsqu'on définit une variable sans l'initialiser, elle prend la valeur undef, qui est une valeur spéciale : elle est fausse en contexte booléen, vaut 0 en contexte numérique et "" en contexte de string (et l'utiliser provoque alors un warning). C'est utile pour éviter des initialisations superflue (par exemple initialiser à une valeur qui n'aura aucune importance par la suite), par exemple ici, comme j'emploie @$deleted plus tard, la variable $deleted est "autovivifiée" et automatiquement assignée une référence de tableau.

(On peut tester si une variable est différente de undef avec la fonction defined, ceci permet de différencier undef d'une autre valeur fausse comme 0 qui aurait un sens différent dans ce cas particulier, par exemple pour signaler la fin d'un fichier on renvoie undef)

--
Jedaï

**ecniv** · 18/08/2006, 18h00

Merci pour ces explications precises. Je pense avoir tt saisie sur les references (enfin la base).
Cependant un point trouble subsiste

Code :

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

1
2
3
 
@hold_lines{@$sold} = ();
@hnew_lines{@$snew} = ();

Si j'ai bien saisie la manip.
On attribut a la premiere clef %hold_lines, le contenu de la premiere valeur de @old.
On attribut a la premiere valeur de %hold_lines, la valeur undef
Nous repetons l'operation jusqu'a la derniere valeur de @old
Nous faisons de meme pour %new_line et @new.

Ensuite on vient voir si les valeur de @new correspondent a une clef de %hold_lines
idem pour @hold et les clefs de %new_lines

Pourquoi passer par 2 hashs intermediaires? ne peut on pas venir faire un exist direcement sur les valeurs des tableaux?
ex:
foreach (@old)
if $_ !exist @new
push @deleted,$_

et vice vers pour @added

**Woufeil** · 19/08/2006, 21h38

Envoyé par ecniv

Pourquoi passer par 2 hashs intermediaires? ne peut on pas venir faire un exist direcement sur les valeurs des tableaux?
ex:
foreach (@old)
if $_ !exist @new
push @deleted,$_

et vice vers pour @added

Non, ça ne peut pas marcher comme ça. En fait, exists regarde si la clé de la table de hachage existe ou si l'élement d'indice n existe dans le tableau. Elle ne sert pas à rechercher un élement précis du tableau. Il faut donc passer par deux tables de hachage intermédiaires.

Comparaison du contenu de 2 fichiers

Langage Perl

Discussions similaires

Partager

Partager