{"id":55000335,"date":"2022-08-01T00:00:00","date_gmt":"2023-03-02T17:03:14","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=335"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"VBA_Basics_Makros_Prozeduren_Funktionen_und_Co","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/VBA_Basics_Makros_Prozeduren_Funktionen_und_Co\/","title":{"rendered":"VBA Basics: Makros, Prozeduren, Funktionen und Co."},"content":{"rendered":"

VBA-Code in VBA-Projekten von Office-Anwendungen landet zuerst einmal in Modulen. Darunter gibt es einige weitere Strukturen, auf welche die Anweisungen aufgeteilt werden. Während Deklarationen von Variablen auch direkt in einem Modul angelegt werden können, müssen ausführbare Codezeilen zwingend in Konstrukten untergebracht werden, die je nach Anwendung Makros oder Prozeduren genannt werden. Außerdem gibt es noch Funktionen. Was es mit all diesen Begriffen auf sich hat und wieso diese nicht einheitlich definiert sind, erläutern wir in diesem Artikel.<\/b><\/p>\n

Makros vs. Prozeduren<\/h2>\n

Wer erstmal mit VBA unter Excel, Word oder PowerPoint in Kontakt kommt, erledigt dies in der Regel über das Aufzeichnen von Makros – mehr dazu im Artikel VBA: Makros aufzeichnen <\/b>(www.access-im-unternehmen.de\/324<\/b>). Bei der Aufzeichnung kommt ein sogenanntes Makro heraus. Schaut man sich das im VBA-Editor an, findet man jedoch eine Sub-Prozedur vor. Wir könnten nun einfach die Begriffe Makro und Sub-Prozedur synonym verwenden, wenn da nicht noch Access wäre: Hier gibt es nämlich neben VBA noch einen eigenen Objekttyp zum Erstellen von Automatisierungen, der wiederum Makro heißt.<\/p>\n

Allerdings hat das Makro unter Access nichts mit VBA zu tun, sondern es handelt sich dabei eher um eine Möglichkeit zum “Zusammenklicken” von Automatisierungen. Microsoft hat also den Begriff Makro in verschiedenen Office-Anwendungen für unterschiedliche Techniken verwendet, was bei Benutzern und Programmierern für Verwirrung sorgt.<\/p>\n

Allerdings ist das nicht nur dort problematisch, sondern auch für unser Magazin Visual Basic Entwickler<\/b>.Wir wollen hier ja über den Einsatz von Visual Basic for Applications <\/b>(VBA<\/b>) und verwandten Sprachen wie Visual Basic.NET <\/b>oder twinBASIC <\/b>berichten, und zwar für alle Office-Anwendungen. <\/p>\n

Um Verwechslungen auszuschließen, werden wir also den Begriff “Makro” nur noch dort verwenden, wo wir tatsächlich die Funktion zum Aufzeichnen von Makros nutzen. An allen anderen Stellen bezeichnen wir alle Code-Konstrukte, die in der ersten Zeile das Schlüsselwort Sub <\/b>tragen, als Prozedur.<\/p>\n

Prozeduren und Funktionen<\/h2>\n

Neben den Prozeduren gibt es noch zwei weitere Konstrukte, die zur Ausführung bestimmte Codezeilen aufnehmen können. Das erste ist die sogenannte Funktion, das zweite sind die Property…<\/b>-Methoden. Diese treten allerdings erst in Zusammenhang mit der objektorientierten Programmierung von Klassenmodulen auf, sodass wir in diesem Artikel nicht darauf eingehen wollen.<\/p>\n

Eigentlich sind die Bezeichnungen “Prozedur” und “Funktion” auch wieder nicht ganz konsequent, denn eigentlich sind beide Prozeduren – eine mit dem Schlüsselwort Sub <\/b>und eine mit dem Schlüsselwort Function<\/b>. Die korrekteren Bezeichnungen sind wohl Sub<\/b>-Prozedur und Function<\/b>-Prozedur. Allerdings denke ich, dass auch die Bezeichnungen Prozedur <\/b>und Funktion <\/b>verständlich sind, solange sie konsequent verwendet werden.<\/p>\n

Prozeduren und Funktionen führen beide eine oder mehrere Anweisungen aus. Der wichtigste Unterschied zwischen beiden ist, dass die Funktionen ein Funktionsergebnis direkt zurückgeben können. Dazu zwei Beispiele. Eine Prozedur sieht im einfachsten Fall wie folgt aus:<\/p>\n

Sub <\/span>Meldung()\r\n     MsgBox<\/span> \"Meldung per Prozedur\"\r\nEnd Sub<\/span><\/pre>\n
Eine sehr einfache Funktion sieht so aus:<\/p>\n
Function <\/span>Eingabe()\r\n     Eingabe = InputBox(\"Funktionswert eingeben:\")\r\nEnd Function<\/span><\/pre>\n
Wir sehen schon, dass die Prozedur lediglich eine Meldung anzeigt. Die Funktion hingegen ruft eine InputBox auf und weist das Ergebnis einer Variablen namens Eingabe <\/b>zu.<\/p>\n
Aber was soll das denn nun? Wir haben doch im Artikel VBA-Basics: Variablen <\/b>(www.access-im-unternehmen.de\/319<\/b>) geschrieben, dass Variablen ein Präfix wie zum Beispiel str <\/b>für eine String<\/b>-Variable enthalten sollen? Und überhaupt – es ist nirgends eine Variable namens Eingabe <\/b>deklariert?<\/p>\n
Und das ist der Punkt: Der Name einer Funktion ist gleichzeitig der Name der Variablen, der wir den Rückgabewert der Funktion zuweisen. Es ist also erstens kein Präfix erforderlich, außer Du möchtest diesen bei Funktionen verwenden. Zweitens ist aber auch kein Datentyp angegeben, obwohl wir das im oben genannten Artikel ebenfalls empfohlen haben, weil sonst der Datentyp Variant <\/b>verwendet wird, der mehr Speicherplatz als ein explizit angegebener Datentyp benötigt.<\/p>\n
Und wir haben geschrieben, dass die obigen Beispiele sehr einfache Beispiele sind. Dementsprechend haben wir auch nicht explizit einen Gültigkeitsbereich für die Prozedur und die Funktion angegeben.<\/p>\n
Genau wie bei Variablen gilt hier: Wenn kein Schlüsselwort wie Public <\/b>oder Private <\/b>angegeben wurde, ist das Element öffentlich erreichbar. Explizit müssten wir die Prozedur also wie folgt definieren, wenn diese im kompletten VBA-Projekt erreichbar sein soll:<\/p>\n
Public Sub <\/span>Meldung()\r\n     MsgBox<\/span> \"Meldung per Prozedur\"\r\nEnd Sub<\/span><\/pre>\n
Für die Funktion gilt das Gleiche – und hier geben wir nun auch noch den Datentyp für den Rückgabewert Eingabe <\/b>an, der nicht nur Funktionsname, sondern auch noch Variable ist:<\/p>\n
Public Function <\/span>Eingabe() As String<\/span>\r\n     Eingabe = InputBox(\"Funktionswert eingeben:\")\r\nEnd Function<\/span><\/pre>\n
Routine als Synonym für Prozeduren und Funktionen<\/h2>\n
Wir werden im folgenden und auch in weiteren Artikeln Grundlagen und Techniken vorstellen, die für Prozeduren und Funktionen identisch sind. An diesen Stellen erwähnen wir nicht immer “Prozeduren und Funktionen”, sondern nutzen gelegentlich den Begriff Routine als Synonym für beide.<\/p>\n
Aufruf per Direktbereich<\/h2>\n
Die Prozedur und die Funktion können wir beide über den Direktbereich des VBA-Editors aufrufen. Dazu aktivieren wir diesen, sofern noch nicht eingeblendet, mit Strg + G<\/b>. Wenn er schon eingeblendet ist, kannst Du ihn mit dieser Tastenkombination aktivieren.<\/p>\n
Dort gibst Du einfach den Namen der Prozedur ein und schließt den Aufruf mit der Eingabetaste ab. Das Ergebnis sieht wie in Bild 1 aus.<\/p>\n
\"Aufruf<\/p>\n
Bild 1: Aufruf einer Prozedur<\/span><\/b><\/p>\n
Die Funktion können wir auf die gleiche Weise aufrufen. Das zeigt die InputBox <\/b>an, aber die Eingabe wird nicht ausgewertet. Um den Inhalt der InputBox <\/b>auszugeben, können wir beispielsweise die folgende Anweisung nutzen:<\/p>\n
Debug.Print<\/span> Eingabe<\/pre>\n
Dies ruft die Anzeige der InputBox <\/b>wie in Bild 2 hervor. Und nach der Eingabe wird der eingegebene Text unter der Anweisung im Direktbereich ausgegeben.<\/p>\n
\"Aufruf<\/p>\n
Bild 2: Aufruf einer Funktion<\/span><\/b><\/p>\n
Aufruf einer Funktion von einer anderen Prozedur oder Funktion aus<\/h2>\n
Normalerweise soll das Ergebnis einer Funktion jedoch nicht im Direktbereich ausgegeben werden, sondern wir speichern es in einer Variablen oder verwenden es anderweitig weiter.<\/p>\n
Außerdem wollen wir in diesem Zusammenhang direkt einmal zeigen, wie wir die Funktion von einer anderen Funktion aus aufrufen können. Dazu deklarieren wir im folgenden Beispiel eine String<\/b>-Variable namens strEingabe <\/b>und weisen nun dieser das Ergebnis der Funktion Eingabe <\/b>zu. Danach geben wir dieses wieder im Direktbereich aus, um zu prüfen, ob das Ergebnis korrekt verarbeitet wurde:<\/p>\n
Public Sub <\/span>EingabeSpeichern()\r\n     Dim <\/span>strEingabe As String<\/span>\r\n     strEingabe = Eingabe\r\n     Debug.Print<\/span> strEingabe\r\nEnd Sub<\/span><\/pre>\n
Die Prozedur EingabeSpeichern <\/b>rufen wir zunächst wieder vom Direktbereich aus auf, indem wir ihren Namen eingeben und die Eingabetaste betätigen.<\/p>\n
Aufruf einer anderen Routine unterbricht die aktuelle Routine<\/h2>\n
Wichtig für das Verständnis des Ablaufs ist, dass Routinen unter VBA immer synchron ablaufen, dass heißt, dass immer nur eine gleichzeitig ausgeführt wird. Wenn Routine A also mit einer Anweisung Routine B aufruft, dann wird Routine A solange angehalten, bis Routine B beendet ist. Anderenfalls würde man von asynchroner Ausführung reden, was aber in reinem VBA nicht möglich ist.<\/p>\n
Aufruf einer Prozedur von einer anderen Prozedur aus<\/h2>\n
Wenn wir eine Prozedur von einer anderen Prozedur aus aufrufen wollen, können wir dies genau wie im Direktbereich erledigen.<\/p>\n
Wir tragen also einfach den Namen der zu startenden Prozedur als eigene Zeile innerhalb einer anderen Prozedur ein – hier wieder mit der zuerst vorgestellten Prozedur namens Meldung<\/b>:<\/p>\n
Public Sub <\/span>AndereProzedurAufrufen()\r\n     Meldung\r\nEnd Sub<\/span><\/pre>\n
Dies funktioniert, aber etwas sauberer wirkt die Variante, in der wir die Call<\/b>-Anweisung für den Aufruf der Prozedur nutzen:<\/p>\n
Call<\/span> Meldung<\/pre>\n
Dies können wir auch im Direktbereich verwenden. Die Call<\/b>-Anweisung hat keine Nachteile, aber sie kann in bestimmten Situationen Vorteile liefern. Diese sind aber rar. Wenn Du zum Beispiel zwei Prozeduraufrufe in einer Zeile unterbringen möchtest, was unüblich ist und bestenfalls ein oder zwei Codezeilen spart, kannst Du Call einsetzen:<\/p>\n
Call<\/span> Meldung: Call<\/span> Eingabe<\/pre>\n
Wenn Du hier nur Meldung : Eingabe <\/b>schreibst, wird Meldung als Sprungmarke interpretiert und der Code sieht anschließend so aus:<\/p>\n
Meldung:\r\n     Eingabe<\/pre>\n
Prozeduren und Funktionen direkt aufrufen<\/h2>\n
Es gibt noch weitere Methoden für den Aufruf von Prozeduren und Funktionen. Diese funktionieren aber nur, solange diese keine Parameter verwenden. Ist das der Fall, kannst Du die auszuführende Prozedur oder Funktion einfach im VBA-Editor markieren, indem Du die Einfügemarke an einer beliebigen Stelle des Codes der Prozedur oder Funktion platzierst und dann eine der folgenden Aktionen ausführst:<\/p>\n