Variablen & Datentypen in VBA

Eine Variable ist ein benannter Behälter für einen Wert. In VBA sagst du Access möglichst genau, was für ein Wert dort hineinkommt — dann arbeitet dein Code schneller, verbraucht weniger Speicher und fängt Fehler früher ab.

Deklarieren mit Dim

Mit Dim legst du eine Variable an. Das Schema ist immer gleich: Dim Name As Typ.

Option Explicit

Public Sub Beispiel()
    Dim kundenNr As Long
    Dim name As String
    Dim umsatz As Double
    Dim aktiv As Boolean

    kundenNr = 4711
    name = "Meier GmbH"
    umsatz = 1234.56
    aktiv = True
End Sub

Der Name folgt dem Typ mit As. Lässt du As Typ weg, wird die Variable automatisch zum Typ Variant — und den willst du meist nicht (dazu unten mehr).

Option Explicit ganz oben im Modul zwingt dich, jede Variable zu deklarieren. Ohne diese Zeile macht ein Tippfehler wie umstz still eine neue, leere Variable auf — und du suchst den Bug stundenlang. Immer einschalten.

Konstanten mit Const

Werte, die sich nie ändern, deklarierst du als Konstante mit Const. Der Wert steht schon bei der Deklaration fest und lässt sich später nicht überschreiben.

Const MWST As Double = 0.19
Const FIRMA As String = "Ously Games GmbH"
Const MAX_ZEILEN As Long = 1000

Konstanten machen Code lesbar: preis * (1 + MWST) sagt mehr als preis * 1.19.

Die wichtigsten Datentypen

Du kommst im Access-Alltag mit einer Handvoll Typen aus:

Typ	Wofür	Beispielwert
`Long`	Ganze Zahlen (32 Bit), Standard für Zähler & IDs	`4711`
`Double`	Kommazahlen mit hoher Genauigkeit	`1234.56`
`Currency`	Geldbeträge, 4 Nachkommastellen, rundungssicher	`19.99`
`String`	Text	`"Hallo"`
`Boolean`	Wahr/Falsch	`True` / `False`
`Date`	Datum und Uhrzeit	`#2026-07-01#`
`Variant`	Beliebiger Typ, auch `Null`/`Empty`	alles
`Object`	Verweis auf ein Objekt (Recordset, Form …)	`Nothing`

Merke dir vor allem: Long für ganze Zahlen, Double für Kommazahlen, String für Text, Currency für Geld. Damit deckst du 90 % ab.

Datumswerte

Date speichert Datum und Uhrzeit als Zahl. Literale schreibst du zwischen Rauten im US-Format #Monat/Tag/Jahr#:

Dim heute As Date
heute = Date              ' nur Datum
heute = Now               ' Datum + Uhrzeit
heute = #7/1/2026#        ' festes Datum
Debug.Print Format(heute, "dd.mm.yyyy")   ' 01.07.2026

Typische Fehler

Variant-Overhead

Eine Variant-Variable kann jeden Typ aufnehmen — bequem, aber teuer. Sie belegt mehr Speicher, muss bei jeder Operation ihren Typ prüfen und macht Code langsam und unvorhersehbar. Deklariere so konkret wie möglich:

' Schlecht: implizit Variant
Dim zaehler
' Gut: konkret
Dim zaehler As Long

Integer statt Long

Integer ist nur 16 Bit breit und läuft schon bei 32.767 über — bei einem Overflow-Fehler ist dann Schluss. Auf modernen Systemen bringt Integer keinen Geschwindigkeitsvorteil mehr. Nimm grundsätzlich Long:

Dim i As Integer
i = 40000          ' Laufzeitfehler 6: Überlauf!

Mehrere Variablen in einer Zeile

Ein klassischer Stolperstein: In einer Zeile gilt As Typ nur für die letzte Variable. Die anderen werden Variant!

Dim a, b, c As Long     ' a und b sind Variant, nur c ist Long
Dim x As Long, y As Long, z As Long   ' so ist es richtig

Umwandeln zwischen Typen

Manchmal musst du einen Wert von einem Typ in einen anderen bringen — etwa Text aus einem Textfeld in eine Zahl. Dafür gibt es die C…-Funktionen:

Funktion	Wandelt in	Beispiel
`CLng`	`Long`	`CLng("42")` → `42`
`CDbl`	`Double`	`CDbl("3,14")` → `3.14`
`CStr`	`String`	`CStr(42)` → `"42"`
`CDate`	`Date`	`CDate("01.07.2026")`
`CCur`	`Currency`	`CCur("19,99")`
`CBool`	`Boolean`	`CBool(0)` → `False`

Dim eingabe As String
Dim menge As Long
eingabe = Me!txtMenge.Value
menge = CLng(eingabe) * 2

Vorsicht bei leeren oder ungültigen Werten: CLng(Null) und CLng("abc") lösen einen Laufzeitfehler aus. Prüfe vorher mit IsNumeric() oder Nz().

Nothing, Null und Empty — drei „Leere"

Diese drei verwechselt man leicht, sie bedeuten aber völlig Unterschiedliches:

Wert	Gilt für	Bedeutung	Test
`Nothing`	`Object`-Variablen	zeigt auf kein Objekt	`Is Nothing`
`Null`	`Variant` / Feldwerte	Datenbankfeld ohne Wert	`IsNull()`
`Empty`	`Variant`	noch nie zugewiesen	`IsEmpty()`

Dim rs As DAO.Recordset      ' Object
Debug.Print (rs Is Nothing)  ' True, noch nicht gesetzt

Dim v As Variant
Debug.Print IsEmpty(v)       ' True, noch nichts zugewiesen

' Null kommt aus der Datenbank:
If IsNull(Me!txtEmail.Value) Then MsgBox "E-Mail fehlt"

Für Datenbankfelder ist Null der Normalfall. Mit Nz(wert, ersatz) ersetzt du ein Null bequem durch einen Standardwert:

Dim ort As String
ort = Nz(Me!txtOrt.Value, "unbekannt")

Gültigkeitsbereich in Kürze

Wo du deklarierst, entscheidet, wo die Variable sichtbar ist:

In einer Prozedur (Dim innerhalb einer Sub/Function): nur dort gültig, verschwindet am Prozedurende.
Oben im Modul (vor der ersten Prozedur): im ganzen Modul gültig.
Mit Public oben im Modul: im gesamten Projekt gültig.

Halte Variablen so lokal wie möglich — globale Variablen machen Fehler schwer auffindbar. Mehr dazu in der Lektion zu Prozeduren und Gültigkeitsbereich.

Zusammengefasst

Dim Name As Typ deklarieren, Const für feste Werte, Option Explicit immer an.
Standardtypen: Long, Double, Currency, String, Boolean, Date.
Variant vermeiden (Overhead), Long statt Integer (Überlauf), As Typ gilt pro Variable.
Umwandeln mit CLng, CDbl, CStr, CDate — vorher auf gültige Werte prüfen.
Nothing (Objekt), Null (Feld), Empty (nie zugewiesen) sind drei verschiedene Dinge.