Discussion :

[Charly910]

Bonjour,

je cherche la méthode la plus rapide pour calculer le nombre de ligne d'un fichier txt.

Méthode 1 : on fait des Readln jusqu'à EOF

Méthode 2 : on copie le fichier dans un TFileStream et on compte les Chr(13)+Chr(10)

Autre méthode : ?

Je pourrais tester, mais je peine à programmer la méthode 2 et puis il y a peut être mieux ?

et puis cela dépend peut être de la taille du fichier (pour moi c'est gros maximum 500 lignes d'environ 10 caractères maxi chacune)

A+
Charly

[Andnotor]

Je ne me fatiguerais pas pour si peu : TStringList, LoadFromFile, Count.

[Charly910]

Ben Oui, tu as raison !

Merci

A+

[Charly910]

Voilà :

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
{ =========================================================================== }
Function NumLines(FileName : String) : Integer ;
Var
  Liste    : TStringList ;
begin
  If FileExists(Filename) Then
    Begin
      Liste := TStringList.Create ;
      Liste.LoadFromFile(Filename);
      Result := Liste.Count ;
    End
  Else
    Result := 0 ;
End ;
{ =========================================================================== }

Mais est ce bien plus rapide que :

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
{ =========================================================================== }
Function NumLines2(FileName : String) : Integer ;
Var
  F        : TextFile ;
begin
  If FileExists(Filename) Then
    Begin
      AssignFile(F,Filename) ;
      Reset(F) ;
      Result := 0 ;
      Repeat
        Readln(F) ;
        Inc(Result)  ;
      Until EOF(F);
      CloseFile(F);
    End
  Else
    Result := 0 ;
End ;
{ =========================================================================== }

Car j'ai vu dans l'aide que TStringList.LoadFromFile élimine les doublons, ce qui doit prendre du temps ?

A+
Charly

[Charly910]

J'ai testé : les 2 méthodes avec Readln et StringList sont équivalentes.

et StringList.LoadFromFile n'élimine pas les doublons !

Merci AndNotOr

A+
Charly

[ShaiLeTroll]

Pour les Doublons, fait Duplicates à dupIgnore
L'avantage de ReadLn le fichier n'est pas chargé en mémoire, cela peut être un gain, surtout en D7 sans FastMM

Après, si l'on parle de fichier entre 1 000 ou 1 000 000 lignes, disons que le gain, tu ne le verras pas avant un certain volume.

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
procedure CountLn(const FileName: string): Cardinal;
var
   FLNC: TextFile;
begin
      Result := 0;
      AssignFile(FLNC, FileName);
      Reset(FLNC);
      try
         while not Eof(FLNC) do
         begin
            Inc(Result);
            Readln(FLNC);
         end;
      finally
         CloseFile(FLNC);
      end;
end;

Et une lecture binaire est évidemment plus rapide car encore une fois, on lit la donnée directement sans recopier la chaine trouvé dans le buffer de ReadLn : Compter le nombre de lignes d'un fichier ? en prenant le principe de chercher sLineBreak via SearchStringInFile (franchment j'ignore si c'est la dernière version à jour)

Je me suis fait aussi une classe TTextFileReader dans le contexte d'une lecture d'un fichier texte à multiple reprise, création d'un index des lignes pour ensuite pouvoir si balader d'avant-arrière facilement ... je précise que c'était des fichiers de plusieurs Go

[Charly910]

Merci Shai,

la lecture binaire est surement plus rapide, mais je me contente des Readln, car mes fichiers ne sont pas trop volumineux.

A+
Charly

PS : le TextFile FLNC c'était un travail pour les Corses ?

[ShaiLeTroll]

Je dirais FLnC, File Line Counter ... franchement, j'ai écrit la fonction pour le forum et je pense que cela m'a rire à l'époque ... à mon avis, on devait en parler aux infos

je te confirme, 500 lignes, c'est minuscule, j'ai des fichier INI plus grand
Si tu avais retenue le TStringList, j'aurais proposer de modifier le Capacity du TStringList à 600, ça fera gagner un poil de temps en D7 pour la réallocation du tableau d'item (string+object) car en fait avec un fichier si petit, 5Ko, si la lecture du Stream utilise une implémentation avec un buffer à 64Ko, il est lu en entier et placé dans le buffer et le buffer du fichier est donc parsé entièrement en mémoire en une seule fois, donc juste une grosse conso mémoire

tu ne verras jamais la différence car ReadLn utilise aussi un buffer de lecture (qui a changé avec l'unicode) plus petit et en fait sur un gros fichiers, en fait, ReadLn devient plus lent mais si trop gros, la TStringList ne peut plus le charger en mémoire (1Go de buffer fichier max + 1Go de String découpé à un instant T ... )
Donc en gros quand la performance entre en jeu c'est a peu près au moment où finalement, tu n'as plus de RAM donc on ne se pose plus la question ... je te dis ça à l'époque où je bossais en D7 avec un PC à 512Mo de RAM, donc utiliser une TStringList qui swappe tout le fichier, hérésie, maintenant, à l'age du 64Bits et des Go de RAM ... je te dirais tant que c'est un programme client, c'est pas trop grave.