Einige nützliche Dateifunktionen

[Mattin]

Hallo Zusammen,

hier ein paar nützliche Funktionen zu Dateien und Pfade von mir.

************************************************** ******************************
* Überprüft ob ein "\" am Ende des Pfades ist.
* function UeberpruefeSlash(const Pfad : String): String;
* Wenn nicht wird "\" darangehängt.
************************************************** ******************************
* Liefert den Filenamen aus einen einen String zurueck
* function GetFileName(const FileName :String):String;
* Bsp : GetFileName('C:\WINDOWS\SYSTEM\README.TXT') --> 'README.TXT'
************************************************** *****************************
* Liefert den Pfad einer Datei zurueck
* function GetDirName(const FileName: String):String;
* Bsp : GetDirName('C:\WINDOWS\SYSTEM\README.TXT') --> 'C:\WINDOWS\SYSTEM\'
************************************************** *****************************
* Liefert den Extender eines Dateinamens in Kleinbuchstaben zurück
* function GetExtender(const FileName: String) :String;
* Bsp_: GetExtender('Readme.TxT') --> 'txt'
************************************************** *****************************
* Holt den Dateinamen ohne Extender
* function GetName(const FileName: String) :String;
* Bsp.: GetName(Notepad.Exe) --> 'Notepad'
************************************************** ******************************
* Liefert den letzten Ordner aus einem Pfad zurück
* function GetLastDirName(const FileName: String):String;
* Bsp : GetLastDirName('C:\Programme\MeinProgramm') --> 'MeinProgramm'
************************************************** *****************************

Delphi-Quellcode:

function UeberpruefeSlash(const Pfad : String): String;
begin
 Result := Pfad;
 if (Length(Pfad) > 0) AND (Pfad[Length(Pfad)] <> '\') then Result := Result + '\';
end;

function GetFileName(const FileName: String):String;
var
  i:     Integer;   //Zaehlvariable
  S:     Integer;   //Slashposition im Filename

Begin
  S := 0;
  For i:= Length(FileName) downto 0 do
  Begin
    IF S = 0 then
    Begin
      If FileName[I] = '\' then S := I;
      result := copy(FileName, S+1, Length(Filename)-S+1);
    End;
  End;
End;

function GetDirName(const FileName: String):String;
var
  i:     Integer;   //Zaehlvariable
  S:     Integer;   //Slashposition im Filename

Begin
  S := 0;
  For i:= Length(FileName) downto 0 do
  Begin
    IF S = 0 then
    Begin
      If FileName[I] = '\' then S := I;
      result := copy(FileName, 1, S );
    End;
  End;
End;

function GetExtender(const FileName: String) :String;
var
  i:     Integer;
  s:     Integer;

Begin
  s := 0;
  For i := Length(FileName) downto 0 do
  Begin
    IF S = 0 then
    Begin
      If FileName[I] = '.' then S := I;
      result := copy(FileName, S+1, Length(Filename)-S+1);
      result := Lowercase(result);
    End;
  End;
End;

function GetName(const FileName: String) :String;
var
  i:     Integer;
  y,s:   Integer;
  Ext:   String;
Begin
  s := 0;
  For i := Length(FileName) downto 0 do
  Begin
    IF S = 0 then
    Begin
      If FileName[I] = '\' then S := I;
      Ext := copy(FileName, S+1, Length(Filename)-S+1);
      y := Pos('.',Ext);
      result := Copy(Ext,0, y -1);
      result := Lowercase(result);
    End;
  End;
End;

function GetLastDirName(const FileName: String):String;
var
  i:     Integer;   //Zaehlvariable
  S:     Integer;   //Slashposition im Filename

Begin
  S := 0;
  For i:= Length(FileName) downto 0 do
  Begin
    IF S = 0 then
    Begin
      If FileName[I] = '\' then S := I;
      result := copy(FileName, S+1, Length(Filename)-S+1);
    End;
  End;
End;

Das wars auch schon... :hi:

[Smokey]

find ich klasse, nur was spricht dagegen, die bereits von Delphi mitgelieferten Funktionen zu benutzen ?

[Thunderchild]

Wenn Du auf die Indizes eines Strings zugreifst, solltest Du aber nur bis 1 runter zählen. Im Index 0 steht bei Strings der oben verwendeten Sorte die Länge, da ist kein Nutz-Zeichen drin.

[Mattin]

Zitat:

Zitat von Smokey

find ich klasse, nur was spricht dagegen, die bereits von Delphi mitgelieferten Funktionen zu benutzen ?

Nix :)

Bloss langweilig wenns sowas schon gibt :-D

[himitsu]

Es tut mir leid, aber ich falle auch mal über diese Codes her.

Mal abgesehn davon, das es schon fertige Funktionen in Delphi gibt, sind diese Codes auch noch extrem ineffizient.

Oder ist noch keinem aufgefallen, das verschiedene Befehle sinnloserweise abgearbeitet werden?

Gegen UeberpruefeSlash kann mal nicht sagen, das ist schon nicht schlecht gemacht.
Wobei das so schon etwas besser währe:

Delphi-Quellcode:

Function UeberpruefeSlash(Const Pfad: String): String;
  Begin
    If (Length(Pfad) > 0) AND (Pfad[Length(Pfad)] <> '\') Then
      Result := Pfad + '\'
    Else
      Result := Pfad;
  End;

sonst aber nicht schlecht.


Nehmen wir uns aber mal GetFileName vor:

Delphi-Quellcode:

Function GetFileName(Const FileName: String): String;
  Var I, S: Integer;

  Begin
    S := 0;
    For I := Length(FileName) downto 1 do 
      IF S = 0 Then Begin
        If FileName[I] = '\' Then S := I;
        Result := Copy(FileName, S + 1, Length(FileName) - S + 1);
      End;
  End;

Bei FileName = "C:\Test\Dat.ei" kommt dann sowas raus:
(hab mal versucht die Zeilen in ihrer Abarbeitungsreihenfolge aufzuschreiben)

Delphi-Quellcode:

For I := ...           (* I = 14 *)
IF 0{S} = 0 Then Begin
  If 'i'{FileName[I]} = '\' Then ...
  Result := 'C:\Test\Dat.ei'{Copy(FileName, 0 + 1, 14 - 0 + 1)};
End;
For I := ...           (* I = 13 *)
IF 0{S} = 0 Then Begin
  If 'e'{FileName[I]} = '\' Then ...
  Result := 'C:\Test\Dat.ei'{Copy(FileName, 0 + 1, 14 - 0 + 1)};
End;
For I := ...           (* I = 12 *)
IF 0{S} = 0 Then Begin
  If '.'{FileName[I]} = '\' Then ...
  Result := 'C:\Test\Dat.ei'{Copy(FileName, 0 + 1, 14 - 0 + 1)};
End;
For I := ...           (* I = 11 *)
IF 0{S} = 0 Then Begin
  If 't'{FileName[I]} = '\' Then ...
  Result := 'C:\Test\Dat.ei'{Copy(FileName, 0 + 1, 14 - 0 + 1)};
End;
For I := ...           (* I = 10 *)
IF 0{S} = 0 Then Begin
  If 'a'{FileName[I]} = '\' Then ...
  Result := 'C:\Test\Dat.ei'{Copy(FileName, 0 + 1, 14 - 0 + 1)};
End;
For I := ...           (* I = 9 *)
IF 0{S} = 0 Then Begin
  If 'D'{FileName[I]} = '\' Then ...
  Result := 'C:\Test\Dat.ei'{Copy(FileName, 0 + 1, 14 - 0 + 1)};
End;
For I := ...           (* I = 8 *)
IF 0{S} = 0 Then Begin
  If '\'{FileName[I]} = '\' Then S := 8{I};
  Result := 'Dat.ei'{Copy(FileName, 8 + 1, 14 - 8 + 1)};
End;
For I := ...           (* I = 7 *)
IF 0{S} = 8 Then ...   (* FileName[7] = 't' *)
For I := ...           (* I = 6 *)
IF 0{S} = 8 Then ...   (* FileName[6] = 's' *)
For I := ...           (* I = 5 *)
IF 0{S} = 8 Then ...   (* FileName[5] = 'e' *)
For I := ...           (* I = 4 *)
IF 0{S} = 8 Then ...   (* FileName[4] = 'T' *)
For I := ...           (* I = 3 *)
IF 0{S} = 8 Then ...   (* FileName[3] = '\' *)
For I := ...           (* I = 2 *)
IF 0{S} = 8 Then ...   (* FileName[2] = ':' *)
For I := ...           (* I = 1 *)
IF 0{S} = 8 Then ...   (* FileName[1] = 'C' *)

• Result wird ständing neu gesetzt.
• selbst wenn das Ergebnis gefunden wurde, wird die Schleife noch bis zum Ende ausgeführt
  (bei langen Verzeichnissen, ist das schon ein ganzes Stückchen)
• ...

http://www.delphipraxis.net/images/common/divider.jpg
http://www.FrankNStein.de/Smiley-Kuss.gif * * http://www.FrankNStein.de/Smiley-Spinne.gif * * * http://www.FrankNStein.de/Smiley-Winken.gif

[Luckie]

Delphi-Quellcode:

function UeberpruefeSlash(const Pfad : String): String;

Ganz schlecht. deutsch-englischer Mischmasch im Funktionsnamen. Das ist das erste was mich stört. Dann impliziert der Funktionsname, dass True oder False zurückgeliefert wird. Stattdessen stellt das Ding was mit meinem Pfad an. Was wenn ich wirklich nur wissen will ob jetzt ein BackSlash am Ende steht oder nicht? Dann muss ich noch mal extra überprüfen, ob deine Funktion einen Backslash angehangen hat oder nicht und ihn gegebenenfalls wieder entfernen.

Ich habe mir mal in einem nonVCL Programm sowas dafür gemacht:

Delphi-Quellcode:

function HasBackslash(Dir: String): Boolean;
begin
  result :=  Dir[length(Dir)] = '\';
end;

Und zum entfernen:

Delphi-Quellcode:

function DelBackSlash(Dir: String): String;
begin
  if length(dir) > 0 then
    SetLength(Result, Length(Result)-1);
end;

[himitsu]

Na gut Luckie,

Wenn er das Ding z.B. ExtendetBackSlash oder so nennt, stört dich dann wohl nicht mehr all zu viel da dran. :mrgreen:

Aber im Verhältnis zu den anderen Codes ist es doch ganz gut gelungen. :wink:

http://www.delphipraxis.net/images/common/divider.jpg
http://www.FrankNStein.de/Smiley-Kuss.gif * * http://www.FrankNStein.de/Smiley-Spinne.gif * * * http://www.FrankNStein.de/Smiley-Winken.gif

[sakura]

Ich habe das mal verschoben, da die Codes wohl noch etwas Arbeit benötigen, um hilfreich zu sein. Zumal es für die meisten bereits elegantere Lösungen durch Delphi gibt ;-)

...:cat:...

[Mattin]

[quote="himitsu"]Na gut Luckie,

Wenn er das Ding z.B. ExtendetBackSlash oder so nennt, stört dich dann wohl nicht mehr all zu viel da dran. :mrgreen:

Aber im Verhältnis zu den anderen Codes ist es doch ganz gut gelungen. :wink:


Ich muss dazu sagen, die Funktionen sind Uralt. Ich habe diese unter Delphi 1
damals geschrieben. War glaub ich 1992/3 oder so.

Sicherlich führen viele Wege nach Rom um auf das gleiche Ergebnis zu kommen. :)

Aber verschiedene Lösungsvorlschläge sind ja mal auch nicht schlecht. Oder ?

[sakura]

Zitat:

Zitat von Mattin

Ich muss dazu sagen, die Funktionen sind Uralt. Ich habe diese unter Delphi 1
damals geschrieben. War glaub ich 1992/3 oder so.

:mrgreen: Delphi 1 kam Ende Sommer 1995 auf den Markt ;-)

Zitat:

Zitat von Mattin

Aber verschiedene Lösungsvorlschläge sind ja mal auch nicht schlecht. Oder ?

Nein, nie. Das ist auch wünschenswert ;-) Deswegen würde ich mich auch freuen, wenn Du am Ende alle Prozeduren nach Beheben der Mängel noch einmal vorstellst :-)

...:cat:...

[roderich]

Luckie, deine beiden Routinen sind aber auch nicht das Gelbe vom Ei.

Delphi-Quellcode:

function HasBackslash(Dir: String): Boolean;
begin
  result :=  Dir[length(Dir)] = '\';
end;

Dir = Leerstring -> Knatsch !!

Delphi-Quellcode:

function DelBackSlash(Dir: String): String;
begin
  if length(dir) > 0 then
    SetLength(Result, Length(Result)-1);
end;

ok, kein Absturz, aber damit löscht du jedes Zeichen von hinten, nicht nur Slash'e


Roderich

[Mattin]

[quote="sakura"]

Zitat:

Zitat von Mattin

Ich muss dazu sagen, die Funktionen sind Uralt. Ich habe diese unter Delphi 1
damals geschrieben. War glaub ich 1992/3 oder so.

:mrgreen: Delphi 1 kam Ende Sommer 1995 auf den Markt ;-)

:oops: Wusste nicht mehr genau wann Delphi raus kam.Schrieb ja schon vorsichtshalber oder so .

Zitat:

Zitat von Mattin

Aber verschiedene Lösungsvorlschläge sind ja mal auch nicht schlecht. Oder ?

Nein, nie. Das ist auch wünschenswert ;-) Deswegen würde ich mich auch freuen, wenn Du am Ende alle Prozeduren nach Beheben der Mängel noch einmal vorstellst :-)

Wenn ich Zeit dazu finde werde ich mir mal Prozeduren nochmal zu Brust nehmen. Kann aber ein weilchen Dauern.

[Luckie]

Zitat:

Zitat von roderich

Luckie, deine beiden Routinen sind aber auch nicht das Gelbe vom Ei.

Habe ich auch nicht behauptet.

Zitat:

Delphi-Quellcode:

function HasBackslash(Dir: String): Boolean;
begin
  result :=  Dir[length(Dir)] = '\';
end;

Dir = Leerstring -> Knatsch !!

Stimmt, da habe ich die Überprügung, woie bei der zweiten.

Zitat:

Delphi-Quellcode:

function DelBackSlash(Dir: String): String;
begin
  if length(dir) > 0 then
    SetLength(Result, Length(Result)-1);
end;

ok, kein Absturz, aber damit löscht du jedes Zeichen von hinten, nicht nur Slash'e

Tja, da muss man vorher überprüfen, ob es auch einen '\' gibt. Kann man aber auch noch mit einbauen.

So verbessert:

Delphi-Quellcode:

////////////////////////////////////////////////////////////////////////////////
// Procedure : HasBackslash
// Comment   : Checks whether path ends with a backslash or not

function HasBackslash(Dir: String): Boolean; 
begin
  if length(Dir) > 0 then 
   result :=  Dir[length(Dir)] = '\'; 
end; 


////////////////////////////////////////////////////////////////////////////////
// Procedure : DelBackSlash
// Comment   : Removes the last backslash of a path

function DelBackSlash(Dir: String): String;
begin
  if (length(dir) > 0) and (Dir[length(Dir)] = '\') then
    SetLength(Result, Length(Result)-1);
end;

[choose]

Zitat:

Zitat von Luckie

Delphi-Quellcode:

function HasBackslash(Dir: String): Boolean;
//...

function DelBackSlash(Dir: String): String;
begin
  if (length(dir) > 0) and (Dir[length(Dir)] = '\') then
    SetLength(Result, Length(Result)-1);
end;

Hallo Luckie,

diese Funktion hast Du tatsächlich im Einsatz ("Ich habe mir mal in einem nonVCL Programm sowas dafür gemacht")?! Mal davon ab, dass der Funktionsname HasBackslash ebenfalls nicht sprechend ist (schließlich könnte er irgendeinen Backslash erkennen) und "Backslash" anders schreibt als in DelBackSlash, wo wird denn Result innerhalb von DelBackSlash gesetzt? Du prüfst einen Parameter und änderst daraufhin den Rückgabewert, der bisher nicht belegt worden ist, andernfalls wird der Rückgabewert nicht einmal angefasst...

Vielleicht so?

Delphi-Quellcode:

function GetWithoutTrailingBackslash(const ADirectory: string): string;
begin
  Result:= ADirectory;
  while HasTrailingBackslash(Result) do 
    SetLength(Result, Length(Result)-1);
end;

Wenn der Ton etwas aggressiv klingen sollte, liegt das vielleicht daran, dass ich gerade auf der Arbeitsplatte wg einer defekten Kaffeekanne die Dispersionseigenschaften selbigen Inhalts beobachten könnte... ;)

[Luckie]

[quote="choose"] Mal davon ab, dass der Funktionsname HasBackslash ebenfalls nicht sprechend ist (schließlich könnte er irgendeinen Backslash erkennen)´
[quote]
Er sit aussagekräftig, da sich die Funktion in einer Include-Datei namens FileTools befindet. Um was soll es also anderes gehen, als um Pfade?

Zitat:

und "Backslash" anders schreibt als in DelBackSlash,

Tippfehler. Sollte aber keine Katastrophe heraufbeschwören.

Zitat:

wo wird denn Result innerhalb von DelBackSlash gesetzt?

In setlength, wo sonst?

Zitat:

Du prüfst einen Parameter und änderst daraufhin den Rückgabewert, der bisher nicht belegt worden ist, andernfalls wird der Rückgabewert nicht einmal angefasst...

Hm, das könnte in der Tat ein Problem sein. Aber die modifizierte Fassung hab eich nich nicht benutzt.

Zitat:

Vielleicht so?

Delphi-Quellcode:

function GetWithoutTrailingBackslash(const ADirectory: string): string;
begin
  Result:= ADirectory;
  while HasTrailingBackslash(Result) do 
    SetLength(Result, Length(Result)-1);
end;

Nein so bestimmt nicht. Der Funktionsname ist ja ein halber Roman und was ist HasTrailingBackSlash? Eine Funktion? Nicht sehr gut, die wird ja jedes mal auf gerufen, so lange die Schleife läuft.
Wenn dann so:

Delphi-Quellcode:

function DelBackSlash(Dir: String): String;
begin
  result := Dir;
  if (length(dir) > 0) and (Dir[length(Dir)] = '\') then
    SetLength(Result, Length(Result)-1);
end;

[MathiasSimmack]

Ich will auch mal, :mrgreen:, denn wenn ich irgendeinen Wert an "Result" übergebe, dann benutze ich auch "Result" zum Testen. Ansonsten könnte man auch die Variable im Funktionskopf bearbeiten und dann an das Funktionsergebnis weiterreichen. Geht hier aber nicht, weil es eine Konstante ist. Absichtlich! Dann kommt man nämlich gar nicht erst in Versuchung, den Wert direkt bearbeiten zu wollen.

Delphi-Quellcode:

function DelBackslash(const Dir: string): string;
begin
  Result := Dir;

  if(Result <> '') then
    while(Result[length(Result)] = '\') do
      SetLength(Result,length(Result)-1);
end;

[choose]

Zitat:

Zitat von Luckie

Zitat:

Zitat von choose

Mal davon ab, dass der Funktionsname HasBackslash ebenfalls nicht sprechend ist (schließlich könnte er irgendeinen Backslash erkennen)

Zitat:

Er sit aussagekräftig, da sich die Funktion in einer Include-Datei namens FileTools befindet. Um was soll es also anderes gehen, als um Pfade?

Dieser String "c:\foo\bar\foobar" enthält drei Backslashes, ich erwarte, dass der Rückgabewert einer Funktion HasBackslash den Wert True enthält.

Zitat:

Zitat von Luckie

Hm, das könnte in der Tat ein Problem sein. Aber die modifizierte Fassung hab eich nich nicht benutzt.

funktioniert sie nun, oder nicht?

Zitat:

Zitat von Luckie

[...]und was ist HasTrailingBackSlash? Eine Funktion? Nicht sehr gut, die wird ja jedes mal auf gerufen, so lange die Schleife läuft.
Wenn dann so:

Delphi-Quellcode:

function DelBackSlash(Dir: String): String;
begin
  result := Dir;
  if (length(dir) > 0) and (Dir[length(Dir)] = '\') then
    SetLength(Result, Length(Result)-1);
end;

Genau genommen wird sie im Idealfall genau einmal aufgerufen und mach die selben Tests wie die direkte Implementierung (short-circuit). Der Aufruf der Funktion ist daher kaum "teurer", verdeutlicht hingegen aber die Intention, ohne dass die Statements verstanden werden müssen.
Eine Schleife habe ich nur für den unwahrschienlichen Fall, dass der Inhalb des Strings etwas in dieser Form ist "c:\foo\\". Unter diesen Umständen würde die Implementierung mit if trotzdem einen Backslash am Ende hinterlassen...

[edit]zu den mitromanenvergleichbaren Bezeichnern: Auch hier wird durch DelBackslash nicht klar, welcher Backslash nun gelöscht wird, bzw. ob im Fall "c:\\" beide gelöscht werden, tatsächlich setzt sich der Bezeichner GetWithoutTrailingBackslash aus mehr Zeichen zusammen, enthält aber auch mehr information:

• Es wird nicht der Parameter verändert, wie der gekürzte Imparativ "Delete" suggeriert (siehe auch System.Delete)
• Die Funktion betrachtete ausschließlich die Backslashes am Ende des Strings
• Die Funktion gibt einen String zurück, der keinen der betrachteten Backslashes mehr enthält (also ist auch der Fall mit mehreren Backslashes geklärt)

[/edit]