recursive Dateisuche -> Algorythmusfragen

[richard_boderich]

hallo leute!

ich hab mir im netz ein bisschen code besorgt und etwas angepasst. habe mir auch die snipsel von lucky
in der codelib angeschaut, komme aber einfach nich hinter die logik des Algorythmus. hoffe ihr koennt mir da helfen.
hier ist erstmal der code. Aenderungen sind mit sternchen gekennzeichnet. paar kleine Fragen zum code sind kommentiert
try und finally bloecke hab ich eingefügt -> nach luckys beispiel code, ist sicherer falls exeption denk ich :).

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ComCtrls;

type
  TForm1 = class(TForm)
    Label1: TLabel;
    Button1: TButton;
    ListBox1: TListBox;
    procedure Button1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    procedure GetFilesInDirectory(ADirectory: string; AMask: String; AList: TStrings; ARekursiv: Boolean);
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;
  filecount,dircount,x,y:integer;
  start:string[255];
  sr:tsearchrec;
implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
GetFilesInDirectory('C:\test\','*.*',Listbox1.Items,true);
end;

//------------------------------------------------------------------------------------------

procedure Tform1.GetFilesInDirectory(ADirectory: string; AMask: String; AList: TStrings; ARekursiv: Boolean);
var
  SR: TSearchRec;
begin
  if (ADirectory<>'') and (ADirectory[length(ADirectory)]<>'\') then
    ADirectory:=ADirectory+'\';


  if (FindFirst(ADirectory+AMask,faAnyFile-faDirectory,SR)=0) then
    try                                                            // ** eingefügt
    repeat
      if (SR.Name<>'.') and (SR.Name<>'..') and (SR.Attr<>faDirectory) then
          label1.caption:= ADirectory+SR.Name;                     // warum kein begin
          AList.Add(ADirectory+SR.Name)                            // end block und kein abschlusssemikolon???
    until FindNext(SR)<>0;
    finally                                                        //** eingefügt
    FindClose(SR);
  end;                                                             //ist das end ohne begin überfluessig, wo ist der bezug? 


  if ARekursiv then
    if (FindFirst(ADirectory+'*.*',faDirectory,SR)=0) then
      try                                                         //** eingefügt
      repeat
        if (SR.Name<>'.') and (SR.Name<>'..') then
          GetFilesInDirectory(ADirectory+SR.Name,AMask,AList,True);
      until FindNext(SR)<>0;
      finally                                                     //** eingefügt
      FindClose(SR);
    end;                                                          //ist das end ohne begin überfluessig, wo ist der bezug? 
end;


//---------- ab hier is bloedsinn--------------------------------------------------

procedure TForm1.FormCreate(Sender: TObject);
begin
    start:='C:\';
    dircount:=0;
    filecount:=0;
    x:=20;
    y:=20;
end;

end.

so jetz zu meiner frage. ich versteh den algorythmus an dieser stelle nicht

Delphi-Quellcode:

c:\
   test1 ---------------------------------------------------- bla
   test2 ------------------------------ tester              - muell.txt
   test3 ---- hastenichgesehn         - hallo               - bla2.hastenichgesehn
            - test4                   - kacke

-> suche in c:\
-> finde directory test1
-> recursiver aufruf

-> suche in c:\test1
-> finde directory bla
-> recursiver aufruf

-> suche in c:\test1\bla
-> keine directorys!
-> liste enthaltene dateien
-> muell.txt, bla2.hastenichgesehn
-> setzte rootpfad zurüeck auf 'c:\' //denkfehler hier :wall:
-> recursiver aufruf

soweit alles klar!
aber wenn ich jetz recursiv aufrufe sucht er wieder in 'c:\' und findet er zuerst ja wieder den selben directory zweig (nahmlich test,
und ich hab ne tolle endlosschleife)

meine problem ist, das ja die direinträge immer in der selben reihenfolge kommen, und ich nicht weis wie ich nach test2 sozusagen weiterschalte

das problem tritt ueberall auf, wo sich mehr als 1 unterverzeichnis im aktuellen zweig befindet

der obige code funktioniert jedoch, aber ich uebersehe etwas und finde nich die stelle die auf den zweig "test2" umschaltet

ich hatte vor ewigen zeiten das gleiche prob mit turbopascal, dort hab ich es super umständlich geloest, über dyn array's und verzeichnisebenen speicherung
waere nett wenn mich jemand leutern koennte :)


bis denne!

[der-C]

Delphi-Quellcode:

try
...
Anweisung
...
finally
...
Anweisung
...
end;

das end; gehört zu try-finally

Zitat:

block und kein abschlusssemikolon???

bei der letzten Anweisung in einem Block braucht man glaub ich keine Semikolon.

Zitat:

Delphi-Quellcode:

if (SR.Name<>'.') and (SR.Name<>'..') then
          GetFilesInDirectory(ADirectory+SR.Name,AMask,AList,True);

hier ruft sich die function selbst auf aber mit einem neuen (unter)Directory (ADirectory+SR.Name)

Delphi-Quellcode:

until FindNext(SR)<>0;

nachdem er wieder zurückkommt wird mit FindNext der nächste ordner ausgewählt

[Wuaegner]

HI!

Zu der wiederholten Frage:

Code:

    FindClose(SR); 
  end;                                                             //ist das end ohne begin überfluessig, wo ist der bezug? 


  if ARekursiv then 
    if (FindFirst(ADirectory+'*.*',faDirectory,SR)=0) then 
      try                                                         //** eingefügt 
      repeat 
        if (SR.Name<>'.') and (SR.Name<>'..') then 
          GetFilesInDirectory(ADirectory+SR.Name,AMask,AList,True); 
      until FindNext(SR)<>0; 
      finally                                                     //** eingefügt 
      FindClose(SR); 
    end;                                                          //ist das end ohne begin überfluessig, wo ist der bezug?

bringt die Hilfe das hier:

Code:

Reset(F);

try
 ...  // process file F
finally
  CloseFile(F);
end;

Zitat:

The syntax of a try...finally statement is

try statementList1 finally statementList2 end

Grüße Flo

[richard_boderich]

ja, ok aber das mit dem algorythmus schnall ich net. was heist ueberhaupt "wenn er zurueckkommt"

dafür muesste er die directorystrucktur doch komplett irgenwo in ein array speichern oder

so etwa in der art

lies c:\

speichere dirs -> array

array index[1]:=dir1
index[2]:=dir2
index[3]:=dir3


if no more dirs then
inc(arrayindex);

recursiver aufruf, und das für jede verzeichnisebene oder ??

[Steve]

Hi,

Mal ausgehend von der Verzeichnisstruktur

Code:

a
|
|_b
| |
| |_ba
| |
| |_bb
|
|_c
|_.....

wird der Code folgendermaßen arbeiten:
1. Suche alle Dateien in a (FindFirst)
2. Liste alle Files in a nacheinander auf (repeat until FindNext)
3. Falls rekursiv, suche alle Verzeichnisse in a (FindFirst im unteren Abschnitt)
4. Rufe sich selbst für jedes einzelne gefundene Verzeichnis in a nacheinander auf (repeat until FindNext im unteren Abschnitt), d.h. er findet b und sucht nun in b, bis er keine Verz. mehr in b findet, dann arbeitet er in der repeat-Schleife des Codes, der in a sucht, weiter ab (unterer Abschnitt) und findet c ....

das heißt, es wird nix auf 'C:\' "zurückgesetzt" oder so, sondern er arbeitet den Code nach dem rekursiven Aufruf weiter ab (nächster Schritt der repeat-Schleife)

Ich hoffe das war halbwegs verständlich erklärt :)

Gruß
Stephan :dance:

[richard_boderich]

ja,schon, aber wo merkt er sich den status bzw den fortschritt der suche in verzeichnis a, wenn eien anderes findfirst in verzeichnis b sucht???
is dat irgentwie intern geregelt und ich brauch mich da gar nich drum kümmern ??

[Steve]

Das wird in der aufrufenden Routine "gespeichert". Die Routine wird ja nicht einfach nochmal von vorne angefangen, sondern (soz. als "eigenständige Routine" neu aufgerufen).

Gruß
Stephan :dance:

[der-C]

angenommen verzeichnissstrucktur
c:\
c:\unterverz

er sucht also in C:\ findet "unterverz" und geht mit

Delphi-Quellcode:

GetFilesInDirectory(ADirectory+SR.Name,AMask,AList,True);

in die nächste ebene(c:\unterverz), dort gibt es keine unterverzeichnisse meher --> er läuft bis zum ende der funktion und kehrt an die stelle zurück von der er aufgerufen wurde(also eine ebene höher C:\),
also 1 Zeile unterhalb von

Delphi-Quellcode:

GetFilesInDirectory(ADirectory+SR.Name,AMask,AList,True);

da ist nun

Delphi-Quellcode:

      until FindNext(SR)<>0;

--> er sucht nach dem nächsten Verzeichniss in C:\

[richard_boderich]

ok danke jetz hab ichs kapiert, so wie eine geschachtelte for next schleife ja ???

[der-C]

GENAU :thumb: