{"id":55000478,"date":"2025-08-01T00:00:00","date_gmt":"2025-10-12T10:40:42","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=478"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Dateimanagement_mit_dem_FileSystemObject","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Dateimanagement_mit_dem_FileSystemObject\/","title":{"rendered":"Dateimanagement mit dem FileSystemObject"},"content":{"rendered":"<p><b>VBA bietet bereits einige Befehle, mit denen wir Dateioperationen ausf&uuml;hren k&ouml;nnen. Wir k&ouml;nnen mit MkDir neue Verzeichnisse erstellen, mit Dir pr&uuml;fen, ob Dateien oder Verzeichnisse vorhanden sind oder mit Kill Dateien l&ouml;schen. Diese Befehle sind aber recht kompliziert in der Handhabung. Daher schauen wir uns in diesem Artikel einmal die Klasse &#8220;FileSystemObject&#8221; an, mit der wir deutlich komfortabler mit Dateien und Verzeichnissen arbeiten k&ouml;nnen. Damit l&auml;sst sich alles erledigen, was mit dem Anlegen, Kopieren, Verschieben und L&ouml;schen zusammenh&auml;ngt &#8211; und vieles mehr.<\/b><\/p>\n<h2>Definition<\/h2>\n<p>Im Rahmen dieses Artikels werden wir folgende Bezeichnungen verwenden:<\/p>\n<p><b>Verzeichnis<\/b>: Laufwerksbuchstabe plus Unterverzeichnisse, zum Beispiel <b>c:\\Temp<\/b><\/p>\n<p><b>Dateiname<\/b>: Nur der Dateiname ohne Verzeichnisse, also beispielsweise <b>Test.txt<\/b><\/p>\n<p><b>Pfad<\/b>: Verzeichnis plus Dateiname, hier also <b>c:\\Temp\\Test.txt<\/b><\/p>\n<h2>Die Klasse FileSystemObject<\/h2>\n<p>Die Klasse <b>FileSystemObject <\/b>ist Teil der Bibliothek <b>Microsoft Scripting Runtime<\/b>, die wir als Erstes referenzieren m&uuml;ssen.<\/p>\n<p>Dazu &ouml;ffnen wir im VBA-Editor den <b>Verweise<\/b>-Dialog und f&uuml;gen den entsprechenden Eintrag hinzu (siehe Bild 1).<\/p>\n<p class=\"image\"><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2025_04\/pic_478_002.png\" alt=\"Verweis auf die Bibliothek Microsoft Scripting Runtime hinzuf&uuml;gen\" width=\"424,6267\" height=\"334,749\"\/><\/p>\n<p><b><span style=\"color:darkgrey;\">Bild 1: Verweis auf die Bibliothek Microsoft Scripting Runtime hinzuf&uuml;gen<\/span><\/b><\/p>\n<p>Danach k&ouml;nnen wir den Objektkatalog &ouml;ffnen und finden alle Elemente der Klasse <b>FileSystemObject <\/b>vor (siehe Bild 2).<\/p>\n<p class=\"image\"><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2025_04\/pic_478_001.png\" alt=\"Die Elemente der Klasse FileSystemObject in der &Uuml;bersicht im Objektkatalog\" width=\"424,6267\" height=\"694,4225\" \/><\/p>\n<p><b><span style=\"color:darkgrey;\">Bild 2: Die Elemente der Klasse FileSystemObject in der &Uuml;bersicht im Objektkatalog<\/span><\/b><\/p>\n<p>Hier steigen wir nun ein und schauen uns die verschiedenen Elemente erst einmal in der &Uuml;bersicht an &#8211; sp&auml;ter gehen wir detailliert auf jedes einzelne ein:<\/p>\n<ul>\n<li><b>BuildPath<\/b>: Stellt aus Verzeichnis und Dateinamen einen Pfad zusammen und erg&auml;nzt gegebenenfalls das fehlende Backslash-Zeichen zwischen den beiden Elementen.<\/li>\n<li><b>CopyFile<\/b>: Kopiert eine Datei.<\/li>\n<li><b>CopyFolder<\/b>: Kopiert ein Verzeichnis.<\/li>\n<li><b>CreateFolder<\/b>: Erstellt ein Verzeichnis.<\/li>\n<li><b>CreateTextFile<\/b>: Erstellt eine Textdatei.<\/li>\n<li><b>DeleteFile<\/b>: L&ouml;scht eine Datei.<\/li>\n<li><b>DeleteFolder<\/b>: L&ouml;scht ein Verzeichnis.<\/li>\n<li><b>DriveExists<\/b>: Pr&uuml;ft, ob ein Laufwerk vorhanden ist.<\/li>\n<li><b>Drives<\/b>: Liefert eine Auflistung von <b>Drive<\/b>-Objekten, die Informationen zu den einzelnen Laufwerken liefern.<\/li>\n<li><b>FileExists<\/b>: Pr&uuml;ft, ob eine Datei vorhanden ist.<\/li>\n<li><b>FolderExists<\/b>: Pr&uuml;ft, ob ein Verzeichnis vorhanden ist.<\/li>\n<li><b>GetAbsolutePathname<\/b>: Holt einen absoluten Pfadnamen.<\/li>\n<li><b>GetBaseName<\/b>: Holt den Basisdateinamen ohne Dateiendung.<\/li>\n<li><b>GetDrive<\/b>: Ermittelt ein <b>Drive<\/b>-Objekte auf Basis eines Laufwerksbuchstabens, des Laufwerksverzeichnisses oder des Rootverzeichnisses.<\/li>\n<li><b>GetDriveName<\/b>: Ermittelt das Verzeichnis eines Laufwerkes auf Basis eines Verzeichnisses, das auch Unterordner enthalten kann.<\/li>\n<li><b>GetExtensionName<\/b>: Holt die Dateinamenerweiterung.<\/li>\n<li><b>GetFile<\/b>: Holt ein <b>File<\/b>-Objekt.<\/li>\n<li><b>GetFileName<\/b>: Ermittelt einen Dateinamen.<\/li>\n<li><b>GetFileVersion<\/b>: Ermittelt die Version einer Datei.<\/li>\n<li><b>GetFolder<\/b>: Holt ein <b>Folder<\/b>-Objekt.<\/li>\n<li><b>GetParentFolderName<\/b>: Ermittelt das &uuml;bergeordnete Verzeichnis.<\/li>\n<li><b>GetSpecialFolder<\/b>: Ermittelt ein <b>Folder<\/b>-Objekt zu einem Spezialverzeichnis.<\/li>\n<li><b>GetStandardStream<\/b>: Liefert ein Stream-Objekt auf Basis einer Datei.<\/li>\n<li><b>GetTempName<\/b>: Liefert einen zuf&auml;lligen tempor&auml;ren Dateinamen.<\/li>\n<li><b>MoveFile<\/b>: Verschiebt eine Datei.<\/li>\n<li><b>MoveFolder<\/b>: Verschiebt ein Verzeichnis.<\/li>\n<li><b>OpenTextFile<\/b>: &Ouml;ffnet eine Textdatei.<\/li>\n<\/ul>\n<h2>Die Klasse FileSystemObject nutzen<\/h2>\n<p>Um die Elemente der Klasse <b>FileSystemObjekt <\/b>zu nutzen, m&uuml;ssen wir zun&auml;chst ein Objekt auf Basis dieser Klasse erstellen.<\/p>\n<p>Das erledigen wir bei Early Binding, also mit vorhandenem Verweis auf die Bibliothek <b>Microsoft Scripting Runtime<\/b>, wie folgt:<\/p>\n<pre><span style=\"color:blue;\">Dim <\/span>fso<span style=\"color:blue;\"> As <\/span>Scripting.FileSystemObject\r\n<span style=\"color:blue;\">Set<\/span> fso = <span style=\"color:blue;\">New<\/span> Scripting.FileSystemObject<\/pre>\n<p>Wenn wir Late Binding nutzen, also ohne Verweis arbeiten wollen, nutzen wir:<\/p>\n<pre><span style=\"color:blue;\">Dim <\/span>fso<span style=\"color:blue;\"> As Object<\/span>\r\n<span style=\"color:blue;\">Set<\/span> fso = CreateObject(\"Scripting.FileSystemObject\")<\/pre>\n<p>Der Vorteil von Early Binding liegt darin, dass wir w&auml;hrend der Entwicklung die Funktionen von IntelliSense nutzen k&ouml;nnen.<\/p>\n<p>Wir nutzen hier eine Objektvariable mit der Bezeichnung <b>fso<\/b>. Man k&ouml;nnte auch beispielsweise <b>objFileSystemObject <\/b>nutzen, damit man direkt wei&szlig;, welche Klasse damit referenziert wird.<\/p>\n<p>Wir verwenden hier aus Platzgr&uuml;nden die k&uuml;rzere Variante (eine Alternative ist <b>objFSO<\/b>).<\/p>\n<h2>Laufwerksinformationen ermitteln mit Drive<\/h2>\n<p>Die <b>Drives<\/b>-Auflistung liefert uns Informationen &uuml;ber die verschiedenen Laufwerke. Wir k&ouml;nnen folgende Informationen erhalten:<\/p>\n<ul>\n<li><b>AvailableSpace<\/b>: Liefert den freien Speicherplatz in Bytes.<\/li>\n<li><b>DriveLetter<\/b>: Liefert nur den Laufwerksbuchstaben, also beispielsweise <b>c<\/b>.<\/li>\n<li><b>DriveType<\/b>: Liefert den Typ des Laufwerks als Zahlenwert mit den m&ouml;glichen Werten <b>0 (Unknown Type<\/b>), <b>1 <\/b>(<b>Removable<\/b>), <b>2 <\/b>(<b>Fixed<\/b>), <b>3 <\/b>(<b>Remote<\/b>), <b>4 <\/b>(<b>CDRom<\/b>) oder <b>5 <\/b>(<b>RamDisk<\/b>).<\/li>\n<li><b>FileSystem<\/b>: Liefert beispielsweise den Wert <b>FAT32 <\/b>oder <b>NTFS<\/b>.<\/li>\n<li><b>FreeSpace<\/b>: Liefert den freien Speicherplatz f&uuml;r den aktuellen Benutzer. Dieser kann identisch sein mit dem Wert von <b>AvailableSpace<\/b>.<\/li>\n<li><b>IsReady<\/b>: Gibt an, ob das Laufwerk verf&uuml;gbar ist.<\/li>\n<li><b>Path<\/b>: Gibt den Laufwerkbuchstaben gefolgt von einem Doppelpunkt an, zum Beispiel <b>c:<\/b>.<\/li>\n<li><b>RootFolder<\/b>: Gibt den Laufwerkbuchstaben gefolgt von einem Doppelpunkt und einem Backslash an, zum Beispiel <b>c:\\<\/b>.<\/li>\n<li><b>SerialNumber<\/b>: Gibt die Seriennummer des Laufwerks an.<\/li>\n<li><b>ShareName<\/b>: Liefert den Namen der Windows-Freigabe, wenn das Laufwerk ein Netzlaufwerk ist. Anderenfalls liefert es eine leere Zeichenkette.<\/li>\n<li><b>TotalSize<\/b>: Gibt den gesamten Speicherplatz des Laufwerks in Bytes zur&uuml;ck.<\/li>\n<li><b>VolumeName<\/b>: Beschriftung des Laufwerks, wie er im Windows Explorer angezeigt wird.<\/li>\n<\/ul>\n<p>Mit der Prozedur aus Listing 1 geben wir alle Informationen aller Laufwerke aus, indem wir diese in einer <b>For Each<\/b>-Schleife &uuml;ber die <b>Drives<\/b>-Auflistung durchlaufen. Dabei weisen wir die einzelnen Elemente einer Objektvariablen namens <b>objDrive <\/b>mit dem Typ <b>FileSystemObject.Drive <\/b>zu.<\/p>\n<pre><span style=\"color:blue;\">Public Sub <\/span>LaufwerksbuchstabenErmitteln()\r\n     <span style=\"color:blue;\">Dim <\/span>fso<span style=\"color:blue;\"> As <\/span>Scripting.FileSystemObject\r\n     <span style=\"color:blue;\">Dim <\/span>objDrive<span style=\"color:blue;\"> As <\/span>Scripting.Drive\r\n     <span style=\"color:blue;\">Set<\/span> fso = <span style=\"color:blue;\">New<\/span> Scripting.FileSystemObject\r\n     \r\n     For Each objDrive In fso.Drives\r\n         <span style=\"color:blue;\">Debug.Print<\/span> \"AvailbableSpace: \" & objDrive.AvailableSpace\r\n         <span style=\"color:blue;\">Debug.Print<\/span> \"DriveLetter:\" & objDrive.DriveLetter\r\n         <span style=\"color:blue;\">Debug.Print<\/span> \"DriveType:\" & objDrive.DriveType\r\n         <span style=\"color:blue;\">Debug.Print<\/span> \"FileSystem:\" & objDrive.FileSystem\r\n         <span style=\"color:blue;\">Debug.Print<\/span> \"FreeSpace:\" & objDrive.FreeSpace\r\n         <span style=\"color:blue;\">Debug.Print<\/span> \"IsReady:\" & objDrive.IsReady\r\n         <span style=\"color:blue;\">Debug.Print<\/span> \"Path:\" & objDrive.Path\r\n         <span style=\"color:blue;\">Debug.Print<\/span> \"RootFolder:\" & objDrive.RootFolder\r\n         <span style=\"color:blue;\">Debug.Print<\/span> \"SerialNumber:\" & objDrive.SerialNumber\r\n         <span style=\"color:blue;\">Debug.Print<\/span> \"ShareName:\" & objDrive.ShareName\r\n         <span style=\"color:blue;\">Debug.Print<\/span> \"TotalSize:\" & objDrive.TotalSize\r\n         <span style=\"color:blue;\">Debug.Print<\/span> \"VolumeName:\" & objDrive.VolumeName\r\n     <span style=\"color:blue;\">Next<\/span> objDrive\r\n<span style=\"color:blue;\">End Sub<\/span><\/pre>\n<p><b><span style=\"color:darkgrey;\">Listing 1: Prozedur zur Ausgabe von Laufwerksinformationen im Direktbereich<\/span><\/b><\/p>\n<p>F&uuml;r das Laufwerk <b>C:\\<\/b> erhalten wir beispielsweise folgende Ausgabe im Direktbereich:<\/p>\n<pre>AvailbableSpace: 207972556800\r\nDriveLetter:C\r\nDriveType:2\r\nFileSystem:NTFS\r\nFreeSpace:207972556800\r\nIsReady:Wahr\r\nPath:C:\r\nRootFolder:C:\\\r\nSerialNumber:-966946150\r\nShareName:\r\nTotalSize:1999516987392\r\nVolumeName:Hauptlaufwerk<\/pre>\n<h2>Laufwerk referenzieren mit GetDrive<\/h2>\n<p>Mit der Funktion <b>GetDrive<\/b> k&ouml;nnen wir ein <b>Drive<\/b>-Objekt zu einem Ausdruck wie <b>c<\/b>, <b>c: <\/b>oder <b>c:\\ <\/b>ermitteln.<\/p>\n<p>Im folgenden Beispiel deklarieren wir eine <b>Drive<\/b>-Variable namens <b>objDrive <\/b>und weisen ihr das Ergebnis der <b>GetDrive<\/b>-Funktion f&uuml;r <b>c:\\ <\/b>zu.<\/p>\n<p>Danach geben wir den verf&uuml;gbaren Speicherplatz dieses Laufwerks aus:<\/p>\n<pre><span style=\"color:blue;\">Public Sub <\/span>LaufwerkReferenzieren()\r\n     <span style=\"color:blue;\">Dim <\/span>fso<span style=\"color:blue;\"> As <\/span>Scripting.FileSystemObject\r\n     <span style=\"color:blue;\">Dim <\/span>objDrive<span style=\"color:blue;\"> As <\/span>Scripting.Drive\r\n     <span style=\"color:blue;\">Set<\/span> fso = <span style=\"color:blue;\">New<\/span> Scripting.FileSystemObject\r\n     <span style=\"color:blue;\">Set<\/span> objDrive = fso.GetDrive(\"c:\\\")\r\n     <span style=\"color:blue;\">Debug.Print<\/span> objDrive.AvailableSpace\r\n<span style=\"color:blue;\">End Sub<\/span><\/pre>\n<p>Die Standardeigenschaft der <b>Drive<\/b>-Klasse ist die Eigenschaft <b>Path<\/b>. <\/p>\n<p>Wir k&ouml;nnen <b>c: <\/b>also auch einfach so ausgeben lassen:<\/p>\n<pre><span style=\"color:blue;\">Debug.Print<\/span> objDrive<\/pre>\n<h2>Name eines Laufwerks ermitteln mit GetDriveName<\/h2>\n<p>Mit der Funktion <b>GetDriveName <\/b>k&ouml;nnen wir den Namen eines Laufwerks f&uuml;r einen beliebigen Pfad ermitteln.<\/p>\n<p>Wenn wir also etwas das Laufwerk ben&ouml;tigen, auf dem sich die aktuelle Datenbankdatei befindet, nutzen wir die folgenden Anweisungen (siehe Funktion <b>LaufwerkNameErmitteln<\/b>), der wir <b>CurrentProject.Path <\/b>als Parameter &uuml;bergeben:<\/p>\n<pre><span style=\"color:blue;\">Dim <\/span>fso<span style=\"color:blue;\"> As <\/span>Scripting.FileSystemObject\r\n<span style=\"color:blue;\">Dim <\/span>objDrive<span style=\"color:blue;\"> As <\/span>Scripting.Drive\r\n<span style=\"color:blue;\">Set<\/span> fso = <span style=\"color:blue;\">New<\/span> Scripting.FileSystemObject\r\n<span style=\"color:blue;\">Debug.Print<\/span> fso.GetDriveName(CurrentProject.Path)<\/pre>\n<h2>Mit DriveExists pr&uuml;fen, ob ein Laufwerk existiert<\/h2>\n<p>Die Funktion <b>DriveExists <\/b>pr&uuml;ft, ob ein Laufwerk existiert. Dazu k&ouml;nnen wir den Laufwerksbuchstaben (<b>c<\/b>), das Verzeichnis (<b>c:<\/b>) oder das Rootverzeichnis (<b>c:\\<\/b>) &uuml;bergeben. F&uuml;r das Laufwerk <b>d: <\/b>liefert die folgende Prozedur beispielsweise den Wert <b>False<\/b>, wenn kein entsprechendes Laufwerk vorhanden ist:<\/p>\n<pre><span style=\"color:blue;\">Dim <\/span>fso<span style=\"color:blue;\"> As <\/span>Scripting.FileSystemObject\r\n<span style=\"color:blue;\">Dim <\/span>objDrive<span style=\"color:blue;\"> As <\/span>Scripting.Drive\r\n<span style=\"color:blue;\">Set<\/span> fso = <span style=\"color:blue;\">New<\/span> Scripting.FileSystemObject\r\n<span style=\"color:blue;\">Debug.Print<\/span> fso.DriveExists(\"d:\\\")<\/pre>\n<h2>Mit Verzeichnissen arbeiten<\/h2>\n<p>Nachdem wir die Funktionen f&uuml;r die Laufwerke erledigt haben, kommen wir zu den Funktionen f&uuml;r den Umgang mit Verzeichnissen. Hier k&ouml;nnen wir Verzeichnisse erstellen, pr&uuml;fen, ob ein Verzeichnis existiert, Verzeichnisse l&ouml;schen, kopieren oder verschieben, Eigenschaften von Verzeichnissen auslesen und &uuml;bergeordnete Verzeichnisse oder Spezialverzeichnisse ermitteln.<\/p>\n<h2>Verzeichnisse erstellen mit CreateFolder<\/h2>\n<p>Mit der Methode <b>CreateFolder <\/b>k&ouml;nnen wir ein Verzeichnis erstellen. Dazu geben wir einfach den kompletten Pfad zum Verzeichnis an, zum Beispiel <b>c:\\Temp\\Ordner 1<\/b>:<\/p>\n<pre>fso.CreateFolder \"c:\\Temp\\Ordner 1\"<\/pre>\n<p>Wenn wir versuchen, einen Ordner zu erstellen, der bereits vorhanden ist, erhalten wir Fehler <b>58<\/b>, <b>Datei existiert bereits<\/b>. Um dies zu verhindern, k&ouml;nnen wir mit <b>FolderExists <\/b>vorab pr&uuml;fen, ob das Verzeichnis bereits vorhanden ist (siehe weiter unten).<\/p>\n<p>Wir k&ouml;nnen mit <b>CreateFolder <\/b>immer nur ein Verzeichnis gleichzeitig erstellen. Um <b>c:\\Temp\\Ordner 1\\Ordner 2 <\/b>zu erstellen, ben&ouml;tigen wir zwei Anweisungen:<\/p>\n<pre>fso.CreateFolder \"c:\\Temp\\Ordner 1\"\r\nfso.CreateFolder \"c:\\Temp\\Ordner 1\\Ordner 2\"<\/pre>\n<p>Wir k&ouml;nnen auch das Ergebnis von <b>CreateFolder <\/b>mit einer <b>Folder<\/b>-Variablen referenzieren, um dann die Operationen der <b>Folder<\/b>-Klasse auszuf&uuml;hren &#8211; mehr dazu weiter unten (dort finden wir eine weitere Methode zum Anlegen von Verzeichnissen):<\/p>\n<pre><span style=\"color:blue;\">Dim <\/span>objFolder<span style=\"color:blue;\"> As <\/span>Scripting.Folder\r\n<span style=\"color:blue;\">Set<\/span> objFolder = fso.CreateFolder(\"c:\\Temp\\Ordner 1\")<\/pre>\n<h2>Mit FolderExists pr&uuml;fen, ob ein Verzeichnis existiert<\/h2>\n<p>Mit der Funktion <b>FolderExists <\/b>k&ouml;nnen wir pr&uuml;fen, ob ein Verzeichnis bereits existiert. Dieser Funktion &uuml;bergeben wir den vollst&auml;ndigen Pfad bis zu dem zu untersuchenden Verzeichnis:<\/p>\n<pre><span style=\"color:blue;\">Debug.Print<\/span> fso.FolderExists(\"c:\\Temp\\Ordner 1\")<\/pre>\n<p>Vor den verschiedenen Operationen auf Basis eines Verzeichnisses sollten wir in einer <b>If&#8230;Then<\/b>-Bedingung pr&uuml;fen, ob das Verzeichnis &uuml;berhaupt vorhanden ist:<\/p>\n<pre><span style=\"color:blue;\">If <\/span>fso.FolderExists(\"c:\\Temp\\Ordner 1\")<span style=\"color:blue;\"> Then<\/span>\r\n     ''... Operationen mit diesem Verzeichnis\r\n<span style=\"color:blue;\">End If<\/span><\/pre>\n<h2>Verzeichnisse l&ouml;schen mit DeleteFolder<\/h2>\n<p>Mit der Methode <b>DeleteFolder <\/b>k&ouml;nnen wir Verzeichnisse l&ouml;schen.<\/p>\n<pre>fso.DeleteFolder \"c:\\Temp\\Ordner 1\"<\/pre>\n<p>Wenn sich im Verzeichnis beispielsweise eine aktuell ge&ouml;ffneten Access-Datenbank befindet, liefert <b>DeleteFolder <\/b>Fehler <b>70<\/b>, <b>Zugriff verweigert<\/b>. Das Gleiche ist der Fall, wenn der Ordner schreibgesch&uuml;tzt ist.<\/p>\n<p>Wenn wir ein solches Verzeichnis dennoch l&ouml;schen wollen, k&ouml;nnen wir <b>DeleteFolder <\/b>f&uuml;r den zweiten Parameter <b>Force <\/b>den Wert <b>True <\/b>&uuml;bergeben:<\/p>\n<pre>fso.DeleteFolder \"c:\\Temp\\Ordner 1\", <span style=\"color:blue;\">True<\/span><\/pre>\n<p>Dies l&ouml;scht jedoch nur schreibgesch&uuml;tzte Elemente, eine ge&ouml;ffnete Access-Datenbank oder andere durch das System schreibgesch&uuml;tzten Elemente lassen sich auch auf diese Weise nicht l&ouml;schen.<\/p>\n<h2>Verzeichnisse kopieren mit CopyFolder<\/h2>\n<p>Die Methode <b>CopyFolder <\/b>kopiert das mit dem ersten Parameter angegebene Verzeichnis in das Verzeichnis aus dem zweiten Parameter. Dabei werden auch alle enthaltenen Unterverzeichnisse und Dateien kopiert.<\/p>\n<p>Wenn wir also den Inhalt von <b>Ordner 1 <\/b>in einen neuen <b>Ordner 2 <\/b>kopieren wollen, der gleichzeitig angelegt wird, verwenden wir diesen Aufruf:<\/p>\n<pre>fso.CopyFolder \"c:\\Temp\\Ordner 1\", \"c:\\temp\\Ordner 2\"<\/pre>\n<p>Wenn wir das Verzeichnis <b>Ordner 1 <\/b>in <b>Ordner 2 <\/b>kopieren wollen, sodass <b>Ordner 2 <\/b>unterhalb von <b>Ordner 1 <\/b>angelegt wird, nutzen wir:<\/p>\n<pre>fso.CopyFolder \"c:\\Temp\\Ordner 1\", \"c:\\temp\\Ordner 2\\\"<\/pre>\n<p>Mit dem dritten Parameter <b>OverwriteFiles <\/b>k&ouml;nnen wir noch angeben, dass eventuell vorhandene Dateien und Verzeichnisse gleichen Namens &uuml;berschrieben werden sollen.<\/p>\n<h2>Verzeichnisse verschieben mit MoveFolder<\/h2>\n<p>Auf die gleiche Weise arbeitet <b>MoveFolder<\/b>, nur dass das urspr&uuml;ngliche Verzeichnis bei diesem Vorgang gel&ouml;scht wird:<\/p>\n<pre>fso.MoveFolder \"c:\\Temp\\Ordner 1\", \"c:\\temp\\Ordner 2\\\"<\/pre>\n<h2>Folder-Objekt holen mit GetFolder<\/h2>\n<p>Die <b>FileSystemObject<\/b>-Klasse bietet nicht nur eine <b>Drive<\/b>-Klasse mit weiteren Eigenschaften eines Laufwerks, sondern auch entsprechende Klassen f&uuml;r Verzeichnisse (<b>Folder<\/b>) und Dateien (<b>File<\/b>).<\/p>\n<p>Das <b>Folder<\/b>-Objekt liefert weitere Methoden und Eigenschaften f&uuml;r Verzeichnisse.<\/p>\n<p>Um ein solches zu erhalten, nutzen wir zum Beispiel die <b>GetFolder<\/b>-Funktion. Das Ergebnis weisen wir einer Variablen des Typs <b>Folder <\/b>zu, die wir zuvor deklarieren:<\/p>\n<pre><span style=\"color:blue;\">Dim <\/span>objFolder<span style=\"color:blue;\"> As <\/span>Scripting.Folder\r\n<span style=\"color:blue;\">Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\n<span style=\"color:blue;\">Debug.Print<\/span> objFolder<\/pre>\n<p>Danach k&ouml;nnen wir die Methoden und Eigenschaften von <b>objFolder <\/b>nutzen &#8211; mehr dazu weiter unten. Hier geben wir nur die Standardeigenschaft aus, n&auml;mlich den Pfad zu diesem Verzeichnis:<\/p>\n<pre>c:\\Temp\\Ordner 1<\/pre>\n<h2>&Uuml;bergeordnetes Verzeichnis ermitteln mit GetParentFolderName<\/h2>\n<p>Mit der Funktion <b>GetParentFolderName <\/b>der <b>FileSystemObject<\/b>-Klasse ermitteln wir das &uuml;bergeordnete Verzeichnis eines Verzeichnisses:<\/p>\n<pre><span style=\"color:blue;\">Debug.Print<\/span> fso.GetParentFolderName(\"c:\\Temp\\Ordner 1\")<\/pre>\n<p>Dies liefert:<\/p>\n<pre>c:\\Temp<\/pre>\n<h2>Spezialverzeichnisse ermitteln mit GetSpecialFolder<\/h2>\n<p>Mit der Funktion <b>GetSpecialFolder <\/b>k&ouml;nnen wir verschiedene Standardverzeichnisse ermitteln. Dazu &uuml;bergeben wir einen der folgenden Werte:<\/p>\n<ul>\n<li><b>SystemFolder<\/b> (<b>1<\/b>): Liefert standardm&auml;&szlig;ig <b>C:\\Windows\\System32<\/b>.<\/li>\n<li><b>TemporaryFolder<\/b> (<b>2<\/b>): Liefert standardm&auml;&szlig;ig <b>C:\\Users\\User\\AppData\\Local\\Temp<\/b>.<\/li>\n<li><b>WindowsFolder<\/b> (<b>0<\/b>): Liefert standardm&auml;&szlig;ig <b>C:\\Windows<\/b>.<\/li>\n<\/ul>\n<p>Die Funktion rufen wir wie folgt auf:<\/p>\n<pre><span style=\"color:blue;\">Debug.Print<\/span> fso.GetSpecialFolder(SystemFolder)\r\n<span style=\"color:blue;\">Debug.Print<\/span> fso.GetSpecialFolder(TemporaryFolder)\r\n<span style=\"color:blue;\">Debug.Print<\/span> fso.GetSpecialFolder(WindowsFolder)<\/pre>\n<p>Das Ergebnis lautet:<\/p>\n<pre>C:\\Windows\\System32\r\nC:\\Users\\User\\AppData\\Local\\Temp\r\nC:\\Windows<\/pre>\n<p>Hier ist zu beachten, dass <b>GetSpecialFolder <\/b>jeweils ein <b>Folder<\/b>-Objekt liefert und die <b>Debug.Print<\/b>-Anweisungen wieder den Wert der Standardeigenschaft liefern.<\/p>\n<p>Wie k&ouml;nnen das Ergebnis also auch einer <b>Folder<\/b>-Objektvariablen zuweisen und damit weitere Operationen ausf&uuml;hren (siehe weiter unten).<\/p>\n<h2>Operationen der Folder-Klasse<\/h2>\n<p>Wenn wir beispielsweise mit <b>GetFolder <\/b>oder <b>GetSpecialFolder <\/b>einen Verweis auf ein <b>Folder<\/b>-Objekt geholt haben, k&ouml;nnen wir dessen Methoden und Eigenschaften nutzen, die wir in den folgenden Abschnitten vorstellen. Diese liefert die folgenden Elemente:<\/p>\n<ul>\n<li><b>Attributes<\/b>: Liefert einen Zahlenwert, der verschiedene Attribute kombiniert.<\/li>\n<li><b>Copy<\/b>: Kopiert das Verzeichnis in das angegebene Verzeichnis.<\/li>\n<li><b>CreateTextFile<\/b>: Erstellt eine Textdatei im Verzeichnis.<\/li>\n<li><b>DateCreated<\/b>: Liefert das Erstellungsdatum des Verzeichnisses.<\/li>\n<li><b>DateLastAccessed<\/b>: Liefert das Datum des letzten lesenden Zugriffs.<\/li>\n<li><b>DateLastModified<\/b>: Liefert das Datum des letzten schreibenden Zugriffs.<\/li>\n<li><b>Delete<\/b>: L&ouml;scht das Verzeichnis.<\/li>\n<li><b>Drive<\/b>: Ermittelt einen Verweis auf das <b>Drive<\/b>-Objekt des Verzeichnisses.<\/li>\n<li><b>Files<\/b>: Liefert die <b>Files<\/b>-Auflistung des Verzeichnisses.<\/li>\n<li><b>IsRootFolder<\/b>: Gibt an, ob es sich bei dem Verzeichnis um das Rootverzeichnis handelt, also beispielsweise <b>c:\\<\/b>.<\/li>\n<li><b>Move<\/b>: Verschiebt das Verzeichnis in das angegebene Verzeichnis.<\/li>\n<li><b>Name<\/b>: Liefert den Namen des Verzeichnisses.<\/li>\n<li><b>ParentFolder<\/b>: Liefert ein <b>Folder<\/b>-Objekt f&uuml;r das &uuml;bergeordnete Verzeichnis.<\/li>\n<li><b>Path<\/b>: Liefert den Pfad zu dem Verzeichnis.<\/li>\n<li><b>ShortName<\/b>: Liefert den kurzen Namen des Verzeichnisses.<\/li>\n<li><b>ShortPath<\/b>: Liefert den kurzen Pfad des Pfades zum Verzeichnis.<\/li>\n<li><b>Size<\/b>: Liefert die Gr&ouml;&szlig;e des Verzeichnisses inklusive der enthaltenen Dateien.<\/li>\n<li><b>SubFolders<\/b>: Liefert eine Auflistung der Unterordner des Verzeichnisses.<\/li>\n<li><b>Type<\/b>: Gibt den Typ des Verzeichnisses aus.<\/li>\n<\/ul>\n<p>In den folgenden Abschnitten setzen wir voraus, dass wir <b>objFolder <\/b>zuvor mit einem Verweis auf ein Verzeichnis gef&uuml;llt haben.<\/p>\n<h2>Attribute eines Verzeichnisses mit Attributes ermitteln<\/h2>\n<p>F&uuml;r ein herk&ouml;mmliches Verzeichnis liefert das <b>Attributes<\/b>-Attribut den Wert <b>16<\/b>. Die Werte k&ouml;nnen wir im Objektkatalog unter <b>FileAttribute <\/b>einsehen.<\/p>\n<p>Die Werte lauten <b>Alias <\/b>(<b>1.024<\/b>), <b>Archive <\/b>(<b>32<\/b>), <b>Compressed <\/b>(<b>2.048<\/b>), <b>Directory <\/b>(<b>16<\/b>), <b>Hidden <\/b>(<b>2<\/b>), <b>Normal <\/b>(<b>0<\/b>), <b>ReadOnly <\/b>(<b>1<\/b>), <b>System <\/b>(<b>4<\/b>) und <b>Column <\/b>(<b>8<\/b>). Sie gelten gleicherma&szlig;en f&uuml;r das <b>File<\/b>&#8211; und das <b>Folder<\/b>-Objekt.<\/p>\n<p>Ob ein Verzeichnis eines der genannten Attribute aufweist, k&ouml;nnen wir pr&uuml;fen, indem wir wie folgt vorgehen &#8211; hier am Beispiel des Attributs <b>Directory<\/b>:<\/p>\n<pre><span style=\"color:blue;\">Dim <\/span>objFolder<span style=\"color:blue;\"> As <\/span>Scripting.Folder\r\n<span style=\"color:blue;\">Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\")\r\n<span style=\"color:blue;\">Debug.Print<\/span> objFolder.Attributes\r\n<span style=\"color:blue;\">If <\/span>(objFolder.Attributes And Directory) = Directory<span style=\"color:blue;\"> Then<\/span>\r\n     <span style=\"color:blue;\">Debug.Print<\/span> \"Verzeichnis hat das Attribut ''Directory''\"\r\n<span style=\"color:blue;\">End If<\/span><\/pre>\n<h2>Ermitteln, wann ein Verzeichnis erstellt, gelesen oder bearbeitet wurde<\/h2>\n<p>Mit den drei Eigenschaften <b>DateCreated<\/b>, <b>DateLastAccessed <\/b>und <b>DateLastModified <\/b>finden wir heraus, wann ein Verzeichnis erstellt, zuletzt gelesen und zuletzt bearbeitet wurde:<\/p>\n<pre><span style=\"color:blue;\">Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\")\r\n<span style=\"color:blue;\">Debug.Print<\/span> objFolder.DateCreated\r\n<span style=\"color:blue;\">Debug.Print<\/span> objFolder.DateLastAccessed\r\n<span style=\"color:blue;\">Debug.Print<\/span> objFolder.DateLastModified<\/pre>\n<p>Die Ausgabe lautet beispielsweise:<\/p>\n<pre>22.07.2025 22:09:37 \r\n08.10.2025 22:21:56 \r\n08.10.2025 22:21:56 <\/pre>\n<h2>Weitere Verzeichniseigenschaften<\/h2>\n<p>Das <b>Folder<\/b>-Objekt liefert noch einige weitere Eigenschaften, die wir hier zusammenfassen und f&uuml;r ein Verzeichnis mit einem l&auml;ngeren Namen als acht Zeichen ausgeben:<\/p>\n<pre><span style=\"color:blue;\">Set<\/span> objFolder = _\r\n     fso.CreateFolder(\"c:\\temp\\LangerVerzeichnisname\")\r\n<span style=\"color:blue;\">Debug.Print<\/span> objFolder.IsRootFolder\r\n<span style=\"color:blue;\">Debug.Print<\/span> objFolder.Name\r\n<span style=\"color:blue;\">Debug.Print<\/span> objFolder.Path\r\n<span style=\"color:blue;\">Debug.Print<\/span> objFolder.ShortName\r\n<span style=\"color:blue;\">Debug.Print<\/span> objFolder.ShortPath\r\n<span style=\"color:blue;\">Debug.Print<\/span> objFolder.Size<\/pre>\n<p>Die Ergebnisse lauten:<\/p>\n<pre>Falsch                        ''IsRootFolder\r\nLangerVerzeichnisname         ''Name\r\nC:\\Temp\\LangerVerzeichnisname ''Path\r\nLANGER~1                      ''ShortName\r\nC:\\temp\\LANGER~1              ''ShortPath\r\n  0                            ''Size<\/pre>\n<h2>Verzeichnis kopieren mit Copy<\/h2>\n<p>Um das Verzeichnis aus <b>objFolder <\/b>in ein anderes Verzeichnis zu kopieren, rufen wir Folgendes auf:<\/p>\n<pre><span style=\"color:blue;\">Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\nobjFolder.Copy \"c:\\Temp\\Ordner 2\\\"<\/pre>\n<p>Damit landet <b>Ordner 1 <\/b>als Unterverzeichnis in <b>Ordner 2<\/b>.<\/p>\n<p>Wenn wir nicht das Verzeichnis selbst, sondern nur seinen Inhalt in <b>Ordner 2 <\/b>kopieren wollen, lassen wir das letzte Backslash-Zeichen im Zielverzeichnis weg:<\/p>\n<pre><span style=\"color:blue;\">Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\nobjFolder.Copy \"c:\\Temp\\Ordner 2\"<\/pre>\n<p>Wir k&ouml;nnen das Verzeichnis <b>Ordner 1 <\/b>auch in einen neuen <b>Ordner 3 <\/b>kopieren.<\/p>\n<p>Dies erzeugt ein neues Verzeichnis namens <b>Ordner 3<\/b>, das den Inhalt von <b>Ordner 1 <\/b>enth&auml;lt:<\/p>\n<pre><span style=\"color:blue;\">Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\nobjFolder.Copy \"c:\\Temp\\Ordner 3\"<\/pre>\n<h2>Verzeichnis verschieben mit Move<\/h2>\n<p>Auf &auml;hnliche Weise k&ouml;nnen wir mit <b>Move <\/b>einen Ordner oder seinen Inhalt in den Zielordner verschieben. Die Syntax f&uuml;r die drei oben genannten F&auml;lle ist gleich, der zu verschiebende Ordner wird dann nach dem Kopieren entfernt. Aber wir k&ouml;nnen nur zwei der drei F&auml;lle nutzen:<\/p>\n<p><b>Ordner 1 <\/b>in <b>Ordner 2 <\/b>verschieben:<\/p>\n<pre><span style=\"color:blue;\">Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\nobjFolder.Move \"c:\\Temp\\Ordner 2\\\"<\/pre>\n<p>Inhalt von <b>Ordner 1 <\/b>in <b>Ordner 2 <\/b>verschieben funktioniert nicht, sondern liefert Fehler <b>58<\/b>, <b>Datei existiert bereits<\/b>:<\/p>\n<pre><span style=\"color:blue;\">Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\nobjFolder.Move \"c:\\Temp\\Ordner 2\"<\/pre>\n<p><b>Ordner 1 <\/b>in <b>Ordner 3 <\/b>verschieben bewirkt letztlich ein Umbenennen von <b>Ordner 1 <\/b>in <b>Ordner 3<\/b>:<\/p>\n<pre><span style=\"color:blue;\">Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\nobjFolder.Move \"c:\\Temp\\Ordner 3\"<\/pre>\n<h2>Verzeichnis l&ouml;schen mit Delete<\/h2>\n<p>Zum L&ouml;schen des mit <b>objFolder<\/b> markierten Verzeichnisses brauchen wir einfach nur die <b>Delete<\/b>-Methode dieses Objekts aufzurufen:<\/p>\n<pre><span style=\"color:blue;\">Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\nobjFolder.Delete<\/pre>\n<h2>Ermitteln des Drive-Objekts mit Drive<\/h2>\n<p>Mit der <b>Drive<\/b>-Eigenschaft der <b>Folder<\/b>-Klasse k&ouml;nnen wir das <b>Drive<\/b>-Objekt zu dem Ordner ermitteln. Wenn man also zum Beispiel einen neuen Ordner im gleichen Laufwerk anlegen m&ouml;chte, w&auml;re dies ein guter Startpunkt:<\/p>\n<pre><span style=\"color:blue;\">Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\n<span style=\"color:blue;\">Set<\/span> objDrive = objFolder.Drive\r\n<span style=\"color:blue;\">Debug.Print<\/span> objDrive.Path<\/pre>\n<h2>Files-Auflistung mit Files<\/h2>\n<p>Mit der <b>Files<\/b>-Eigenschaft holen wir eine <b>Files<\/b>-Auflistung der Dateien eines Verzeichnisses. Hier geben wir die Anzahl der enthaltenen Dateien aus &#8211; weiter unten zeigen wir weitere Optionen der <b>Files<\/b>-Auflistung:<\/p>\n<pre><span style=\"color:blue;\">Dim <\/span>objFiles<span style=\"color:blue;\"> As <\/span>Scripting.Files\r\n---\r\n<span style=\"color:blue;\">Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\n<span style=\"color:blue;\">Set<\/span> objFiles = objFolder.Files\r\n<span style=\"color:blue;\">Debug.Print<\/span> objFiles.Count<\/pre>\n<h2>Folders-Auflistung mit SubFolders<\/h2>\n<p>Auf &auml;hnliche Weise k&ouml;nnen wir die Auflistung der Unterordner eines Verzeichnisses holen. Dazu nutzen wir die <b>SubFolders<\/b>-Eigenschaft.<\/p>\n<p>Das Ergebnis speichern wir in einem <b>Folders<\/b>-Objekt und geben anschlie&szlig;end die Anzahl der Unterordner aus:<\/p>\n<pre><span style=\"color:blue;\">Dim <\/span>objFolder<span style=\"color:blue;\"> As <\/span>Scripting.Folder\r\n<span style=\"color:blue;\">Dim <\/span>objFolders<span style=\"color:blue;\"> As <\/span>Scripting.Folders\r\n<span style=\"color:blue;\">Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\n<span style=\"color:blue;\">Set<\/span> objFolders = objFolder.SubFolders\r\n<span style=\"color:blue;\">Debug.Print<\/span> objFolders.Count<\/pre>\n<h2>&Uuml;bergeordnetes Verzeichnis mit ParentFolder<\/h2>\n<p>Mit der Eigenschaft <b>ParentFolder <\/b>holen wir ein <b>Folder<\/b>-Objekt f&uuml;r das &uuml;bergeordneten Verzeichnis. Hier speichern wir es in einem <b>Folder<\/b>-Objekt namens <b>objParentFolder <\/b>und geben das Verzeichnis mit <b>Path<\/b> aus:<\/p>\n<pre><span style=\"color:blue;\">Dim <\/span>objFolder<span style=\"color:blue;\"> As <\/span>Scripting.Folder\r\n<span style=\"color:blue;\">Dim <\/span>objParentFolder<span style=\"color:blue;\"> As <\/span>Scripting.Folder\r\n<span style=\"color:blue;\">Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\\Ordner 2\")\r\n<span style=\"color:blue;\">Set<\/span> objParentFolder = objFolder.ParentFolder\r\n<span style=\"color:blue;\">Debug.Print<\/span> objParentFolder.Path<\/pre>\n<h2>Erstellen einer Textdatei mit CreateTextFile<\/h2>\n<p>Mit <b>CreateTextFile <\/b>k&ouml;nnen wir im Verzeichnis aus <b>objFolder <\/b>eine neue, leere Textdatei erstellen:<\/p>\n<pre><span style=\"color:blue;\">Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\nobjFolder.CreateTextFile \"Test.txt\"<\/pre>\n<p>Mehr zur Verwendung von Textdateien findest Du weiter unten.<\/p>\n<h2>Verzeichnisse durchlaufen &uuml;ber die Folders-Auflistung<\/h2>\n<p>Die <b>Folders<\/b>-Auflistung, die wir mit der <b>SubFolders<\/b>-Eigenschaft holen k&ouml;nnen, k&ouml;nnen wir durchlaufen und damit alle Unterordner ausgeben lassen.<\/p>\n<p>Dazu nutzen wir eine <b>For Each<\/b>-Schleife:<\/p>\n<pre><span style=\"color:blue;\">Dim <\/span>objFolder<span style=\"color:blue;\"> As <\/span>Scripting.Folder\r\n<span style=\"color:blue;\">Dim <\/span>objFolders<span style=\"color:blue;\"> As <\/span>Scripting.Folders\r\n<span style=\"color:blue;\">Set<\/span> objFolder = fso.GetFolder(CurrentProject.Path)\r\n<span style=\"color:blue;\">Set<\/span> objFolders = objFolder.SubFolders\r\nFor Each objFolder In objFolders\r\n     <span style=\"color:blue;\">Debug.Print<\/span> objFolder\r\n<span style=\"color:blue;\">Next<\/span> objFolder<\/pre>\n<h2>Verzeichnis zur Folders-Auflistung hinzuf&uuml;gen<\/h2>\n<p>Wenn wir einmal eine <b>Folders<\/b>-Auflistung referenziert haben, k&ouml;nnen wir mit der <b>Add<\/b>-Methode ein neues Unterverzeichnis zum referenzierten Verzeichnis hinzuf&uuml;gen:<\/p>\n<pre><span style=\"color:blue;\">Dim <\/span>objFolder<span style=\"color:blue;\"> As <\/span>Scripting.Folder\r\n<span style=\"color:blue;\">Dim <\/span>objFolders<span style=\"color:blue;\"> As <\/span>Scripting.Folders\r\n<span style=\"color:blue;\">Set<\/span> objFolder = fso.GetFolder(CurrentProject.Path)\r\n<span style=\"color:blue;\">Set<\/span> objFolders = objFolder.SubFolders\r\nobjFolders.Add \"Folder 4\"<\/pre>\n<h2>Mit Dateien arbeiten<\/h2>\n<p>Nun folgen die Funktionen der <b>FileSystemObject<\/b>-Klasse f&uuml;r das Arbeiten mit Dateien.<\/p>\n<p>Hier k&ouml;nnen wir pr&uuml;fen, ob eine Datei existiert, Dateien l&ouml;schen, kopieren oder verschieben, Dateinamen und -version ermitteln oder mit <b>GetFile <\/b>auf <b>File<\/b>-Objekte zugreifen.<\/p>\n<p>Au&szlig;erdem k&ouml;nnen wir alle Dateien eines Verzeichnisses mit der <b>Files<\/b>-Auflistung eines <b>Folder<\/b>-Objekts durchlaufen und verarbeiten oder analysieren.<\/p>\n<h2>Mit FileExists pr&uuml;fen, ob eine Datei existiert<\/h2>\n<p>Mit der Funktion <b>FileExists <\/b>k&ouml;nnen wir pr&uuml;fen, ob eine Datei vorhanden ist:<\/p>\n<pre><span style=\"color:blue;\">Debug.Print<\/span> fso.FileExists(CurrentDb.Name)<\/pre>\n<p>Hier pr&uuml;fen wir, ob die aktuelle Datenbankdatei vorhanden ist, was nat&uuml;rlich das Ergebnis <b>True <\/b>zur&uuml;ckliefert.<\/p>\n<h2>Datei l&ouml;schen mit DeleteFile<\/h2>\n<p>Mit der <b>DeleteFile<\/b>-Methode k&ouml;nnen wir die Datei mit dem angegebenen Pfad l&ouml;schen:<\/p>\n<pre>fso.DeleteFile CurrentProject.Path & \"\\test.txt\"<\/pre>\n<h2>Datei kopieren mit CopyFile<\/h2>\n<p>Mit der Methode <b>CopyFile <\/b>kopiert eine Datei in die angegebene Datei:<\/p>\n<pre>fso.CopyFile \"c:\\Temp\\test.txt\", \"c:\\Temp\\test2.txt\"<\/pre>\n<h2>Datei verschieben mit MoveFile<\/h2>\n<p>Mit der <b>MoveFile<\/b>-Methode k&ouml;nnen wir eine Datei verschieben.<\/p>\n<p>Bei Angabe des gleichen Quell- wie Zielpfades wird die Datei prinzipiell umbenannt:<\/p>\n<pre>fso.MoveFile \"c:\\Temp\\test.txt\", \"c:\\Temp\\test3.txt\"<\/pre>\n<p>Wir k&ouml;nnen diese auch in ein anderes Verzeichnis verschieben:<\/p>\n<pre>fso.MoveFile \"c:\\Temp\\test.txt\", _\r\n     \"c:\\Temp\\Ordner 1\\test3.txt\"<\/pre>\n<h2>Dateiname ermitteln mit GetFileName<\/h2>\n<p>Der <b>GetFileName<\/b>-Funktion k&ouml;nnen wir den vollst&auml;ndigen Pfad zu einer Datei &uuml;bergeben und erhalten lediglich den Dateinamen ohne Laufwerks- und Verzeichnisangabe als Ergebnis:<\/p>\n<pre><span style=\"color:blue;\">Debug.Print<\/span> fso.GetFileName(CurrentDb.Name)<\/pre>\n<h2>File-Objekt holen mit GetFile<\/h2>\n<p>Auf &auml;hnliche Art holen wir uns ein <b>File<\/b>-Objekt auf Basis der f&uuml;r die <b>GetFile<\/b>-Funktion angegebenen Datei.<\/p>\n<p>Hier geben wir den Wert der Eigenschaft <b>Name <\/b>des <b>File<\/b>-Objekts im Direktbereich aus:<\/p>\n<pre><span style=\"color:blue;\">Dim <\/span>objFile<span style=\"color:blue;\"> As <\/span>Scripting.File\r\n<span style=\"color:blue;\">Set<\/span> objFile = fso.GetFile(CurrentDb.Name)\r\n<span style=\"color:blue;\">Debug.Print<\/span> objFile.Name<\/pre>\n<h2>Dateiversion ermitteln mit GetFileVersion<\/h2>\n<p>Mit <b>GetFileVersion <\/b>holen wir die Dateiversion. F&uuml;r die aktuelle Datenbank liefert die Funktion eine leere Zeichenkette:<\/p>\n<pre><span style=\"color:blue;\">Debug.Print<\/span> fso.GetFileVersion(CurrentDb.Name)<\/pre>\n<p>Tats&auml;chlich liefert <b>GetFileVersion <\/b>nur eine Version f&uuml;r Dateien wie <b>.exe<\/b>, <b>.dll <\/b>und &auml;hnliche Dateien.<\/p>\n<p>So k&ouml;nnen wir beispielsweise wie folgt die Version der <b>MSAccess.exe <\/b>ermitteln:<\/p>\n<pre><span style=\"color:blue;\">Debug.Print<\/span> fso.GetFileVersion(SysCmd(acSysCmdAccessDir) _\r\n     & \"\\MSAccess.exe\")<\/pre>\n<h2>Dateien eines Verzeichnisses durchlaufen mit der Files-Auflistung<\/h2>\n<p>Genau wir mit der <b>Folders<\/b>-Auflistung f&uuml;r Verzeichnisse k&ouml;nnen wir mit der <b>Files<\/b>-Auflistung alle Dateien eines Verzeichnisses durchlaufen &#8211; hier beispielsweise f&uuml;r alle Dateien des aktuellen Datenbankverzeichnisses:<\/p>\n<pre><span style=\"color:blue;\">Dim <\/span>objFolder<span style=\"color:blue;\"> As <\/span>Scripting.Folder\r\n<span style=\"color:blue;\">Dim <\/span>objFiles<span style=\"color:blue;\"> As <\/span>Scripting.Files\r\n<span style=\"color:blue;\">Dim <\/span>objFile<span style=\"color:blue;\"> As <\/span>Scripting.File\r\n<span style=\"color:blue;\">Set<\/span> fso = <span style=\"color:blue;\">New<\/span> Scripting.FileSystemObject\r\n<span style=\"color:blue;\">Set<\/span> objFolder = fso.GetFolder(CurrentProject.Path)\r\n<span style=\"color:blue;\">Set<\/span> objFiles = objFolder.Files\r\nFor Each objFile In objFiles\r\n     <span style=\"color:blue;\">Debug.Print<\/span> objFile.Name\r\n<span style=\"color:blue;\">Next<\/span> objFile<\/pre>\n<h2>Operationen der File-Klasse<\/h2>\n<p>Genau wie die <b>Folder<\/b>-Klasse liefert auch die <b>File<\/b>-Klasse einige Methoden und Eigenschaften. Die folgenden Eigenschaften und Methoden funktionieren genauso wie bei der oben beschriebenen <b>Folder<\/b>-Klasse:<\/p>\n<p><b>Attributes<\/b>, <b>Copy<\/b>, <b>DateCreated<\/b>, <b>DateLastAccessed<\/b>, <b>DateLastModified<\/b>, <b>Delete<\/b>, <b>Drive<\/b>, <b>Move<\/b>, <b>Name<\/b>, <b>ParentFolder<\/b>, <b>Path<\/b>, <b>ShortName<\/b>, <b>ShortPath<\/b>, <b>Size<\/b>, <b>Type<\/b>.<\/p>\n<p>Lediglich die <b>OpenAsTextStream<\/b>-Methode ist neu. Mit dieser k&ouml;nnen wir ein <b>TextStream<\/b>-Objekt auf Basis einer Datei &ouml;ffnen. Mehr dazu gleich im Anschluss.<\/p>\n<h2>Mit Textdateien arbeiten<\/h2>\n<p>Schlie&szlig;lich folgen drei Funktionen, mit denen wir speziell mit Textdateien arbeiten k&ouml;nnen.<\/p>\n<p>Diese k&ouml;nnen wir nutzen, um Textdateien zu erstellen, diese auszulesen und sie zum Beschreiben zu &ouml;ffnen.<\/p>\n<p>Diese Methoden und Funktionen beschreiben wir in einem weiteren Artikel namens <b>Textdateien und Stream mit FileSytemObject <\/b>(<b>www.vbentwickler.de\/479<\/b>).<\/p>\n<ul>\n<li><b>CreateTextFile<\/b>: Erstellt eine leere Textdatei.<\/li>\n<li><b>GetStandardStream<\/b>: Holt einen Stream aus einer Datei.<\/li>\n<li><b>OpenTextFile<\/b>: &Ouml;ffnet eine Datei zum Bearbeiten.<\/li>\n<\/ul>\n<h2>Weitere Funktionen<\/h2>\n<p>Es gibt noch einige weitere Funktionen, mit denen wir zum Beispiel Pfade aus Verzeichnis und Dateinamen zusammenstellen, absolute Pfadnamen holen oder die Dateierweiterung auslesen k&ouml;nnen.<\/p>\n<h2>Pfad aus Verzeichnis und Dateiname zusammenstellen<\/h2>\n<p>Als Access-Entwickler haben wir &ouml;fter die Aufgabe, einen Pfad aus einem Verzeichnis und einem Dateinamen zusammenzustellen. Beispiel:<\/p>\n<pre><span style=\"color:blue;\">Debug.Print<\/span> CurrentProject.Path & \"\\Dateiname.txt\"<\/pre>\n<p>Wir wissen an dieser Stelle, dass <b>CurrentProject.Path <\/b>den Namen des Verzeichnisses der aktuellen Access-Datenbank liefert, und zwar ohne abschlie&szlig;enden Backslash, sodass wir dieses Zeichen dem angeh&auml;ngten Dateinamen voranstellen.<\/p>\n<p>Damit wir nicht immer pr&uuml;fen m&uuml;ssen, ob im Verzeichnis ein abschlie&szlig;endes Backslash-Zeichen enthalten ist, k&ouml;nnen wir die Funktion <b>BuildPath<\/b> nutzen. Diese pr&uuml;ft das automatisch und erg&auml;nzt das Backslash-Zeichen gegebenenfalls:<\/p>\n<pre><span style=\"color:blue;\">Public Sub <\/span>PfadAusVerzeichnisUndDateiname()\r\n     <span style=\"color:blue;\">Dim <\/span>fso<span style=\"color:blue;\"> As <\/span>Scripting.FileSystemObject\r\n     <span style=\"color:blue;\">Set<\/span> fso = <span style=\"color:blue;\">New<\/span> Scripting.FileSystemObject\r\n     <span style=\"color:blue;\">Debug.Print<\/span> fso.BuildPath(CurrentProject.Path, _\r\n         \"Test.txt\")\r\n<span style=\"color:blue;\">End Sub<\/span><\/pre>\n<h2>Den absoluten Pfadnamen holen<\/h2>\n<p>Die Funktion <b>GetAbsolutePathname <\/b>holt den Pfad f&uuml;r die angegebene Datei oder den angegebenen Ordner ausgehend vom aktuellen Basispfad.<\/p>\n<p>Diesen k&ouml;nnen wir mit der VBA-Funktion <b>CurDir <\/b>ermitteln.<\/p>\n<ul>\n<li>Mit einer leeren Zeichenkette liefert <b>GetAbsolutePathname <\/b>also den gleichen Pfad wie <b>CurDir<\/b>.<\/li>\n<li>Mit einer Datei wie <b>Test.txt <\/b>als Parameter liefert <b>GetAbsolutePathname <\/b>den Pfad aus <b>CurDir <\/b>plus dieser Datei.<\/li>\n<li>Mit <b>&#8220;..&#8221; <\/b>als Parameter wird das &uuml;bergeordnete Verzeichnis geliefert.<\/li>\n<li>Mit <b>&#8220;..\\.. &#8221; <\/b>als Parameter erhalten wir das Verzeichnis zwei Ebenen &uuml;ber dem aus <b>CurDir<\/b>.<\/li>\n<\/ul>\n<h2>Den Basisnamen holen<\/h2>\n<p>Mit <b>GetBaseName <\/b>holen wir den reinen Dateinamen ohne Dateiendung.<\/p>\n<p>Dabei k&ouml;nnen wir beispielsweise einen kompletten Pfad zu einer Datei, aber auch nur einen Dateinamen &uuml;bergeben.<\/p>\n<p>In den beiden folgenden Beispielen erhalten wir jeweils den Wert <b>Test<\/b>:<\/p>\n<pre><span style=\"color:blue;\">Debug.Print<\/span> fso.GetBaseName(\"c:\\Temp\\Ordner 1\\Test.txt\")\r\n<span style=\"color:blue;\">Debug.Print<\/span> fso.GetBaseName(\"Test.txt\")<\/pre>\n<h2>Dateierweiterung holen mit GetExtensionName<\/h2>\n<p>Auch die Dateierweiterung k&ouml;nnen wir auslesen. Dazu nutzen wir die Funktion <b>GetExtensionName<\/b>.<\/p>\n<p>Auch hier k&ouml;nnen wir sowohl vollst&auml;ndige Pfade als auch Dateinamen &uuml;bergeben:<\/p>\n<pre><span style=\"color:blue;\">Debug.Print<\/span> fso.GetExtensionName(c:\\Temp\\Ordner 1\\Test.txt\")\r\n<span style=\"color:blue;\">Debug.Print<\/span> fso.GetExtensionName(\"Test.txt\")<\/pre>\n<h2>Dateiname f&uuml;r tempor&auml;re Dateien holen mit GetTempName<\/h2>\n<p>Wenn wir einmal einen Namen f&uuml;r eine tempor&auml;re Datei ben&ouml;tigen, k&ouml;nnen wir diesen mit <b>GetTempName <\/b>ermitteln.<\/p>\n<p>Der folgende Aufruf holt einen Namen wie <b>radF5C86.tmp<\/b>:<\/p>\n<pre><span style=\"color:blue;\">Debug.Print<\/span> fso.GetTempName()<\/pre>\n<h2>Zusammenfassung und Ausblick<\/h2>\n<p>Mit den Methoden, Eigenschaften und Funktionen der <b>FileSystemObject<\/b>-Klasse und der enthaltenen Klassen k&ouml;nnen wir alle denkbaren Dateioperationen durchf&uuml;hren.<\/p>\n<p>Das gilt sowohl f&uuml;r Laufwerke (<b>Drive<\/b>), Ordner (<b>Folder<\/b>) und Dateien (<b>File<\/b>). Wir k&ouml;nnen diverse Operationen zum Anlegen, Kopieren, Verschieben und L&ouml;schen von Dateien und Verzeichnissen erledigen.<\/p>\n<p>Au&szlig;erdem k&ouml;nnen wir damit auf Textdateien und ihre Inhalte zugreifen. Wie das gelingt, zeigen wir in einem weiteren Artikel namens <b>Textdateien und Stream mit FileSytemObject <\/b>(<b>www.vbentwickler.de\/479<\/b>).<\/p>\n<h2>Downloads zu diesem Beitrag<\/h2>\n<p>Enthaltene Beispieldateien:<\/p>\n<p>DateimanagementMitFileSystemObject.accdb<\/p>\n<p><a href=\"..\/fileadmin\/beispiele\/05C5101B-D25B-4C7D-ADAB-3F0FCC8AE7E7\/vbe_478.zip\">Download<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"<p>VBA bietet bereits einige Befehle, mit denen wir Dateioperationen ausf&uuml;hren k&ouml;nnen. Wir k&ouml;nnen mit MkDir neue Verzeichnisse erstellen, mit Dir pr&uuml;fen, ob Dateien oder Verzeichnisse vorhanden sind oder mit Kill Dateien l&ouml;schen. Diese Befehle sind aber recht kompliziert in der Handhabung. Daher schauen wir uns in diesem Artikel einmal die Klasse &#8220;FileSystemObject&#8221; an, mit der wir deutlich komfortabler mit Dateien und Verzeichnissen arbeiten k&ouml;nnen. Damit l&auml;sst sich alles erledigen, was mit dem Anlegen, Kopieren, Verschieben und L&ouml;schen zusammenh&auml;ngt &#8211; und vieles mehr.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662025,66042025,44000023,44000025,44000028],"tags":[],"yst_prominent_words":[],"class_list":["post-55000478","post","type-post","status-publish","format-standard","hentry","category-662025","category-66042025","category-PowerApps","category-VBAProgrammierung","category-Word_programmieren"],"aioseo_notices":[],"aioseo_head":"\n\t\t<!-- All in One SEO 4.9.10 - aioseo.com -->\n\t<meta name=\"description\" content=\"VBA bietet bereits einige Befehle, mit denen wir Dateioperationen ausf\u00fchren k\u00f6nnen. Wir k\u00f6nnen mit MkDir neue Verzeichnisse erstellen, mit Dir pr\u00fcfen, ob Dateien oder Verzeichnisse vorhanden sind oder mit Kill Dateien l\u00f6schen. Diese Befehle sind aber recht kompliziert in der Handhabung. Daher schauen wir uns in diesem Artikel einmal die Klasse &quot;FileSystemObject&quot; an, mit der wir deutlich komfortabler mit Dateien und Verzeichnissen arbeiten k\u00f6nnen. Damit l\u00e4sst sich alles erledigen, was mit dem Anlegen, Kopieren, Verschieben und L\u00f6schen zusammenh\u00e4ngt - und vieles mehr.\" \/>\n\t<meta name=\"robots\" content=\"max-image-preview:large\" \/>\n\t<meta name=\"author\" content=\"Andr\u00e9 Minhorst\"\/>\n\t<link rel=\"canonical\" href=\"https:\/\/vbentwickler.de\/Dateimanagement_mit_dem_FileSystemObject\/\" \/>\n\t<meta name=\"generator\" content=\"All in One SEO (AIOSEO) 4.9.10\" \/>\n\t\t<meta property=\"og:locale\" content=\"de_DE\" \/>\n\t\t<meta property=\"og:site_name\" content=\"Visual Basic Entwickler - Das Magazin f\u00fcr Datenbankentwickler auf Basis von Visual Studio und Co.\" \/>\n\t\t<meta property=\"og:type\" content=\"article\" \/>\n\t\t<meta property=\"og:title\" content=\"Dateimanagement mit dem FileSystemObject - Visual Basic Entwickler\" \/>\n\t\t<meta property=\"og:description\" content=\"VBA bietet bereits einige Befehle, mit denen wir Dateioperationen ausf\u00fchren k\u00f6nnen. Wir k\u00f6nnen mit MkDir neue Verzeichnisse erstellen, mit Dir pr\u00fcfen, ob Dateien oder Verzeichnisse vorhanden sind oder mit Kill Dateien l\u00f6schen. Diese Befehle sind aber recht kompliziert in der Handhabung. Daher schauen wir uns in diesem Artikel einmal die Klasse &quot;FileSystemObject&quot; an, mit der wir deutlich komfortabler mit Dateien und Verzeichnissen arbeiten k\u00f6nnen. Damit l\u00e4sst sich alles erledigen, was mit dem Anlegen, Kopieren, Verschieben und L\u00f6schen zusammenh\u00e4ngt - und vieles mehr.\" \/>\n\t\t<meta property=\"og:url\" content=\"https:\/\/vbentwickler.de\/Dateimanagement_mit_dem_FileSystemObject\/\" \/>\n\t\t<meta property=\"og:image\" content=\"https:\/\/datenbankentwickler.net\/wp-content\/uploads\/2022\/08\/cropped-header_vbe-1.png\" \/>\n\t\t<meta property=\"og:image:secure_url\" content=\"https:\/\/datenbankentwickler.net\/wp-content\/uploads\/2022\/08\/cropped-header_vbe-1.png\" \/>\n\t\t<meta property=\"article:published_time\" content=\"2025-10-12T10:40:42+00:00\" \/>\n\t\t<meta property=\"article:modified_time\" content=\"-001-11-30T00:00:00+00:00\" \/>\n\t\t<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n\t\t<meta name=\"twitter:title\" content=\"Dateimanagement mit dem FileSystemObject - Visual Basic Entwickler\" \/>\n\t\t<meta name=\"twitter:description\" content=\"VBA bietet bereits einige Befehle, mit denen wir Dateioperationen ausf\u00fchren k\u00f6nnen. Wir k\u00f6nnen mit MkDir neue Verzeichnisse erstellen, mit Dir pr\u00fcfen, ob Dateien oder Verzeichnisse vorhanden sind oder mit Kill Dateien l\u00f6schen. Diese Befehle sind aber recht kompliziert in der Handhabung. Daher schauen wir uns in diesem Artikel einmal die Klasse &quot;FileSystemObject&quot; an, mit der wir deutlich komfortabler mit Dateien und Verzeichnissen arbeiten k\u00f6nnen. Damit l\u00e4sst sich alles erledigen, was mit dem Anlegen, Kopieren, Verschieben und L\u00f6schen zusammenh\u00e4ngt - und vieles mehr.\" \/>\n\t\t<meta name=\"twitter:image\" content=\"https:\/\/datenbankentwickler.net\/wp-content\/uploads\/2022\/08\/cropped-header_vbe-1.png\" \/>\n\t\t<script type=\"application\/ld+json\" class=\"aioseo-schema\">\n\t\t\t{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"BlogPosting\",\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/Dateimanagement_mit_dem_FileSystemObject\\\/#blogposting\",\"name\":\"Dateimanagement mit dem FileSystemObject - Visual Basic Entwickler\",\"headline\":\"Dateimanagement mit dem FileSystemObject\",\"author\":{\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/author\\\/andreminhorst-com\\\/#author\"},\"publisher\":{\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/#organization\"},\"image\":{\"@type\":\"ImageObject\",\"url\":\"..\\\/fileadmin\\\/_temp_\\\/2025_04\\\/pic_478_002.png\",\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/Dateimanagement_mit_dem_FileSystemObject\\\/#articleImage\"},\"datePublished\":\"2025-08-01T00:00:00+00:00\",\"dateModified\":\"-0001-11-30T00:00:00+00:00\",\"inLanguage\":\"de-DE\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/Dateimanagement_mit_dem_FileSystemObject\\\/#webpage\"},\"isPartOf\":{\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/Dateimanagement_mit_dem_FileSystemObject\\\/#webpage\"},\"articleSection\":\"2025, 4\\\/2025, PowerApps, VBA-Programmierung, Word programmieren\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/Dateimanagement_mit_dem_FileSystemObject\\\/#breadcrumblist\",\"itemListElement\":[{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/vbentwickler.de#listItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/vbentwickler.de\",\"nextItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/category\\\/2025\\\/#listItem\",\"name\":\"2025\"}},{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/category\\\/2025\\\/#listItem\",\"position\":2,\"name\":\"2025\",\"item\":\"https:\\\/\\\/vbentwickler.de\\\/category\\\/2025\\\/\",\"nextItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/category\\\/2025\\\/4\\\/2025\\\/#listItem\",\"name\":\"4\\\/2025\"},\"previousItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/vbentwickler.de#listItem\",\"name\":\"Home\"}},{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/category\\\/2025\\\/4\\\/2025\\\/#listItem\",\"position\":3,\"name\":\"4\\\/2025\",\"item\":\"https:\\\/\\\/vbentwickler.de\\\/category\\\/2025\\\/4\\\/2025\\\/\",\"nextItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/Dateimanagement_mit_dem_FileSystemObject\\\/#listItem\",\"name\":\"Dateimanagement mit dem FileSystemObject\"},\"previousItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/category\\\/2025\\\/#listItem\",\"name\":\"2025\"}},{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/Dateimanagement_mit_dem_FileSystemObject\\\/#listItem\",\"position\":4,\"name\":\"Dateimanagement mit dem FileSystemObject\",\"previousItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/category\\\/2025\\\/4\\\/2025\\\/#listItem\",\"name\":\"4\\\/2025\"}}]},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/#organization\",\"name\":\"Datenbankentwickler\",\"description\":\"Das Magazin f\\u00fcr Datenbankentwickler auf Basis von Visual Studio und Co.\",\"url\":\"https:\\\/\\\/vbentwickler.de\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"url\":\"https:\\\/\\\/vbentwickler.de\\\/wp-content\\\/uploads\\\/2022\\\/08\\\/cropped-header_vbe-1.png\",\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/Dateimanagement_mit_dem_FileSystemObject\\\/#organizationLogo\",\"width\":664,\"height\":225},\"image\":{\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/Dateimanagement_mit_dem_FileSystemObject\\\/#organizationLogo\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/author\\\/andreminhorst-com\\\/#author\",\"url\":\"https:\\\/\\\/vbentwickler.de\\\/author\\\/andreminhorst-com\\\/\",\"name\":\"Andr\\u00e9 Minhorst\",\"image\":{\"@type\":\"ImageObject\",\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/Dateimanagement_mit_dem_FileSystemObject\\\/#authorImage\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"width\":96,\"height\":96,\"caption\":\"Andr\\u00e9 Minhorst\"}},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/Dateimanagement_mit_dem_FileSystemObject\\\/#webpage\",\"url\":\"https:\\\/\\\/vbentwickler.de\\\/Dateimanagement_mit_dem_FileSystemObject\\\/\",\"name\":\"Dateimanagement mit dem FileSystemObject - Visual Basic Entwickler\",\"description\":\"VBA bietet bereits einige Befehle, mit denen wir Dateioperationen ausf\\u00fchren k\\u00f6nnen. Wir k\\u00f6nnen mit MkDir neue Verzeichnisse erstellen, mit Dir pr\\u00fcfen, ob Dateien oder Verzeichnisse vorhanden sind oder mit Kill Dateien l\\u00f6schen. Diese Befehle sind aber recht kompliziert in der Handhabung. Daher schauen wir uns in diesem Artikel einmal die Klasse \\\"FileSystemObject\\\" an, mit der wir deutlich komfortabler mit Dateien und Verzeichnissen arbeiten k\\u00f6nnen. Damit l\\u00e4sst sich alles erledigen, was mit dem Anlegen, Kopieren, Verschieben und L\\u00f6schen zusammenh\\u00e4ngt - und vieles mehr.\",\"inLanguage\":\"de-DE\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/#website\"},\"breadcrumb\":{\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/Dateimanagement_mit_dem_FileSystemObject\\\/#breadcrumblist\"},\"author\":{\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/author\\\/andreminhorst-com\\\/#author\"},\"creator\":{\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/author\\\/andreminhorst-com\\\/#author\"},\"datePublished\":\"2025-08-01T00:00:00+00:00\",\"dateModified\":\"-0001-11-30T00:00:00+00:00\"},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/#website\",\"url\":\"https:\\\/\\\/vbentwickler.de\\\/\",\"name\":\"Datenbankentwickler\",\"description\":\"Das Magazin f\\u00fcr Datenbankentwickler auf Basis von Visual Studio und Co.\",\"inLanguage\":\"de-DE\",\"publisher\":{\"@id\":\"https:\\\/\\\/vbentwickler.de\\\/#organization\"}}]}\n\t\t<\/script>\n\t\t<!-- All in One SEO -->\n\n","aioseo_head_json":{"title":"Dateimanagement mit dem FileSystemObject - Visual Basic Entwickler","description":"VBA bietet bereits einige Befehle, mit denen wir Dateioperationen ausf\u00fchren k\u00f6nnen. Wir k\u00f6nnen mit MkDir neue Verzeichnisse erstellen, mit Dir pr\u00fcfen, ob Dateien oder Verzeichnisse vorhanden sind oder mit Kill Dateien l\u00f6schen. Diese Befehle sind aber recht kompliziert in der Handhabung. Daher schauen wir uns in diesem Artikel einmal die Klasse \"FileSystemObject\" an, mit der wir deutlich komfortabler mit Dateien und Verzeichnissen arbeiten k\u00f6nnen. Damit l\u00e4sst sich alles erledigen, was mit dem Anlegen, Kopieren, Verschieben und L\u00f6schen zusammenh\u00e4ngt - und vieles mehr.","canonical_url":"https:\/\/vbentwickler.de\/Dateimanagement_mit_dem_FileSystemObject\/","robots":"max-image-preview:large","keywords":"","webmasterTools":{"miscellaneous":""},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"BlogPosting","@id":"https:\/\/vbentwickler.de\/Dateimanagement_mit_dem_FileSystemObject\/#blogposting","name":"Dateimanagement mit dem FileSystemObject - Visual Basic Entwickler","headline":"Dateimanagement mit dem FileSystemObject","author":{"@id":"https:\/\/vbentwickler.de\/author\/andreminhorst-com\/#author"},"publisher":{"@id":"https:\/\/vbentwickler.de\/#organization"},"image":{"@type":"ImageObject","url":"..\/fileadmin\/_temp_\/2025_04\/pic_478_002.png","@id":"https:\/\/vbentwickler.de\/Dateimanagement_mit_dem_FileSystemObject\/#articleImage"},"datePublished":"2025-08-01T00:00:00+00:00","dateModified":"-0001-11-30T00:00:00+00:00","inLanguage":"de-DE","mainEntityOfPage":{"@id":"https:\/\/vbentwickler.de\/Dateimanagement_mit_dem_FileSystemObject\/#webpage"},"isPartOf":{"@id":"https:\/\/vbentwickler.de\/Dateimanagement_mit_dem_FileSystemObject\/#webpage"},"articleSection":"2025, 4\/2025, PowerApps, VBA-Programmierung, Word programmieren"},{"@type":"BreadcrumbList","@id":"https:\/\/vbentwickler.de\/Dateimanagement_mit_dem_FileSystemObject\/#breadcrumblist","itemListElement":[{"@type":"ListItem","@id":"https:\/\/vbentwickler.de#listItem","position":1,"name":"Home","item":"https:\/\/vbentwickler.de","nextItem":{"@type":"ListItem","@id":"https:\/\/vbentwickler.de\/category\/2025\/#listItem","name":"2025"}},{"@type":"ListItem","@id":"https:\/\/vbentwickler.de\/category\/2025\/#listItem","position":2,"name":"2025","item":"https:\/\/vbentwickler.de\/category\/2025\/","nextItem":{"@type":"ListItem","@id":"https:\/\/vbentwickler.de\/category\/2025\/4\/2025\/#listItem","name":"4\/2025"},"previousItem":{"@type":"ListItem","@id":"https:\/\/vbentwickler.de#listItem","name":"Home"}},{"@type":"ListItem","@id":"https:\/\/vbentwickler.de\/category\/2025\/4\/2025\/#listItem","position":3,"name":"4\/2025","item":"https:\/\/vbentwickler.de\/category\/2025\/4\/2025\/","nextItem":{"@type":"ListItem","@id":"https:\/\/vbentwickler.de\/Dateimanagement_mit_dem_FileSystemObject\/#listItem","name":"Dateimanagement mit dem FileSystemObject"},"previousItem":{"@type":"ListItem","@id":"https:\/\/vbentwickler.de\/category\/2025\/#listItem","name":"2025"}},{"@type":"ListItem","@id":"https:\/\/vbentwickler.de\/Dateimanagement_mit_dem_FileSystemObject\/#listItem","position":4,"name":"Dateimanagement mit dem FileSystemObject","previousItem":{"@type":"ListItem","@id":"https:\/\/vbentwickler.de\/category\/2025\/4\/2025\/#listItem","name":"4\/2025"}}]},{"@type":"Organization","@id":"https:\/\/vbentwickler.de\/#organization","name":"Datenbankentwickler","description":"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Visual Studio und Co.","url":"https:\/\/vbentwickler.de\/","logo":{"@type":"ImageObject","url":"https:\/\/vbentwickler.de\/wp-content\/uploads\/2022\/08\/cropped-header_vbe-1.png","@id":"https:\/\/vbentwickler.de\/Dateimanagement_mit_dem_FileSystemObject\/#organizationLogo","width":664,"height":225},"image":{"@id":"https:\/\/vbentwickler.de\/Dateimanagement_mit_dem_FileSystemObject\/#organizationLogo"}},{"@type":"Person","@id":"https:\/\/vbentwickler.de\/author\/andreminhorst-com\/#author","url":"https:\/\/vbentwickler.de\/author\/andreminhorst-com\/","name":"Andr\u00e9 Minhorst","image":{"@type":"ImageObject","@id":"https:\/\/vbentwickler.de\/Dateimanagement_mit_dem_FileSystemObject\/#authorImage","url":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","width":96,"height":96,"caption":"Andr\u00e9 Minhorst"}},{"@type":"WebPage","@id":"https:\/\/vbentwickler.de\/Dateimanagement_mit_dem_FileSystemObject\/#webpage","url":"https:\/\/vbentwickler.de\/Dateimanagement_mit_dem_FileSystemObject\/","name":"Dateimanagement mit dem FileSystemObject - Visual Basic Entwickler","description":"VBA bietet bereits einige Befehle, mit denen wir Dateioperationen ausf\u00fchren k\u00f6nnen. Wir k\u00f6nnen mit MkDir neue Verzeichnisse erstellen, mit Dir pr\u00fcfen, ob Dateien oder Verzeichnisse vorhanden sind oder mit Kill Dateien l\u00f6schen. Diese Befehle sind aber recht kompliziert in der Handhabung. Daher schauen wir uns in diesem Artikel einmal die Klasse \"FileSystemObject\" an, mit der wir deutlich komfortabler mit Dateien und Verzeichnissen arbeiten k\u00f6nnen. Damit l\u00e4sst sich alles erledigen, was mit dem Anlegen, Kopieren, Verschieben und L\u00f6schen zusammenh\u00e4ngt - und vieles mehr.","inLanguage":"de-DE","isPartOf":{"@id":"https:\/\/vbentwickler.de\/#website"},"breadcrumb":{"@id":"https:\/\/vbentwickler.de\/Dateimanagement_mit_dem_FileSystemObject\/#breadcrumblist"},"author":{"@id":"https:\/\/vbentwickler.de\/author\/andreminhorst-com\/#author"},"creator":{"@id":"https:\/\/vbentwickler.de\/author\/andreminhorst-com\/#author"},"datePublished":"2025-08-01T00:00:00+00:00","dateModified":"-0001-11-30T00:00:00+00:00"},{"@type":"WebSite","@id":"https:\/\/vbentwickler.de\/#website","url":"https:\/\/vbentwickler.de\/","name":"Datenbankentwickler","description":"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Visual Studio und Co.","inLanguage":"de-DE","publisher":{"@id":"https:\/\/vbentwickler.de\/#organization"}}]},"og:locale":"de_DE","og:site_name":"Visual Basic Entwickler - Das Magazin f\u00fcr Datenbankentwickler auf Basis von Visual Studio und Co.","og:type":"article","og:title":"Dateimanagement mit dem FileSystemObject - Visual Basic Entwickler","og:description":"VBA bietet bereits einige Befehle, mit denen wir Dateioperationen ausf\u00fchren k\u00f6nnen. Wir k\u00f6nnen mit MkDir neue Verzeichnisse erstellen, mit Dir pr\u00fcfen, ob Dateien oder Verzeichnisse vorhanden sind oder mit Kill Dateien l\u00f6schen. Diese Befehle sind aber recht kompliziert in der Handhabung. Daher schauen wir uns in diesem Artikel einmal die Klasse &quot;FileSystemObject&quot; an, mit der wir deutlich komfortabler mit Dateien und Verzeichnissen arbeiten k\u00f6nnen. Damit l\u00e4sst sich alles erledigen, was mit dem Anlegen, Kopieren, Verschieben und L\u00f6schen zusammenh\u00e4ngt - und vieles mehr.","og:url":"https:\/\/vbentwickler.de\/Dateimanagement_mit_dem_FileSystemObject\/","og:image":"https:\/\/datenbankentwickler.net\/wp-content\/uploads\/2022\/08\/cropped-header_vbe-1.png","og:image:secure_url":"https:\/\/datenbankentwickler.net\/wp-content\/uploads\/2022\/08\/cropped-header_vbe-1.png","article:published_time":"2025-10-12T10:40:42+00:00","article:modified_time":"-001-11-30T00:00:00+00:00","twitter:card":"summary_large_image","twitter:title":"Dateimanagement mit dem FileSystemObject - Visual Basic Entwickler","twitter:description":"VBA bietet bereits einige Befehle, mit denen wir Dateioperationen ausf\u00fchren k\u00f6nnen. Wir k\u00f6nnen mit MkDir neue Verzeichnisse erstellen, mit Dir pr\u00fcfen, ob Dateien oder Verzeichnisse vorhanden sind oder mit Kill Dateien l\u00f6schen. Diese Befehle sind aber recht kompliziert in der Handhabung. Daher schauen wir uns in diesem Artikel einmal die Klasse &quot;FileSystemObject&quot; an, mit der wir deutlich komfortabler mit Dateien und Verzeichnissen arbeiten k\u00f6nnen. Damit l\u00e4sst sich alles erledigen, was mit dem Anlegen, Kopieren, Verschieben und L\u00f6schen zusammenh\u00e4ngt - und vieles mehr.","twitter:image":"https:\/\/datenbankentwickler.net\/wp-content\/uploads\/2022\/08\/cropped-header_vbe-1.png"},"aioseo_meta_data":{"post_id":"55000478","title":null,"description":null,"keywords":null,"keyphrases":null,"primary_term":null,"canonical_url":null,"og_title":null,"og_description":null,"og_object_type":"default","og_image_type":"default","og_image_url":null,"og_image_width":null,"og_image_height":null,"og_image_custom_url":null,"og_image_custom_fields":null,"og_video":null,"og_custom_url":null,"og_article_section":null,"og_article_tags":null,"twitter_use_og":false,"twitter_card":"default","twitter_image_type":"default","twitter_image_url":null,"twitter_image_custom_url":null,"twitter_image_custom_fields":null,"twitter_title":null,"twitter_description":null,"schema":{"blockGraphs":[],"customGraphs":[],"default":{"data":{"Article":[],"Course":[],"Dataset":[],"FAQPage":[],"Movie":[],"Person":[],"Product":[],"ProductReview":[],"Car":[],"Recipe":[],"Service":[],"SoftwareApplication":[],"WebPage":[]},"graphName":"","isEnabled":true},"graphs":[]},"schema_type":"default","schema_type_options":null,"pillar_content":false,"robots_default":true,"robots_noindex":false,"robots_noarchive":false,"robots_nosnippet":false,"robots_nofollow":false,"robots_noimageindex":false,"robots_noodp":false,"robots_notranslate":false,"robots_max_snippet":null,"robots_max_videopreview":null,"robots_max_imagepreview":"large","priority":null,"frequency":null,"local_seo":null,"limit_modified_date":false,"created":"2025-10-12 08:45:51","updated":"2026-05-16 09:21:10","ai":null,"breadcrumb_settings":null,"seo_analyzer_scan_date":null},"aioseo_breadcrumb":"<div class=\"aioseo-breadcrumbs\"><span class=\"aioseo-breadcrumb\">\n\t\t\t<a href=\"https:\/\/vbentwickler.de\" title=\"Home\">Home<\/a>\n\t\t<\/span><span class=\"aioseo-breadcrumb-separator\">&raquo;<\/span><span class=\"aioseo-breadcrumb\">\n\t\t\t<a href=\"https:\/\/vbentwickler.de\/category\/2025\/\" title=\"2025\">2025<\/a>\n\t\t<\/span><span class=\"aioseo-breadcrumb-separator\">&raquo;<\/span><span class=\"aioseo-breadcrumb\">\n\t\t\t<a href=\"https:\/\/vbentwickler.de\/category\/2025\/4\/2025\/\" title=\"4\/2025\">4\/2025<\/a>\n\t\t<\/span><span class=\"aioseo-breadcrumb-separator\">&raquo;<\/span><span class=\"aioseo-breadcrumb\">\n\t\t\tDateimanagement mit dem FileSystemObject\n\t\t<\/span><\/div>","aioseo_breadcrumb_json":[{"label":"Home","link":"https:\/\/vbentwickler.de"},{"label":"2025","link":"https:\/\/vbentwickler.de\/category\/2025\/"},{"label":"4\/2025","link":"https:\/\/vbentwickler.de\/category\/2025\/4\/2025\/"},{"label":"Dateimanagement mit dem FileSystemObject","link":"https:\/\/vbentwickler.de\/Dateimanagement_mit_dem_FileSystemObject\/"}],"_links":{"self":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000478","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/comments?post=55000478"}],"version-history":[{"count":0,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000478\/revisions"}],"wp:attachment":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/media?parent=55000478"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/categories?post=55000478"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/tags?post=55000478"},{"taxonomy":"yst_prominent_words","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/yst_prominent_words?post=55000478"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}