Anzahl Zeilen in einem Textfile

[IngoD7]

Zitat:

Zitat von Jens Schumann

Da bin ich mir nicht so sicher. Ich habe es öfter mit TxT-Dateien zu tun, die zwischen 300 und 500 MB groß sind. Da nehme ich doch lieber ne normale TextFile mit Reset und Readln und so anstatt TStringList.

Gut, solche Monsterdateien habe ich nun nicht bedacht - zugegeben. Da fehlt mir auch jegliche Erfahrung. Sollten aber die Ausnahme darstellen, oder?
Obwohl :gruebel: , ab welcher Datei-Größe würdest du denn von TStringList abweichen?

[Jens Schumann]

Zitat:

Zitat von IngoD7

Zitat:

Zitat von Jens Schumann

Da bin ich mir nicht so sicher. Ich habe es öfter mit TxT-Dateien zu tun, die zwischen 300 und 500 MB groß sind. Da nehme ich doch lieber ne normale TextFile mit Reset und Readln und so anstatt TStringList.

Gut, solche Monsterdateien habe ich nun nicht bedacht - zugegeben. Da fehlt mir auch jegliche Erfahrung. Sollten aber die Ausnahme darstellen, oder?
Obwohl :gruebel: , ab welcher Datei-Größe würdest du denn von TStringList abweichen?

Weiss ich auch nicht so genau. Evt ab 3 MB

[GuenterS]

Zitat:

Zitat von Jens Schumann

Zitat:

Zitat von IngoD7

Zitat:

Zitat von TomDooley

loadFromFile erwartet einen String (FileName)... ich habe jedoch eine geöffnete Datei (Typ Text).

und ich wiederhole, dass wenn du TStringList lieben und anwenden gelernt hast, du keine Textdatei jemals wieder öffnest. :twisted:

Da bin ich mir nicht so sicher. Ich habe es öfter mit TxT-Dateien zu tun, die zwischen 300 und 500 MB groß sind. Da nehme ich doch lieber ne normale TextFile mit Reset und Readln und so anstatt TStringList.

[OT]
300 - 500 MB ... Dein Tagebuch? *fg*
[/OT]

[Hansa]

Ich habe das Thema jetzt nur überflogen, aber anfangs gings hier drum :

Zitat:

Ich möchte die Anzahl Zeilen in einem Textfile auslesen (Typ: textfile).

Delphi-Quellcode:

var d : TextFile;
    i : integer;
begin
  i := 0;
  AssignFile (d,'meintext.txt');
  reset (d);
  while not eof (d) do begin
    readln (d);
    i := i + 1;
  end;
  showmessage (IntToStr (i))+ ' Zeilen');
end.

Die paar Zeilen sind das kompette Programm !! Ohne Stringlist und sonstigen Firlefanz. Und 500 MB :shock: sind dem auch egal.

[IngoD7]

Zitat:

Zitat von Hansa

Die paar Zeilen sind das kompette Programm !! Ohne Stringlist und sonstigen Firlefanz.

Tja, und die paar Zeilen aus Gollums Posting sind noch kompakter - sogar mit, oder besser, wegen dem "Firlefanz". :roll:

[SirThornberry]

Sorry, aber irgendwie macht ihr das ganze ziemlich unperformant. Wozu immer Readln? Da wird erst geprüft wo ein Zeileumbruch ist und dann erst in den buffer eingelesen.

Ich würde die datei per TFileStream öffnen und dann in einer schleife die gesamte datei durchgehen und prüfen wann ein #13 und anschließend ein #10 kommt. Die Zeilenanzahl kann dann einfach angehängt werden in dem die datei im append-modus geöffnet wird

Natürlich auch nicht jedes zeichen einzeln lesen sondern einen ziemlich großen buffer einmal allozieiren und den buffer dann durchgehen...

[TomDooley]

Hallo

Anschliessend mal den Code, wie ich ihn jetzt verwende... Ich hoffe er ist verständlich. Funktioniert, aber ist vielleicht nicht so sauber:

Delphi-Quellcode:

OFile : Textfile;


AssignFile(OFile,FileName);
Rewrite(OFile);
TmpStr := 'abc';
WriteLn(OFile,TmpStr); //manchmal müssen hier mehrer Zeilen eingefügt werden
for Lp := 0 to StringListe.Count-1 do
  Writeln(OFile, StringListe.Strings[Lp]);
Reset(OFile);
while not Eof(OFile) do begin
  ReadLn(OFile, TmpStr);
  StringListe2.Add(TmpStr);
end;
TmpStr := 'abc'; //abc = AnzahlZeilen --> von StringListe + obigen Anz. TmpStr abhängig
StringListe2.Insert(0, TmpStr); //abc muss unbedingt am Anfang eingefügt werden
Rewrite(OFile);
for Cnt := 0 to StringListe2.Count-1 do
  Writeln(OFile, StringListe2.Strings[Cnt]);
CloseFile(OFile);

Gruss

Tom

[Hansa]

Ah ja Gollums Beitrag habe ich nicht gesehen. 8) Ich habe einige größere Textdateien, die in eine Interbase Datenbank rein müssen. Da mir für so etwas nie eine Stringlist eingefallen wäre, habe ich deshalb mal eine kleine Testreihe gemacht, die ziemlich eindeutige Ergebnisse liefert:

1. Versuch : 400 MB, mein Vorschlag : 27 sek., mit der stringlist "out of memory"

2. Versuch : 120 MB, mein Vorschlag : 12 sek., mit der stringlist 334 sek. nur lesen, das free schätze ich zusätzlich noch auf 1-2 Min. Das ging nur einmal. Beim 2. Versuch blieb Rechner sogar hängen.

3. Versuch : 20 MB 570 ms, Stringliste 2994 ms

Insofern schätze/behaupte ich mal, über 2 MB ist die Stringliste "Firlefanz". :mrgreen:

[EDIT] Was natürlich auch heißt, daß sie für kleinere Sachen schon brauchbar ist. Der Performanceverlust und Speicherbedarf ist dann wohl kaum zu bemerken.

[alcaeus]

Zitat:

Zitat von TomDooley

Funktioniert, aber ist vielleicht nicht so sauber:

Du bist gut..nicht so sauber, also das ist noch sehr milde ausgedrückt. Ich versteh nicht was das ganze herumgeschreibe mit der Datei soll. Wieso verwendest du nicht eine Stringlist, fügst am Anfang deine ABC's ein, dann ganz vorne nochmal StringList1.Count und dann schreibst du das mit SaveToFile in die (inzwischen geschlossene) Datei?

[sakura]

Hier mal die Anzahl der Zeilen aus einer Datei in einer eigenen Funktion ;)

Delphi-Quellcode:

function CountLines(aFileName: string): Integer;
const
  BUF_SIZE = 4096;
var
  Buffer: array[0..Pred(BUF_SIZE)] of Byte;
  Cnt: Integer;
  FS: TFileStream;
begin
  FS := TFileStream.Create(aFileName, fmOpenRead or fmShareDenyWrite);
  try
    Result := 0;
    repeat
      Cnt := FS.Read(Buffer[0], BUF_SIZE);
      asm
        // load data count
        mov  EAX, Cnt
        dec  EAX
        js   @@NoData // no data

        // load current line count
        mov  ECX, Result

        // loop data buffer
        @@LoopBuffer:
        // compare byte in memory
        cmp  byte ptr[Buffer + EAX], $0A
        jnz  @@CheckDataLeft // not a line break (#10)
        // increment line count
        inc  ECX

        // goto next byte
        @@CheckDataLeft:
        dec  EAX
        jns  @@LoopBuffer

        // return result
        mov  Result, ECX
        @@NoData:
      end;
    until Cnt < BUF_SIZE;
  finally
    FS.Free;
  end;
end;

Okay, ich gebe es, ich wollte mal wieder mit Assembler rumspielen :mrgreen:

...:cat:...