ist durch die Anführungszeichen deutlich gemacht, dass es sich um einen String<\/b> handelt. VBA speichert den Text nun als Variant, der intern ein Kennzeichen enthält, welches mit dem Marker für einen String versehen wird. Die eigentlichen Daten werden je nach Typ in einer bestimmten Datenstruktur abgelegt, über die man ebenfalls nichts erfährt. Ein Zeiger auf die Struktur macht den Variant vollständig.<\/p>\n
Nicht immer ist die Sache jedoch so eindeutig. Nehmen Sie etwa diese Wertzuweisung:<\/p>\n
Dim <\/span>A As Variant<\/span>\r\nA = 123<\/pre>\nWas nimmt VBA hier als Datentyp an Dass es sich um eine Zahl handelt, ist nicht schwer zu erraten. Doch liegt hier ein Long<\/b>-Wert vor, ein Integer<\/b>, oder ein Double<\/b>-Wert<\/p>\n
Sie sind nicht auf Spekulationen angewiesen, denn die Funktion TypeName<\/b> von VBA kann Auskunft darüber geben, wie VBA die Variable sieht:<\/p>\nDebug.Print<\/span> TypeName ( A)\r\n> \"Integer\"<\/pre>\nHoffentlich liegt es hier richtig! Denn folgende Formel könnte zu einem Fehler wegen überlaufs führen:<\/p>\n
A = A * A * A \r\nDebug.Print<\/span> A, TypeName(A)<\/pre>\nEine Fehlermeldung tritt jedoch nicht auf. Das Ergebnis wird korrekt angezeigt, und der Datentyp ist auf Long<\/b> gewechselt. ähnlich verhält es sich mit<\/p>\nDebug.Print<\/span> TypeName (A \/ 3)\r\n> \"Double\"<\/pre>\nAber auch dies ist möglich:<\/p>\n
A = \"123\"\r\nDebug.Print<\/span> TypeName (A)\r\nA = A \/ 3\r\nDebug.Print<\/span> TypeName (A)\r\n> \"String\"\r\n \"Double\"<\/pre>\nObwohl hier VBA zunächst einen String<\/b> annimmt, stolpert es im nächsten Schritt über den Teilungsoperator und verwandelt deshalb schnell den Datentyp in Double<\/b>, um die Berechnung durchführen zu können.<\/p>\n
Anderes Beispiel:<\/p>\n
A = 123\r\nDebug.Print<\/span> TypeName(A)\r\nA = A & \"ACCESS\"\r\nDebug.Print<\/span> A, TypeName(A)\r\n> \"Integer\"\r\n \"String\"<\/pre>\nDurch den Verknüpfungsoperator &<\/b> für Strings errät VBA, dass das Ergebnis ebenfalls ein String sein muss, weshalb der Wert der Integer<\/b>-Variablen A<\/b> intern zunächst in einen String<\/b> umgewandelt und schließlich der hartkodierte Text angefügt wird.<\/p>\n
VBA scheint also ziemlich intelligent zu sein, wenn es um das Erraten der benötigten Datentypen geht. Das geht auch solange gut, wie Sie lediglich die VBA-Bibliothek selbst benutzen. Sobald Sie aber auch andere Bibliotheken verwenden, etwa die Datenzugriffsbibliothek DAO<\/b>, ist VBA häufig überfordert.<\/p>\n
Denn bei der Zuweisung eines Variablenwerts etwa zum Feldinhalt einer Tabelle weiß VBA unter Umständen nichts über den Datentyp, den Sie beim Entwurf der Tabelle für das Feld vorsahen. Hier kann es zu Fehlern wegen nicht übereinstimmender Datentypen kommen, oder zu Fehlern durch überläufe.<\/p>\n
Option Explicit<\/h2>\n
Um solche undurchsichtigen Fehler zu vermeiden, setzen Sie besser in den Modulkopf jedes Ihrer Module ein Option Explicit<\/b>. Das weist VBA an, jede im Programmcode auftauchende Variable zu überprüfen und deren Deklaration zu suchen. Findet es keine, so tritt beim Kompilieren eine entsprechende Fehlermeldung auf. Das manuelle Einsetzen der Option-Explicit-Anweisung<\/b> können Sie sich sparen, wenn Sie in den Optionen<\/b> von VBA (Menü Extras<\/b>) den Eintrag Variablendeklaration erforderlich aktivieren (siehe Bild 1). Dann nämlich setzt VBA beim Neuanlegen eines Moduls die Anweisung automatisch in den Modulkopf.<\/p>\n
![\"Optionen](\"..\/tl_files\/images\/VBAOptionen.png\")
<\/a><\/p>\nBild 1: Optionen von VBA: Einschalten der Notwendigkeit für Variablendatentypen<\/p>\n
Die Variablendeklarationen können Sie, je nach deren Gültigkeitsbereich, in den Modulkopf setzen, oder in die einzelnen Funktionsroutinen. Die Stelle spielt dabei keine Rolle. Eine Dim<\/b>-Anweisung kann auch irgendwo mitten im Funktionstext stehen.<\/p>\n
Die Schlüsselwörter für die Deklarationen lauten Dim<\/b>, Private<\/b>, Public<\/b>, Friend<\/b> und Static<\/b>. Static<\/b> ist nur innerhalb von Routinen erlaubt, Public<\/b>, Friend<\/b> und Private<\/b> nur im Modulkopf.<\/p>\n
Neben dem Namen der Variablen ist zusätzlich deren Datentyp anzugeben:<\/p>\n
Dim <\/span>A As Long<\/span>\r\nA = 123<\/pre>\nGanz stimmt das allerdings nicht, denn auch ein schnödes<\/p>\n
Dim <\/span>A<\/pre>\nist möglich. In diesem Fall nimmt VBA für A aber den Typ Variant an. Die Typbezeichnung lässt sich auch durch ein Kürzel ersetzen:<\/p>\n
Dim <\/span>A$<\/pre>\netwa deklariert die Variable als String<\/b>. Die Kürzel im überblick:<\/p>\n& String (Text)\r\n% Integer (16bit-Integer)\r\n& Long (32bit-Integer)\r\n^ LongLong (64bit-Integer;\r\n nur unter Office 64 verfügbar)\r\n# Double (Fließkomma, genau)\r\n! Single (Fließkomma, einfach)\r\n@ Currency (Währung)<\/pre>\nDiese Kürzel machen den Programmcode allerdings schlecht lesbar.<\/p>\n
Das strikte Erfordernis zur Variablendeklaration führt nun natürlich dazu, dass die Beispiele von oben nicht mehr alle funktionieren. Ist die Variable A<\/b> als Long<\/b> deklariert, so kann ihr natürlich kein durch Division zustande gekommener Double-Wert mehr zugewiesen werden. Die interne beim Variant von VBA vorgenommene Konversion schränkt sich damit ein, ist aber nicht außer Kraft gesetzt. Denn dies etwa geht nach wie vor fehlerfrei über die Bühne:<\/p>\nDim <\/span>A As Integer<\/span>\r\nDim <\/span>B As Long<\/span>\r\nB = 123\r\nA = B<\/pre>\nVBA weiß hier über beide Datentypen Bescheid, überprüft die Werte der Variablen und kann dann den einen Wert erfolgreich in den anderen überführen, solange der Bereich nicht überläuft, was beim Long<\/b>-Wert 123 der nicht der Fall ist.<\/p>\n
Wenn man sich auf die eingebaute Intelligenz von VBA aber nicht verlassen will, dann gibt einen ganzen Satz von Konvertierungsfunktionen, die die Bibliothek VBA bereithält.<\/p>\n
VBA-Conversion<\/h2>\n
Rufen Sie den Objektkatalog<\/b> im VBA-Editor auf, setzen die Combobox links oben auf die Bibliothek VBA<\/b> und markieren die Klasse Conversion<\/b>. Rechts werden Ihnen nun sämtliche Konvertierungsmethoden aufgelistet (Bild 2). Die reinen Konvertierfunktionen beginnen alle mit dem Präfix C. Angehängt daran ist ein Kürzel für den Ergebnisdatentyp der Funktion. CBool<\/b> etwa hat als Ergebnis einen Boolean-Wer<\/b>t, CLng<\/b> einen Long<\/b> und CDate<\/b> ein Datum.<\/p>\n
![\"Der](\"..\/tl_files\/images\/Objektkatalog.png\")
<\/a><\/p>\nBild 2: Der VBA-Objektkatalog mit der für Konvertierungen zuständigen VBA-Klasse Conversion<\/p>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Access [basics]<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 400 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t