rekursionstiefe erkennen bei ordnern

[blinder007]

hallo liebe foren-mitglieder,
also, ich schreibe zzt. ein Programm um meine Musiksammlung nicht per hand in eine datenbank eingliedern zu müssen. die ordner sind in genre, künstler, album aufgeteilt. mit der findfirst methode und diesen dingen schaffe ich es eine liste aller Ordner zu erhalten und sie auszugeben. Sprich: ich habe (in dem fall) eine Textdatei oder halt eine tstringlist, in der untereinander weg erst genre, dan künstler und dann album stehen. für einen uneingeweiten ist das natürlich unübersichtlich. deswegen würde ich gerne vor die einträge schreiben etwas wie "künstler:" und "album". sozusagen unterüberschriften einfügen. die ausgabe soll im enteffekt auch dazu genutzt werden außenstehenden einen Überblick über meine Sammlung zu geben.
mein ansatz war zu erkennen, auf welcher rekursionstiefe die funktion ist, um ein entsprechendes präfix zu setzen. das funktioniert leider nicht so ganz. hier mein code der besagten methode:

Delphi-Quellcode:

procedure tform1.FindAllFiles(var FileList: TStrings; RootFolder: string; Mask: string ='*.*'; Recurse: Boolean = True);
procedure schreibename(name: string);
begin
if not (name[1] = '.') then liste.Add(name);
end;
var
SR: TSearchRec;
begin
RootFolder := IncludeTrailingPathDelimiter(RootFolder);
if Recurse then
        if FindFirst(RootFolder + '*.*', faAnyFile, SR) = 0 then
        try
        repeat
        if SR.Attr and faDirectory = faDirectory then begin
                if (sr.name <> '.') and (SR.Name <> '..') then
         FindAllFiles(FileList, RootFolder + SR.Name, Mask, Recurse);
         //schreibename(sr.name);
         end;
        until FindNext(SR) <> 0;
        finally
        FindClose(SR);
end;

 if FindFirst(RootFolder + Mask, faAnyFile, SR) = 0 then
  try
   repeat
     if SR.Attr and faDirectory <> faDirectory then
     begin
      //FileList.Add(RootFolder + SR.Name);
       end;
      until FindNext(SR) <> 0;
     finally
   FindClose(SR);
  end;
 end;

[TiGü]

Zitat:

Zitat von blinder007 (Beitrag 1273175)

das funktioniert leider nicht so ganz.

Was genau funktioniert denn nicht?

[himitsu]

Delphi-Quellcode:

...; Recurse: Boolean = True; Recursionstiefe: Integer=0);

und dann beim Aufruf der Recursion dort Recursionstiefe+1 übergeben? :stupid:

Zitat:

das funktioniert leider nicht so ganz. hier mein code der besagten methode:

Nicht ganz?

Es geht garnicht, denn entgegen deiner Beschreibung ist da doch garnichts an Code drin enthalten, was dafür zuständig sein könnte.
Dein nicht vorhandener Versuch funktioniert also ohne Probleme. (es ist nichts drin, was nicht funktioniert und somit funktioniert alles, wie es soll :roll:)

Zitat:

Delphi-Quellcode:

if not (name[1] = '.') then liste.Add(name);

Falsch, denn um dich einfach mal nach Linux, oder besser in einen Apache gucken zu lassen ... du kennst nicht zufällig Dateien wie .htaccess, oder wie wäre es mit den .git- und .svn-Verzeichnissen?
Auch wenn der Explorer sich weigert solche Dateinamen händisch anlegen zu lassen. Das Dateisystem erlaubt es und viele Programme machen es auch.

Delphi-Quellcode:

if (Name <> '.') and (Name <> '..') then

oder

Delphi-Quellcode:

if MatchStr(Name, ['.', '..']) then

wäre möglich.
Rein theoretisch wäre es möglich im Dateisystem eine Datei "ohne" Namen zu haben, womit dann ein Zugriff ala

Delphi-Quellcode:

Name[1]

knallen würde, da es kein erstes Zeichen gibt, aber zum Glück für dich ist das nahezu ausgeschlossen.
Oder wolltest du damit Verzeichnisse mit solchen Namen ausblenden?

[blinder007]

ich habe versucht einen integer in die procedure einzubauen, der die recursionstiefe mitzählt. aber im enteffekt hatte ich immer nur den schleifendurchlauf, aber nie die rekursionstiefe

[Faxe]

Zitat:

Zitat von blinder007 (Beitrag 1273175)

if SR.Attr and faDirectory <> faDirectory then

Was bringt eigentlich hierbei die 2. Bedingung?

[pelzig]

Eine Procedure (tform1.FindAllFiles) rekursiv aufrufen?

himitsu, bitte übernehmen Sie :wink:

MfG

[Mikkey]

Mal abgesehen vom Lerneffekt...

Mit dem Kommandozeilenbefehl

Code:

DIR {Verzeichnis} /S /B

erhältst Du eine wunderschöne Liste aller Dateien im angegebenen Verzeichnis und südlich davon.

Das ließe sich per Programm auch gut auseinandernehmen...

[himitsu]

Zitat:

Zitat von Mikkey (Beitrag 1273203)

Mal abgesehen vom Lerneffekt...

Seit paar Jahren gibt es auch die Unit IOUtils, worin sich z.B. ein TDirectory.GetFiles versteckt.

Zitat:

ich habe versucht einen integer in die procedure einzubauen, der die recursionstiefe mitzählt. aber im enteffekt hatte ich immer nur den schleifendurchlauf, aber nie die rekursionstiefe

Eine lokale Variable in der Funktion kann natürlich nur Dinge darin zählen, aber nichts Prozedurübergreifendes.
Dafür braucht man entweder eine böse globale Variable, was wir natürlich nicht verwenden
oder man muß die Variable an die anderen Prozeduren übergeben. (als VAR kann man die Verzeichnisanzahl zählen und als normaler Parameter die Tiefe, da sich Änderungen immer nur nach unten auswirken und nicht zurück)

[pelzig]

Müsste man beim rekursiven Procedure-Aufruf nicht irgendwo trotzdem noch global den Anfangswert der Rekursionstiefe setzen :?:

MfG

[Faxe]

Man könnte auch bei jedem gefundenen Ordner im Namen mal die PathDelimiter zählen und das als jeweilige Tiefe ansehen.

[sx2008]

Auf Github habe ich eine FileScanner Klasse, die für jede gefundene Datei (und jedes Verzeichnis) ein Event feuert.
https://github.com/sx2008/Delphi-Tes...er/FileScanner
Über das Event bekommt man nicht nur den Dateinamen sondern auch Pfad, Dateigröße, Datum und die Verzeichnistiefe mitgeteilt.
Mit einer kleinen Änderung könnte man sogar die Suchtiefe auf einen bestimmten Wert begrenzen.

[nuclearping]

Wenn du es in deiner eigenen Funktion lösen willst, dann brauchst du (wie schon gesagt wurde) entweder eine globale Variable (:shock:) oder du musst die Tiefe in deiner Prozedur "mitschleifen".

Delphi-Quellcode:

procedure tform1.FindAllFiles(var FileList: TStrings; RootFolder: string; RecurseLevel: Integer = 0; Mask: string ='*.*'; Recurse: Boolean = True);
begin
  //...
  if RecurseLevel = 0 then
    ShowMessage('Root')
  else
    ShowMessage(Format('%d. Ebene', [RecurseLevel + 1]);
  r := FindFirst(...);  
  while r = 0 do
    begin
      if (SR.Attr and faDirectory = faDirectory) and (sr.name[1] <> '.') then
        FindAllFiles(..., ..., RecurseLevel + 1, ...)
      else ...
    end;
end;

[himitsu]

Zitat:

Zitat von pelzig (Beitrag 1273208)

Müsste man beim rekursiven Procedure-Aufruf nicht irgendwo trotzdem noch global den Anfangswert der Rekursionstiefe setzen :?:

Zitat:

Zitat von nuclearping (Beitrag 1273214)

oder du musst die Tiefe in deiner Prozedur "mitschleifen".

siehe #3 :angel:

Entweder manuell beim ersten/äußeren Aufruf die 0 (Startwert) übergeben, oder das als Defaultwert automatisch machen lassen.

[pelzig]

Also Alles was Recht ist, Herr nuclearping:

So einfach ein "ShowMessage()" innen Süßkot reinschreiben kann doch jeder :-(

Hier HEFTIGER angesagt ist das Parsen aller Map-Dateien, die über streng geheime Compileroptionen in der DPR-Datei mit ifDef und abwegigen *.inc-Dateipfaden...

[Srg+O+O] geht wohl nicht mehr nach neuer als Delph7personal?

Man man man! Deutsch, nicht män män män!

Die Problemlösung für den TE dürfte recht einfach sein, da fast Jeder schon mal rekursiv Ordner nach Dateien durchsucht hat.

Aber eine Copy&Paste-Lösung hier für den TE reinstellen möchte ich
(oder himitsu?/nuclearping?) nicht! Die kann der TE sich ergoogeln!

MfG

[himitsu]

Reicht es nicht, wenn die schon zwei Mal gepostet und mindestens 5 Mal erwähnt wurde?

[pelzig]

Manchmal bekommt man erfrischend neue Sachen von der DP mit, wenn man seinen Cache löscht...

MfG

[Luckie]

Darf ich auch noch mal? :cyclops:

Also entweder in einer Globalen Variable mitzählen. Kann man auch schön in eine Klasse kapseln und/oder einen Event bei jedem Aufruf auslösen und von außen mitzählen. Das kann man auch schön in eine Klasse kapseln.