Autor Beitrag
DelphiNoobCoder
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 98

Win XP SP1

BeitragVerfasst: So 03.12.06 01:43 
Hi wollt fragen ob es geht das man immer eine bestimmte Zeile einer TXT datei + nimmt?
z.B.:
(hp 15)
man gibt ins Edit 5 ein und dan kommt
(hp 20)
bloß das es die ganze txt datei durchsuchen soll nach (hp xx) und dan + die Zahl.

MFG Maddin
Horst_H
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 1654
Erhaltene Danke: 244

WIN10,PuppyLinux
FreePascal,Lazarus
BeitragVerfasst: So 03.12.06 08:15 
Hallo,

falls es keine sehr grosse datei ist, kann man die Datei als Tstringlist einlesen.
Die Zeilen sind dann direkt als Index von 0 bis count-1 abrufbar.
Dann braucht man nur einen Speicher für die aktuelle zeile und mit diesem rechnen (aktZeile := aktzeile+StrToInt(Edit?.text)), wobei man beachten muss, nicht kleiner 0 und größer,gleich Stringlist.Count zu werden.

Gruss Horst
DelphiNoobCoder Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 98

Win XP SP1

BeitragVerfasst: So 03.12.06 11:31 
Naja die Datei is sehr groß und Durcheinander.
Darum kann es mal da und mal da stehen.
Horst_H
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 1654
Erhaltene Danke: 244

WIN10,PuppyLinux
FreePascal,Lazarus
BeitragVerfasst: So 03.12.06 11:41 
Hallo,

wieviele Megabyte sind es denn. Ich würde es ersteinmal testen.
Wenn Du einen FileStream benutzt, ist der Speicher für das File auch von Windows in Cache benutzt, da spart man nichts.

Gruss Horst
Grenzgaenger
Ehemaliges Mitglied
Erhaltene Danke: 1



BeitragVerfasst: So 03.12.06 11:49 
@DelphiNoobCoder: hat dir datei eine bestimmte strukur (z.b. file of ...)? falls ja, kannst du ja den index berechnen und wahlfrei drauf zugreifen.

andernfalls (neben den tip von horst), würd ich mir überlegen

a) die datei in eine bestimmte struktur zu bringen
b) sie zu sortieren
c) sie in deine datenbank zu bringen (indexiert)

damit du auf einzelne bereiche zugreifen kannst.
Horst_H
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 1654
Erhaltene Danke: 244

WIN10,PuppyLinux
FreePascal,Lazarus
BeitragVerfasst: So 03.12.06 12:07 
Hallo,

Heiko hatte doch mal einen Thread mit Zeilenumbruch suchen.
www.delphi-forum.de/viewtopic.php?t=48737
Also ersteinmal die komplette Datei als stream einlesen (geht ja auch blockweise) und die Position der Zeilenumbrüche einfach in einem dynamischen array merken.
Dann hast Du alles beisammen, um in einem Filestream zu suchen.

Gruss Horst
In Turbopascal hatte ich doch mal etwas aehnliches (aber nur gezählt)
ausblenden volle Höhe Delphi-Quelltext
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:
program Suchtext;
uses dos,crt;
const
   num=100;
   Fname = 'C:\Such.txt';
   Gname = 'C:\Test.txt';
   BufSize = 4096;
   Textlaenge = 255;
type
   tBuffer         = array [  0..BufSize-1] of char;
   tBufferKomplett = array [-Textlaenge..BufSize-1] of char;
   tSuchfile = file;
var
   T1,T0 :longint;
   i,j,k,
   Anzahl,
   leng      : Longint;
   MaxPos,
   Pos_Alt,
   Position,
   DateiPosition  : integer;
   Gelesen   : word;

   stri      : string;
   Buffer    : tBufferkomplett;
   MaxBufp,
   Bufp      : ^char;
   g : tSuchfile;
   f : text;
   ErstesZeichen : char;
   found     : boolean;

   function Zeit:longint;
   var
      std,min,sek,sek100:word;
   begin
      gettime(std,min,sek,sek100);
      Zeit := 360000*Std+6000*min+100*sek+sek100;
   end;

{variablen}
BEGIN
{strings in datei}
{Erzeuge TextText}
{
assign(f,GName);
rewrite(F);
for i := 0 to 199999 do
   write(F,i:8);
close (F);
}

{Erzeuge SuchText}
assign(f,FName);

rewrite(f);
writeln(f,'111');
writeln(f,'10101');
writeln(f,'99999');
writeln(f,'TAG');
close(f);

reset(f);

assign(g,GName);

clrscr;
for k:=1 to num do {jeder string}
begin
   If NOT(EOF(F)) then
   begin
      readln(f,stri);
      leng := length(stri);
      ErstesZeichen := Stri[1];
      window(1,1,20,3);
      clrscr;
      writeln('Suche nach: ',Stri,' ',ErstesZeichen);
      {Date wieder an die Startposition}
      reset(g,1);
      DateiPosition := 1;
      Anzahl := 0;
      T0 := Zeit;
      j := 0;
      Pos_Alt := 0;
      window(1,5,21,5+11);
      clrscr;
      repeat
         BlockRead(g,Buffer[0],BufSize,Gelesen);
         Position := Pos_Alt;
         MaxPos := Gelesen-leng;
         MaxBufp := ADDR(Buffer[MaxPos]);
         while Position <= MaxPos do
         begin
            Bufp := ADDR(Buffer[Position]);
            while Bufp<MaxBufp do
            begin
                If Bufp^ = ErstesZeichen then
                   break;
                inc(Bufp);
                Inc(Position);
            end;
            i := 0;
            repeat
               inc(i);
               found := (Bufp^ = Stri[i]);
               inc(Bufp);
               inc(Position);
            until not(found) or (i = leng);
            Position := Position-i+1;
            if found then
            begin
               inc(Anzahl);
               {Ausgabe der Position 
               write(DateiPosition+Position:8,' ');
               bufp := bufp-leng;
               for i := 1 to leng do
               begin
                  write(Bufp^);
                  inc(bufp)
               end;
               writeln;
               }

            end;
         end;
         inc(DateiPosition,Gelesen);
         Pos_Alt := Position-Gelesen;
         if Pos_Alt <>0 then
            move(Buffer[BufSize-Leng+1],Buffer[-Leng+1],Leng-1);
      until gelesen <> BufSize;
      T1 := Zeit;
      Writeln(Anzahl,' "',stri,'" in ');
      writeln((T1-T0)/100:0:2,' s gefunden!');
      repeat until keypressed;readkey;
   end;
end;
   writeln('-------ENDE-------');
   readkey;
end.
Horst_H
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 1654
Erhaltene Danke: 244

WIN10,PuppyLinux
FreePascal,Lazarus
BeitragVerfasst: Mo 04.12.06 21:50 
Hallo,

mal etwas umgestrickt für delphi(oder freepascal) :
ausblenden volle Höhe Delphi-Quelltext
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:
program Suchtext;

{$Apptype console}
uses
  sysutils,classes;

const
   CRLF= #13#10;
   Gname = 'C:\test.txt';
   BufSize =4096;
   Textlaenge = 255;
type
   tBuffer         = array [  0..BufSize-1] of char;
   tBufferKomplett = array [-Textlaenge..BufSize-1] of char;
var
   T1,T0 :TDateTime;
   i,j,k,
   Zeile,
   Anzahl,
   leng,
   len      : Longint;
   MaxPos,
   Pos_Alt,
   Position,
   DateiPosition  : longint;
   Gelesen   : longint;

   stri      : string;
   Buffer    : tBufferkomplett;
   MaxBufp,
   Bufp      : ^char;
   g : tFileStream;
   ErstesZeichen : char;
   found     : boolean;
   StartPositionen : array of cardinal;

{variablen}
BEGIN
randomize;
If Not(FileExists(GNAme)) then
  begin
  //Simulation eines writeln
  g := TfileStream.create(GName,fmCreate);
  For I := 0 to 999999 do
    begin
    stri := Format('%8d'+CRLF,[i]);
    gelesen :=g.write(stri[1],length(stri));
    end;
  g.free;
  end;

g := TfileStream.create(GName,fmOpenRead);

stri :=CRLF;//stri ist Zeilenende CR LF
ErstesZeichen := stri[1];
leng := length(stri);
DateiPosition := 1;
Anzahl := 0;
T0 := time;
j := 0;
Pos_Alt := 0;
setlength(StartPositionen,10);
StartPositionen[0] :=0;
repeat
  gelesen := g.read(Buffer[0],BufSize);
  Position := Pos_Alt;
  MaxPos := Gelesen-leng;
  MaxBufp := ADDR(Buffer[MaxPos]);
  while Position <= MaxPos do
    begin
    Bufp := ADDR(Buffer[Position]);
    while Position <= MaxPos do
      begin
      If Bufp^ = ErstesZeichen then
        break;
      inc(Bufp);
      Inc(Position);
      end;
    i := 0;
    repeat
      inc(i);
      found := (Bufp^ = Stri[i]);
      inc(Bufp);
      inc(Position);
    until not(found) or (i = leng);
    Position := Position-i+1;
    if found then
      begin
      inc(Anzahl);
      StartPositionen[Anzahl] := DateiPosition+Position;
      if Anzahl >= High(StartPositionen) then
        setlength(StartPositionen,Anzahl*4 div 3);
      end;
    end;
    inc(DateiPosition,Gelesen);;
    Pos_Alt := Position-Gelesen;
    if Pos_Alt <>0 then
      move(Buffer[BufSize-Leng+1],Buffer[-Leng+1],Leng-1);
until gelesen <> BufSize;

T1 := time;
Writeln(Anzahl,' "',stri,'" in ');
writeln(Formatdatetime('hh:mm:ss.zzz',(T1-T0)),' s gefunden!');

//Zufällige Zeilen in String kopieren und anzeigen
For i := 0 to 25 do
  begin
  Zeile := random(Anzahl);
  g.position := StartPositionen[Zeile];
  len :=StartPositionen[Zeile+1]-StartPositionen[Zeile]-leng;
  setlength(stri,len);
  gelesen := g.read(stri[1],len);
  writeln(i:8,Zeile:8,' ',stri);
  end;
g.free;
   writeln('-------ENDE-------');
   readln;

end.


Je nach Zufallszeilen dauert es 0,09 bis 0,15 Sekunden für die Ausgabe dieser Zeilen.
Jetzt braucht man also nur sich die aktuelle Zeile merken und den Wert von Edit darauf addieren(+ -) und dabei die Grenzen beachten von 0 bis Anzahl.

Gruss Horst
P.S. Vielleicht sollte man eine Klasse hierfür erstellen in der Anzahl,Datei und Startpositionen zentral verwaltet werden.