VBA Programmierung

IDE (Integrated Development Environment)

Komponenten

Menü - bedienen der IDE
VB-Symbolleiste - zugreifen auf IDE-Funktionen(Bearbeiten, Debuggen, UserForm, Default)
Projektexplorer (Strg+R) - verwalten der Applikationsobjekte(cls), Module(bas), Klassenmodule(cls) und Formulare(frm) des VBA-Projekts
Eigenschaftenfenster (F4) - einstellen der Objekteigenschaften
Code (F7) - eingeben von Quellcode
Objektkatalog (F2) - informieren über Objekte, Eigenschaften und Methoden
Direktbereich (Strg+G) - testen von Quellcode
Lokal-Fenster
Überwachungsfenster

Eingabehilfen:

Automatische Elementliste für Eigenschaft oder Methode (Objekt)
manuelle Elementliste für Eigenschaft oder Methode (Objekt + Kontextmenü - Eigenschaften/Methoden anzeigen)
Auswahl der Eigenschaft oder Methode
- Element auswählen - Strg+Enter oder Tab oder Doppelklick
- Element auswählen + Zeilenumbruch - Enter
- Elementliste schließen - Esc
Automatische Direkthilfe für Funktion oder Methode - Funktion/Methode ( nächster Parameter in fetter Schrift)
Manuelle Direkthilfe für Funktion oder Methode - Funktion/Methode + Kontextmenü(Parameterinfo oder Quickinfo)
Manuelle Konstantenliste für Funktion oder Methode - Funktion/Methode + Kontextmenü(Konstanten anzeigen)o

Hilfe

Cursor in Schlüsselwort bringen und F1 drücken

Debuggen

Über das Objekt debug kann man Ausgaben an das Direktfenster senden!

Grundlagen

Syntax

nur eine! Anweisung pro Zeile!
lange Anweisung mit _(Leerzeichen + Unterstrich) umbrechen
alle Variablen und Konstanten zu Beginn eines Moduls bzw. Prozedur deklarieren
verschachtelte Schleifen und Verzweigungen entsprechend einrücken
nur eine! Anweisung pro Zeile!
den Quelltext ausführlich mit Kommentaren versehen - alles was nach ' oder Rem bis zum Zeilenende folgt ist ein Kommentar!
nur eine! Anweisung pro Zeile!
"case insensitiv" - Schlüsselwörter werden automatisch formatiert, Variabeln-, Konstanten- und Prozedurnamen nach ihrer ersten Verwendung im Modul(Deklaration!?)
Variabeln-, Konstanten- und Prozedurnamen haben folgende Syntax:
- erstes Zeichen muss ein Buchstabe sein!
- folgende Zeichen dürfen nicht verwendet werden: Leerzeichen , . ! @ & $ #
- maximal 255 Zeichen Länge
- keine Namen von verwendeten VBA-Anweisungen, Funktionen und Methoden
- keine Doppelnennung innerhalb eines Gültigkeitsbereiches

Variablen

Variablen können Werte für eine spätere Verwendung zwischenspeichern
im Speicher befindliche Werte können über den Variablennamen statt über die Speicheradresse angesprochen werden
bei der Deklaration einer Variablen wird ihr Datentyp festgelegt
Variablen können abhängig von ihrem Datentyp verschiedene Werte aufnehmen
Datentypen sind:
- Datentyp ([Typkennzeichen] <-- deprecated)
  Speicherbedarf
  Wertebereich --> 0
- Byte
  1 Byte
  0 bis 255 --> 0
- Boolean
  2 Bytes
  True / False --> False
- Integer (%)
  2 Bytes
  -32.768 bis 32.767 --> 0
- Long (lange Ganzzahl - &)
  4 Bytes
  -2.147.483.648 bis 2.147.483.647 --> 0
- Single (Gleitkommazahl mit einfacher Genauigkeit - !)
  4 Bytes
  -3,402823 E38 bis -1,401298 E-45 (negative Werte) / 1,401298 E-45 - 3,402823 E38 (positive Werte) --> 0
- Double (Gleitkommazahl mit doppelter Genauigkeit - #)
  8 Bytes
  -1,79769313486232 E308 bis -4,94065645841247 E-324 (negative Werte) / 4,94065645841247 E-324 bis 1,79769313486232 E308 (positive Werte) --> 0
- Currency (skalierte Ganzzahl - @)
  8 Bytes
  -922.337.203.685.477,5808 bis 922.337.203.685.477,5807 --> 0
- Decimal
  14 Bytes
  +/-79.228.162.514.264.337.593.543.950.335 ohne Dezimalzeichen / +/-7,9228162514264337593543950335 mit 28 Nachkommastellen / die kleinste Zahl ungleich Null ist +/-0,000000000000000000000000001 --> 0
- Date
  8 Bytes
  1. Januar 100 bis 31. Dezember 9999 --> #12:00:00 AM#(00:00:00 Uhr!)
- Object
  4 Bytes
  beliebiger Verweis auf ein Objekt vom Typ Object --> Nothing
- String (variable Länge)
  10 Bytes + Zeichenfolgenlänge
  0 bis ca. 2 Milliarden --> Nothing
- String (fester Länge)
  Zeichenfolgenlänge
  1 bis ca. 65.400 --> Nothing
- Variant (mit Zahlen)
  16 Bytes
  Numerische Werte im Bereich des Datentyps Double --> ???
- Variant (mit Zeichenfolge)
  22 Bytes + Zeichenfolgenlänge
  Werte wie beim Zeichentyp String mit variabler Länge --> ???
Variablen sollten vor ihrer Verwendung grundsätzlich deklariert und die "Option Explicit On" (Deklarationspflicht!) zu Beginn eines Moduls bzw. einer Prozedur verwendet werden <-- Fehlermeldung von IDE beim Kompilieren wenn ein nicht deklarierter Variablenname verwendet wird
fehlende Deklaration oder Deklaration ohne Angabe des Datentyps macht eine Variable automatisch zum Typ Variant (Default Datentyp --> viel Speicherplatz --> langsame Makros)
die Deklaration erfolgt mit der Dim-Anweisung: Dim [As ] =
die Option "Option Strict On" am Anfang eines Modulblatt macht eine Typenangabe und eine explizite Konvertierung bei einer evtl. späteren Typenumwandlung zur Pflicht (Probleme werden bereits bei Entwicklung und nicht erst bei Ausführung erkannt!)
die Initialisierung von Variablen sollte! vor! der Benutzung erfolgen, damit keine! Default-Werte verwendet werden!
die Zuweisung von Werten erfolgt bei Zeichenketten mit ""(Variable = "String") und bei Datumsangaben mit ##(Variable = #19.01.97#)

Konstanten

Konstanten können ihren definierten Wert im Programmverlauf nicht ändern - sie sind unveränderlich
(globale) Konstanten können den Wartungsaufwand verringern, da ihr einmalig vergebener Wert in der gesamten Anwendung gültig ist
Deklaration und Definition von Konstanten erfolgt mit der Const Anweisung: Const [As ] =
die Angabe des Datentyps ist optional und überschreibt den Datentyp des Ausdrucks, welcher als Standard-Datentyp verwendet wird
zugewiesene Zeichenketten (Strings) müssen in Anführungszeichen und Datumsangaben (Dates) in Doppelkreuze (Rauten) eingeschlossen werden
selbstdefinierte Konstanten sind beim debuggen nicht sichtbar und können deshalb nicht über das Direkt- oder Überwachungsfenster genutzt werden

Arrays(Datenfelder)

es gibt Listen (1-dimensional) und Matrizen (2-dimensional)
sie enthalten mehrere Variablen des gleichen Typs
die Variablen werden über Indexnummern (Indizes) angesprochen
Arrays müssen! vor ihrer ersten Anwendung dimensioniert (Typ und Anzahl der Felder[Zeilen und Spalten]) werden!
wenn die Option "Option Base 1" nicht am Modulanfang gesetzt wird beginnen die Indizes bei 0!
statische Arrays werden bei der Deklaration bereits eindeutig dimensioniert (Dim Array(3, 2) As Datentyp - Matrize mit 3 Zeilen und 2 Spalten oder Dim Array(4) As Datentyp - Liste mit 4 Zeilen
dynamische Arrays werden bei der Deklaration noch nicht! eindeutig dimensioniert sondern erst während der Laufzeit des Programms - Dim Array() As Datentyp
dynamische Arrays werden mit ReDim zur Laufzeit dimensioniert, wobei vorhandene Werte verloren gehen! - ReDim Array(1) oder ReDim Array(1, 1)
mit dem Schlüsselwort Preserve können vorhandene Werte bei der Vergrößerung eines Arrays behalten werden - ReDim Preserve Array(2) oder ReDim Preserve Array(2, 2)
die Wertzuweisung (Initialisierung) erfolgt so für jedes Datenfeld - Array(1, 1) = Wert
es können auch Arrays mit minimalem und maximalem Index dimenioniert werden - Dim Array(21 To 30, 40 To 50) As Datentyp - Matrize mit 10 Zeilen(Index 21 bis 30) und 11 Spalten(Index 40 bis 50) oder Dim Array(20 To 30) As Datentyp - Liste mit 11 Zeilen(Index 21 bis 30)
mit LBound (untere) und UBound (obere) kann man Indexgrenzen von bereits (re-) dimensionierten statischen und dynamischen Arrays ermitteln --> Variable = LBound(Array) oder UBound(Array)
mit erase kann man dynamische Arrays löschen und damit reservierten Speicherplatz freigeben - erase Array()
wird erase bei statischen Arrays angewendet werden nur alle Felder auf "empty" - leer gesetzt und das Array nicht ganz gelöscht!

Gültigkeitsbereiche von Variablen(Wertigkeit), Konstanten(Wertigkeit) und Objekten(Zugreifbarkeit)

der Gültigkeitsbereich von Variablen und Konstanten richtet sich nach dem Ort der Deklaration
- auf Prozedurebene --> gültig zu Laufzeit! der Prozedur und nur im Bereich dieser! (Haupt-)Prozedur auch gültig während der Laufzeit von Unterprozeduren aber nicht! von diesem Bereich zugreifbar!)
- auf Modulebene --> gültig zur Laufzeit des Moduls und nur im Bereich dieses Moduls
- auf Prozedurebene mit Static anstatt Dim deklariert --> wie auf Modulebene!

Operationszeichen

Rechenzeichen:
- + --> Addition von Zahlen und zeichenketten
- - --> Subtraktion von Zahlen
- / --> Division mit Rückgabe einer Fließkommazahl
- \ --> Division mit Rückgabe einer ganzen Zahl - Divident und Divisor werden vorher! und der Quotient danach ganzzahlig gerundet!
- Mod --> Division mit Rückgabe des Restes - Divident und Divisor werden vorher ganzzahlig gerundet!
- ^ --> Potenzieren von Zahlen
- * --> Multiplikation von Zahlen
- ACHTUNG: Bei "nackten" Berechnungen, wo nur das Ergebnis einer Variablen zugewiesen wird, kann es zu Überlauffehlern kommen, weil VBA die Rechenmethode benutzt in deren Bereich die Zahlen(nicht die Ergebnisvariable!) liegen!
- um dies zu vermeiden sollten man die "nackten" Zahlen Variablen zuweisen die vom entsprechenden Datentyp sind
Logische Operatoren:
- logische Operatoren dienen dazu, logische Ausdrücke zu formulieren und liefern immer einen Wert vom Typ Boolean zurück!
- A AND B (1 and 1 = 1; 1 and 0 = 0; 0 and 0 = 0; 0 and 1 = 0) - beide wahr
- A OR B (1 or 1 = 1; 1 or 0 = 1; 0 or 0 = 0; 0 or 1 = 1) - mindestens einer wahr
- A XOR B (1 xor 1 = 0; 1 xor 0 = 1; 0 xor 0 = 1; 0 xor 1 = 0) - genau einer wahr
- NOT (B)(not 1 = 0; not 0 = 1 - Gegenteil)
Verkettungsoperatoren:
- die Operatoren & und + dienen zur Verkettung von einzelnen Zeichen oder Zeichenketten, wobei + nur bei explizit ausgewiesenen Strings angewendet werden kann

Prozeduren

Funktion(Function) und Unterprozedur(Sub) sind die 2 möglichen Prozedurtypen
Prozeduren bestehen aus einem Prozedurkopf(Namen und Parameterliste[zur Parameterübergabe]), und dem Prozedurrumpf(Anweisungen)
Prozeduren werden nach erreichen der letzten Zeile der Prozedur(End Sub bzw. End Function) oder mit der Anweisung Exit Sub bzw. Exit Function beendet
- Unterprozeduren (Sub)
- Sub Unterprozedurname() ... End Sub
Funktionen (Function):
- Function Funktionsname() As Datentyp ... End Function
- Funktionen können Werte zurückgeben: Funktionsname = "Wert"
Parameterliste:
- Parameter dienen dazu Werte an eine Prozedur zu übergeben
- beim Aufrufen einer Unterprozedur werden evtl. zu übergebende Parameter hinter dem Unterprozedurnamen kommagetrennt aufgelistet --> Unterprozedurname Parameter1, Parameter2, ...
- auch eine Nennung der Parameternamen ist möglich --> Unterprozedurname Parametername1:=Parameter1, Parametername2:=Parameter2, ...
- Funktionen ohne Rückgabewert werden wie Unterprozeduren aufgerufen
- soll aber der Rückgabewert einer Funktion abgefangen werden muss der Funktion eine Variable zugewiesen und die Parameterliste in Klammern eingeschlossen werden! --> Variable = Funktion(Parameter1, Parameter2, ...)
- optionale Parameter können weggelassen, aber das Komma muss gesetzt werden, damit die Parameter in der richtigen Reihenfolge übergeben werden! --> Variable = Funktion(Parameter1, , Parameter3, ...)
- wird auch der Parametername genannt kann das Komma für optionale Parameter weggelassen und die Reihenfolge der Nennung selber bestimmt werden --> Variable = Funktion(Parametername3:=Parameter3, Parametername1:=Parameter1, ...)
  - Parameterübergabe by Reference(ByRef)
  - Datentyp der übergebenen Variablen muss mit der übernommenen Variablen übereinstimmen oder bei der Übergabe konvertiert werden!
  - die Speicherstelle(Adresse im Hauptspeicher), also die Referenz des entsprechenden Wertes wird übergeben
  - Änderungen an der Variablen sind innerhalb und außerhalb der Prozedur gültig an die der Wert übergeben wurde!
  - Parameterübergabe by Value(ByVal)
  - der Wert wird direkt übergeben und nicht die Referenz auf die Adresse
  - Änderungen an der Variablen sind nur innerhalb der Prozedur gültig an die der Wert übergeben wurde, da es sich nur um eine Kopie handelt!

Klassen, Objekte, Methoden und Eigenschaften

Objekte:
- VBA-Objekte sind Teile der jeweiligen Anwendung(Applikation) - Statusleiste, Menü, Schaltfläche, Formular, ...
- Objekte stellen eine Einheit aus Daten(Eigenschaften, Attribute) und der darauf anwendbaren Operationen(Methoden) dar
- gleichartige Objekte sind Instanzen(Exemplare) einer Klasse
- Objekte einer Klasse unterscheiden sich untereinander durch den Wert mindestens eines Attributs!
Klassen:
- eine Klasse ist die Zusammenfassung gleichartiger Objekte - Klassen definieren gleichartige Objekte - die Instanz einer Klasse ist das aus der Klasse abgeleitete Objekt
- die Übertragung von Eigenschaften einer Klasse auf die Instanz nennt man Vererbung
Methoden:
Eigenschaften: