Unterordner und deren unterordner

[gangs-taas]

Hey,
wüsstet ihr eine möglichkeit in einem Ordner nach unterordern zu suchen und falls in diesen unterordnern auch unterorder sind diese auch ect. ?
also allgemein unterordner suchen geht ja leicht mit FindFirst ect.
aber ich bin planlos wie ich es hinbekommen kann beleibig viele ebenen zu durchsuchen ...

also er soll halt alle ebenen in diesem ordner durchsuchen bis es keine mehr gib ....

wüsstet ihr wie das möglich wäre ?

danke schonmal

[Matze]

Hallo,

dafür ist die Rekursion wie geschaffen (eine Funktion ruft sich selbst wieder auf). Schaue mal nach FindAllFiles. Intern wird wieder FindFirst/FindNext benutzt.

Grüße, Matze

[gangs-taas]

ich bin zu dämlich um zu verstehn wie das funst

[Matze]

Die Rekursion ist auch nicht ganz einfach. Wenn man sie jedoch verstanden hat, lassen sich damit viele Dinge mit sehr wenig Code lösen (Türme von Hanoi, Berechnung der Fakultät, ...). Sie kommt meist dort zum Einsatz, wo man von vornherein keine direkte Abbruchbedingung für eine Schleife angeben kann (die Anzahl der Unterordner ist vorerst unbekannt). Mit Schleifen geht es sicher auch, nur deutlich komplizierter.

Ganz grob mal wie's geht, aber um es genau zu verstehen müsstest du auch die internen Abläufe wissen. Vielleicht findest du bei Wikipedia eine entsprechende Erklärung.

Die CL-Funktionen erwarten als Parameter das Verzeichnis, in dem gesucht werden soll. Dann beginnt die Funktion per FindFirst/FindNext nach einem Unterordner zu suchen. Wurde einer gefunden, ruft sich die Funktion selbst wieder auf mit dem Unterordner als Parameter. Für den neuen Funktionsaufruf ist das aktuelle Verzeichnis somit der Unterordner. Dann wird darin nach dem "Unter-Unterordner" gesucht etc. pp.

Jedes Mal, wenn sich die Funktion selbst wieder aufruft, wird die Funktion ihren weiteren Ablauf unterbrechen. Das was nach dem rekursiven Aufruf an Code folgt, muss jedoch irgendwann auch abgearbeitet werden und das erfolgt nach allen rekursiven Aufrufen (letzter Unterordner) rückwärts, da das ganze so auf dem Stack abgelegt ist (First in, Last out, wenn man so will).
Naja es ist kompliziert und das eben so zu erklären kann ich nicht wirklich. Ich hoffe in der Beschreibung keinen Fehler gemacht zu haben (es ist schon spät).
Da solltest du dich ggf. mit anderen Quellen näher beschäftigen, um das wirklich zu verstehen.

Grüße, Matze

[himitsu]

Matze meinte ja ich solle mein "Wissen" teilen

ohne Recursion würde es z.B. auch so gehn

- ein Verzeichnis kann maximal MAX_PATH lang sein
(inklusive abschließender PChar-#0 und der Laufwerkskennung)
- macht also 255 Zeichen für den Pfad
- ein Pfad kann mindestens 1 Zeichen lang sein
- macht sozusagen 255/2 = maximal 127 Verzeichnisebenen

bedeutet du müßtest 127 Leseschleifen verschachteln

Hier mal der gekürzte Code ... für die ersten 3 und die letzte Schleife
(die restlichen 123 Schleifen müßte man also NUR noch einfügen und durchnummerieren)

Delphi-Quellcode:

Procedure FindAllFilesWithoutRekursion(Dir: String; SL: TStrings);
  Var R1, R2, R3, R4, R5 ... R127: TSearchRec;
    D2, D3, D4, D5 ... D127: String;

  Begin
    Dir := IncludeTrailingPathDelimiter(Dir);
    If FindFirst(Dir + '*.*', R1) = 0 Then Begin
      Repeat
        If (R1.Name = '.') or (R1.Name = '..') Then Continue;
        If R1.Attr and faDirectory <> 0 Then Begin

          D2 := Dir + R1.Name + '\';
          If FindFirst(D2 + '*.*', R2) = 0 Then Begin
            Repeat
              If (R2.Name = '.') or (R2.Name = '..') Then Continue;
              If R2.Attr and faDirectory <> 0 Then Begin

                D3 := D2 + R2.Name + '\';
                If FindFirst(D3 + '*.*', R3) = 0 Then Begin
                  Repeat
                    If (R3.Name = '.') or (R3.Name = '..') Then Continue;
                    If R3.Attr and faDirectory <> 0 Then Begin

                      ...

                      D127 := D126 + R126.Name + '\';
                      If FindFirst(D127 + '*.*', R127) = 0 Then Begin
                        Repeat
                          If (R127.Name = '.') or (R127.Name = '..') Then Continue;
                          If R127.Attr and faDirectory <> 0 Then
                            Raise Exception.Create('zuviele Verzeichnisse gefunden');
                          Else SL.Add(D127 + R127.Name);
                        Until FindNext(R127) <> 0;
                        FindClose(R127);
                      End;

                      ...

                    End Else SL.Add(D3 + R3.Name);
                  Until FindNext(R3) <> 0;
                  FindClose(R3);
                End;

              End Else SL.Add(D2 + R2.Name);
            Until FindNext(R2) <> 0;
            FindClose(R2);
          End;

        End Else SL.Add(Dir + R1.Name);
      Until FindNext(R1) <> 0;
      FindClose(R1);
    End;
  End;

also ganz im Ernst ... lerne lieber das mit der Rekursion


PS: wenn man sich den Code so ansieht, dann kann man das ganze auch ganz schön via Interation lösen

[waub]

Möglicherweise ist der folgende Beitrag hilfreich:
Rekursive Suche

[Lannes]

Hallo,

Zitat von himitsu:

...
PS: wenn man sich den Code so ansieht, dann kann man das ganze auch ganz schön via Interation lösen

ja, und das mit nur einer Schleife die solange läuft bis in der Ordner-Sammel-Stringliste das Ende erreicht ist.
Hab das mal ausgetestet, ist auch nur geringfügig langsamer als die rekursive Lösung.

[gangs-taas]

Zitat von Matze:

Die Rekursion ist auch nicht ganz einfach. Wenn man sie jedoch verstanden hat, lassen sich damit viele Dinge mit sehr wenig Code lösen (Türme von Hanoi, Berechnung der Fakultät, ...). Sie kommt meist dort zum Einsatz, wo man von vornherein keine direkte Abbruchbedingung für eine Schleife angeben kann (die Anzahl der Unterordner ist vorerst unbekannt). Mit Schleifen geht es sicher auch, nur deutlich komplizierter.

Ganz grob mal wie's geht, aber um es genau zu verstehen müsstest du auch die internen Abläufe wissen. Vielleicht findest du bei Wikipedia eine entsprechende Erklärung.

Die CL-Funktionen erwarten als Parameter das Verzeichnis, in dem gesucht werden soll. Dann beginnt die Funktion per FindFirst/FindNext nach einem Unterordner zu suchen. Wurde einer gefunden, ruft sich die Funktion selbst wieder auf mit dem Unterordner als Parameter. Für den neuen Funktionsaufruf ist das aktuelle Verzeichnis somit der Unterordner. Dann wird darin nach dem "Unter-Unterordner" gesucht etc. pp.

Jedes Mal, wenn sich die Funktion selbst wieder aufruft, wird die Funktion ihren weiteren Ablauf unterbrechen. Das was nach dem rekursiven Aufruf an Code folgt, muss jedoch irgendwann auch abgearbeitet werden und das erfolgt nach allen rekursiven Aufrufen (letzter Unterordner) rückwärts, da das ganze so auf dem Stack abgelegt ist (First in, Last out, wenn man so will).
Naja es ist kompliziert und das eben so zu erklären kann ich nicht wirklich. Ich hoffe in der Beschreibung keinen Fehler gemacht zu haben (es ist schon spät).
Da solltest du dich ggf. mit anderen Quellen näher beschäftigen, um das wirklich zu verstehen.

Grüße, Matze

vielen dank erst einmal dafür hat mir echt geholfen das system zu verstehen
ich hab noch eine frage dazu
wenn du z.b. die Fakulät mit einer Reursion lösen möchte...
woher weiß das programm denn dann wann es aufhören muss sich selbst aufzurufen ?

[Matze]

Du musst eine entsprechende Abbruchbedingung definieren:

Delphi-Quellcode:

function fak_rek(n: Integer): Integer;
begin
  if n <= 1 then // Abbruchbedingung
    Result := 1
  else
    Result := n * fak_rek(n-1);
end;

[gangs-taas]

hm.. okay
jetzt muss ich nur noch versuchen, dass auf mein problem zu übertragen
das hier :

Zitat von waub:

Möglicherweise ist der folgende Beitrag hilfreich:
Rekursive Suche

hab ich mir zwar angeguckt ich will das aber eigl. nicht einfach übernehmen, sondern es so nachvollziehen, das ich das auch ohne copy&past schreiben kann

danke für eure hilfe !!