Zwei Wörter am Anfang eines Moduls ersparen Ihnen Stunden der Fehlersuche: Option Explicit. Wer sie vergisst, bekommt von VBA jeden Tippfehler in einem Variablennamen klaglos als neue Variable durchgewinkt – und einen Fehler, der sich erst Wochen später als falsches Ergebnis zeigt. In gewachsenen Anwendungen fehlt die Anweisung erfahrungsgemäß in einem Teil der Module. Dieser Beitrag zeigt, wie Sie die Lücken per VBA aufspüren und schließen, ohne jedes Modul einzeln zu öffnen.<\/b><\/p>\n
Warum die Anweisung unverzichtbar ist<\/h2>\n
Ohne Option Explicit<\/b> darf jede Variable ohne Deklaration verwendet werden. VBA legt sie beim ersten Auftreten stillschweigend als Variant<\/b> an. Was das bedeutet, zeigt folgendes Listing – ein einziger fehlender Buchstabe genügt:<\/p>\n Die Ausgabe im Direktbereich lautet:<\/p>\n Erwartet hätte man 150. Stattdessen hat VBA die Variable lngSume<\/b> neu angelegt, ihr das Ergebnis zugewiesen und sie danach nie wieder angesehen. Kein Fehler, keine Warnung – nur ein falscher Wert. Mit Option Explicit<\/b> dagegen scheitert schon das Kompilieren mit der Meldung, dass die Variable nicht definiert ist.<\/p>\n Der Nebeneffekt ist ebenfalls bemerkenswert: Alle stillschweigend erzeugten Variablen sind vom Typ Variant<\/b> und damit langsamer und speicherhungriger als nötig. Es gibt schlicht keinen guten Grund, ohne diese Anweisung zu arbeiten.<\/p>\n Damit die Anweisung in neuen Modulen automatisch erscheint, gibt es im VBA-Editor eine Option. Sie finden sie unter Extras\/Optionen<\/b> auf der Registerseite Editor<\/b> unter dem Namen Variablendeklaration erforderlich<\/b> (siehe Bild 1). Ist sie aktiviert, setzt Access die Anweisung in jedes neu angelegte Modul.<\/p>\n Bild 1: Die Option Variablendeklaration erforderlich im VBA-Editor<\/span><\/b><\/p>\n Und genau hier liegt das Problem, das diesen Beitrag nötig macht: Die Einstellung wirkt ausschließlich für Module, die danach neu entstehen.<\/b> Bestehende Module bleiben unangetastet. Wer die Option erst nach Jahren entdeckt – oder eine Datenbank übernimmt, in der sie nie aktiv war – hat einen bunt gemischten Bestand vor sich. Die Einstellung gilt außerdem pro Installation und nicht pro Datenbank; auf dem Rechner eines Kollegen kann sie also anders stehen.<\/p>\n Um Module per Code zu untersuchen, greifen wir auf das Objektmodell des VBA-Editors zu. Dazu benötigen wir einen Verweis auf die Bibliothek Microsoft Visual Basic for Applications Extensibility 5.3 Object Library<\/b>, den wir wie in Bild 2 setzen.<\/p>\n Bild 2: Setzen eines Verweises auf die Bibliothek Microsoft Visual Basic for Applications Extensibility 5.3 Object Library<\/span><\/b><\/p>\n Der VBA-Editor kann mehrere Projekte gleichzeitig geöffnet haben – etwa weitere Datenbanken oder Add-Ins. Wir brauchen deshalb eine Funktion, die gezielt das Projekt der aktuellen Datenbank heraussucht. Der Vergleich läuft über den Dateinamen (siehe Listing 1).<\/p>\n Listing 1: Ermitteln des VBA-Projekts der aktuellen Datenbank<\/span><\/b><\/p>\n Ein Test im Direktbereich zeigt, ob die Vorbereitungen geglückt sind:<\/p>\n Die Zahl umfasst dabei alle Standard- und Klassenmodule sowie die Klassenmodule von Formularen und Berichten. Letztere erscheinen unter Namen wie Form_frmArtikel<\/b> – allerdings nur, wenn das Formular überhaupt ein Modul besitzt, seine Eigenschaft Enthält Modul<\/b> also auf Ja<\/b> steht.<\/p>\n Ein Hinweis zur Fehlerbehandlung: Die Eigenschaft FileName<\/b> löst einen Fehler aus, wenn ein Projekt noch nie gespeichert wurde. Kommen bei Ihnen mehrere Projekte ins Spiel, sollten Sie die Schleife mit On Error Resume Next<\/b> absichern.<\/p>\n Nun zur eigentlichen Prüfung, ob ein Modul die Anweisung Option Explicit<\/b> enthält. Diese führen wir mit der Funktion HasOptionExplicit <\/b>durch (siehe Listing 2). Option Explicit<\/b> steht immer im Deklarationsbereich, also oberhalb der ersten Prozedur. Wie viele Zeilen dieser umfasst, verrät die Eigenschaft CountOfDeclarationLines<\/b> – wir müssen also nicht das ganze Modul durchsuchen.<\/p>\n Listing 2: Prüfen eines einzelnen Moduls<\/span><\/b><\/p>\n Zwei Details sind interessant. Die Methode Lines<\/b> erwartet Startzeile und Anzahl, liefert hier also genau eine Zeile. Und der Vergleich mit StrComp<\/b> und vbTextCompare<\/b> ignoriert die Groß- und Kleinschreibung – ein option explicit<\/b> in Kleinbuchstaben wird also ebenfalls erkannt. Das Abschneiden am Apostroph sorgt dafür, dass auch eine Zeile mit angehängtem Kommentar richtig bewertet wird.<\/p>\n So sieht der Aufruf für ein bestimmtes Modul aus:<\/p>\n Fehlt die Anweisung in einem Modul, tragen wir sie nach. Diese Aufgabe übernimmt die Prozedur InsertOptionExplicit<\/b> aus Listing 3. Sie erwartet als einzigen Parameter das CodeModule<\/b>-Objekt des Moduls, in dem Option Explicit<\/b> ergänzt werden soll.<\/p>\n Listing 3: Die Prozedur InsertOptionExplicit ergänzt die fehlende Anweisung<\/span><\/b><\/p>\n Die Prozedur arbeitet in zwei Schritten. Im ersten durchläuft die For<\/b>-Schleife die Zeilen des Deklarationsbereichs, deren Anzahl die Eigenschaft CountOfDeclarationLines<\/b> liefert.<\/p>\n Die Methode Lines<\/b> holt die jeweilige Zeile in die Variable strLine<\/b>, wobei Trim$<\/b> führende Leerzeichen entfernt. Beginnt die Zeile mit Option Compare<\/b>, merkt sich die Prozedur die Zeilennummer in lngOptionCompareLine<\/b> und verlässt die Schleife mit Exit For<\/b>.<\/p>\n Im zweiten Schritt entscheidet der Wert dieser Variablen, wo die neue Zeile landet. Steht dort noch die 0<\/b>, gibt es im Modul keine Option Compare<\/b>-Anweisung, und InsertLines<\/b> setzt Option Explicit<\/b> in Zeile 1<\/b>. Andernfalls übergeben wir InsertLines<\/b> die gemerkte Zeilennummer.<\/p>\n Dabei ist zu beachten, dass InsertLines<\/b> die neue Zeile vor<\/b> der angegebenen Zeilennummer einfügt. Option Explicit<\/b> steht anschließend also über Option Compare Database<\/b>. Für die Funktion ist das gleichgültig, denn die Reihenfolge der Option-Anweisungen spielt keine Rolle. Wer die gewohnte Schreibweise bevorzugt, übergibt stattdessen lngOptionCompareLine + 1<\/b>.<\/p>\n Für einen Test rufen wir die Prozedur mit dem CodeModule<\/b> eines einzelnen Moduls auf und lassen uns danach die ersten Zeilen des Deklarationsbereichs ausgeben:<\/p>\n Damit sind alle Bausteine beisammen. Die Prozedur AddOptionExplicitToAllModules<\/b> aus Listing 4 setzt sie zusammen und erledigt die Arbeit für die komplette Anwendung.<\/p>\n Listing 4: AddOptionExplicitToAllModules rüstet alle Module der Anwendung nach<\/span><\/b><\/p>\n Die Prozedur ermittelt zunächst mit GetCurrentVBProject<\/b> das Projekt der aktuellen Datenbank und legt es in objCurrentVBProject<\/b> ab. Danach folgen zwei Prüfungen, die verhindern, dass die Prozedur in einen Laufzeitfehler läuft.<\/p>\n Die erste fängt den Fall ab, dass GetCurrentVBProject<\/b> kein passendes Projekt gefunden hat und deshalb Nothing<\/b> zurückliefert.<\/p>\n Die zweite wertet die Eigenschaft Protection<\/b> aus: Liefert sie einen anderen Wert als vbext_pp_none<\/b>, ist das VBA-Projekt mit einem Kennwort geschützt und lässt sich nicht ändern.<\/p>\n In beiden Fällen erscheint eine Meldung, und die Prozedur wird mit Exit Sub<\/b> verlassen – das ist verständlicher als eine kryptische Fehlermeldung mitten im Durchlauf.<\/p>\n Die anschließende For Each<\/b>-Schleife durchläuft die Auflistung VBComponents<\/b> des Projekts. Für jede Komponente holt sich die Prozedur das zugehörige CodeModule<\/b>, übergibt es an die Funktion HasOptionExplicit<\/b> und ruft nur dann InsertOptionExplicit<\/b> auf, wenn die Anweisung tatsächlich fehlt. Bereits versorgte Module bleiben also unangetastet und werden auch nicht als geändert markiert.<\/p>\n Aufgerufen wird die Prozedur ohne Parameter:<\/p>\n Bevor Sie eine gewachsene oder fremde Anwendung auf einen Schlag umbauen, wollen Sie vermutlich wissen, was Sie erwartet. Dafür gibt es die Funktion ModulesWithoutOptionExplicit<\/b> aus Listing 5. Sie ändert nichts, sondern schreibt die Namen der betroffenen Module in den Direktbereich und liefert deren Anzahl als Rückgabewert.<\/p>\n Listing 5: ModulesWithoutOptionExplicit liefert eine Übersicht, ohne etwas zu ändern<\/span><\/b><\/p>\n Der Aufbau entspricht dem der Prozedur AddOptionExplicitToAllModules<\/b>, nur dass anstelle von InsertOptionExplicit<\/b> eine Ausgabe erfolgt.<\/p>\n Für jedes Modul ohne Option Explicit<\/b> gibt die Funktion den Typ und den Namen der Komponente aus, getrennt durch einen Tabulator, und erhöht den Zähler lngAnzahl<\/b>. Nach der Schleife folgt die Gesamtzahl, die außerdem als Rückgabewert dient.<\/p>\n Den Typ liefert die Eigenschaft Type<\/b> des VBComponent<\/b>-Objekts allerdings nur als Zahl. Die Funktion Typbezeichnung<\/b> übersetzt sie in einen lesbaren Text:<\/p>\n Die drei Konstanten vbext_ct_StdModule<\/b>, vbext_ct_ClassModule<\/b> und vbext_ct_Document<\/b> stammen aus der Extensibility-Bibliothek. Die letzte steht für die Klassenmodule von Formularen und Berichten, die in der Auflistung VBComponents<\/b> unter Namen wie Form_frmArtikel<\/b> auftauchen.<\/p>\n Der Aufruf im Direktbereich liefert dann eine Übersicht wie diese:<\/p>\n Die letzte Zeile ist der Rückgabewert, den Debug.Print<\/b> zusätzlich ausgibt. Wer nur die Auflistung sehen will, ruft die Funktion ohne Debug.Print<\/b> auf, also einfach mit ModuleWithoutOptionExplicit<\/b>.<\/p>\n Manchmal will man nicht alles auf einmal ändern, sondern sich die betroffenen Module nacheinander ansehen. Dafür gibt es die Prozedur ShowNextModuleWithoutOptionExplicit<\/b> aus Listing 6.<\/p>\n Listing 6: ShowNextModuleWithoutOptionExplicit öffnet das nächste betroffene Modul<\/span><\/b><\/p>\n Sie öffnet jeweils das nächste Modul, in dem die Anweisung fehlt, im VBA-Editor und hält dann an.<\/p>\n Der Anfang gleicht der Prozedur AddOptionExplicitToAllModules<\/b>: Auch hier ermittelt die Prozedur das Projekt und prüft es auf Nothing<\/b> und auf einen Kennwortschutz. Der Unterschied steckt im Inneren der Schleife. Findet die Prozedur ein Modul ohne Option Explicit<\/b>, ruft sie über dessen CodePane<\/b>-Objekt die Methode Show<\/b> auf und beendet sich sofort mit Exit Sub<\/b>.<\/p>\n Das CodePane<\/b> ist das Codefenster einer Komponente im VBA-Editor, und Show<\/b> holt es in den Vordergrund. Sie landen also unmittelbar im betreffenden Modul und können die Anweisung selbst ergänzen oder sich den Deklarationsbereich vorher ansehen.<\/p>\n Ein erneuter Aufruf führt Sie zum nächsten Modul. Sind alle versorgt, läuft die Schleife durch, ohne fündig zu werden, und die Prozedur gibt die Meldung aus, dass alle Module die Anweisung enthalten.<\/p>\n Am bequemsten weisen Sie diese Prozedur einer Tastenkombination zu oder legen sie auf eine Schaltfläche in der Symbolleiste für den Schnellzugriff – dann arbeiten Sie sich per Mausklick durch die Anwendung.<\/p>\n Der wichtigste Schritt kommt zum Schluss, und er lässt sich nicht automatisieren. Mit Option Explicit<\/b> werden all die bisher stillschweigend erzeugten Variablen zu Fehlern.<\/p>\n Wählen Sie deshalb im VBA-Editor Debuggen\/Kompilieren<\/b> und arbeiten Sie sich durch die Meldungen.<\/p>\n Erschrecken Sie nicht über die Anzahl. Die meisten Meldungen betreffen schlicht vergessene Dim<\/b>-Anweisungen und sind in Sekunden erledigt. Interessant sind die Fälle, in denen ein Name nur um einen Buchstaben abweicht – das sind genau die Fehler, die Ihre Anwendung bisher stillschweigend falsch rechnen ließen.<\/p>\n Für den Einsatz in der Praxis kommen noch drei Punkte hinzu:<\/p>\nPublic Sub <\/span>OhneOptionExplicit()\r\n Dim <\/span>lngSumme As Long<\/span>\r\n lngSumme = 100\r\n lngSume = lngSumme + 50 ' Tippfehler!\r\n Debug.Print<\/span> lngSumme\r\nEnd Sub<\/span><\/pre>\n100<\/pre>\n
Die Einstellung im VBA-Editor<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2026_05\/pic_1619_001.png\")
<\/p>\nVorbereitung: Verweis setzen<\/h2>\n
![\"Setzen](\"..\/fileadmin\/_temp_\/2026_05\/pic_1619_002.png\")
<\/p>\nDas eigene Projekt finden<\/h2>\n
Public Function <\/span>GetCurrentVBProject() As <\/span>VBIDE.VBProject\r\n Dim <\/span>objVBProject As <\/span>VBIDE.VBProject\r\n For Each objVBProject In Application.VBE.VBProjects\r\n If <\/span>StrComp(objVBProject.FileName, CurrentProject.FullName, vbTextCompare) = 0 Then<\/span>\r\n Set<\/span> GetCurrentVBProject = objVBProject\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Next<\/span> objVBProject\r\nEnd Function<\/span><\/pre>\nDebug.Print<\/span> GetCurrentVBProject.Name\r\nDebug.Print<\/span> GetCurrentVBProject.VBComponents.Count\r\nBeispieldatenbank\r\n14<\/pre>\nPrüfen, ob ein Modul „Option Explicit“ enthält<\/h2>\n
Public Function <\/span>HasOptionExplicit(ByVal objCodeModule As <\/span>VBIDE.CodeModule) As Boolean<\/span>\r\n Dim <\/span>lngLineNumber As Long<\/span>\r\n Dim <\/span>lngCommentPosition As Long<\/span>\r\n Dim <\/span>strLine As String<\/span>\r\n For lngLineNumber = 1 To objCodeModule.CountOfDeclarationLines\r\n strLine = Trim$(objCodeModule.Lines(lngLineNumber, 1))\r\n ' Kommentar am Ende der Zeile entfernen\r\n lngCommentPosition = InStr<\/span>(strLine, \"'\")\r\n If <\/span>lngCommentPosition > 0 Then<\/span>\r\n strLine = Trim$(Left$(strLine, lngCommentPosition - 1))\r\n End If<\/span>\r\n If <\/span>StrComp(strLine, \"Option Explicit\", vbTextCompare) = 0 Then<\/span>\r\n HasOptionExplicit = True<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Next<\/span> lngLineNumber\r\nEnd Function<\/span><\/pre>\nDim <\/span>objVBProject As <\/span>VBIDE.VBProject\r\nSet<\/span> objVBProject = GetCurrentVBProject()\r\nDebug.Print<\/span> HasOptionExplicit(objVBProject. _\r\n VBComponents(\"mdlGarKeinOption\").CodeModule)<\/pre>\nDie Anweisung „Option Explicit“ einfügen<\/h2>\n
Public Sub <\/span>InsertOptionExplicit(ByVal objCodeModule As <\/span>VBIDE.CodeModule)\r\n Dim <\/span>lngLineNumber As Long<\/span>\r\n Dim <\/span>lngOptionCompareLine As Long<\/span>\r\n Dim <\/span>strLine As String<\/span>\r\n For lngLineNumber = 1 To objCodeModule.CountOfDeclarationLines\r\n strLine = Trim$(objCodeModule.Lines(lngLineNumber, 1))\r\n If <\/span>StrComp(Left$(strLine, 14), \"Option Compare\", vbTextCompare) = 0 Then<\/span>\r\n lngOptionCompareLine = lngLineNumber\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> lngLineNumber\r\n If <\/span>lngOptionCompareLine = 0 Then<\/span>\r\n objCodeModule.InsertLines 1, \"Option Explicit\"\r\n Else<\/span>\r\n objCodeModule.InsertLines lngOptionCompareLine, \"Option Explicit\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nDim <\/span>objCodeModule As <\/span>VBIDE.CodeModule\r\nSet<\/span> objCodeModule = GetCurrentVBProject(). _\r\n VBComponents(\"mdlImport\").CodeModule\r\nInsertOptionExplicit objCodeModule\r\nDebug.Print<\/span> objCodeModule.Lines(1, 2)<\/pre>\nAlle Module in einem Durchgang nachrüsten<\/h2>\n
Public Sub <\/span>AddOptionExplicitToAllModules()\r\n Dim <\/span>objCurrentVBProject As <\/span>VBIDE.VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBIDE.VBComponent\r\n Dim <\/span>objCodeModule As <\/span>VBIDE.CodeModule\r\n Set<\/span> objCurrentVBProject = GetCurrentVBProject()\r\n If <\/span>objCurrentVBProject Is Nothing Then<\/span>\r\n MsgBox<\/span> \"Das aktuelle VBA-Projekt wurde nicht gefunden.\", vbExclamation\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n If <\/span>objCurrentVBProject.Protection <> vbext_pp_none Then<\/span>\r\n MsgBox<\/span> \"Das aktuelle VBA-Projekt ist geschützt.\", vbExclamation\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n For Each objVBComponent In objCurrentVBProject.VBComponents\r\n Set<\/span> objCodeModule = objVBComponent.CodeModule\r\n If <\/span>Not<\/span> HasOptionExplicit(objCodeModule) Then<\/span>\r\n InsertOptionExplicit objCodeModule\r\n End If<\/span>\r\n Next<\/span> objVBComponent\r\nEnd Sub<\/span><\/pre>\nAddOptionExplicitToAllModules<\/pre>\n
Die betroffenen Module auflisten<\/h2>\n
Public Function <\/span>ModulesWithoutOptionExplicit() As Long<\/span>\r\n Dim <\/span>objVBProject As <\/span>VBIDE.VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBIDE.VBComponent\r\n Dim <\/span>lngAnzahl As Long<\/span>\r\n Set<\/span> objVBProject = GetCurrentVBProject()\r\n If <\/span>objVBProject Is Nothing Then<\/span> Exit Function<\/span>\r\n For Each objVBComponent In objVBProject.VBComponents\r\n If <\/span>Not<\/span> HasOptionExplicit(objVBComponent.CodeModule) Then<\/span>\r\n Debug.Print<\/span> Typbezeichnung(objVBComponent.Type) & vbTab & objVBComponent.Name\r\n lngAnzahl = lngAnzahl + 1\r\n End If<\/span>\r\n Next<\/span> objVBComponent\r\n Debug.Print<\/span> \"Betroffene Module: \" & lngAnzahl\r\n ModulesWithoutOptionExplicit = lngAnzahl\r\nEnd Function<\/span><\/pre>\nPrivate Function <\/span>Typbezeichnung( _\r\n ByVal lngTyp As Long<\/span>) As String<\/span>\r\n Select Case lngTyp\r\n Case <\/span>vbext_ct_StdModule\r\n Typbezeichnung = \"Standardmodul\"\r\n Case <\/span>vbext_ct_ClassModule\r\n Typbezeichnung = \"Klassenmodul\"\r\n Case <\/span>vbext_ct_Document\r\n Typbezeichnung = \"Formular\/Bericht\"\r\n Case Else<\/span>\r\n Typbezeichnung = \"sonstiges\"\r\n End Select<\/span>\r\nEnd Function<\/span><\/pre>\nDebug.Print<\/span> ModuleWithoutOptionExplicit()\r\nStandardmodul mdlImport\r\nKlassenmodul clsKunde\r\nFormular\/Bericht Form_frmArtikel\r\nFormular\/Bericht Report_rptRechnung\r\nBetroffene Module: 4\r\n4<\/pre>\nDas nächste Modul ohne Option Explicit anzeigen<\/h2>\n
Public Sub <\/span>ShowNextModuleWithoutOptionExplicit()\r\n Dim <\/span>objCurrentVBProject As <\/span>VBIDE.VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBIDE.VBComponent\r\n Dim <\/span>objCodeModule As <\/span>VBIDE.CodeModule\r\n Set<\/span> objCurrentVBProject = GetCurrentVBProject()\r\n If <\/span>objCurrentVBProject Is Nothing Then<\/span>\r\n MsgBox<\/span> \"Das aktuelle VBA-Projekt wurde nicht gefunden.\", vbExclamation\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n If <\/span>objCurrentVBProject.Protection <> vbext_pp_none Then<\/span>\r\n MsgBox<\/span> \"Das aktuelle VBA-Projekt ist geschützt.\", vbExclamation\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n For Each objVBComponent In objCurrentVBProject.VBComponents\r\n Set<\/span> objCodeModule = objVBComponent.CodeModule\r\n If <\/span>Not<\/span> HasOptionExplicit(objCodeModule) Then<\/span>\r\n objCodeModule.CodePane.Show\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n Next<\/span> objVBComponent\r\n MsgBox<\/span> \"Alle Module enthalten Option Explicit.\", vbInformation\r\nEnd Sub<\/span><\/pre>\nNach dem Nachrüsten kompilieren<\/h2>\n