Discussion :

[GoustiFruit]

Le soucis est qu'effectivement avec deux fichiers de 10000 lignes chacun, j'ai laissé tombé après 2 heures... .

Euh, 10000 lignes ce n'est pas énorme, je n'ai pas regardé le code mais j'imagine que ce genre de problème doit se résoudre au maximum en quelques secondes avec un processeur moyen.

[bertrantitude]

Désolé j'aurai du le voir qu'il manquait tfdeux... . J'étais persuadé que ça venait du ";" de procedure CompareStringLists(List1, List2: TStringList; Missing1, Missing2: TStrings);



@goustifruit Ben je t'assure qu'avec le code précédent, qui fonctionnait, pour comparer deux fichiers de 10.000 (longues) lignes c'était parti pour prendre (au moins) 4 heures... .


Maintenant j'ai droit à un un "valeur de propriété incorrect"

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
program Project1;

uses
  Forms,
  uprinc in 'uprinc.pas' {FPrinc},
  udeux in 'udeux.pas' {Fdeux},
  udatamod in 'udatamod.pas' {DataMod: TDataModule};

{$R *.res}

begin
  Application.Initialize;
  Application.CreateForm(TFPrinc, FPrinc);
  Application.CreateForm(TFdeux, Fdeux);
  Application.CreateForm(TDataMod, DataMod); // c'est ici que ça bloque
  Application.Run;
end.

alors que pourtant il n'y a rien de spécial dans le datamodule

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
unit udatamod;
 
interface
 
uses
  SysUtils, Classes;
 
type
  TDataMod = class(TDataModule)
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
var
  DataMod: TDataMod;
 
implementation
 
{$R *.dfm}
 
end.

J'en déduis que ça doit venir de ceci mais je ne trouve pas d'où...

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
procedure tfdeux.CompareStringLists(List1, List2: TStringList; Missing1, Missing2: TStrings);
  var
  i, j   : Integer ;
   begin
        List1.Sort;                                                               //on trie la list1
        List2.Sort;                                                                //on trie la list1
        I := 0;                                                                      //on initialise i à 0
        J := 0;                                                                             //on initialise j à 0
                while (I < List1.Count) and (J < List2.Count) do        // tant qu'on est pas à la fin de list1 et list2
                         begin
                                  if List1[I] < List2[J] then
                                         begin
                                         Missing2.Add(List1[I]);               // on ajoute ce qu'il manque dans missing2 ce qu'il manque dans la list1
                                         Inc(I);                                     //  Un passe au suivant(incrémente i)
                                         end
                                 else if List1[I] > List2[J] then
                                         begin
                                         Missing1.Add(List2[J]);               // on ajoute ce qu'il manque dans missing2 ce qu'il manque dans la list1
                                         Inc(J);                                         // on passe au suivant
                                         end
                                 else
                                         begin
                                         Inc(I);
                                         Inc(J);
                                         end;
                         end;
               for I := I to List1.Count - 1 do                              // le -1 je suppose que c'est pcq on commence à compter à partir de 0
                          Missing2.Add(List1[I]);                                                       // ces 4 lignes servent à quoi?
                for J := J to List2.Count - 1 do
                          Missing1.Add(List2[J]);
   end;
procedure TFdeux.btncompareclickClick(Sender: TObject);
var
  List1: TStringList;
  List2: TStringList;
begin
  List1 := TStringList.Create;                          // on créée un stringlist list 1
  List2 := TStringList.Create;                           // on créée un stringlist list 2
  

  try
    List1.LoadFromFile(nom1);                      // on charge le fichier nom1
    List2.LoadFromFile(Nom2);                      // on charghe le fichier nom2
    Memo2.Lines.Assign(List1);                     // on envoie la list1 dans le memo2
    Memo3.Lines.Assign(List2);                     // on envoie la list2 dans le memo3
    CompareStringLists(List1, List2, Memo2.Lines, Memo3.Lines); // on compare le tout

  finally
    List2.Free;                              // on vide
    List1.Free;                              // on vide
  end;

end;

[Jipété]

Maintenant j'ai droit à un un "valeur de propriété incorrect"

Code :

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

1
2
3
4
5
               for I := I to List1.Count - 1 do                              // le -1 je suppose que c'est pcq on commence à compter à partir de 0
                          Missing2.Add(List1[I]);                                                       // ces 4 lignes servent à quoi?
                for J := J to List2.Count - 1 do
                          Missing1.Add(List2[J]);

Y a rien qui te choque, ci-dessus ? Je le refais en plus court :

Code :

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

1
2
 
  for I := I to List1.Count - 1 do    // le -1 je suppose que c'est pcq on commence à compter à partir de 0 --> YES

Et donc tu commences à compter à partir de ???

Code :

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

                // ces 4 lignes servent à quoi?

Je ne sais pas, ça dépend de ce que fait le prog, et la procédure Missing1

[GoustiFruit]

Pourrait-on avoir un extrait de chaque fichier à comparer ?

[bertrantitude]

Pourrait-on avoir un extrait de chaque fichier à comparer ?

test1.txt
test2.txt

Voici le type de fichier (avec beaucoup moins de ligne car sinon ça dépasse les 64ko). Ici comme je n'avais qu'un seul fichier, j'ai fait des modifications mineures afin d'en avoir un second. Mais de toute façon, ce sont rarement des changements de plusieurs caractères.


@jipité : c'est le fait qu'au dessus, j'ai déjà "I := 0; J := 0;" et que donc ils ont déjà été initialisés? Sinon je vois pas

[Jipété]

@jipité : c'est le fait qu'au dessus, j'ai déjà "I := 0; J := 0;" et que donc ils ont déjà été initialisés? Sinon je vois pas

J'ai dû très mal m'exprimer, désolé, plus le fait que j'étais persuadé qu'on ne pouvait pas modifier une variable de boucle (et je viens de faire un test et, oui, c'est possible), donc mettons que je n'ai rien dit.

Par contre, j'ai déjà "I := 0; J := 0;", non, car ton code au début des boucle "For" est avant truffé de Inc(I) et Inc(J) donc, non, tu ne dois pas commencer à zéro, là (je n'avais pas regardé au-dessus, ce midi, persuadé qu'on ne pouvait pas modifier la variable).

Pas d'autre idée, je passe (pas confortable du tout de regarder du code dans ces petites fenêtres du forum).

[foetus]

pas confortable du tout de regarder du code dans ces petites fenêtres du forum

le 'Visualiser dans une fenêtre à part' ne sert que pour les chiens

[tourlourou]

Merci, foetus, je ne sais pas à qui elle est destinée (sûrement à ceux qui ont les yeux en face des trous !), mais cette fonctionnalité bien pratique m'avait échappé...

[Jipété]

le 'Visualiser dans une fenêtre à part' ne sert que pour les chiens

Merci, foetus, je ne sais pas à qui elle est destinée (sûrement à ceux qui ont les yeux en face des trous !), mais cette fonctionnalité bien pratique m'avait échappé...

Salut YL !

Bah, c'est pour moi, ça, foetus il aime bien me taquiner

Et moi non plus je n'avais jamais eu l'idée de cliquer sur ce lien, peut-être pas assez explicite ? Fallait mettre Visualiser tout le code ci-dessous dans une autre fenêtre un autre onglet.
EDIT : correction ci-dessus

[Charly910]

Bonjour,

pourquoi tu n'as pas exploité complètement le lien donné par GoustiFruit. C'est exactement ce que tu veux ? Dans le petit projet joint j'ai juste ajouté un Memo supplémentaire pour les lignes identiques.

Après tu peux adapter l'interface à ton gout et aussi décortiquer les lignes non identiques si tu le souhaites.

A+
Charly

CompFile.zip

[bertrantitude]

J'ai suivi le lien de goustifruit et voici plus ou moins (car j'ai changé pas mal de chose pour essayer que ça tourne) ce à quoi j'étais parvenu. Ce n'était pas trop différent de vous mais ça ne fonctionnait pas tout à fait.

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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
unit udeux;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, Grids, Buttons;
 
type
  TFdeux = class(TForm)
    Memo1: TMemo;
    Memo2: TMemo;
    OpenDialog1: TOpenDialog;
    OpenDialog2: TOpenDialog;
    Edit1: TEdit;
    Edit2: TEdit;
    PrintDialog1: TPrintDialog;
    PrinterSetupDialog1: TPrinterSetupDialog;
    Memo3: TMemo;
    Memo4: TMemo;
    btnrechercherfichieroldFile: TBitBtn;
    btnrechercherNewFile: TBitBtn;
    btnReset: TButton;
    SaveDialog1: TSaveDialog;
    btnChangements: TBitBtn;
    LabelAdd: TLabel;
    LabelMinus: TLabel;
    SaveDialog2: TSaveDialog;
    Button1: TButton;
    //procedure btnrechercherfichieroldFileClick(Sender: TObject);
   // procedure btnrechercherNewFileClick(Sender: TObject);
    procedure btnResetClick(Sender: TObject);
    procedure btnChangementsClick(Sender: TObject);
   procedure CompareStringLists(List1, List2: TStringList; Missing1, Missing2: TStrings);
    procedure Button1Click(Sender: TObject);
 
  private
    { Déclarations privées }
 
  public
    { Déclarations publiques }
 
  end;
 
var
  Fdeux: TFdeux;
   Fichier1, Fichier2  : TextFile ;
   Nom1, Nom2          : String ;
   Ligne1, Ligne2      : String ;
   i, j                : Integer ;
   list1, list2         : string;
 
implementation
 
{$R *.dfm}
{
procedure TFdeux.btnrechercherfichieroldFileClick(Sender: TObject);
   begin
        OpenDialog1.Execute;
        AssignFile(fichier1,OpenDialog1.FileName);
        Edit1.Text := OpenDialog1.FileName
   end;
 
procedure TFdeux.btnrechercherNewFileClick(Sender: TObject);
   begin
        OpenDialog2.Execute;
        AssignFile(fichier2,OpenDialog2.FileName);
        Edit2.Text := OpenDialog2.FileName;
        //btncompareclick.Visible:=true;
       // btncompare2.Visible:=true;
   end;
}
 
procedure TFdeux.CompareStringLists(List1, List2: TStringList; Missing1, Missing2: TStrings);
  var
  i, j   : Integer ;
   begin
         List1.Sort;
        List2.Sort;
        I := 0;
        J := 0;
                while (I < List1.Count) and (J < List2.Count) do
                         begin
                                  if List1[I] < List2[J] then
                                         begin
                                         Missing2.Add(List1[I]);
 
                                         Inc(I);
                                         end
                                 else if List1[I] > List2[J] then
                                         begin
                                          Missing1.Add(List2[J]);
 
                                         Inc(J);
                                         end
                                 else
                                         begin
                                         Inc(I);
                                         Inc(J);
                                         end;
                         end;
                for I := I to List1.Count - 1 do
                          Missing2.Add(List1[I]);
 
                for J := J to List2.Count - 1 do
                          Missing1.Add(List2[J]);
   end;
 
 
 
 
 
 
procedure TFdeux.btnResetClick(Sender: TObject);
begin
Memo1.Clear;
Memo2.Clear;
Memo3.Clear;
Memo4.Clear;
btnChangements.visible:=false;
end;
 
 
 
procedure TFdeux.btnChangementsClick(Sender: TObject);
var lineSup: string;
var lineLess: string;
begin
if SaveDialog1.Execute then
 
  begin
 
    lineSup := SaveDialog1.FileName;
 
 
    Memo3.Lines.SaveToFile(lineSup);
  end;
if SaveDialog2.Execute then
  begin
     lineLess :=SaveDialog2.FileName;
    Memo2.Lines.SaveToFile(lineLess);
  end;
end;
 
procedure TFdeux.Button1Click(Sender: TObject);
 
 
var
  List1: TStringList;
  List2: TStringList;
begin
  List1 := TStringList.Create;
  List2 := TStringList.Create;
 
  try
    List1.LoadFromFile('a.txt');
    List2.LoadFromFile('b.txt');
    Memo1.Lines.Assign(List1);
    Memo4.Lines.Assign(List2);
 
   CompareStringLists(List1, List2,Memo1.Lines, Memo4.Lines);
 
  finally
    List2.Free;
    List1.Free;
  end;
 
end;
 
end.

Votre code fonctionne lorsqu'il y a seulement quelques lignes, mais ne fonctionne pas en cas de long document (si vous faite juste des copier coller des lignes dans chacun des deux documents txt que j'ai envoyé, de sorte d'arriver à plus de 1000lignes, ça ne marché déjà plus). Je ne pouvais pas envoyer des document plus grand (limite de taille de développez.com). Je ne pensai pas que cela aurai pu changer quelque chose.

A un moment j'ai eu le même soucis avec mon fichier, mais vu que la même chose se produit avec le vôtre, je ne comprends du tout d'où ça vient. Est-ce la valeur "integer"? J'ai lu que ça pouvait aller jusque +-21000 (de mémoire) et les colonnes comprennant 800 caractères (lignes de gauche à droite), donc pour un fichier de 1000 lignes, ça ferait 80000 ? Où je me trompe complètement ...

Voici les deux fichier où il faut faire des copier coller (de sorte à arriver à plus de 1000 lignes), vu qu'il y a une limite de tailler pour les envois de fichiers.

test1.txttest2.txt

et voici le votre code

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
unit F_CompareFile;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;
 
type
  TCompareFile = class(TForm)
    OpenDialog1: TOpenDialog;
    Memo1: TMemo;
    OpenDialog2: TOpenDialog;
    Memo2: TMemo;
    Memo3: TMemo;
    Memo4: TMemo;
    Label1: TLabel;
    Label2: TLabel;
    Label3: TLabel;
    Label4: TLabel;
    Memo5: TMemo;
    Label5: TLabel;
    Btn_ComparerFichiers: TButton;
    Label6: TLabel;
    Label7: TLabel;
    Label8: TLabel;
    Label9: TLabel;
    Label10: TLabel;
    procedure CompareStringLists(List1, List2: TStringList;
                                 Missing1, Missing2, Common1 : TStrings);
    procedure Btn_ComparerFichiersClick(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
var
  CompareFile: TCompareFile;
 
implementation
 
 
{$R *.dfm}
 
{ ========================================================================== }
procedure TCompareFile.CompareStringLists(List1, List2 : TStringList;
  Missing1, Missing2, Common1 : TStrings);
var
  I: Integer;
  J: Integer;
begin
  List1.Sort;
  List2.Sort;
  I := 0;
  J := 0;
  while (I < List1.Count) and (J < List2.Count) do
  begin
    if List1[I] < List2[J] then
    begin
      Missing2.Add(List1[I]);
      Inc(I);
    end
    else if List1[I] > List2[J] then
    begin
      Missing1.Add(List2[J]);
      Inc(J);
    end
    else
    begin
      Common1.Add(List2[J]);
      Inc(I);
      Inc(J);
    end;
  end;
  for I := I to List1.Count - 1 do
    Missing2.Add(List1[I]);
  for J := J to List2.Count - 1 do
    Missing1.Add(List2[J]);
end;
{ ========================================================================== }
procedure TCompareFile.Btn_ComparerFichiersClick(Sender: TObject);
var
  List1: TStringList;
  List2: TStringList;
  n1, n2, n3, n4, n5 ,n6 : Integer ;
begin
  List1 := TStringList.Create;
  List2 := TStringList.Create;
  try
    n1 := 0 ; n2 := 0 ; n3 := 0 ; n4 := 0 ; n4 := 0 ; n6 := 0 ;
    List1.LoadFromFile('test3.txt');
    List2.LoadFromFile('test4.txt');
 
    Memo1.Lines.Assign(List1);
    Memo2.Lines.Assign(List2);
    CompareStringLists(List1, List2, Memo3.Lines, Memo4.Lines, Memo5.Lines);
    n1 := Memo1.Lines.Count ;
    n2 := Memo2.Lines.Count ;
    n3 := Memo3.Lines.Count ;
    n4 := Memo4.Lines.Count ;
    n5 := Memo5.Lines.Count ;
    Label6.Caption := IntToStr(n1) + ' lignes' ;
    Label7.Caption := IntToStr(n2) + ' lignes' ;
    Label8.Caption := IntToStr(n3) + ' lignes' ;
    Label9.Caption := IntToStr(n4) + ' lignes' ;
    Label10.Caption := IntToStr(n5) + ' lignes' ;
  finally
    List2.Free;
    List1.Free;
  end;
end;
{ ========================================================================== }
 
procedure TCompareFile.FormCreate(Sender: TObject);
begin
 
end;
 
end.

En tout cas merci pour votre aide

[ShaiLeTroll]

Faudrait ajouter BeginUpdate\EndUpdate qui éviterait un dessin des TMemo a chaque modification de leurs propriétés Lines, c'est un cout important en terme de temps !

Sans BeginUpdate - 7563 ms
Avec BeginUpdate - 826 ms
Test1 1932 lignes
Test2 3276 lignes

Voici le code utilisé pour la mesure, juste un TForm1 avec un btn1, Memo3, Memo4 et Memo5

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
procedure TForm1.btn1Click(Sender: TObject);
 
  procedure CompareStringLists(List1, List2 : TStringList; Missing1, Missing2, Common1 : TStrings);
  var
    I: Integer;
    J: Integer;
  begin
    List1.Sort;
    List2.Sort;
    I := 0;
    J := 0;
    while (I < List1.Count) and (J < List2.Count) do
    begin
      if List1[I] < List2[J] then
      begin
        Missing2.Add(List1[I]);
        Inc(I);
      end
      else if List1[I] > List2[J] then
      begin
        Missing1.Add(List2[J]);
        Inc(J);
      end
      else
      begin
        Common1.Add(List2[J]);
        Inc(I);
        Inc(J);
      end;
    end;
    for I := I to List1.Count - 1 do
      Missing2.Add(List1[I]);
    for J := J to List2.Count - 1 do
      Missing1.Add(List2[J]);
  end;
 
var
  List1: TStringList;
  List2: TStringList;
 
  TickStart, TickEnd: TLargeInteger;
  TickPerSec: TLargeInteger;
 
begin
  QueryPerformanceFrequency(TickPerSec);
 
  List1 := TStringList.Create;
  List2 := TStringList.Create;
  try
    // Sans BeginUpdate
    QueryPerformanceCounter(TickStart);
 
    List1.Clear();
    List2.Clear();
    Memo3.Lines.Clear();
    Memo4.Lines.Clear();
    Memo5.Lines.Clear();
 
    List1.LoadFromFile('test1.txt');
    List2.LoadFromFile('test2.txt');
 
    CompareStringLists(List1, List2, Memo3.Lines, Memo4.Lines, Memo5.Lines);
 
    QueryPerformanceCounter(TickEnd);
    ShowMessage(Format('Sans BeginUpdate - %d ms', [Trunc((TickEnd - TickStart) / TickPerSec * MSecsPerSec)]));
 
    // Avec BeginUpdate
    QueryPerformanceCounter(TickStart);
 
    Memo3.Lines.BeginUpdate();
    Memo4.Lines.BeginUpdate();
    Memo5.Lines.BeginUpdate();
 
    List1.Clear();
    List2.Clear();
    Memo3.Lines.Clear();
    Memo4.Lines.Clear();
    Memo5.Lines.Clear();
 
    List1.LoadFromFile('test1.txt');
    List2.LoadFromFile('test2.txt');
 
    CompareStringLists(List1, List2, Memo3.Lines, Memo4.Lines, Memo5.Lines);
 
    Memo5.Lines.EndUpdate();
    Memo4.Lines.EndUpdate();
    Memo3.Lines.EndUpdate();
 
    QueryPerformanceCounter(TickEnd);
    ShowMessage(Format('Avec BeginUpdate - %d ms', [Trunc((TickEnd - TickStart) / TickPerSec * MSecsPerSec)]));
 
  finally
    List2.Free;
    List1.Free;
  end;
end;

, je ne comprends du tout d'où ça vient. Est-ce la valeur "integer"? J'ai lu que ça pouvait aller jusque +-21000 (de mémoire) et les colonnes comprennant 800 caractères (lignes de gauche à droite), donc pour un fichier de 1000 lignes, ça ferait 80000 ? Où je me trompe complètement ...

21000 avec quelques zéros de plus +-2100000000, faudrait un minimum lire la documentation : Types simples (Delphi)
Et donc exactement un Integer c'est -2147483648..2147483647

[Charly910]

Bonjour,
Effectivement, le traitement était tellement instantané avec les fichiers de test que j'avais omis les Begin et EndUpdate !

Heureusement Shai est toujours là pour veiller au grain !

A+
Charly

[Charly910]

Avec 1050 lignes, et les begin et EndUpdate, c'est presque instantané : 1 seconde environ

A+
Charly

[bertrantitude]

ça fonctionne . merci à tous