VBA Programmieren mit Visual Basic for Applications

Transcription

2
easy
know-how
VBA
Programmieren mit
Visual Basic for Applications
“Investition in Wissen zahlt die besten Zinsen”
Benjamin Franklin
easy2know-how – Erhard Closs, Ihr PC-Coach, Tel.: 089/ 910 72 813, Fax.: 089/ 910 72 813
 Dieses Werk ist urheberrechtlich geschützt.
Alle dadurch begründeten Rechte, insbesondere der Nachdruck, die Übersetzung, die Wiedergabe auf
photomechanischen oder ähnlichen Wegen, die Speicherung und Verarbeitung mit Hilfe der EDV
bleiben auch auszugsweise dem Urheber vorbehalten.
3
Inhaltsverzeichnis
Modul 1: Einführung in die Programmierung .................................................................................................. 5
Grundlagen von VBA ....................................................................................................................................... 6
Projekte, Eigenschaften und Module ............................................................................................................... 7
Planung eines Programms ................................................................................................................................ 8
Eingeben eines Programms .............................................................................................................................. 9
Unterschiede zwischen Anweisungen und Funktionen .................................................................................. 10
Prozeduren ..................................................................................................................................................... 11
Befehle zur Ein- und Ausgabe ........................................................................................................................ 12
Ausführen und Testen eines Programms ......................................................................................................... 13
Einzelschrittmodus ......................................................................................................................................... 14
Zusammenfassen und Vertiefen: Einführung in die Programmierung ............................................................. 15
-
Modul 2: Variablen und Konstanten ..............................................................................................................
Konstanten, Variablen, Datenfelder ...............................................................................................................
Variablen .......................................................................................................................................................
Datentypen ....................................................................................................................................................
Gültigkeitsbereiche von Variablen ................................................................................................................
Gültigkeitsdauer ............................................................................................................................................
Konstanten .....................................................................................................................................................
Datenfelder ....................................................................................................................................................
Zusammenfassen und Vertiefen: Variablen und Konstanten ..........................................................................
16
17
18
19
20
21
22
23
24
Modul 3: Prozeduren und Funktionen ...........................................................................................................
Parameter ......................................................................................................................................................
Referenzübergabe oder Wertübergabe? .........................................................................................................
Funktionen .....................................................................................................................................................
Gültigkeitsbereiche von Prozeduren ..............................................................................................................
Exkurs: Optionale Parameter .........................................................................................................................
Exkurs: Parameterfelder .................................................................................................................................
Zusammenfassen und Vertiefen: Prozeduren und Funktionen ........................................................................
25
26
27
28
29
30
31
32
Modul 4: Objekte und Auflistungen ..............................................................................................................
Überblick.......................................................................................................................................................
Zugriff auf Elemente einer Auflistung ............................................................................................................
Arbeiten mit Eigenschaften ............................................................................................................................
Arbeiten mit Methoden ..................................................................................................................................
Objektkatalog ...............................................................................................................................................
With-Anweisung ............................................................................................................................................
Exkurs: Klassenmodule ..................................................................................................................................
Exkurs: Benutzerdefinierte Eigenschaften und Methoden ..............................................................................
Zusammenfassen und Vertiefen: Objekte und Auflistungen ..........................................................................
33
34
35
36
37
38
39
40
41
42
Modul 5: Programmstrukturen .......................................................................................................................
Überblick über Schleifen ...............................................................................................................................
For Next .....................................................................................................................................................
For Each Next .............................................................................................................................................
Do Loop ......................................................................................................................................................
Überblick über Verzweigungen .....................................................................................................................
If Then Else ..............................................................................................................................................
Select Case End Select ...............................................................................................................................
Zusammenfassen und Vertiefen: Programmstrukturen ....................................................................................
43
44
45
46
47
48
49
50
51
4
Modul 6: Fehlerbehandlung .........................................................................................................................
Benutzerdefinierte Fehlerroutinen ................................................................................................................
Exkurs: Auslösen von benutzerdefinierten Fehlern ......................................................................................
Hierarchie der Fehlerroutinen ......................................................................................................................
Zusammenfassen und Vertiefen: Fehlerbehandlung ....................................................................................
52
53
54
55
56
Modul 7: Formulare und Dialogfelder .........................................................................................................
Erstellen von Dialogfeldern ..........................................................................................................................
Hinzufügen von Steuerelementen ................................................................................................................
Ändern der Größe und Position von Steuerelementen .................................................................................
Eigenschaften von Steuerelementen ............................................................................................................
Ereignisprozeduren .......................................................................................................................................
Anzeigen von Dialogfeldern.........................................................................................................................
Zusammenfassen und Vertiefen: Formulare und Dialogfelder ....................................................................
57
58
59
60
61
62
63
64
Modul 8: Datenaustausch mit anderen Anwendungen ................................................................................
Zugriff auf Objekte anderer Anwendungen ..................................................................................................
Exkurs: Datenaustausch mit DDE ................................................................................................................
Exkurs: Zugriff auf Windows-Funktionen .....................................................................................................
Zusammenfassen und Vertiefen: Datenaustausch mit anderen Anwendungen ...........................................
65
66
67
68
69
Wichtige Tastenkombinationen ................................................................................................................... 70
Index ............................................................................................................................................................. 71
5
Modul 1
Einführung in die Programmierung
Was ist VBA? Was ist der Unterschied zu Visual Basic? Wofür kann man VBA einsetzen? Wie kann
ich ein Projekt erstellen? Wie kann ich Eigenschaften von Dokumenten einstellen? Was ist ein Modul?
Wie kann ich ein Modul erstellen? Wie plane ich ein Programm? Wie kann ich ein Programm eingeben,
ausführen und testen? Was ist der Unterschied zwischen Anweisungen und Funktionen? Wie erstelle
ich Prozeduren? Wie kann ich mit dem Benutzer kommunizieren?
In diesem Modul werden folgende Themen behandelt:
Grundlagen von VBA
Projekte, Eigenschaften und Module
Planung eines Programms
Eingeben eines Programms
Unterschiede zwischen Anweisungen und Funktionen
Prozeduren
Befehle zur Ein- und Ausgabe
Ausführen und Testen eines Programms
Einzelschrittmodus
Lernziel
Der Anwender lernt die Bedienung des Visual Basic-Editors und die Grundlagen der Programmierung kennen.
Voraussetzungen
Grundlagenkenntnisse im Umgang mit Word-Dokumenten, Excel-Arbeitsmappen und/oder Powerpoint-Präsentationen und im Umgang mit einer Textverarbeitung.
6
Grundlagen von VBA
Was ist VBA? Was sind die Unterschiede zu Visual Basic und VB-Skript? Wie rufe ich den VBA-Editor
auf?
-
Abb.1: Aufruf des Visual Basic-Editors
VBA (Visual Basic für Applikationen) stellt eine Sprachfamilie von Microsoft dar, die
u.a. Visual Basic für Word, Excel, Powerpoint und Access umfaßt. Daneben unterstützen noch einige andere Microsoft-Anwendungen VBA, z.B. Project und Visual C++.
Eine Untermenge von VBA stellt VB-Skript dar, das derzeit nur vom Internet Explorer
und von Outlook unterstützt wird. Die Möglichkeiten von VB-Skript sind sehr
eingeschränkt.
Abgrenzung
VBA ist eine Untermenge von Visual Basic. Im Unterschied zu Visual Basic kann man
mit VBA keine eigenständigen Anwendungen kreieren, sondern ist immer auf eine der
Office-Anwendungen angewiesen. Einzig zu Access gibt es optional ein RuntimeModul, das es ermöglicht, Access Datenbanken samt dem VBA-Code auszuführen,
ohne daß Access installiert ist. Visual Basic und VBA haben viele Gemeinsamkeiten.
Anwendungen
VBA ersetzt die verschiedenen Makro-Sprachen der Microsoft Office-Anwendungen.
Der Vorteil ist, daß der Programmierer nur mehr eine Programmiersprache erlernen
muß, um alle Office-Anwendungen zu programmieren. Mit VBA ist es nicht nur
möglich, die aktuelle Anwendung zu beeinflussen, sondern man kann auch fremde
Anwendungen, soweit diese das erlauben, fernsteuern. Alle Anwendungen, die
sogenannte OLE-Automatisierungs-Server darstellen, können mit VBA gesteuert werden.
OLE-Anwendungen
In Word, Excel und Powerpoint können Sie den Visual Basic-Editor auf die gleiche Weise aufrufen. Hierzu wählen
Sie Menü ExtrasMakroVisual-Basic Editor. Access hat in bezug auf VBA eine Sonderstellung.
7
Projekte, Eigenschaften und Module
Was ist ein Projekt? Wie füge ich neue Module in ein Projekt ein? Wie kann ich Eigenschaften für
Dokumente festlegen?
-
Abb.2: Projekt-Explorer und Eigenschaftenfenster
In Visual Basic stellt ein Projekt normalerweise eine komplette Anwendung dar. In
VBA wird ein Projekt definiert durch ein Office-Dokument, wie z. B. ein WordDokument oder eine Excel-Arbeitsmappe. In einem Projekt werden gespeichert
Projekt
das Dokument
alle Makros, die mit diesem Dokument verbunden sind
Benutzerformulare (Dialogboxen)
Verweise auf andere Dokumente, Anwendungen, Vorlagen u. ä.
Die Makros werden in Modulen zusammengefaßt, die den Gültigkeitsbereich bestimmen.
Module
Alle geöffneten Projekte sowie deren Komponenten kann man im Projekt-Explorer
betrachten und verwalten. Diesen kann man mit AnsichtProjekt-Explorer oder über
das Symbol Projekt-Explorer im Visual Basic-Editor ein- und ausblenden. Komponenten kann man löschen, indem man auf sie mit der rechten Maustaste klickt und den
Befehl Entfernen von <Komponenten-Name>... auswählt. Man kann auch den Befehl
DateiEntfernen von <Komponenten-Name>... auswählen.
Projekt-Explorer
Die Eigenschaften zu einer Komponente werden im Eigenschaftenfenster angezeigt
und bearbeitet. Dieses wird mit AnsichtEigenschaften oder dem Symbol Eigenschaftenfenster ein- und ausgeblendet. Im Eigenschaftenfenster legt man z. B. den Namen von
Komponenten fest.
Eigenschaftenfenster
Ein neues Modul fügt man in das gerade ausgewählte Projekt mit dem Befehl EinfügenModul oder über
das Symbol Modul einfügen ein.
8
Planung eines Programms
Was muß bei der Erstellung einer VBA-Anwendung beachtet werden? Wie kann ich ein größeres
Projekt planen?
-
Abb.3: Elemente eines Teilprogramms
Jeder in sich abgeschlossene Programmteil besteht aus 5 Elementen, die sorgfältig vor
der Implementierung geplant werden sollten:
Teilprogramme
1. Schnittstelle: Über die Schnittstelle (Interface) kommuniziert ein Programmteil mit
anderen Programmteilen. Nicht jeder Programmteil verfügt über eine solche
Schnittstelle.
Schnittstelle
2. Deklarationsteil: Hier werden Variablen und Datentypen deklariert, die im
Programmteil verwendet werden sollen.
Deklarationsteil
3. Eingabe: Jedes Programm benötigt Daten, die es verarbeiten kann. Diese Daten
können über die Schnittstelle kommen, vom Benutzer eingegeben werden, oder
aus anderen Datenquellen (z. B. Dokumente oder Datenbanken) extrahiert werden.
Eingabe
4. Verarbeitung: Die eingegebenen Daten werden mit Hilfe eines Algorithmus
(Lösungsweges) verarbeitet. Kompliziertere Algorithmen sollten verbal oder graphisch dargestellt werden. Zur graphischen Darstellung eignen sich u.a.
Struktogramme und Flußdiagramme.
Verarbeitung
5. Ausgabe: Die Ergebnisse der Verarbeitung können über die Schnittstelle, über
Benutzerschnittstellen (z.B. Dialogboxen) oder in andere Datenquellen (z.B.
Dokumente oder Datenbanken) ausgegeben werden.
Ausgabe
Bei großen Projekten sollte man vor der Implementierung Ist- und Soll-Analysen durchführen, um das Ziel des
Projektes klar zu definieren. Solche Projekte werden dann in viele kleinere Programmteile zerlegt.
9
Eingeben eines Programms
Wo gebe ich meine Programme ein? Welche Möglichkeiten bietet der Visual Basic-Editor?
-
Abb.4: Visual Basic-Editor
Bevor man ein Programm eingeben kann, muß man ein Modul erzeugen. Jedes
Dokument hat bereits ein Standardmodul. Dieses kann angezeigt werden, indem man
das Dokument im Projekt-Explorer auswählt und den Menübefehl AnsichtCode
ausführt. Man kann aber auch einfach auf das Dokument doppelklicken. Ebenso
haben benutzerdefinierte Formulare bereits ein eigenes Modul. Diese Module sollten
jedoch nur für Ereignisprozeduren und direkt damit in Zusammenhang stehende
Prozeduren und Funktionen verwendet werden. Man sollte daher den Großteil des
VBA-Codes auf eigene Module verteilen.
Code-Ansicht
Den Programmcode kann man wie in einer Textverarbeitung eingeben. Jede Anweisung und jeder Befehl wird in eine neue Zeile geschrieben. Mit der TABULATOR-Taste
erfolgen Einrückungen, die den Programmcode übersichtlicher machen. Mit UMSCHALT + TABULATOR können Einrückungen zurückgenommen werden. Der
Programmcode kann ansonsten wie in einer Textverarbeitung üblich bearbeitet,
verschoben und kopiert werden. Im Menü Bearbeiten stehen zudem die Befehle
Suchen... und Ersetzen... zur Verfügung.
Eingeben des Codes
Das Apostroph () markiert den dahinterstehenden Text als Kommentar.
Kommentare
Bei den meisten Schlüsselwörtern zeigt der Editor nach der Eingabe die Syntax der Parameter in Form eines
QuickTips an. Konstanten, Eigenschaften und Methoden zu Objekten können häufig aus automatisch aufklappenden Listen gewählt werden. Dabei kann man auch die ersten paar Buchstaben der Konstanten eintippen und den
Namen mit TABULATOR vervollständigen.
10
Unterschiede zwischen Anweisungen und Funktionen
Was ist eine Anweisung? Was ist ein Befehl? Was ist eine Funktion?
-
Abb.5: Datenfluß zwischen Prozeduren und Funktionen
Anweisungen legen die grundsätzliche Programmstruktur fest, z.B. Deklarations-,
Schleifen- und Verzweigungsanweisungen, während Befehle die eigentliche Datenverarbeitung erledigen, z.B. Ein- und Ausgabebefehle. Daneben kann man auch
eigene Befehle definieren, die Prozeduren genannt werden.
Anweisungen
Hauptmerkmal von Befehlen ist, daß die Ausgabe entweder über die Benutzerschnittstelle (z.B. Dialogboxen) oder in eine andere Datenquelle (z.B. Dokumente, Datenbanken) erfolgt.
Befehle
Fast jedes Programm benötigt Berechnungen, um das gewünschte Ergebnis zu
erreichen. VBA unterstützt die Grundrechnungsarten und das Potenzieren. Daneben
gibt es eine Reihe eingebauter Funktionen, die kompliziertere Berechnungen durchführen.
Funktionen
Funktionen können nie als eigenständige Befehle im Programm stehen, sondern das
Ergebnis einer Funktion muß immer sofort von einer Anweisung oder einem Befehl
weiterverarbeitet werden. Z.B. liefert die Funktion Int(Zahl) den ganzzahligen Teil
einer Zahl. Das Ergebnis dieser Funktion wird aber weder gespeichert noch am
Bildschirm ausgegeben, sondern es wird direkt an das aufrufende Programm zurückgegeben. Int kann daher nur Teil einer Anweisung sein, die das Ergebnis weiterverarbeitet.
Verwendung von
Funktionen
Sowohl die meisten Befehle und Prozeduren als auch die meisten Funktionen benötigen Parameter. Sie dürfen
bei Prozeduren und Befehlen die Parameterniemals in Klammern schreiben, bei Funktionen müssen Sie sieimmer
in Klammern schreiben. Hat eine Funktion keine Parameter, müssen Sie leere Klammern anschließen, z. B.Date().
11
Prozeduren
Was sind Prozeduren? Wie deklariere ich Prozeduren? Wie werden Prozeduren aufgerufen?
-
Abb.6: Einfügen einer Prozedur
Prozeduren sind das Grundgerüst eines jeden Projekts. Man unterscheidet allgemeine
Prozeduren und Ereignisprozeduren. Allgemeine Prozeduren ohne Parameter werden
auch Makros genannt und können von den Office-Programmen (mit Ausnahme von
Access) aus mit dem Menübefehl ExtrasMakroMakros direkt als Makros aufgerufen
werden. Ereignisprozeduren werden in der Regel automatisch beim Eintreten der
verschiedenen Ereignisse aufgerufen. Alle Prozeduren, also auch allgemeine Prozeduren mit Parametern, können von anderen Prozeduren oder Funktionen aus aufgerufen werden.
Prozeduren
Eine Prozedur ohne Parameter sieht folgendermaßen aus:
Public Sub Prozedurname ()
Es folgen die Anweisungen
End Sub
Diese Deklaration kann aber auch über Menü EinfügenProzedur oder über das
Symbol Prozedur einfügen erfolgen. Im darauf folgenden Dialog ist der Name der
Prozedur einzugeben.
Die anderen Einstellungen in diesem Dialog betreffen den Typ, den Gültigkeitsbereich
der Prozedur und die Gültigkeitsdauer von Variablen. Die Standardeinstellungen
werden in den meisten Fällen sinnvoll sein.
Aufgerufen wird eine Prozedur von einer anderen Prozedur oder Funktion aus mit der
Anweisung Call Prozedurname.
Aufruf
Die Anweisung Call können Sie immer weglassen, wodurch Sie die Prozedur nur unter Angabe des Prozedurnamens aufrufen können. Sie können Prozeduren mit der Anweisung Exit Sub innerhalb des Modulkörpers
vorzeitig verlassen.
12
Befehle zur Ein- und Ausgabe
Wie kann man Benutzereingaben entgegennehmen? Wie kann man Meldungen am Bildschirm
ausgeben?
-
Abb.7: Meldungsbox und Eingabebox
Der MsgBox-Befehl und die MsgBox-Funktion zeigen eine Meldungsbox mit einem
frei definierbaren Text und verschiedenen Schaltflächen an.
MsgBox
Die InputBox-Funktion fordert den Benutzer zur Eingabe eines Textes auf und gibt
diesen als Zeichenkette zurück.
InputBox
MsgBox Meldungstext, , Titeltext
Syntax
Anweisung
MsgBox (Meldungstext, Buttons, Titeltext) Funktion
InputBox (Meldung, Titeltext, Vorgabe)
Meldungstext
Frei definierbarer Text, der in der Meldungsbox erscheinen soll.
Buttons
Eine Summe von Konstanten, die die Schaltflächen und das
Symbol in der Meldungsbox festlegen. (Optional, wenn nur die
Ok-Schaltfläche benötigt wird.)
Titeltext
Der Text, der in der Titelleiste der Meldungsbox erscheinen soll.
(Optional)
Vorgabe
Vorgabetext, der in der Eingabebox erscheinen soll.
Die MsgBox-Funktion gibt abhängig von der Schaltfläche, die der Benutzer angeklickt
hat, einen Wert zurück, der je nach Schaltflächen mit verschiedenen Konstanten
verglichen werden kann.
Parameter
Rückgabewert
Die InputBox-Funktion gibt den vom Benutzer eingegeben Text zurück. Klickt der
Benutzer auf Abbrechen, wird eine leere Zeichenkette zurückgegeben.
Zu Testzwecken können Sie Ausgaben für den Benutzer unsichtbar im Direktbereich bzw. Testfenster vornehmen. Dazu dient die Anweisung Debug.Print, die auch mit Debug.? abgekürzt werden kann. Nähere Informationen zu diesen Befehlen finden Sie in der Hilfe.
13
Ausführen und Testen eines Programms
Wie kann ich Makros aufrufen? Wie zeige ich den Direktbereich an? Wie kann ich den Inhalt von
Variablen anzeigen?
-
Abb.8: Direktbereich, Lokalfenster, Überwachungsfenster
Allgemeine Prozeduren ohne Parameter werden auch Makros genannt und können
von den Office-Programmen (mit Ausnahme von Access) aus direkt als Makros
aufgerufen werden. Dazu dient der Menübefehl ExtrasMakroMakros.
Makros ausführen
Im Visual Basic-Editor stellt man den Cursor in die entsprechende Prozedur und wählt
aus dem Menü AusführenSub/UserForm ausführen.
Prozeduren ausführen
Der Direktbereich stellt eine weitere Möglichkeit dar, Prozeduren und auch einzelne
Anweisungen und Befehle zu testen. Mit dem Befehl AnsichtDirektbereich kann
man diesen ein- und ausblenden. Im Direktbereich gibt man einfach die Anweisung,
den Befehl oder den Prozedurnamen ein und drückt die EINGABETASTE. Hier können
auch Prozeduren mit Parametern und Funktionen getestet werden. Um den Inhalt von
Variablen oder das Ergebnis von Funktionen auszugeben, dient der Befehl Print bzw.
?. Z. B. gibt Print Int(3.5) als Ergebnis 3 zurück.
Direktbereich
Mit dem Befehl AnsichtLokal-Fenster wird ein Fenster angezeigt, das alle lokalen
Variablen der aktiven Prozedur mit deren Inhalt anzeigt. Der Befehl Ansicht
Überwachungsfenster zeigt ein Fenster an, in dem man Überwachungsausdrücke
definieren kann, deren Ergebnis hier ständig angezeigt wird. Diese Ausdrücke
definiert man mit dem Befehl TestenÜberwachung hinzufügen....
Lokal-Fenster
Im Überwachungsfenster lassen sich auch Situationen definieren, bei denen das Programm gestoppt werden soll,
was bei der Fehlersuche hilfreich sein kann.
14
Einzelschrittmodus
Wie kann ich die Anweisungen eines Programms einzeln ausführen? Welche Möglichkeiten bietet der
Einzelschrittmodus?
-
Abb.9: Symbolleiste Testen
Häufig muß man ein Programm im Einzelschrittmodus ausführen, um Fehler zu
finden. Dazu setzt man an entsprechender Stelle im Programm einen Haltepunkt. Das
Setzen und Löschen von Haltepunkten erfolgt durch einen Mausklick in den grauen
Bereich links neben der entsprechenden Zeile. Stoppt das Programm an diesem
Haltepunkt, stehen folgende Befehle zur Verfügung:
Haltepunkte
TestenEinzelschritt
Führt die Anweisung aus und stoppt das Programm abermals.
TestenProzedurschrittt
Führt die Anweisung aus. Wird hierbei eine andere Prozedur aufgerufen, wird
diese nicht im Einzelschrittmodus ausgeführt.
TestenProzedur abschließen
Wurde mit Testen Einzelschritt in eine andere Prozedur gesprungen, so führt
dieser Befehl die Prozedur ohne Pause aus und stoppt nach dem Rücksprung ins
aufrufende Programm.
TestenAusführen bis Cursor-Position
Führt das Programm bis zur Cursor-Position ohne Pause aus.
AusführenFortsetzen
Führt das Programm ohne Pause bis zum nächsten Haltepunkt aus.
Diese Befehle findet man auch auf der Symbolleiste Testen.
Im Einzelschrittmodus kann man auch die Anweisung festlegen, die als nächstes ausgeführt werden soll, indem
man den gelben Pfeil im Code-Fenster zu einer anderen Anweisung zieht.
15
Zusammenfassen und Vertiefen
Modul 1: Einführung in die Programmierung
1. Visual Basic für Applikationen stellt eine einheitliche Makro-Sprache für alle
Microsoft-Anwendungen dar, die auch anwendungsübergreifendes Programmieren erlaubt. Der Visual Basic Editor wird in Word, Excel und Powerpoint über den
Menübefehl ExtrasMakroVisual Basic Editor aufgerufen.
Grundlagen
Seite 6
2. Im Projekt-Explorer können die Komponenten eines Projektes verwaltet werden,
im Eigenschaften-Fenster können die Eigenschaften der Objekte bestimmt werden. Der Programm-Code wird in Module eingegeben, die sich über den Menübefehl EinfügenModul erzeugen lassen.
Projekte, Eigenschaften,
Module
Seite 7
3. Jeder abgeschlossene Programmteil besteht aus einer Schnittstelle, einem
Deklarationsteil, dem Eingabeteil, dem Verarbeitungsteil und dem Ausgabeteil.
Besonders bei größeren Programmierprojekten ist eine sorgfältige Planung wichtig.
Planung
Seite 8
4. Beim Eingeben des Programm-Codes ist es wichtig, daß jeder Befehl in eine eigene
Zeile geschrieben wird. Kommentare werden mit einem Apostroph () gekennzeichnet.
Eingabe
Seite 9
5. Bei Anweisungen und Befehlen sind die Parameter nie in Klammern zu schreiben,
bei Prozeduren hingegen schon. Eine Prozedur kann nie alleine aufgerufen
werden, sondern das Ergebnis muß immer in irgendeiner Weise weiterverarbeitet
werden.
Anweisungen Funktionen
Seite 10
6. Prozeduren werden immer mit dem SchlüsselwortSub eingeleitet und mit End Sub
beendet. Eine Prozedur kann einfach durch Angabe des Prozedurnamens aufgerufen werden.
Prozeduren
Seite 11
7. Mit den Funktionen MsgBox und InputBox können Meldungen an den Benutzer
weitergeleitet werden bzw. Eingaben entgegengenommen werden. MitDebug.Print
kann man Testausgaben im Direktbereich vornehmen.
Ein- und Ausgabe
Seite 12
8. Im Direktbereich können Programme und Befehle getestet werden. Über die
Befehle AnsichtLokal-Fenster und AnsichtÜberwachungsfenster lassen sich
zwei Fenster einblenden, die zur Überwachung der Inhalte von Variablen eingesetzt werden.
Testen, Ausführen
Seite 13
9. Im Einzelschrittmodus können fehlerhafte Programme leichter korrigiert werden.
Dabei wird nach der Ausführung eines jeden Befehls gestoppt, und man kann die
Inhalte von Variablen kontrollieren.
Einzelschrittmodus
Seite 14
-
16
Modul 2
Variablen und Konstanten
Wie kann ich Daten in Programmen zwischenspeichern? Wie kann ich häufig verwendete Werte
vordefinieren? Wie kann ich auf eine Reihe gleichartiger Daten am einfachsten zugreifen? Welche
Datentypen gibt es in VBA? Wie lange sind Variablen gültig? Wo kann ich überall Variablen verwenden?
Konstanten, Variablen, Datenfelder
Deklaration von Variablen
Datentypen
Gültigkeitsbereich
Gültigkeitsdauer
Konstanten
Datenfelder
Lernziel
Der Anwender erlernt den Unterschied zwischen Variablen und Konstanten sowie deren Verwendung im
Programm.
Voraussetzungen
Kenntnis über die Bedienung des Visual Basic-Editors. Kenntnisse über den Unterschied zwischen Projekten,
Modulen und Prozeduren sowie über die Deklaration eigener Prozeduren.
17
Konstanten, Variablen, Datenfelder
Wo kann ich Konstanten und Variablen einsetzen? Wie verwende ich Datenfelder?
-
Abb.10: Variablen und Datenfelder
Fast jedes Programm benötigt Speicherplätze, wo es Werte für eine spätere Verwendung zwischenspeichern kann. Man kann sich diese Speicherplätze wie Schubladen
vorstellen. Jede Schublade stellt eine Variable dar. Die Beschriftung der Schublade ist
der Variablenname. In dieser Schublade kann man Werte verschiedenen Typs
(Zahlen, Texte, Objekte) speichern. Der Inhalt dieser Variablen läßt sich jederzeit
abrufen und verändern.
Variablen
In vielen Programmen gibt es neben diesen variablen Werten auch eine Anzahl von
konstanten Werten. Manchmal ist es sinnvoll, auch diesen konstanten Werten Namen
zuzuweisen. Man spricht dann von Konstanten. In Visual Basic sind bereits zahlreiche
Konstanten vordefiniert. Ihr Name beginnt immer mit vb. Außerdem gibt es spezielle
Word-Konstanten, die alle mit wd beginnen, spezielle Excel-Konstanten, die alle mit
xl beginnen und spezielle Access-Konstanten, die mit ac beginnen. Konstanten
werden einmal definiert und dürfen über die gesamte Laufzeit eines Programms nicht
verändert werden.
Konstanten
Oft will man auf eine größere Anzahl gleichartiger Daten unter dem gleichen
Variablennamen zugreifen. Der jeweilige Wert soll dabei meist durch den Inhalt einer
anderen Variablen ausgewählt werden. Man kann sich das als Schubladenschrank mit
einem bestimmten Namen vorstellen. Die einzelnen Laden werden dabei durch
Nummern gekennzeichnet. In Programmiersprachen spricht man dabei von Datenfeldern oder Arrays.
Datenfelder
Egal ob Sie Variablen, Konstanten oder Datenfelder definieren. Sie können sie alle überall an Stelle von jedem
anderen Wert verwenden.
18
Variablen
Wie deklariere ich Variablen? Welche Datentypen können Variablen haben? Wie kann ich den Inhalt
von Variablen verändern?
-
Abb.11: Verwendung von Variablen
Normalerweise müssen Variablen in Basic nicht deklariert werden. Sie werden dann
bei der ersten Verwendung automatisch mit dem Datentyp Variant angelegt. Es
empfiehlt sich jedoch aus Gründen der Fehlervermeidung und Ablaufgeschwindigkeit
Variablen vorher zu deklarieren. Man kann die Deklaration von Variablen erzwingen,
indem man im Modulkopf (der Bereich am Beginn eines Moduls, bevor die erste
Prozedur deklariert wird) die Anweisung Option Explicit eingibt. Wenn man mit
dem Befehl ExtrasOptionen im Register Editor die Option Variablendeklaration
erforderlich aktiviert, wird diese Anweisung in allen neuen Modulen automatisch
eingefügt.
Deklaration
Variablen können mit verschiedenen Anweisungen entweder im Modulkopf oder
innerhalb einer Prozedur oder Funktion deklariert werden. Dazu verwendet man die
Syntax Dim
Variablenname As
Datentyp. Statt Dim können auch die
Schlüsselwörter Private, Public und Static verwendet werden, die der Variablen einen
unterschiedlichen Gültigkeitsbereich bzw. eine unterschiedliche Gültigkeitsdauer
geben.
Schlüsselwörter
Der Wert einer Variablen wird mit der Syntax Variablenname = Wert zugewiesen. Um einer Variablen vom Typ Object oder eines Untertyps von Object ein Objekt
zuzuordnen, muß die Anweisung Set verwendet werden.
Wertzuweisung
strT = "Text"
Set objO = ActiveWorkbook
Die Schlüsselwörter Dim und Private haben die gleiche Wirkung und können sowohl innerhalb von Prozeduren
als auch im Modulkopf verwendet werden. Public kann nur im Modulkopf verwendet werden, Static nur
innerhalb von Prozeduren.
19
Datentypen
Welche Datentypen können Variablen haben? Welche Besonderheiten haben Objekt- und VariantVariablen?
-
Abb.12: Übersicht über Datentypen
VBA unterstützt folgende Datentypen:
Boolean
Datentypen
2 Bytes, True (-1) oder False (0)
Byte/Integer/Long 1/2/4 Byte, Ganzzahl, 0 bis 255/-32.768 bis +32.767/2.147.483.648 bis +2.147.483.647
Single/Double
4/8 Bytes, Fließkommazahl, 7/15 Dezimalstellen
Currency
8 Bytes, Festkommazahl, 4 Nachkommastellen
Decimal
14 Bytes, Fließkommazahl, 29 Dezimalstellen
Date
8 Bytes, Datum/Uhrzeit
String
10 Bytes + Länge der Zeichenkette, Zeichenketten, bis zu ca. 2
Milliarden Zeichen Länge
Object
4 Bytes, Verweis auf ein beliebiges Objekt
Variant
numerisch: 16 Bytes, String: 22 Bytes + Länge der Zeichenkette,
variabler Universal-Datentyp
Variant kann auch die speziellen Werte Empty (nicht initialisiert), Null und Error
annehmen. Diese Werte können mit den Funktionen IsEmpty(), IsNull() und IsError()
abgefragt werden. Einen Error-Wert erzeugt man mit der Funktion CVError(Fehlernummer). Der eigentliche Datentyp einer Variant-Variable kann mit der Funktion
VarType() ermittelt werden.
Variant
Eine Objektvariable enthält nie das Objekt selbst, sondern nur einen Verweis auf das
Objekt. Mit Set Objektvariable = Nothing wird der Verweis gelöscht.
Objekt
Der Datentyp Object sollte möglichst nicht verwendet werden, statt dessen eine Objektklasse, wie z. B.
Document, Workbook, Recordset oder Form. Variant ist der Standarddatentyp bei Variablen, deren Typ nicht
angegeben wird.
20
Gültigkeitsbereiche von Variablen
In welchen Programmteilen ist der Name einer Variablen gültig? Wie kann ich auf Variablen in anderen
Modulen zugreifen?
-
Abb.13: Sichtbarkeit von Variablen
Für Variablen gibt es die drei Gültigkeitsbereiche Prozedurebene, Modulebene und
Projektebene. Es ist immer empfehlenswert, den Gültigkeitsbereich einer Variablen
soweit wie möglich einzuschränken.
Gültigkeitsbereich
Variablen werden auf Prozedurebene mit den Anweisungen Dim, Private oder Static
deklariert, wobei diese Anweisungen innerhalb der jeweiligen Prozedur, also zwischen Sub und End Sub stehen müssen. Diese Variablen sind nur innerhalb der
Prozedur sichtbar.
Prozedurebene
Um Variablen für alle Prozeduren im gleichen Modul sichtbar zu machen, verwendet
man die Anweisungen Dim oder Private im Modulkopf. Um Variablen im gesamten
Projekt sichtbar zu machen, verwendet man die Anweisung Public im Modulkopf.
Modulebene/Projektebene
Haben Variablen mit unterschiedlichen Gültigkeitsbereichen oder in unterschiedlichen Modulen den gleichen Namen, hat die Variable mit dem kleineren (näherliegenden) Gültigkeitsbereich den Vorrang. Wenn also auf Prozedurebene eine Variable mit
gleichem Namen wie eine andere auf Modulebene deklariert wird, so ist innerhalb der
Prozedur nur die lokale Variable sichtbar. Ebenso haben bei Namensgleichheit
Variablen im gleichen Modul Vorrang vor Variablen in anderen Modulen.
Namenskonflikte
Sie können auf jeden Fall auf Variablen und Prozeduren in anderen und im eigenen Modul zugreifen, indem Sie
die Syntax Modulname.Variablenname bzw. Modulname.Prozedurname verwenden.
21
Gültigkeitsdauer
Wie lange bleibt der Inhalt von Variablen erhalten? Kann man die Gültigkeitsdauer auch verändern?
-
Abb.14: Beispiel einer statischen Variablen
Bei VBA bleibt der Inhalt von Variablen nur solange gültig, bis eines der folgenden
Ereignisse eintritt:
Gültigkeitsbereiche
Erneutes Kompilieren des Projektes
Projekt wird neu initialisiert
Deklaration der Variablen wird verändert
Projekt wird geschlossen
Variablen, die innerhalb einer Prozedur mit dem SchlüsselwortDim deklariert wurden
sind noch kürzer gültig, nämlich nur bis die Prozedur beendet wird, sie also mit Exit
Sub oder End Sub verlassen wird. Der Speicherplatz solcher Variablen wird daraufhin
freigegeben. Beim nächsten Aufruf dieser Prozedur werden die Variablen erneut im
Speicher angelegt und neu intialisiert.
Lokale Variablen
Will man den Inhalt von Variablen auf Prozedurebene zwischen zwei Aufrufen der
gleichen Prozedur erhalten, so sind diese mit dem Schlüsselwort Static an Stelle von
Dim zu deklarieren. Das Schlüsselwort Static kann nicht im Modulkopf verwendet
werden, da alle Variablen auf Modulebene auf jeden Fall statisch sind.
Static
Sollen alle Variablen einer Prozedur automatisch statisch sein, so kann man das Schlüsselwort Static auch im
Prozedurkopf verwenden: Public Static Sub Prozedurname (). Die Variablen können dann sowohl
mit Dim als auch mit Static deklariert werden, verhalten sich aber in jedem Fall so, als ob Sie sie mit Static
deklarieren würden.
22
Konstanten
Wie kann ich Konstanten deklarieren? Wann verwendet man Konstanten?
-
Abb.15: Deklaration von Konstanten
Konstanten werden immer dann verwendet, wenn ein Wert mehrmals im Programm
vorkommt, aber nirgends verändert werden darf.
Verwendung
In Visual Basic sind bereits zahlreiche Konstanten vordefiniert. Ihr Name beginnt
immer mit vb. Außerdem gibt es spezielle Word-Konstanten, die alle mit wd beginnen,
spezielle Excel-Konstanten, die alle mit xl beginnen und spezielle Access-Konstanten,
die mit ac beginnen.
Vordefinierte Konstanten
Konstanten werden mit dem Schlüsselwort Const deklariert. Die Syntax dafür lautet:
Deklaration
Const Konstantenname = Ausdruck
Als Ausdruck kann ein einfacher Wert, wie z. B. eine Zahl oder ein Text zwischen
doppelten Anführungszeichen, dienen. Man kann aber auch Berechnungen an dieser
Stelle durchführen lassen. In diesen Berechnungen dürfen allerdings keine Variablen
und Funktionen vorkommen. Es dürfen aber andere Konstanten darin vorkommen.
Ausdruck
Die Konstantendeklaration erfolgt normalerweise im Modulkopf. Mit den SchlüsselwörternPublic undPrivate vorConst kann ihr Gültigkeitsbereich definiert werden(siehe
Kapitel Gültigkeitsbereich). Es ist außerdem möglich, mit dem Schlüsselwort As
einen genauen Datentyp anzugeben und mehrere Konstanten in einer Zeile zu
definieren.
Gültigkeitsbereich/Datentyp
Konstanten können überall im Programm anstelle des Wertes vorkommen. Sie dürfen aber nicht während der
Laufzeit des Programms verändert werden.
23
Datenfelder
Wie kann man Datenfelder deklarieren? Kann man die Größe von Datenfeldern zur Laufzeit verändern?
-
Abb.16: Beispiel zur Verwendung von Datenfeldern
Man unterscheidet statische und dynamische Datenfelder. Dynamische Datenfelder
können ihre Größe im Programmablauf ändern.
Statisch/Dynamisch
Ein statisches Datenfeld wird mit der Anweisung Dim/Private/Static/Public
Variablenname (niedrigste Indexnummer To höchste Indexnummer)
As Datentyp deklariert. Die Grenzen für die Indexnummern müssen konstant sein.
Werden die niedrigste Indexnummer und das Schlüsselwort To weggelassen, beginnt
der Index mit 0 zu zählen.
Statische Datenfelder
Um ein dynamisches Datenfeld zu deklarieren, läßt man den Wert in Klammern weg,
z. B. Dim A() As String. Ein solches Datenfeld muß vor der ersten Verwendung
nochmals dimensioniert werden. Das geschieht mit der Anweisung ReDim, die auch
mehrmals im Programm erfolgen kann. Dabei geht der Inhalt des Datenfeldes
verloren, was mit dem Schlüsselwort Preserve hinter ReDim verhindert werden kann.
Dynamische Datenfelder
Die einzelnen Elemente eines Datenfeldes spricht man über deren Indexnummern in
Klammern an. Anstelle einer konstanten Zahl kann diese Indexnummer auch durch
eine andere Variable dargestellt werden, z. B.: A(i).
Indexnummern
Bei der Deklaration mehrdimensionaler Datenfelder gibt man die Größe jeder
Dimension separat, durch Komma getrennt an. Beim Zugriff auf Elemente eines
mehrdimensionalen Datenfeldes muß die Position in jeder Dimension angegeben
werden, z. B. A(0, 2, 5).
Mehrdimensionale
Datenfelder
Um die Ober- und Untergrenzen für den Index zu ermitteln, können Sie die Funktionen UBound() und LBound()
verwenden.
24
Modul 2: Variablen und Konstanten
1. Variablen sind eines der wichtigsten Programmierelemente. In ihnen können
Werte für eine spätere Verwendung zwischengespeichert werden.
Variablen
Seite 17
2. Konstanten werden mit dem Schlüsselwort Const deklariert. Sie dürfen über die
gesamte Laufzeit des Programms nicht verändert werden.
Konstanten
Seite 18
3. Variablen werden mit den Schlüsselwörtern Dim, Private, Public oder Static
deklariert. Objektvariablen lassen sich nur mit dem Schlüsselwort Set auf ein
bestimmtes Objekt setzen.
Deklaration von Variablen
Seite 19
4. Die am häufigsten verwendeten Datentypen sind Integer, Long, Single, Double,
String, Variant und Objektklassen. Der Datentyp Variant kann einige besondere
Werte, wie Empty oder Null, enthalten.
Datentypen
Seite 20
5. Je nachdem, an welcher Stelle und mit welchem Schlüsselwort man Variablen
deklariert, haben sie unterschiedliche Gültigkeitsbereiche. Die möglichen Gültigkeitsbereiche sind Projektebene, Modulebene und Prozedurebene.
Gültigkeitsbereich
Seite 21
6. Variablen auf Prozedurebene bleiben normalerweise nur so lange erhalten, wie
die Prozedur läuft, es sei denn, sie werden mit dem Schlüsselwort Static deklariert.
Variablen auf Modul- und Projektebene bleiben über die gesamte Laufzeit des
Projekts erhalten.
Gültigkeitsdauer
Seite 22-23
7. Mit Hilfe von Datenfeldern ist es möglich, mehrere Variablen unter dem gleichen
Namen, aber mit unterschiedlichen Indexnummern anzusprechen. Es gibt statische Datenfelder, deren Größe sich über die gesamte Laufzeit des Programms
nicht verändert, und dynamische Datenfelder, deren Größe sich jederzeit ändern
kann.
Datenfelder
Seite 24
-
25
Modul 3
Prozeduren und Funktionen
Wie kann ich Daten an Prozeduren übermitteln? Wie kann ich eigene Funktionen programmieren? Wie
können Prozeduren und Funktionen Ergebnisse zurückgeben? Was sind Parameter? Was versteht
man unter Call By Reference? Was versteht man unter Call by Value? Wie lassen sich optionale
Parameter deklarieren?
Parameter
Referenzübergabe oder Wertübergabe?
Funktionen
Gültigkeitsbereiche
Optionale Parameter
Parameterfelder
Lernziel
Der Anwender lernt Möglichkeiten kennen, Eingabewerte an Prozeduren und Funktionen zu übergeben, und
Ergebnisse zurückzugeben.
Voraussetzungen
Deklaration von Prozeduren und Variablen, Kenntnisse über Datentypen, Gültigkeitsbereiche, Gültigkeitsdauer und
Datenfelder.
26
Parameter
Wie deklariere ich Parameter? Wie kann ich an eine Prozedur Eingabewerte übergeben?
-
Abb.17: Übergabe von Parametern
Durch die Deklaration von Parametern steht eine klar definierte Schnittstelle für die
Eingabewerte einer Prozedur zur Verfügung. Der Nachteil ist, daß Prozeduren mit
Parametern nicht mehr als Makros, sondern nur mehr von anderen Prozeduren oder
Funktionen aus aufgerufen werden können. Sie stellen sozusagen benutzerdefinierte
Befehle dar.
Schnittstelle
Um eine Prozedur mit Parametern zu deklarieren, schreibt man in die Klammern im
Prozedurkopf den Namen des Parameters, gefolgt vom Schlüsselwort As und einem
Datentyp. Mehrere Parameter werden durch Komma getrennt. Wird das Schlüsselwort As und der Datentyp weggelassen, erhält der Parameter den Datentyp Variant.
Beispiele:
Deklaration
Public Sub A (Par1 As Integer, Par2 As String)
Public Sub B (Par3)
Im zweiten Beispiel bekommt Par3 den Datentyp Variant. Beim Aufruf dieser
Prozeduren sind die Parameter durch Werte, Konstanten oder Variablen des gleichen
oder eines kompatiblen Datentyps zu ersetzen, z. B.:
Aufruf
A 20, "Text"
B #01.01.97#
Die übergebenen Parameter können innerhalb der Prozedur wie Variablen unter
Angabe des Parameternamens verwendet werden.
Verwendung
Prozeduren mit Parametern können nicht als Makros eingesetzt werden.
Für Parameter stehen alle Datentypen zur Verfügung, die Sie auch für Variablen verwenden können.
27
Referenzübergabe oder Wertübergabe?
Was ist der Unterschied zwischen Call by Reference und Call by Value?
-
Abb.18: Unterschied Referenzübergabe Wertübergabe
Parameter können an Prozeduren über Referenz und über den Wert übergeben
werden. Der Unterschied zwischen den beiden Übergabearten wirkt sich nur bei der
Übergabe einer Variablen als Parameter aus.
Parameter übergeben
Bei der Referenzübergabe wird lediglich die Adresse der Variablen übergeben. Die
Prozedur kann somit die übergebene Variable selbst verändern, was eine Möglichkeit
darstellt, Ergebnisse an die aufrufende Prozedur zurückzugeben, aber auch eine
zusätzliche Fehlerquelle ist.
Referenzübergabe
Bei der Wertübergabe wird hingegen eine Kopie des Inhaltes der Variablen erzeugt
und diese Kopie übergeben. Die Prozedur kann somit die übergebene Variable selbst
nicht verändern. Änderungen wirken sich auf die aufrufende Prozedur in keiner Weise
aus, da der Inhalt der Parametervariablen nach Ende der Prozedur verloren geht.
Wertübergabe
Der Aufruf erfolgt bei einer Referenzübergabe. Referenzübergabe ist die Standardeinstellung.
Standard
Bei der Deklaration einer Prozedur definiert man auch, wie die Parameter standardmäßig übergeben werden. Das geschieht mit den Schlüsselwörtern ByRef und ByVal
vor dem Parameternamen, z. B.: Public Sub P (ByRef A As Integer, ByVal
B As Byte).
ByRef / ByVal
Beim Aufruf der Prozedur kann man aber diese Voreinstellung ändern, z. B.:P ByVal
intA, ByRef bytB, wobei intA nun als Wert übergeben wird, während bytB als
Referenz übergeben wird.
Aufruf
Die Übergabe über Referenz bringt nur dann Geschwindigkeitsvorteile, wenn die Parametervariable nicht zu
Beginn der Prozedur in eine lokale Variable kopiert werden muß, um sie vor Veränderungen zu schützen.
28
Funktionen
Wie kann ich eigene Funktionen definieren? Wie werden eigene Funktionen aufgerufen?
-
Abb.19: Rückgabe des Ergebnisses
Eigene Funktionen werden wie Prozeduren deklariert. Man ersetzt jedoch das
Schlüsselwort Sub durchFunction und schreibt ans Ende der DeklarationAs Datentyp,
um den Datentyp des Rückgabewertes zu definieren.
Deklaration
Parameter können wie bei Prozeduren deklariert werden. Zusätzlich wird automatisch eine Variable deklariert, die den Namen der Funktion und den in der Kopfzeile
angegebenen Datentyp erhält. Dieser Variablen weist man das Ergebnis der Funktion
zu. Der Inhalt dieser Variablen wird als Ergebnis an die aufrufende Prozedur
zurückgegeben. Ähnlich wie Prozeduren können auch Funktionen innerhalb des
Funktionskörpers mit der Anweisung Exit Function vorzeitig abgebrochen werden.
Beispiel einer Funktion:
Parameter
Public Function Wurzel (dblZahl As Double, dblExponent _
As Double) As Double
Wurzel = Zahl ^ (1 / Exponent)
End Function
Das Ergebnis einer Funktion muß man sofort weiterverarbeiten. Typische Funktionsaufrufe sind z. B.: W = Wurzel (2, 2) oder Debug.Print Wurzel (2, 2) oder
MsgBox Wurzel (2, 2). In Excel können benutzerdefinierte öffentliche Funktionen auch in Tabellenblättern, in Access in Abfragen, Formularen und Berichten
verwendet werden.
Aufruf
Die Parameter von Funktionen stehen im Gegensatz zu jenen der Prozeduren normalerweise immer in Klammern.
Besitzt eine Funktion keine Parameter, müssen die Klammern trotzdem geschrieben werden, z. B. MsgBox
Gestern ().
29
Gültigkeitsbereiche von Prozeduren
Gibt es bei Prozeduren und Funktionen verschiedene Gültigkeitsbereiche? Wie kann ich diese
einsetzen?
-
Abb.20: Gültigkeitsbereich bei Prozeduren
Um eine Prozedur auf Modulebene zu deklarieren, schreibt man in den Prozedurkopf
das Schlüsselwort Private Sub bzw. bei Funktionen Private Function.
Private
Private Prozeduren können nicht als Makros aufgerufen werden. Private Funktionen
können nicht in Excel-Tabellenblättern und in Access weder in Abfragen oder
Formularen noch in Berichten verwendet werden. Private Prozeduren und Funktionen
können nur innerhalb des Moduls, in dem sie deklariert wurden, aufgerufen werden.
Private Prozeduren
Um eine Prozedur auf Projektebene zu deklarieren, schreibt man in den Prozedurkopf
das SchlüsselwortPublic Sub bzw. bei FunktionenPublic Function. Public ist Standard
bei VBA, kann also auch weggelassen werden.
Public
Öffentliche Prozeduren können, wenn sie keine Parameter verlangen, als Makros in
Word, Excel und Powerpoint aufgerufen werden. Öffentliche Funktionen können in
Excel-Tabellenblättern und in Access in Abfragen, Formularen und Berichten verwendet werden. Öffentliche Prozeduren und Funktionen können im ganzen Projekt
aufgerufen werden.
Öffentliche Prozeduren
Bei Namensgleichheit beim Aufruf zwischen einer Prozedur im eigenen Modul und
einer in einem fremden Modul, hat jene im eigenen Modul den Vorrang. Um auf
Prozeduren und Funktionen in einem fremden Modul zuzugreifen, schreibt man
Modulname.Prozedurname.
Namenskonflikte
Meistens werden Sie Prozeduren und Funktionen mit Public deklarieren. Einzig Ereignisprozeduren sind meist
private Prozeduren.
30
Exkurs: Optionale Parameter
Wie kann ich optionale Parameter deklarieren? Wie kann ich überprüfen, ob ein optionaler Parameter
übergeben wurde?
-
Abb.21: Wurzelfunktion
Bei vielen eingebauten Befehlen und Funktionen sind manche Parameter optional,
wie z. B. bei den Befehlen MsgBox und InputBox.
Optionale Parameter
In eigenen Prozeduren und Funktionen kann man diesen Mechanismus ebenfalls
nachbilden. Dazu deklariert man einen oder mehrere Parameter mit dem Schlüsselwort Optional als optionale Parameter. Beispiele:
Optimal
Public Sub S1 (Optional P1 As Integer)
Public Sub S2 (P1 As Integer, Optional ByVal P2, Optional
ByRef P3)
Das Schlüsselwort Optional steht also immer vor den Schlüsselwörtern ByVal und
ByRef. Außerdem müssen optionale Parameter immer am Schluß der Parameterliste
stehen. Nach dem ersten optionalen Parameter müssen alle folgenden Parameter
ebenfalls optional sein.
Syntax
Die beiden obigen Prozeduren können nach Ihrer Deklaration auf folgende Weise
aufgerufen werden:
Aufruf
S1
S1
S2
S2
S2
S2
20
intA
20, "Kunden"
30, , "Lieferanten"
40, "Kunden", "Lieferanten"
Die Funktion IsMissing (Parametername) überprüft auf fehlende Parameter.
IsMissing()
Achtung: Die Funktion IsMissing kann nur für Parameter vom Typ Variant eingesetzt werden. Daher verwendet
man für optionale Parameter immer nur den Datentyp Variant.
31
Exkurs: Parameterfelder
Wie muß man eine Prozedur deklarieren, bei der die Anzahl der Parameter variabel ist? Wie benutzt
man Parameterfelder?
-
Abb.22: Beispiel zur Verwendung eines Parameterfeldes
In manchen Fällen benötigt man eine Liste von gleichartigen Parametern, wobei der
Programmierer nicht vorhersagen kann, wie viele Parameter übergeben werden
müssen.
Liste gleichartiger Parameter
Solche Parameterfelder werden durch dynamische Datenfelder dargestellt. Dazu
schreibt man vor dem Parameternamen im Prozedurkopf das SchlüsselwortParamArray.
Nach dem Parameternamen schreibt man eine öffnende und eine schließende
Klammer, z. B. ParamArray Liste().
Parameterfelder
Folgendes ist dabei zu beachten:
In einer Parameterliste darf immer nur ein Parameterfeld enthalten sein.
Das Parameterfeld muß der letzte Parameter in der Parameterliste sein.
Parameterfelder müssen den Datentyp Variant haben.
ParamArray darf nicht mit den Schlüsselwörtern Optional, ByVal und ByRef
kombiniert werden.
Verwendung
Parameterfelder sind immer auch optional.
Auf die einzelnen Parameter eines Parameterfeldes greift man auf die gleiche Weise
zu, wie bei herkömmlichen Datenfeldern, also über die Indexnummer. Die Untergrenze von Parameterfeldern beträgt immer 0. Die Anzahl der Parameter im Parameterfeld kann mit der Funktion UBound(Parameterfeld) bestimmt werden. Ist diese Anzahl
kleiner als 0, enthält das Parameterfeld keine Parameter.
Aufruf
Beim Aufruf trennt man die Parameter des Parameterfeldes durch Kommas.
Zur Bearbeitung von Parameterfelder verwendet man praktisch immer eineFor Next-Schleife. Diese und andere
Schleifen werden in einem späteren Modul behandelt.
32
Modul 3: Prozeduren und Funktionen
1. In eigenen Prozeduren lassen sich Parameter deklarieren. Mit Hilfe von Parametern lassen sich über eine definierte Schnittstelle Daten an ein Unterprogramm
übergeben.
Parameter
Seite 26
2. Bei der Parameterübergabe über Referenz wird die Adresse der Variablen
übergeben, wodurch das Unterprogramm das Original der Variablen verändern
kann. Bei der Parameterübergabe über den Wert wird vorher eine Kopie der
Variablen erzeugt, wodurch das Unterprogramm das Original der Variablen nicht
verändern kann.
Referenz- / Wertübergabe
Seite 27
3. Funktionen werden mit dem Schlüsselwort Function deklariert. Die Definition des
Rückgabewertes erfolgt mit Hilfe einer Variablen, die den gleichen Namen wie
die Funktion trägt.
Funktionen
Seite 28
4. Mit den Schlüsselwörtern Public und Private läßt sich der Gültigkeitsbereich von
Prozeduren und Funktionen definieren. Es stehen die Gültigkeitsbereiche Projektebene und Modulebene zur Verfügung.
Gültigkeitsbereich von
Prozeduren
Seite 29
5. Mit dem Schlüsselwort Optional können Parameter deklariert werden, die nicht
angegeben werden müssen. Optionale Parameter stehen immer am Ende der
Parameterliste.
Optionale Parameter
Seite 30
6. Mit dem Schlüsselwort ParamArray lassen sich Parameterfelder deklarieren. Mit
Parameterfeldern kann man eine Reihe gleichartiger Parameter an eine Prozedur
oder Funktion übergeben.
Parameterfelder
Seite 31
-
33
Modul 4
Objekte und Auflistungen
Was ist eine Klasse? Was ist ein Objekt? Was ist eine Auflistung? Wie kann ich auf Elemente einer
Auflistung zugreifen? Wie kann ich Eigenschaften verwenden? Wie kann ich Methoden auf Objekte
anwenden? Wie kann ich eigene Klassen schaffen? Wie kann ich feststellen, welche Objekte,
Eigenschaften und Methoden es gibt?
Überblick über Klassen, Objekte, Auflistungen, Eigenschaften und Methoden
Zugriff auf Elemente einer Auflistung
Arbeiten mit Eigenschaften
Arbeiten mit Methoden
Objektkatalog
With-Anweisung
Klassenmodule
Benutzerdefinierte Eigenschaften und Methoden
Lernziel
Der Anwender lernt, mit Klassen, Objekten, Eigenschaften und Methoden umzugehen und eigene Klassen zu
erstellen.
Voraussetzungen
Umgang mit Variablen, Prozeduren und Funktionen.
34
Überblick
Was sind Objekte, Auflistungen und Klassen? Wozu dienen Eigenschaften und Methoden?
-
Abb.23: Objekte, Eigenschaften, Methoden, Auflistungen
Gleichartige Objekte mit gleichen Eigenschaften und Methoden werden in Klassen
eingeteilt. Jede Anwendung definiert eigene Klassen. Klassen können zur Deklaration
von Objektvariablen eingesetzt werden, z. B.:
Klassen
Dim frmKundenformular As Form.
Zu den meisten Klassen gibt es eine Auflistung, die alle bestehenden Objekte dieser
Klasse zusammenfaßt. Der Name der Auflistung entspricht meist dem Klassennamen
in der Mehrzahl, z. B. enthält die Auflistung Forms alle geöffneten Form-Objekte.
Auflistung
Jedes Objekt kann seinerseits Auflistungen, Eigenschaften und Methoden enthalten,
die durch seine Klasse bestimmt werden. Auflistungen enthalten untergeordnete
Objekte. Z. B. enthält jedes Form-Objekt (Formular) unter anderen eine ControlsAuflistung (Steuerelemente).
Objekt
Neben den Auflistungen besitzt jedes Objekt eine Reihe von Eigenschaften. Die
Einstellungen dieser Eigenschaften unterscheiden es von anderen Objekten der
gleichen Klasse. So besitzen z. B. die meisten Objekte eine Name-Eigenschaft, die den
Namen des Objekts angibt. Die meisten Eigenschaften von Objekten können ähnlich
wie Variablen gelesen und gesetzt werden.
Eigenschaft
Methoden können mit Funktionen und Prozeduren verglichen werden. Sie können auf
ein Objekt angewandt werden, das dann eine bestimmte Reaktion zeigt.
Methode
Die Wurzel des Objekt-Modells ist in jeder Anwendung das Objekt Application. Sie brauchen es aber nie
anzugeben.
35
Zugriff auf Elemente einer Auflistung
Wie kann ich auf einzelne Elemente einer Auflistung zugreifen? Wie kann ich auf Objekte zugreifen,
deren Namen ich nicht kenne?
-
Abb.24: Übersicht über verschiedene Zugriffsmöglichkeiten
Auf Objekte greift man meist dadurch zu, daß man es als Teil einer Auflistung
anspricht. Dazu hat man drei Möglichkeiten:
Objektname bei
Programmierung bekannt
1. Man kennt den Namen des Objektes zum Zeitpunkt der Programmierung, er ist
also konstant. Dann schreibt man:Objekt.Auflistung![Objektname]. Objekt ist das
übergeordnete Objekt, das die Auflistung enthält. Handelt es sich hierbei um das
Application-Objekt, kann es inklusive Punkt weggelassen werden. Beispiel:
Application.Forms!Kunden entspricht Forms!Kunden. Handelt es sich
um die sogenannte Standard-Auflistung, kann man sie weglassen. Workbooks![Telefonkosten.xls]!Worksheets!Prognose entspricht z. B.:
Workbooks![Telefonkosten.xls]!Prognose.
2. Man kennt den Namen des Objektes erst zur Laufzeit, er steht also in einer StringVariable. Dann schreibt man grundsätzlich: Objekt.Auflistung(Stringvariable). Z. B.: Forms(strFormularname) oder Workbooks(strDateiname).
Objektname beim Ablauf
bekannt
Objektname unbekannt
3. Man kennt den Namen des Objektes nicht, sondern will auf ein Objekt über seine
Position in der Auflistung zugreifen. Man schreibt: Objekt.Auflistung(Index). Die
meisten Auflistungen beginnen bei 0 zu zählen. Z. B. ergibt Forms(0).Name das
erste geöffnete Formular. Statt der Indexnummer kann auch eine numerische
Variable stehen.
Die eckigen Klammern um den Objektnamen können weggelassen werden, wenn
der Name keine Sonder- oder Leerzeichen enthält. Um festzustellen, wie viele
Objekte eine Auflistung enthält, haben fast alle Auflistungen die Nur-Lese-Eigenschaft Count, z. B. Forms.Count.
36
Arbeiten mit Eigenschaften
Wie kann ich Eigenschaften setzen? Wie kann ich auf Eigenschaften zugreifen? Welche Arten von
Eigenschaften gibt es?
-
Abb.25: Verwendung von Eigenschaften
Eigenschaften werden ähnlich wie Variablen verwendet. Die meisten Eigenschaften
von Objekten sind Lese-/Schreib-Eigenschaften. Ein Beispiel für so eine Lese-/SchreibEigenschaft, die fast jedes Objekt besitzt, ist die Eigenschaft Name, die den Namen
des Objekts bestimmt. Es gibt auch Nur-Lese-Eigenschaften. Z. B. besitzen fast alle
Auflistungsobjekte die Eigenschaft Count. Ihr Wert kann nur durch das Hinzufügen
und Löschen von Objekten aus der Auflistung verändert werden. Bei manchen
Objekten (z. B. Access-Formularen) gibt es Eigenschaften, die nur gesetzt werden
können, wenn das Objekt in einem bestimmten Modus (z. B. Entwurfs-Modus)
geöffnet wird.
Arten von Eigenschaften
Eigenschaften haben ebenso wie Variablen einen fixen Datentyp. Manche Eigenschaften stellen wiederum Objekte dar. Z. B. haben Range-Objekte (Bereich in Word
oder Excel) die Eigenschaft Font, die ein Font-Objekt zurückliefert, das seinerseits
wieder Eigenschaften wie z. B. Size hat.
Datentyp
In jedem Fall werden Eigenschaften genauso behandelt wie Variablen. Die Syntax für
das Setzen von Eigenschaften lautet: Objekt.Eigenschaft = Wert. Ist die
Eigenschaft ihrerseits ein Objekt, lautet die Syntax natürlich: Set Objekt.Eigenschaft = Objektverweis.
Wertzuweisung
Zum Lese-Zugriff auf normale Eigenschaften schreibt man: Variable = Objekt.Eigenschaft. Bei Eigenschaften, die Objekte darstellen, schreibt man: Set
Objektvariable = Objekt.Eigenschaft.
Lesen
Das Objekt, dessen Eigenschaft Sie verwenden wollen, kann natürlich seinerseits eine Eigenschaft eines Objektes
sein, das wiederum seinerseits meist in einer Auflistung enthalten ist, z. B. Workbooks![Umsatz.xls]!Soll.Range(A1:Z1).Font.Size = 14.
37
Arbeiten mit Methoden
Wie kann ich Methoden auf Objekte anwenden? Welche Arten von Methoden gibt es?
-
Abb.26: Beispiel zu Methoden
Man unterscheidet Prozedurmethoden und Funktionsmethoden. Funktionsmethoden
arbeiten ähnlich wie normale Funktionen und liefern einen Wert oder ein Objekt
zurück. Prozedurmethoden arbeiten hingegen ähnlich wie Prozeduren und liefern
keinen Wert zurück.
Unterscheidung
Prozedurmethoden werden folgendermaßen angewandt: Objekt.Methode. Danach können noch Parameter angeführt sein, die diese Methode benötigt. Die Syntax
dafür ist identisch zu normalen Prozeduren.
Prozedurmethoden
Bei Funktionsmethoden muß der Rückgabewert ähnlich wie bei Funktionen sofort
weiterverarbeitet werden. Der Aufruf erfolgt daher wie folgt: Variable =
Objekt.Methode(). Wie bei Funktionen muß unbedingt das leere Klammernpaar
folgen. Benötigt die Methode Parameter, sind diese in die runden Klammern zu
schreiben. Der zurückgelieferte Wert steht anschließend in der angegebenen Variablen. Wird ein Objekt zurückgegeben, wie z. B. bei der Methode OpenRecordset in
Access, lautet die Syntax natürlich:Set Objektvariable = Objekt.Methode().
Funktionsmethoden
Manche Methoden verlangen keine Parameter. Statt dessen müssen vorher bestimmte Eigenschaften des Objektes
korrekt gesetzt werden. Nähere Informationen zu den Methoden und ihren Parametern finden Sie in der Hilfe der
jeweiligen Anwendung.
38
Objektkatalog
Wie finde ich heraus, welche Objekte, Eigenschaften und Methoden eine Anwendung besitzt? Wie
bekomme ich Hilfe zum Objektmodell?
-
Abb.27: Objektkatalog
Da kein Programmierer die kompletten Objektmodelle aller Anwendungen auswendig können kann, müssen die Anwendungen ihrerseits einen sogenannten Objektkatalog bereitstellen, der sich im Visual Basic-Editor mit dem Menübefehl Ansicht
Objektkatalog oder der Taste F2 ein- und ausblenden läßt. Sie können auch das
Symbol Objektkatalog verwenden.
Anzeigen
Im Objektkatalog-Fenster ist zunächst links oben im Listenfeld die Bibliothek zu
wählen, deren Objektkatalog betrachtet werden soll. In der linken Fensterhälfte wählt
man die Klasse oder Auflistung, deren Eigenschaften, Methoden und Auflistungen man
betrachten möchte. In der rechten Hälfte erscheinen diese dann. Im unteren Teil des
Fensters erscheint die Definition des gewählten Elements und Querverweise auf die
übergeordneten Objekte. Mit der Taste F1 erhält man die Hilfe zu diesem Element.
Objektkatalog-Fenster
Meist stehen die Bibliothek der jeweiligen Anwendung, die Bibliothek des aktuellen
Projekts, die VBA-Bibliothek, die MSForms-Bibliothek und die Office-Bibliothek zur
Verfügung.
Bibliotheken
Weiters ist auch immer die Bibliothek der aktiven Anwendung geladen, z. B. Word
oder Excel. Je nach Anwendung können auch zusätzliche Bibliotheken erscheinen.
Der Objektkatalog besitzt auch eine Suchfunktion für Elemente im Objekt-Modell.
39
With-Anweisung
Wie kann ich den Zugriff auf Objekte beschleunigen? Wie kann ich Schreibarbeit beim Zugriff auf
Objekte sparen?
-
Abb.28: Access-Formular in Dialog umwandeln
Eine Möglichkeit, mehrere Zugriffe auf ein und dasselbe Objekt zu beschleunigen, ist,
das Objekt vorher einer Objektvariablen zuzuordnen und anschließend nur mehr die
Objektvariable zu verwenden, um auf die Eigenschaften und Methoden des Objekts
zuzugreifen. Der Programmablauf wird aber beschleunigt und Tipp-Arbeit eingespart,
wenn man statt dessen das With-Konstrukt verwendet.
Wiederholte Objektzugriffe
Dieses wird mit der Anweisung With Objekt eingeleitet, wobei Objekt ein gültiger
Verweis auf ein Objekt sein muß, aber auch eine Objektvariable sein darf. Innerhalb
dieses With-Konstrukts schreibt man nun statt dem Objektverweis immer nur einen
führenden Punkt (.) oder ein führendes Rufzeichen (!), um auf die Eigenschaften,
Methoden und auf die Standard-Auflistung des Objektes zuzugreifen. Am Ende dieser
Konstruktion muß die Anweisung End With stehen, z. B.:
With
With ActiveSheet.Range("A1:Z1").Font
.Bold = True
.Italic = True
.Size = 14
End With
Natürlich kann man innerhalb von With und End With auch auf andere Objekte
zugreifen, muß aber dabei wie gewohnt die vollständige Syntax verwenden.
Zugriff auf andere Objekte
Die With-Konstruktion spart nicht nur Tipp-Arbeit, sondern beschleunigt auch den Programmablauf, da die
Objekt-Adresse von VBA nur einmal berechnet werden muß. Deshalb empfiehlt es sich, Schleifen, die immer auf
das gleiche Objekt zugreifen, mit With und End With zu ummanteln.
40
Exkurs: Klassenmodule
Wie kann ich eigene Klassen erstellen? Wie kann ich neue Objekte aus meinen Klassen erzeugen?
-
Abb.29: Erzeugen neuer Objekte einer Klasse
Bei der Programmierung ist man nicht auf die fertigen Klassen beschränkt. Um eine
eigene Klasse zu definieren, erstellt man ein neues Klassenmodul. Das geschieht mit
dem Menübefehl Einfügen Klassenmodul. Man kann dazu auch das Symbol
Klassenmodul einfügen benutzen. Im Eigenschaftenfenster legt man mit der Eigenschaft Name den Namen der Klasse fest.
Einfügen
Die Eigenschaften und Methoden im Klassenmodul werden durch globale Variablen,
Eigenschaftsprozeduren und herkömmliche Prozeduren und Funktionen definiert.
Eigenschaften und
Methoden
Um ein neues Objekt der eigenen Klasse zu erzeugen, definiert man zunächst eine
Objektvariable mit dem Namen der Klasse als Typ:
Neue Objekte
Dim Objektvariable As Klasse
StattDim können natürlich auch die anderen Schlüsselwörter zur Variablendeklaration
verwendet werden.
Im zweiten Schritt erzeugt man nun ein neues Objekt der Klasse mit dem Schlüsselwort
New und weist es der Objektvariablen zu:
New
Set Objektvariable = New Klasse
Nun kann man über die Objektvariable auf alle Eigenschaften und Methoden der
eigenen Klasse zugreifen.
Die beiden Schritte der Erstellung kann man auch zu einem Befehl zusammenfassen: Dim Objektvariable
As New Klasse. Dies hat die gleiche Wirkung wie einzelne Dim- und Set-Anweisungen.
41
Exkurs: Benutzerdefinierte Eigenschaften und Methoden
Wie kann ich meinen Klassenmodulen eigene Eigenschaften und Methoden hinzufügen? Was sind
Eigenschaftsprozeduren?
-
Abb.30: Beispiel eines Klassenmoduls
Am einfachsten fügt man durch das Deklarieren einer globalen Variablen im Modulkopf eine benutzerdefinierte Eigenschaft zu einer eigenen Klasse hinzu: Public
Eigenschaftsname As Datentyp. Es handelt sich dabei immer um eine Lese/
Schreib-Eigenschaft.
Öffentliche Variablen
Eigene Methoden sind nichts anderes als Funktionen und Prozeduren in der Klasse.
Diese können wie gewohnt deklariert werden. Der Aufruf erfolgt mit der gewohnten
Syntax Objekt.Methode(). Auch Parameter sind selbstverständlich möglich.
Methoden
Eigenschaftsprozeduren erlauben beim Setzen und Lesen von Eigenschaften weitere
Aktionen durchzuführen, wie z. B. Überprüfungen auf die Korrektheit der Einstellung
oder das Setzen von anderen Eigenschaften.
Property Set / Set
Bei Schreib-/Lese-Eigenschaften benötigt man jeweils zwei Prozeduren mit dem
gleichen Namen. Die erste dient zum Setzen der Eigenschaft und wird entweder mit
Public Property Let Eigenschaftsname (Wertparameter) für normale
Wert-Eigenschaften oder mit Public Property Set Eigenschaftsname
(Objektparameter) für Objekt-Eigenschaften deklariert. Der Parameter dieser
Prozeduren enthält zur Laufzeit den Wert, der dieser Eigenschaft zugewiesen werden
soll.
Property Get
Bei allen Eigenschaften benötigt man auf jeden Fall eine Funktion, die mit Public
Property Get Eigenschaftsname () As Datentyp deklariert wird. Diese spezielle
Funktion soll den Inhalt der Eigenschaft zurückgeben.
Nähere Informationen und Beispiele zu Property-Prozeduren erhalten Sie in der Hilfe unter dem Stichwort
Property.
42
Modul 4: Objekte und Auflistungen
1. Mehrere gleichartige Objekte werden zu Klassen zusammengefaßt. Auflistungen
enthalten Objekte einer Klasse. Jedes Objekt besitzt Eigenschaften, die das Objekt
von anderen der gleichen Klasse unterscheidbar machen, und Methoden, die auf
das Objekt angewandt werden können.
Überblick
Seite 34
2. Auf Objekte wird im allgemeinen über eine Auflistung zugegriffen. Je nachdem, ob
der Objektname bekannt ist und zu welchem Zeitpunkt er bekannt ist, greift man
auf die Elemente von Auflistungen auf unterschiedliche Weise zu.
Zugriffsmöglichkeiten
Seite 35
3. Auf Eigenschaften eines Objektes wird ähnlich zugegriffen wie auf Variablen. Die
meisten Eigenschaften können sowohl gelesen als auch geschrieben werden, es
gibt aber auch Nur-Lese-Eigenschaften.
Eigenschaften
Seite 36
4. Methoden können auf Objekte angewandt werden. Man unterscheidet FunktionsMethoden, die ein Ergebnis zurückgeben, und Prozedur-Methoden, die ähnlich
wie Prozeduren aufgerufen werden.
Methoden
Seite 37
5. Im Objektkatalog können die Objekte und Klassen und deren Auflistungen,
Eigenschaften und Methoden betrachtet werden.
Objektkatalog
Seite 38
6. Mit Hilfe der With-Anweisung können Zugriffe auf immer das gleiche Objekt
beschleunigt und abgekürzt werden.
With
Seite 39
7. Mit dem Menübefehl EinfügenKlassenmodul können eigene Klassen definiert
werden. Ein neues Objekt einer Klasse erzeugt man mit dem Schlüsselwort New.
Klassenmodule
Seite 40
8. Eigene Eigenschaften werden entweder über globale Variablen oder überPropertyProzeduren realisiert. Eigene Methoden werden über Prozeduren und Funktionen
in einem Klassenmodul definiert.
Eigene Methoden und
Eigenschaften
Seit 41
-
43
Modul 5
Programmstrukturen
Wie kann ich Teile meines Programms wiederholt ausführen? Was ist eine Schleife? Welche Arten von
Schleifen gibt es? Was ist eine Verzweigung? Wie kann ich innerhalb eines Programms verzweigen?
Gibt es eine Mehrfach-Verzweigung? Wie kann ich alle Objekte einer Auflistung bearbeiten? Wie kann
ich alle Elemente eines Datenfeldes bearbeiten?
Überblick über Schleifen
For Next
For Each Next
Do Loop
Überblick über Verzweigungen
If Then Else
Select Case End Select
Lernziel
Der Anwender lernt Möglichkeiten kennen, Programmteile wiederholt ausführen zu lassen und innerhalb des
Programms zu verzweigen.
Voraussetzungen
Umgang mit Objekten und Auflistungen
44
Überblick über Schleifen
Was ist eine Schleife? Welche Arten von Schleifen gibt es? Wie oft wird eine Schleife ausgeführt?
-
Abb.31: Elemente einer Schleife
Schleifen sind eines der wichtigsten Programmelemente. Mit ihnen ist es möglich,
Programmteile wiederholt ausführen zu lassen.
Wiederholungen
Jede Schleife besteht aus einem Schleifenkopf mit einer einleitenden Anweisung,
einem Schleifenkörper und einem Schleifenfuß mit einer abschließenden Anweisung.
Der Schleifenkörper enthält die Anweisungen, die innerhalb der Schleife wiederholt
ausgeführt werden sollen.
Elemente
Wie oft der Schleifenkörper wiederholt wird, hängt von einer Abbruchbedingung ab.
Jede Schleife braucht eine Abbruchbedingung. Wenn diese erfüllt wird, wird die
Schleife beendet.
Abbruchbedingung
Grundsätzlich unterscheidet man zwei Arten von Schleifen: Post- und Pre-CheckSchleifen.
Arten
Bei Pre-Check-Schleifen wird die Abbruchbedingung bereits überprüft, bevor der
Schleifenkörper das erste Mal ausgeführt wird, der Schleifenkörper kann also auch gar
nicht ausgeführt werden. Meist steht die Abbruchbedingung einer Pre-Check-Schleife
im Schleifenkopf.
Pre-Check
Bei Post-Check-Schleifen wird die Abbruchbedingung erst überprüft, nachdem der
Schleifenkörper das erste Mal ausgeführt wurde. Sie werden folglich zumindest
einmal ausgeführt. Meist steht die Abbruchbedingung bei einer Post-Check-Schleife
im Schleifenfuß.
Post-Check
Achten Sie beim Formulieren einer Schleife besonders auf die Abbruchbedingung. Sie ist eine der häufigsten
Quellen für Programmierfehler.
45
ForNext
Wie kann ich eine Schleife mit einer fixen Anzahl von Wiederholungen programmieren?
-
Abb.32: Beispiel einer ForNext-Schleife
Die ForNext-Schleife ist eine sogenannte Zählschleife. Sie benötigt eine Zählervariable, die bei jedem Durchlauf um eine bestimmte Schrittweite erhöht oder
reduziert wird. Überschreitet sie ihren Endwert, wird die Schleife beendet. Merkmal
von Zählschleifen ist, daß die Anzahl der Wiederholungen vorher bekannt ist.
Zählschleife
Die Zählvariable einer ForNext-Schleife sollte vorher deklariert werden und hat
meist einen ganzzahligen Datentyp, wie z. B. Byte, Integer oder Long.
Zählvariable
So formulieren Sie eine For Next-Schleife:
ForNext-Schleife
For Zählvariable = Startwert To Endwert Step _
Schrittweite
Schleifenkörper
Next Zählvariable
Wird das Schlüsselwort Step und die Schrittweite weggelassen, beträgt sie immer 1.
Es sind auch negative Schrittweiten erlaubt. Beim Schlüsselwort Next kann der Name
der Zählvariablen auch weggelassen werden.
Step
Die ForNext-Schleife ist eine Pre-Check-Schleife, das bedeutet, daß der Schleifenkörper nicht ausgeführt wird, wenn der Endwert kleiner oder gleich (positive Schrittweite) bzw. größer oder gleich dem Startwert ist.
Pre-Check-Schleife
Soll die For-Next-Schleife noch vor Erreichen des Endwertes innerhalb des Schleifenkörpers verlassen werden, verwendet man die Anweisung Exit For.
Exit For
Beachten Sie: Der Inhalt der Zählvariablen ist am Ende der Schleife nicht gleich dem Endwert, sondern berechnet
sich aus der Formel: Endwert + Schrittweite.
46
For EachNext
Wie kann ich alle Objekte in einer Auflistung auf die gleiche Weise behandeln?
-
Abb.33: Beispiel einer For Each-Next-Schleife
Eine Variante der ForNext-Schleife stellt die For EachNext-Schleife dar. Sie wird
ausschließlich zur Bearbeitung von Auflistungen eingesetzt.
Auflistung
An Stelle einer Zählervariable steht bei diesem Schleifentyp eine Objektvariable.
Diese verweist bei jedem Durchlauf des Schleifenkörpers auf das jeweils nächste
Objekt in der Auflistung, solange bis alle Objekte der Auflistung durchlaufen wurden.
Objektvariable
So formulieren Sie eine For EachNext-Schleife:
Syntax
For Each Objektvariable In Auflistung
Schleifenkörper
Next Objektvariable
Innerhalb des Schleifenkörpers können dann die Eigenschaften und Methoden des
jeweiligen Objektes in der Auflistung wie gewohnt mit der Syntax Objektvariable.Eigenschaft oder Objektvariable.Methode verwendet werden.
Schleifenkörper
Auch bei der For EachNext-Schleife kann die Objektvariable beim Schlüsselwort
Next weggelassen werden.
Auch dieser Schleifentyp ist eine Pre-Check-Schleife. Sind in der Auflistung keine
Objekte enthalten, wird der Schleifenkörper kein einziges Mal ausgeführt.
Pre-Check-Schleife
Wie die ForNext-Schleife kann auch diese Schleife mit der Anweisung Exit For
vorzeitig beendet werden.
Exit For
Beachten Sie: For EachNext-Schleifen können nicht dazu verwendet werden, alle Objekte aus einer Auflistung
zu entfernen. Dazu muß die Auflistung rückwärts mit einer ForNext-Schleife durchlaufen werden.
47
DoLoop
Wie kann ich Schleifen mit allgemeiner Abbruchbedingung formulieren?
-
Abb.34: Beispiel von zwei verschachtelten Do-Loop-Schleifen
Die DoLoop-Schleife ist der flexibelste Schleifentyp in VBA. Er erlaubt sowohl eine
positive als auch eine negative Formulierung der Abbruchbedingung. Diese Schleife
kann sowohl eine Pre- als auch eine Post-Check-Schleife sein. Allgemein sieht eine
Do-Loop-Schleife so aus:
Do-Loop-Schleife
Do [Abbruchbedingung]
Schleifenkörper
Loop [Abbruchbedingung]
Will man eine Pre-Check-Schleife formulieren, schreibt man die Abbruchbedingung
in den Schleifenkopf neben Do, bei einer Post-Check-Schleife in den Schleifenfuß
neben das Schlüsselwort Loop. Es ist nicht erlaubt, Abbruchbedingungen sowohl in
den Schleifenkopf als auch in den Schleifenfuß zu schreiben.
Abbruchbedingung
Die Abbruchbedingung wird entweder mit dem Schlüsselwort While oder mit Until
eingeleitet. Verwendet man While, wird die Schleife solange ausgeführt, solange die
Bedingung neben While erfüllt, also True ist.
While
Verwendet man Until, wird die Schleife ausgeführt, bis die Bedingung neben Until
erfüllt, also True ist. Jede Formulierung mit Until läßt sich in eine While-Formulierung
umkehren und umgekehrt.
Until
Ähnlich wie die anderen Schleifen läßt sich eineDoLoop-Schleife mit der Anweisung
Exit Do auch innerhalb des Schleifenkörpers vorzeitig beenden.
Exit Do
Die DoLoop-Schleife ersetzt die in manchen älteren Basic-Dialekten verwendete WhileWend-Schleife. Die
WhileWend-Schleife ist aber auch in VBA noch vorhanden.
48
Überblick über Verzweigungen
Welche Arten von Verzweigungen gibt es? Wie formuliert man Bedingungen?
-
Abb.35: Arten von Verzweigungen
Bei einer Einfachverzweigung wird ein bestimmter Programmteil nur ausgeführt,
wenn eine Bedingung erfüllt ist. Bei einer Zweifachverzweigung gibt es zusätzlich
noch einen zweiten Zweig, der dann ausgeführt wird, wenn die Bedingung nicht
erfüllt ist. Mehrfachverzweigungen stellen hingegen eine unbegrenzte Anzahl von
verschiedenen Zweigen zur Verfügung.
Arten
Ein- und Zweifachverzweigungen erfolgen so wie Do Loop-Schleifen auf der Basis
von sogenannten Booleschen Ausdrücken. Boolesche Ausdrücke haben als Ergebnis
immer entweder True oder False. Boolesche Ausdrücke können auch Variablen vom
Typ Boolean zugewiesen werden. Der einfachste Boolesche Ausdruck besteht aus
einer Variablen vom Typ Boolean.
Boolesche Ausdrücke
Die wichtigsten Vergleichsoperatoren in VBA sind: = (gleich), > (größer als), < (kleiner
als), >= (größer oder gleich), <= (kleiner oder gleich) und <> (ungleich). Um zu
überprüfen, ob zwei Objektvariablen auf das gleiche Objekt verweisen, verwendet
man den Operator Is.
Vergleichoperatoren
Mehrere Vergleiche lassen sich logisch mit den Operatoren And (logisches Und) und
Or (logisches Oder) verknüpfen. And hat dabei Vorrang vor Or, es sei denn, man
verwendet Klammern. Der Operator Not invertiert das Ergebnis, das heißt aus True
wird False und aus False wird True.
Logische Operatoren
Für weitere Informationen und Beispiele suchen Sie in der Hilfe nach dem Stichwort Vergleichsoperatoren.
49
IfThenElse
Wie kann ich Ein- und Zweifachverzweigungen in VBA realisieren? Können die Zweige auch mehrere
Befehle enthalten?
-
Abb.36: Rabatt in Prozentzahl umwandeln
Für Ein- und Zweifachverzweigungen steht in VBA die Anweisungsfolge IfThenElse
zur Verfügung.
Einfachverzweigung
Wenn nur ein Befehl unter die Bedingung fällt, schreibt man:
If Boolescher Ausdruck Then Befehl oder Anweisung
Die zweite Möglichkeit kann auch dann eingesetzt werden, wenn mehrere Befehle
unter die Bedingung fallen.
If Boolescher Ausdruck Then
Befehle oder Anweisungen
End If
In beiden Fällen werden die Befehle oder Anweisungen nur ausgeführt, wenn der
Boolesche Ausdruck True oder einen Wert ungleich 0 ergibt.
Bei Zweifachverzweigungen wird der zweite Zweig, der nur ausgeführt wird, wenn
der Boolesche Ausdruck False oder einen Wert gleich 0 ergibt, mit dem Schlüsselwort
Else eingeleitet:
If Boolescher Ausdruck Then Befehl/Anweisung Else _
Befehl/Anweisung
bzw.
If Boolescher Ausdruck Then
Else
End If
IfThenElse-Anweisungen lassen sich natürlich auch schachteln.
Zweifachverzweigung
50
Select CaseEnd Select
Wie kann ich in VBA eine Mehrfachverzweigung formulieren? Wie muß ich die Vergleichsausdrücke
formulieren?
-
Abb.37: Beispiel einer Select Case-Struktur
Mehrfachverzweigungen werden in VBA mit dem KonstruktSelect Case Case Case
Else End gebildet, das etwa so aussieht:
Mehrfachverzweigung
Select Case Testausdruck
Syntax
Case Vergleich1
Case Vergleich2
...
Case Else
End Select
Der Testausdruck ist kein Boolescher Ausdruck, sondern ein herkömmlicher Ausdruck, z. B. eine numerische Variable. Bei den Vergleichsausdrücken gibt man einen
anderen Ausdruck an, normalerweise eine Zahl oder einen Text zwischen Anführungszeichen. Bei Gleichheit werden die Befehle oder Anweisungen ausgeführt. Ein
Bereich, in dem der Testausdruck liegen kann, wird mit dem Schlüsselwort To
angegeben, z. B. 1 To 10. Um die Vergleichsoperatoren >, <, >=, <= und <> zu
verwenden, muß das Schlüsselwort Is vorangestellt werden.
Testausdruck
Der Case Else-Zweig kann weggelassen werden. Dieser Zweig wird nur ausgeführt,
wenn kein einziger anderer Case-Zweig zutreffend war.
Case Else
Für weitere Informationen und Beispiele suchen Sie in der Hilfe unter dem Stichwort Select-Anweisung.
51
Modul 5: Programmstrukturen
1. Schleifen bestehen aus einem Schleifenkopf, einem Schleifenkörper und einem
Schleifenfuß. Je nachdem, ob die Abbruchbedingung vor oder nach dem erstmaligen Durchlauf des Schleifenkörpers überprüft wird, unterscheidet man Pre- und
Post-Check-Schleifen.
Schleifen
Seite 44
2. ForNext-Schleifen werden dann eingesetzt, wenn die Anzahl der Wiederholungen vor Eintritt in die Schleife bekannt ist. ForNext-Schleifen sind Pre-CheckSchleifen.
ForNext
Seite 45
3. Zur Bearbeitung von Auflistungen werden For EachNext-Schleifen eingesetzt.
Diese sind mit den ForNext-Schleifen eng verwandt.
For EachNext
Seite 46
4. Für allgemeine Schleifen, die Pre- oder Post-Check-Schleifen sein können, verwendet man die Schlüsselwörter DoLoop.
DoLoop
Seite 47
5. Man unterscheidet Ein-, Zwei- und Mehrfachverzweigungen. Für die Bedingung
bei Ein- und Zweifachverzweigungen verwendet man Boolesche Ausdrücke, die
True oder False ergeben.
Verzweigungen
Seite 48
6. Ein und Mehrfachverzweigungen werden mit IfThen ElseEnd If erzeugt. Der
Else-Zweig ist dabei optional.
IfThenElse
Seite 49
7. Für Mehrfachverzweigungen gibt es die Schlüsselwörter Select CaseCaseCase
ElseEnd Select. Auch hier ist der Case Else-Zweig optional.
Select Case
Seite 50
-
52
Modul 6
Fehlerbehandlung
Wie kann ich auf Fehler überprüfen? Wie kann ich Laufzeitfehler abfangen? Wie kann ich eigene
Laufzeitfehler erzeugen? Wie werden Fehler behandelt?
Benutzerdefinierte Fehlerroutinen
Auslösen von benutzerdefinierten Fehlern
Hierarchie der Fehlerroutinen
Lernziel
Der Anwender lernt Möglichkeiten kennen, Fehler abzufangen und eigene Fehler zu definieren.
Voraussetzungen
Prozeduren, Verzweigungen, Objekte und Eigenschaften.
53
Benutzerdefinierte Fehlerroutinen
Wie kann ich Laufzeitfehler abfangen? Wie werden Fehlerroutinen programmiert?
-
Abb.38: Beispiel einer Fehlerbehandlung
Um Laufzeitfehler abzufangen, muß man die Standard-Fehlerbehandlung mit der
Anweisung On Error Goto Sprungmarke durch benutzerdefinierte Fehlerroutinen ersetzen. Im Programm sieht das dann so aus:
On Error Goto
On Error Goto Sprungmarke
Anweisungen und Befehle
Exit Sub
in Funktionen Exit Function
Sprungmarke:
Anweisungen und Befehle zur Fehlerbehandlung
Resume
oder Resume Next
Die Fehlerroutine wird mit Resume oder Resume Next abgeschlossen. Resume führt
den Befehl, der den Fehler verursacht hat, noch einmal aus, während Resume Next
mit dem nächsten Befehl weitermacht.
Resume
Um wieder die eingebaute Fehlerbehandlung zu aktivieren, verwendet man On Error
Goto 0.
On Error Goto 0
Das Objekt Err enthält u. a. die aktuelle Fehlernummer. Enthält Err den Wert 0, so ist
kein Fehler aufgetreten.
Err
Man kann auf die Fehlerroutine auch verzichten. Dazu schreibt man in das Programm
die Anweisung On Error Resume Next. Nun kann man nach jedem Befehl, der einen
Fehler hervorrufen könnte, Err.Number auf einen Wert ungleich 0 überprüfen, z. B.
If Err Then ...
On Error Resume Next
Um Fehlernummern schnell herauszufinden, erzeugen Sie den Fehler zunächst ohne aktivierte Fehlerroutine und
notieren die Fehlernummer, die VBA meldet.
54
Exkurs: Auslösen von benutzerdefinierten Fehlern
Wie kann ich selbst Fehler auslösen? Was passiert mit meiner Prozedur, wenn ich selbst einen Fehler
auslöse?
-
Abb.39: Auslösen eines benutzerdefinierten Fehlers
Besonders in allgemein gültigen Prozeduren und Funktionen, die in vielen verschiedenen Projekten verwendet werden sollen, ist eine gute Fehlerprüfung notwendig.
Fehlerprüfung
Da solche Fehler meist vom Programmierer verursacht werden, der die Prozedur oder
Funktion falsch verwendet, sollte der Anwender damit nicht in Form eines MsgBoxBefehls behelligt werden. Ebensowenig ist es sinnvoll, die Fehlermeldung im Direktfenster mit Debug.Print auszugeben, da sie dort leicht übersehen werden kann. Statt
dessen sollte man wie bei eingebauten Befehlen einen Laufzeitfehler auslösen.
Laufzeitfehler
Dies geschieht mit derRaise-Methode des Err-Objekts. Die Syntax lautet:Err.Raise
Fehlernummer. Die Fehlernummer kann sowohl eine schon vorhandene sein, die
den Fehler gut beschreibt, als auch eine neue. Die Raise-Methode besitzt noch weitere
Parameter, z. B. für einen Hilfetext oder eine Fehlerbeschreibung. Für nähere
Informationen dazu suchen Sie in der Hilfe unter dem Stichwort Raise-Methode.
Raise
Eine Prozedur oder Funktion, die diese Raise-Methode auslöst, wird sofort beendet.
Die Fehlerbehandlung sollte in der aufrufenden Prozedur oder Funktion erfolgen.
Fehlerbehandlung
Für Informationen über die vordefinierten Fehlercodes aller auffangbaren Fehler suchen Sie in der Hilfe unter dem
Stichwort Auffangbare Fehler.
55
Hierarchie der Fehlerroutinen
Was passiert, wenn innerhalb einer Fehlerroutine wieder ein Fehler auftritt? Was passiert, wenn keine
Fehlerroutine definiert wurde?
-
Abb.40: Programmablauf bei Fehlerbehandlung
Wenn man mit Hilfe der On Error Goto-Anweisung eine benutzerdefinierte Fehlerroutine aktiviert hat, darf innerhalb dieser Fehlerroutine kein weiterer Fehler ausgelöst
werden. In diesem Fall reagiert VBA so, als ob keine Fehlerroutine definiert wäre.
Fehler in Fehlerroutine
Ist in einer Prozedur oder Funktion keine Fehlerroutine definiert und es tritt ein Fehler
auf, wird in jener Prozedur oder Funktion nach einer aktivierten Fehlerroutine
gesucht. Wird eine solche gefunden, wird sie statt dessen ausgeführt. Nach Beendigung dieser Fehlerroutine springt VBA automatisch wieder in das Unterprogramm.
Wird in der aufrufenden Prozedur wieder keine Fehlerroutine gefunden, so versucht
es VBA eine Stufe höher usw.
Rücksprung zur Fehlerbehandlung
Ist in keiner Prozedur oder Funktion der Aufruf-Kette eine Fehlerroutine vorhanden,
so springt VBA wieder zurück zu jenem Befehl, der den Fehler verursacht hat und
stoppt mit einer Fehlermeldung.
Keine Fehlerroutine
Um nun Fehler in einer Fehlerroutine abzufangen, stehen zwei Möglichkeiten zur
Verfügung:
Fehler abfangen
Behandlung des Fehlers in der Fehlerroutine der aufrufenden Prozedur oder
Funktion
Aufruf einer Prozedur zur Behandlung des Fehlers
Der Aufruf einer Prozedur innerhalb einer Fehlerroutine hat den Vorteil, daß diese
Prozedur ihrerseits wieder eine eigene Fehlerroutine besitzen kann.
Für weitere Informationen und Beispiele suchen Sie in der Hilfe nach dem Stichwort On Error-Anweisung.
56
Modul 6: Fehlerbehandlung
1. Benutzerdefinierte Fehlerroutinen werden mit On Error Goto definiert. Fehler
können aber auch mit On Error Resume Next abgefangen werden. In jedem Fall
enthält das Objekt Err die Fehlernummer des aufgetretenen Fehlers.
Definierte Fehlerroutinen
Seite 53
2. Mit Err.Raise können in Prozeduren benutzerdefinierte Fehler ausgelöst werden.
Auslösen
Seite 54
Fehlerbehandlung
Seite 55
3. Kann ein Fehler in einer Prozedur nicht durch eine Fehlerroutine behandelt
werden, wird versucht, den Fehler in der aufrufenden Prozedur durch eine
Fehlerroutine zu beheben. Wenn es nirgends Fehlerroutinen gibt, stoppt VBA mit
einer Standard-Fehlermeldung an der Stelle, die den Fehler ursprünglich verursacht hat.
-
57
Modul 7
Formulare und Dialogfelder
Wie kann ich eigene Dialogfelder gestalten? Wie füge ich Steuerelemente zu Dialogfeldern hinzu? Wie
kann ich das Layout von Dialogfeldern verändern? Welche Eigenschaften haben Steuerelemente? Wie
kann ich die Eigenschaften von Steuerelementen verändern? Wie kann ich Dialogfelder aufrufen? Wie
lese ich Daten aus den Steuerelementen?
Erstellen von Dialogfeldern
Hinzufügen von Steuerelementen
Ändern der Größe und Position von Steuerelementen
Eigenschaften von Steuerelementen
Ereignisprozeduren
Anzeigen von Dialogfeldern
Lernziel
Der Anwender lernt, eigene Dialogfelder zu gestalten und zu programmieren. Dieses Modul ist nicht auf Access
anzuwenden.
Voraussetzungen
Umgang mit Objekten, Auflistungen, Eigenschaften und Methoden.
58
Erstellen von Dialogfeldern
Wie kann ich eigene Dialogfelder gestalten? Was sind die wichtigsten Eigenschaften von Dialogfeldern?
-
Abb.41: Erstellen eines UserForms
Für Dialogfelder in Word, Excel und Powerpoint steht die Bibliothek MSForms zur
Verfügung. In Access werden zu diesem Zweck die in Access integrierten Formulare
verwendet.
MS Forms
Um dem Projekt ein neues Dialogfeld hinzuzufügen, wählt man aus dem Menü des
Visual Basic-Editors EinfügenUserForm. Man kann dazu auch das SymbolUserForm
einfügen verwenden. Es erscheint daraufhin ein leeres Formular und die Werkzeugsammlung. Die Werkzeugsammlung läßt sich mit dem MenübefehlAnsichtWerkzeugsammlung oder dem Symbol Werkzeugsammlung ein- und ausblenden. Das neue
UserForm-Objekt erscheint im Projekt-Explorer in der Kategorie Formulare.
Einfügen eines UserForms
Im Eigenschaftenfenster lassen sich für das neue UserForm viele wichtige Eigenschaften festlegen. Die wichtigsten sind:
Eigenschaften
Name
der Name des UserForm-Objekts
Caption
die Beschriftung in der Titelleiste
SpecialEffect
3D-Effekt für das Formular
BackColor
Hintergrundfarbe
ForeColor
Vordergrundfarbe
BorderColor
Rahmenfarbe
BorderStyle
ob ein Rahmen angezeigt wird
Weitere Informationen und Beispiele zu benutzerdefinierten Dialogfeldern finden Sie in der Hilfe unter dem
Stichwort Erstellen von Dialogfeldern.
59
Hinzufügen von Steuerelementen
Welche Steuerelemente stehen in UserForms zur Verfügung? Wie füge ich Steuerelemente in mein
UserForm ein?
-
Abb.42: Werkzeugsammlung
In UserForms stehen folgende Steuerelemente zur Verfügung:
Bezeichnungsfeld
Beschriftungen im Formular
Textfeld
Eingabefelder
Kombinationsfeld
Kombination aus Textfeld und Listenfeld
Listenfeld
Auswahl aus mehreren Elementen
Kontrollkästchen
Ja/Nein-Auswahl
Rahmen
Gruppierung von Optionsfeldern
Optionsfeld
Auswahl aus mehreren Optionen
Umschaltfläche
Ja/Nein-Auswahl
Steuerelemente
Befehlsschaltfläche Aufruf von Programmen
Register
Verschiedene Registerseiten in einem UserForm
Multiseiten
Zusätzliche Formularseiten in einem UserForm
Bildlaufleiste
Auswahl von Werten
Drehfeld
Auswahl von Werten
Anzeige
Grafik
Um ein Steuerelement dem Formular hinzuzufügen, ziehen Sie entweder das entsprechende Element aus der Werkzeugsammlung in das UserForm, oder wählen Sie das
Element in der Werkzeugsammlung aus und ziehen anschließend einen Rahmen im
UserForm auf, der die Größe des Steuerelements angibt.
Hinzufügen
Je nach Steuerelement stehen im Eigenschaftenfenster eine Reihe von unterschiedlichen Eigenschaften zur
Verfügung. Verwenden Sie diese Eigenschaften, um die Steuerelemente nach Ihren Bedürfnissen einzustellen.
Vor allem sollten Sie die Eigenschaft Name bei jedem Steuerelement sinnvoll belegen.
60
Ändern der Größe und Position von Steuerelementen
Wie kann ich Steuerelemente auswählen? Wie kann ich Größe und Position von Steuerelementen
ändern?
-
Abb.43: Markierung eines Steuerelements
Um ein Steuerelement anzuwählen, klickt man es mit der Maus einmal an. Dabei ist
zu beachten, daß das Symbol Objekte auswählenin der Werkzeugsammlung aktiviert
ist. Man kann aber auch die TABULATOR-Taste so oft betätigen, bis das gewünschte
Steuerelement ausgewählt ist. Zum jeweils ausgewählten Steuerelement kann man im
Eigenschaften-Fenster verschiedene Einstellungen vornehmen.
Markieren
Um mehrere Steuerelemente auszuwählen, gibt es zwei Möglichkeiten: Entweder
man wählt das erste Steuerelement aus, hält dann die STRG-Taste gedrückt und wählt
dann alle anderen Steuerelemente aus. Oder man zieht mit der Maus einen Rahmen
um die Steuerelemente herum auf, die man auswählen will. Alle Steuerelemente, die
vom Rahmen berührt werden, werden ausgewählt.
Mehrfachmarkierung
Hat man ein oder mehrere Steuerelemente ausgewählt, kann man es verschieben,
indem man den Rahmen um das Steuerelement herum mit der Maus an eine andere
Position zieht. Waren dabei mehrere Steuerelemente ausgewählt, werden alle anderen Steuerelemente auch verschoben.
Verschieben
Um die Größe eines ausgewählten Steuerelements zu verändern, zieht man mit der
Maus einen der 8 Ziehpunkte auf die gewünschte Größe.
Größe ändern
Damit Sie bequem Steuerelemente sauber im Formular ausrichten können, stehen Ihnen im Menü Format
verschiedene Befehle zur Ausrichtung zur Verfügung.
61
Was sind die wichtigsten Eigenschaften von Steuerelementen? Wie kann ich die Eigenschaften
innerhalb des Programms ändern?
-
Abb.44: Eigenschaften eines Textfeldes
Name
Legt den Namen des Steuerelements fest.
Caption
Legt die Beschriftung des Steuerelements fest.
Value
Gibt den eigentlichen Wert des Steuerelements an.
Text
Gibt den Text im Steuerelement an.
Enabled
Legt fest, ob der Benutzer den Fokus auf das Steuerelement setzen
kann.
Locked
Gibt an, ob das Steuerelement bearbeitet werden kann.
Visible
Gibt an, ob das Steuerelement sichtbar ist.
Font
Legt die Schriftart des Steuerelements fest.
ForeColor
Legt die Vordergrundfarbe fest.
BackColor
Gibt die Hintergrundfarbe des Steuerelements an.
BackStyle
Gibt an, ob der Hintergrund transparent ist oder nicht.
BorderColor
Gibt die Rahmenfarbe an.
BorderStyle
Gibt an, ob ein Rahmen gezogen werden soll.
SpecialEffect
Legt einen 3D-Effekt für das Steuerelement fest.
ControlTipText
Legt einen QuickTip für das Steuerelement fest.
TextAlign
Gibt die Textausrichtung an.
GroupName
Gibt bei Optionsfeldern einen gemeinsamen Gruppennamen an.
Eigenschaften
Für nähere Informationen zu einer Eigenschaft klicken Sie mit der Maus auf die Eigenschaft und drücken Sie die
F1-Taste.
62
Ereignisprozeduren
Welche Ereignisse können in einem Formular auftreten? Wie schreibt man Ereignisprozeduren?
-
Abb.45: Erstellen von Ereignisprozeduren
Um zu einem Formular Ereignisprozeduren zu schreiben, wechselt man mit dem
Menübefehl Ansicht Code in die Code-Ansicht des Formulars. Darin wählt man im
linken Listenfeld das Objekt, das ein Ereignis auslöst, und im rechten Listenfeld das
Ereignis aus. VBA erstellt daraufhin automatisch den Rumpf für die Ereignisprozedur,
die nur mehr mit Code gefüllt werden muß.
Code-Ansicht
Die wichtigsten Ereignisse des UserForm-Objekts:
Ereignisse
Initialize
Tritt ein, wenn das Objekt geladen wird.
Terminate
Tritt ein, wenn das Objekt entladen wird.
QueryClose
Tritt ein, wenn der Benutzer versucht, das Formular zu schließen.
Die wichtigsten Ereignisse von Steurelementen:
BeforeUpdate
Tritt ein, bevor die Value-Eigenschaft des Steuerelements durch
den Benutzer geändert wird.
AfterUpdate
Tritt ein, nachdem dieValue-Eigenschaft des Steuerelements durch
den Benutzer geändert wurde.
Change
Tritt ein, wenn sich die Value-Eigenschaft geändert hat.
Enter
Tritt ein, wenn das Steuerelement den Fokus erhält.
Exit
Tritt ein, wenn das Steuerelement den Fokus verliert.
Click
Tritt ein, wenn der Benutzer auf das Steuerelement klickt.
DblClick
Tritt ein, wenn der Benutzer auf das Steuerelement doppelklickt.
Einige Ereignisse übergeben automatisch Parameter. Für weitere Informationen zu Ereignissen suchen Sie in der
Hilfe nach dem Namen des jeweiligen Ereignisses.
63
Anzeigen von Dialogfeldern
Wie kann ich ein Dialogfeld anzeigen? Wie initialisiere ich ein Dialogfeld? Wie greife ich auf
Steuerelemente im Formular zu?
-
Abb.46: Anzeigen eines Dialogfeldes
Um ein UserForm programmgesteuert anzuzeigen, muß es zuerst mitLoadUserFormName geladen werden. Anschließend zeigt die Methode Show das UserForm an, z. B.
MeinErstesUserForm.Show. Das Programm, das das UserForm eingeblendet
hat, wird so lange angehalten, bis das UserForm durch Ereignisprozeduren ausgeblendet oder vom Anwender geschlossen wird.
Anzeigen
In Ereignisprozeduren des Formulars kann über die Eigenschaft Visible das Formular
jederzeit ein- und ausgeblendet werden. Wenn Visible auf False gesetzt wird, wird das
Formular ausgeblendet, und VBA setzt mit jener Prozedur fort, die das Formular mit
Show eingeblendet hat.
Visible
Sie können auf ein Steuerelement und seine Eigenschaften vom Programm aus
zugreifen, indem Sie die Syntax UserForm-Name!Steuerelementname verwenden.
Die Value-Eigenschaft der Steuerelemente ist die Standardeigenschaft und braucht
daher nicht angegeben zu werden.
Value
Um die Steuerelemente in einem Formular zu initialisieren, verwenden Sie die Ereignisprozedur Initialize des
Formulars.
64
Modul 7: Formulare und Dialogfelder
1. Eigene Dialogfelder werden dem Projekt über Menü EinfügenUserForm hinzugefügt.
Eigene Dialogfelder
Seite 58
2. Die Werkzeugsammlung enthält Steuerelemente, die Formularen hinzugefügt
werden können.
Steuerelemente
Seite 59, 60
3. Die Position eines Steuerelements kann verändert werden, indem man am Rahmen
zieht. Die Größe kann an einem der 8 Ziehpunkte verändert werden.
4. Im Eigenschaften-Fenster müssen Steuerelemente konfiguriert werden. Besonders
wichtig ist die Name-Eigenschaft, die den Namen festlegt, unter dem das Steuerelement angesprochen werden kann.
Seite 61
5. Ereignisprozeduren reagieren sowohl auf Ereignisse im Formular als auch auf
Ereignisse in Steuerelementen. Sie werden im Code-Modul eines UserForms
definiert.
Ereignisprozeduren
Seite 62
6. Dialogfelder werden mit dem Schlüsselwort Load geladen und mit Show angezeigt. Dabei stoppt die Ausführung des aufrufenden Programms.
Dialogfenster anzeigen
Seite 63
-
65
Modul 8
Datenaustausch mit anderen Anwendungen
Wie kann ich auf das Objektmodell anderer Anwendungen zugreifen? Wie kann ich neue Objekte
fremder Anwendungen erstellen? Wie kann ich Daten mittels DDE austauschen? Wie kann ich
Funktionen in den Windows-APIs aufrufen?
Zugriff auf Objekte anderer Anwendungen
Datenaustausch mit DDE
Zugriff auf Windows-Funktionen
Lernziel
Der Anwender lernt Möglichkeiten kennen, mit anderen Anwendungen über Objektmodelle zu kommunizieren
und Windows-Funktionen einzusetzen.
Voraussetzungen
Umgang mit Objekten, Eigenschaften, Methoden und Auflistungen.
66
Zugriff auf Objekte anderer Anwendungen
Wie kann ich auf Objekte anderer Anwendungen zugreifen? Wie kann ich neue Objekte fremder
Anwendungen erstellen?
-
Abb.47: Öffnen einer Excel-Arbeitsmappe
Um mit Objekten anderer Anwendung zu arbeiten, sollte man zunächst einmal einen
Verweis auf die Bibliothek der Anwendung erstellen. Dazu wählt man aus dem Menü
Extras Verweise... Im darauf folgenden Dialog aktiviert man das Kontrollkästchen
neben jeder Bibliothek, die man in dem Projekt benutzen möchte. Man sollte hier auch
jene Bibliotheken, die nicht benutzt werden, deaktivieren, da sie unnötig Speicherplatz verbrauchen.
Verweise
Nun kann auf die Objekte der Anwendung zugegriffen werden. Dazu erstellt man am
besten zunächst einmal eine Objektvariable der jeweiligen Klasse. Bei Klassen, die
keine eindeutigen Namen tragen, wie z. B. Application, muß man den Namen der
Bibliothek gefolgt von einem Punkt voranstellen, z. B. Word.Application. Beispiele:
Deklaration
Dim appWord As Word.Application
Dim wkbMappe As Workbook
Um das Objekt dann wirklich neu zu erstellen, muß man es mit dem Schlüsselwort
New initialisieren. Beispiele:
Set appWord = New Word.Application
Set wkbMappe = New Workbook
Man kann die beiden Vorgänge auch gleich zu einem Befehl zusammenfassen, z. B.
Dim appWord As New Word.Application.
Um ein solches Objekt wieder aus dem Speicher zu entfernen, weist man der
Objektvariablen Nothing zu, z. B. Set appWord = Nothing.
Nothing
Mit den Objekten in der fremden Anwendung können Sie wie gewohnt arbeiten: Sie können Eigenschaften setzen,
Methoden anwenden und auf Auflistungen zugreifen. Sie sollten natürlich mit dem Objektmodell der anderen
Anwendung vertraut sein.
67
Exkurs: Datenaustausch mit DDE
Was ist DDE? Wie kann ich mit Hilfe von DDE Daten mit anderen Windows-Anwendungen austauschen?
-
Abb.48: Drucken eines Word-Dokumentes über DDE
DDE steht für Dynamic Data Exchange und ist jener Kommunikationsmechanismus,
der vor allem von älteren Windows-Anwendungen und Fax-Programmen unterstützt
wird.
Dynamic Data Exchange
Um eine DDE-Kommunikation aufzubauen, muß die andere Anwendung bereits
geladen sein. Man kann die Anwendung vorher mit Hilfe des Shell-Befehls starten.
Shell
Man muß zunächst mit der Funktion DDEInitiate den DDE Kanal öffnen. Die Syntax
lautet: intKanalnummer = DDEInitiate (Anwendungsname, Thema).
IntKanalnummer ist eine beliebige Integer-Variable, der die Nummer des DDE-Kanals
zugewiesen wird. Sie wird für die folgenden Befehle benötigt. Anwendungsname ist
meist der Dateiname der Anwendung ohne Erweiterung, z. B. WinWord. Thema ist ein
gültiges DDE-Thema der Anwendung, meist ein Dateiname eines Dokuments.
DDEInitiate
Nachdem der DDE-Kanal initialisiert wurde, können mitVariable = DDERequest
(intKanalnummer, Element) Daten angefordert werden bzw. mit DDEPoke
(intKanalnummer, Element, Daten) Daten gesendet werden. DDEExecute
(intKanalnummer, Befehls-String) sendet Befehle an die Anwendung.
Kommunikation
Nach Abschluß der Kommunikation muß der DDE-Kanal mit DDETerminate
(intKanalnummer) geschlossen werden.
DDETerminate
Für weitere Informationen und Beispiele suchen Sie bitte in der Hilfe und Dokumentation der jeweiligen
Anwendung unter dem Stichwort DDE.
68
Exkurs: Zugriff auf Windows-Funktionen
Wie kann ich auf eingebaute Windows-Funktionen zugreifen? Wo finde ich Informationen zu diesen
Funktionen?
-
Abb.49: Deklaration von Windows-Funktionen
Eingebaute Windows-Funktionen müssen vor Ihrer Verwendung als Prozeduren oder
Funktionen auf Modulebene deklariert werden. Dazu dient die folgende Syntax:
Deklaration
Public Declare Sub Prozedurname Lib "Bibliotheksname" _
(Parameterliste)
Public Declare Function Funktionsname Lib _
"Bibliotheksname" (Parameterliste) As Datentyp
Der Prozedurname und der Funktionsname muß exakt dem Namen der WindowsFunktion entsprechen. Ebenso muß die Parameterliste und bei Funktionen der
Rückgabe-Datentyp genau mit der Definition der Funktion übereinstimmen. Der
Bibliotheksname ist der Name der Programmierschnittstelle, normalerweise eine
DLL- oder EXE-Datei. Statt Public kann auf Wunsch natürlich auch Private verwendet
werden.
Um der Prozedur oder Funktion in ihrem Projekt einen anderen Namen zu geben, so
verwendet man das Schlüsselwort Alias, z. B.:
Alias
Declare Sub MessageBeep Lib "User32" Alias "Signal1" _
(ByVal N As Integer)
Die so deklarierten Prozeduren und Funktionen können dann wie normale Prozeduren und Funktionen verwendet werden.
Verwendung
Für Informationen über die Windows-Programmierschnittstellen lesen Sie bitte die Dokumentation zu systemnahen Programmiersprachen, wie z. B. Visual C++. Die Programmierschnittstellen sind auch auf den quartalsmäßig erscheinenden CDs des Microsoft Developer Network dokumentiert.
69
Modul 8: Datenaustausch mit anderen Anwendungen
1. Mit Menü ExtrasVerweise... können Objektbibliotheken anderer Anwendungen
geladen werden. Neue Objekte anderer Anwendungen werden mit dem Schlüsselwort New erzeugt.
Objekte in anderen
Anwendungen
Seite 66
2. Mit Hilfe von DDE kann mit älteren Windows-Anwendungen und Fax-Programmen kommuniziert werden.
Datenaustausch mit DDE
Seite 67
3. Mit dem Schlüsselwort Declare können Windows-Funktionen als Prozeduren und
Funktionen deklariert werden. Man kann dann auf sie wie auf herkömmliche
Prozeduren und Funktionen zugreifen.
Windows-Funktionen
Seite 68
-
70
Wichtige Tastenkombinationen
Wie kann ich meine Arbeit mit VBA beschleunigen?
Taste(n)
F5
Funktion
Ausführen einer Sub-Prozedur oder eines UserForm-Formulars
F8
Zeilenweises Ausführen von Code
UMSCHALT + F8
Zeilenweises Ausführen von Code mit Prozedurschritten
STRG + PAUSE
STRG + G
Unterbrechen der Ausführung einer Visual Basic-Anwendung
Anzeigen des Direktfensters
F7
Code-Fenster anzeigen
F2
STRG + F
Objektkatalog anzeigen
Suchen
STRG + H
Ersetzen
F3
Weitersuchen
UMSCHALT + F3
STRG + NACH-UNTEN
Vorheriges suchen
Nächste Prozedur
STRG + NACH-OBEN
Vorherige Prozedur
STRG + Z
STRG + Y
Rückgängig
Aktuelle Zeile löschen
TAB
UMSCHALT + TAB
Einzug vergrößern
Einzug verkleinern
STRG + UMSCHALT + F9
Alle Haltepunkte löschen
71
Index
Symbole
? ................................ 13
A
Abbruchbedingung ... 44
Abfrage ............... 28, 29
Access 6, 28, 29, 37, 58
AfterUpdate .............. 62
Algorithmus ................ 8
Alias ......................... 68
And ........................... 48
Anweisung ................ 10
Anzeige .................... 59
Application ......... 34, 35
Array ......................... 17
As ..... 18, 22, 23, 26, 28
Auflistung ........... 34, 35
Auflistungsobjekt ...... 36
Ausgabe ...................... 8
B
BackColor ........... 58, 61
BackStyle .................. 61
Befehl ....................... 10
Befehlsschaltfläche ... 59
BeforeUpdate............ 62
Benutzerformular ........ 7
Benutzerschnittstelle .................. 8, 10
Berechnungen ........... 10
Bericht ................ 28, 29
Bezeichnungsfeld ..... 59
Bibliothek ..... 38, 58, 66
Bildlaufleiste ............. 59
Boolean .............. 19, 48
Boolescher
Ausdruck ... 48, 49, 50
BorderColor ........ 58, 61
BorderStyle ......... 58, 61
ByRef ........................ 27
Byte .......................... 19
ByVal ........................ 27
C
Call ........................... 11
Call by Reference ..... 27
Call by Value ............ 27
Caption ............... 58, 61
Case .......................... 50
Case Else ................... 50
Change ..................... 62
Click ......................... 62
Const ........................ 22
Controls .................... 34
ControlTipText .......... 61
Count .................. 35, 36
Currency ................... 19
CVError ..................... 19
D
Date .................... 10, 19
Datenfeld ............ 17, 23
Datentyp ................... 19
Datum/Uhrzeit .......... 19
DblClick ................... 62
DDE .......................... 67
DDEExecute ............. 67
DDEInitiate ............... 67
DDEPoke .................. 67
DDERequest ............. 67
DDETerminate .......... 67
Debug ....................... 12
Debug.Print .............. 12
Decimal .................... 19
Declare ..................... 68
Deklarationsteil .......... 8
Dialogbox ................... 7
Dialogfeld ........... 58, 63
Dim ........ 18, 20, 21, 23
Direktbereich ............ 13
DLL-Datei ................. 68
Do ............................ 47
Do-Loop ............. 47, 48
Document ................. 19
Dokument ................... 7
Double ..................... 19
Drehfeld ................... 59
Dynamic Data
Exchange ............... 67
E
Eigenschaft..... 7, 34, 36,
41, 61
Eigenschaftenfenster .. 7,
40, 58, 59
Eigenschaftsprozedur 41
Einfachverzweigung ................ 48, 49
Eingabe ....................... 8
Einzelschritt .............. 14
Einzelschrittmodus .... 14
Else ........................... 49
Empty ....................... 19
Enabled ..................... 61
End Function ............. 28
End If ........................ 49
End Select ................. 50
End Sub .................... 11
End With................... 39
Enter ......................... 62
Ereignis ..................... 11
Ereignisprozedur ....... 62
Err ....................... 53, 54
Err.Number ............... 53
Err.Raise.................... 54
Error .......................... 19
Ersetzen ...................... 9
Excel ... 6, 28, 29, 38, 58
EXE-Datei.................. 68
Exit ........................... 62
Exit Do ...................... 47
Exit For ............... 45, 46
Exit Function ............. 28
Exit Sub............... 11, 21
F
False ................... 19, 48
Fehlernummer .... 53, 54
Fehlerroutine ...... 53, 55
Festkommazahl ......... 19
Fließkommazahl ....... 19
Flußdiagramme ........... 8
Fokus ........................ 62
Font .................... 36, 61
For ............................ 45
For - Next ..... 31, 45, 46
For Each.................... 46
For Each - Next ......... 46
ForeColor............ 58, 61
Form ................... 19, 34
Forms .................. 34, 35
Formular ............. 28, 29
Function ............. 28, 68
Funktion . 10, 28, 41, 68
Funktionsmethode .... 37
In .............................. 46
Index .................. 23, 35
Indexnummer ..... 23, 31
Initialize .............. 62, 63
InputBox ................... 12
Int ....................... 10, 13
Integer ...................... 19
Internet Explorer ......... 6
Is ......................... 48, 50
IsEmpty ..................... 19
IsError ....................... 19
IsMissing ................... 30
IsNull ........................ 19
-
K
Klasse ........... 19, 34, 40
Klassenmodul ..... 40, 41
Kombinationsfeld ...... 59
Kommentar ................. 9
Kompilieren .............. 21
Konstante ............ 17, 22
Kontrollkästchen ....... 59
L
Laufzeitfehler ............ 53
LBound ..................... 23
Lib ............................ 68
Listenfeld .................. 59
Load ......................... 63
Locked ...................... 61
Lokal-Fenster ............ 13
Long ......................... 19
Loop ......................... 47
H
Haltepunkt ................ 14
M
Makro . 7, 11, 13, 26, 29
Mehrfachverzweigung ................ 48, 50
Meldungsbox ............ 12
MessageBeep ............ 68
Methode ....... 34, 37, 41
Microsoft Developer
Network ................ 68
Modul ......... 7, 9, 20, 29
Modulebene ....... 20, 29
Modulkopf .... 18, 20, 22
MSForms ............. 38, 58
MsgBox..................... 12
Multiseiten ................ 59
I
If ............................... 49
If-Then-Else ............... 49
N
Name ...... 34, 36, 58, 61
New .................... 40, 66
G
Ganzzahl .................. 19
GroupName.............. 61
Grundrechnungsarten 10
Gültigkeitsbereich 20, 29
Gültigkeitsdauer ....... 21
Next .................... 45, 46
Not ........................... 48
Nothing .............. 19, 66
Null .......................... 19
O
Object ................ 18, 19
Objekt 19, 34, 35, 40, 66
Objektkatalog ........... 38
Objektmodell ...... 38, 66
Objektvariable .......... 34
Office ....................... 38
OLE-AutomatisierungsServer ...................... 6
On Error Goto ..... 53, 55
On Error Goto 0 ........ 53
On Error Resume Next 53
OpenRecordset ......... 37
Operator ................... 48
Option Explicit .......... 18
Optional ................... 30
Optionale Parameter . 30
Optionsfeld ............... 59
Or ............................. 48
Outlook ...................... 6
P
ParamArray ............... 31
Parameter .... 10, 26, 28,
31, 37, 62
Parameterfeld............ 31
Post-CheckSchleife ............ 44, 47
Potenzieren ............... 10
Powerpoint ..... 6, 29, 58
Pre-Check-Schleife .. 44,
45, 46, 47
Preserve .................... 23
Print .......................... 13
Private .... 18, 20, 22, 29
Project ........................ 6
Projekt .................. 7, 21
Projekt-Explorer .......... 7
Projektebene ....... 20, 29
Property Get ............. 41
Property Let .............. 41
Property Set .............. 41
Prozedur 11, 26, 27, 29,
30, 31, 37, 41, 68
Prozedurebene.......... 20
Prozedurkopf 26, 29, 31
Prozedurmethode ..... 37
Prozedurschrittt ......... 14
Public .... 18, 20, 21, 22,
23, 29, 41
Q
QueryClose ............... 62
R
Rahmen .................... 59
Raise ......................... 54
Range ....................... 36
Recordset .................. 19
ReDim ...................... 23
Referenz ................... 27
Referenzübergabe ..... 27
Register ..................... 59
Resume ..................... 53
Resume Next ............ 53
S
Schleife ..................... 44
Schleifenfuß .............. 44
Schleifenkopf ............ 44
Schleifenkörper ......... 44
Schnittstelle ................ 8
Schrittweite ............... 45
72
Select Case ............... 50
Set ...................... 18, 19
Shell ......................... 67
Show ........................ 63
Single ........................ 19
Size........................... 36
SpecialEffect ....... 58, 61
Sprungmarke............. 53
Standard-Fehlerbehandlung............ 53
Standardmodul ........... 9
Static....... 18, 20, 21, 23
Step .......................... 45
Steuerelement .... 59, 60,
61, 62, 63
String ........................ 19
Struktogramme............ 8
Sub ..................... 11, 68
Suchen ........................ 9
T
Tabellenblatt ....... 28, 29
Terminate ................. 62
Text .......................... 61
TextAlign .................. 61
Textfeld..................... 59
Then ......................... 49
To ................. 23, 45, 50
True .............. 19, 47, 48
U
Überwachungsfenster 13
UBound .............. 23, 31
Umschaltfläche ......... 59
Until ......................... 47
UserForm 58, 59, 62, 63
V
Value ............ 61, 62, 63
Variable ....... 17, 18, 19,
20, 27
Variablendeklaration
erforderlich ............ 18
Variablenname ... 17, 18
Variant ...................... 19
VarType .................... 19
VB-Skript .................... 6
Verarbeitung ............... 8
Vergleichsoperator .... 48
Verweis................. 7, 66
Verzweigung ............ 48
Visible ................ 61, 63
Visual Basic für
Applikationen .......... 6
Visual Basic-Editor ...... 6
Visual C++ ............ 6, 68
Vorlage ....................... 7
W
Wend ........................ 47
Werkzeugsammlung . 58
Wert ......................... 27
While ........................ 47
While Wend ............ 47
With.......................... 39
Word ........ 6, 29, 38, 58
Word.Application ..... 66
Workbook........... 19, 66
Workbooks ......... 35, 36
Worksheets ............... 35
Z
Zählervariable .......... 45
Zählschleife .............. 45
Zeichenkette ............. 19
Ziehpunkt ................. 60
Zweifachverzweigung ......... 48, 49
2
easy
know-how
Erhard Closs – Ihr PC-Coach
Franz-Fackler-Str. 6
80995 München
Telefon:
089/ 910 72 813
Telefax:
089/ 910 72 814
[email protected]
www.easy2know-how.de
Dieses Werk ist urheberrechtlich geschützt.
Alle dadurch begründeten Rechte, insbesondere der Nachdruck, die Übersetzung, die
Wiedergabe auf photomechanischen oder ähnlichen Wegen, die Speicherung und Verarbeitung mit Hilfe der EDV bleiben auch auszugsweise ausdrücklich dem Urheber
vorbehalten.
Die in den Beispielen verwendeten Namen von Firmen, Produkten, Personen, Zeichen
oder sonstigen Daten sind frei erfunden. Ähnlichkeiten mit tatsächlichen Personen,
Firmen, Produkten oder Ereignissen sind rein zufällig und nicht beabsichtigt.
easy2know-how

VBA Programmieren mit Visual Basic for Applications

Transcription

Similar documents

2 Die Sprache C#

T-Home

PERL für Fortgeschrittene - Centrum für Informations

German - Wikimedia Commons

VBA mit Excel – Das umfassende Handbuch

Grundlagen der VBA-Programmierung

ANSI C - Grundlagen der Programmierung

D B P R O G Datenbank-Programmierung © Herbert Paukert

Reports - the Max Planck Institute for the Physics of Complex Systems