{"id":55000914,"date":"2013-12-01T00:00:00","date_gmt":"2020-05-22T21:31:59","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=914"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"VBAFunktionen_von_A_bis_Z","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/VBAFunktionen_von_A_bis_Z\/","title":{"rendered":"VBA-Funktionen von A bis Z"},"content":{"rendered":"

\"\"<\/p>\n

VBA-Funktionen kann doch jeder programmieren. Funktionsname, Parameter, Rückgabewert – fertig! Es gibt jedoch eine ganze Menge Feinheiten, die man als Programmierer kennen sollte. Dazu gehört beispielsweise das Zurückgeben mehr als eines Ergebniswertes, das übergeben beliebig vieler Parameter oder auch optionale Parameter. Dieser Beitrag liefert alles, was Sie für den Umgang mit Funktionen wissen müssen.<\/b><\/p>\n

Zur Programmierung von VBA-Funktionen muss man keine Raketentechnik studiert haben. Aber wie bereits in der Einleitung erwähnt, gibt es eine Menge verschiedener Techniken, die alle ihre Berechtigung haben. In diesem Beitrag wollen wir einmal einen überblick über die Möglichkeiten von VBA-Funktionen liefern.<\/p>\n

Funktion oder Prozedur<\/b><\/p>\n

Zunächst müssen wir klären, was genau der Unterschied zwischen einer Sub<\/b>– und einer Function<\/b>-Prozedur ist. Dieser liegt genau darin, dass eine Function <\/b>ein Ergebnis zurückliefert, das über die Zuweisung des Funktionsaufrufs etwa an eine Variable, ein Steuerelement et cetera direkt weiterverarbeitet werden kann. Eine Besonderheit ergibt sich bei der Zuweisung dieses Wertes innerhalb der Funktion: Dieser wird nämlich einer Variablen zugewiesen, die den Namen der Funktion hat. Ein Beispiel sieht so aus: <\/p>\n

Public Function <\/span>NameDesAutors() As String<\/span>\r\n     NameDesAutors = \"André Minhorst\"\r\nEnd Function<\/span><\/pre>\n
Rückgabewert verarbeiten<\/b><\/p>\n
Diese Funktion weist ihrem Rückgabewert ein String<\/b>-Literal zu, das beim Aufruf gleich verarbeitet werden kann – zum Beispiel durch die Ausgabe im Direktfenster:<\/p>\n
Debug.Print<\/span> NameDesAutors\r\nAndré Minhorst<\/pre>\n
Auf die gleiche Weise können Sie den Rückgabewert der Funktion etwa in eine Variable schreiben und dann im Direktbereich ausgeben:<\/p>\n
Public Sub <\/span>Test_NameDesAutors()\r\n     Dim <\/span>strNameDesAutors As String<\/span>\r\n     strNameDesAutors = NameDesAutors\r\n     Debug.Print<\/span> strNameDesAutors\r\nEnd Sub<\/span><\/pre>\n
Einfache Parameter<\/b><\/p>\n
Nun liefern Funktionen, denen Sie keinen Parameter übergeben, nicht unbedingt immer den gleichen Wert zurück – Sie können ja von einer solchen Funktion auch etwa das aktuelle Datum oder die Uhrzeit ermitteln lassen oder Informationen wie den Datenbankpfad.<\/p>\n
Allerdings erwarten die meisten Funktionen einen oder mehrere Parameter, auf deren Basis sie das Ergebnis der Funktion ermitteln. Die Parameter einer Funktion werden zunächst im Kopf der Funktion deklariert.<\/p>\n
Dabei geben Sie standardmäßig den Datentyp an, da sonst der Datentyp Variant<\/b> verwendet wird. Die folgende Funktion verkettet die beiden als Parameter übergebenen Zeichenketten:<\/p>\n
Public Function <\/span>Zeichenverkettung( str1 As String<\/span>, str2 As String<\/span>) As String<\/span>\r\n     Zeichenverkettung = str1 & str2\r\nEnd Function<\/span><\/pre>\n
Der Aufruf und das Ergebnis der Funktion sehen etwa wie folgt aus:<\/p>\n
  Zeichenverkettung(\"Mon\",\"tag\")\r\nMontag<\/pre>\n
Optionale Parameter<\/b><\/p>\n
Sie können die Parameter einer Abfrage als optionale Parameter definieren. Dazu verwenden Sie das Schlüsselwort Optional <\/b>vor dem eigentlichen Namen des Parameters. Dabei gibt es einen wichtigen Punkt zu beachten: Hinter einem optionalen Parameter dürfen nur noch weitere optionale Parameter folgen.  Anderenfalls löst bereits die Definition der Kopfzeile der Funktion einen Fehler aus (s. Bild 1).<\/p>\n
Standardwerte<\/b><\/p>\n
Wenn Sie sicherstellen wollen, dass der Parameter auch dann einen Wert liefert, wenn die aufrufende Routine keinen Wert für den Parameter übergeben hat, können Sie wie in Listing 1 einen Standardwert angeben. Diesen tragen Sie hinter dem Datentyp, sonst direkt hinter dem Namen des Parameters ein. Wenn Sie dem Parameter der Funktion beim Aufruf einen Wert übergeben, liefert sie das folgende Ergebnis:<\/p>\n
Public Function <\/span>EingabeGleichAusgabe(Optional<\/span> str1 As String<\/span> = \"Kein Wert angegeben\")\r\n     EingabeGleichAusgabe = str1\r\nEnd Function<\/span><\/pre>\n
Listing 1: Verwendung von Standardwerten für optionale Parameter<\/span><\/b><\/p>\n
  EingabeGleichAusgabe(\"Wert angegeben\")\r\nWert angegeben<\/pre>\n
Geben Sie keinen Wert für den Parameter an, verwendet die Funktion den Standardwert:<\/p>\n
  EingabeGleichAusgabe\r\nKein Wert angegeben<\/pre>\n
Auf optionale Parameter prüfen<\/b><\/p>\n
Wenn Sie optionale Parameter verwenden, können Sie von Haus aus nur für den Datentyp Variant prüfen, ob der Benutzer diese übergeben hat. Variablen vom Typ Variant können als einziges den Wert Null <\/b>aufnehmen. Ob der Parameter übergeben wurde, prüfen Sie mit der IsMissing<\/b>-Funktion. Diese liefert den Wert True <\/b>zurück, wenn der Parameter leer ist.<\/p>\n
übrigens ist IsMissing <\/b>nicht gleichbedeutend mit IsNull<\/b>. Dies können Sie mit der Funktion aus Listing 2 prüfen. Wenn Sie die Prozedur komplett ohne Parameter aufrufen, erhalten Sie folgende Ausgabe im Direktfenster:<\/p>\n
Public Function <\/span>OptionaleParameter(Optional<\/span> str1 As String<\/span>, Optional<\/span> var1 As Variant<\/span>)\r\n     Debug.Print<\/span> \"Fehlt str1\", IsMissing(str1), IsNull(str1)\r\n     Debug.Print<\/span> \"Fehlt var1\", IsMissing(var1), IsNull(var1)\r\nEnd Function<\/span><\/pre>\n
Listing 2: Prüfung von optionalen Parametern mit IsMissing<\/span><\/b><\/p>\n
Fehlt str1   Falsch        Falsch\r\nFehlt var1   Wahr          Falsch<\/pre>\n
Das heißt, dass eine leere Variant<\/b>-Variable zwar als fehlend eingestuft wird, aber nicht den Wert Null <\/b>enthält. Dies können Sie nochmals testen, indem Sie den Wert Null <\/b>für den Parameter var1 <\/b>übergeben:<\/p>\n
Debug.Print<\/span> OptionaleParameter(\"\", Null)<\/pre>\n
Das Ergebnis sieht so aus:<\/p>\n
Fehlt str1   Falsch        Falsch\r\nFehlt var1   Falsch        Wahr<\/pre>\n
Die Variant<\/b>-Variable mit dem Wert Null <\/b>fehlt also nicht und wird mit IsNull <\/b>korrekt als Null <\/b>erkannt.<\/p>\n
Wenn Sie einen anderen Datentyp als optionalen Parameter verwenden und prüfen wollen, ob die aufrufende Routine einen Wert für diesen übergeben hat, müssen Sie einen kleinen Trick anwenden. Das Werkzeug dafür haben Sie schon kennengelernt – den Standardwert. Geben Sie einfach einen Ausdruck als Standardwert an, der normalerweise nicht übergeben wird.<\/p>\n
Wenn die Funktion dann aufgerufen wird, prüfen Sie, ob der Parameter den als Standardwert angegebenen Wert enthält oder einen anderen. Im ersten Fall können Sie dann davon ausgehen, dass kein Parameter übergeben wurde, anderenfalls liegt ein Wert für den Parameter vor.<\/p>\n
Ein Beispiel für einen solchen Test zeigt die Funktion StringparameterVorhanden <\/b>aus Listing 3. Sie verwendet die Zeichenkette **** als Standardwert. Der folgende Aufruf zeigt, wie die Funktion reagiert:<\/p>\n
Public Function <\/span>StringparameterVorhanden(Optional<\/span> str1 As String<\/span> = \"****\") As Boolean<\/span>\r\n     If <\/span>Not<\/span> str1 = \"****\" Then<\/span>\r\n         StringparameterVorhanden = True<\/span>\r\n     End If<\/span>\r\nEnd Function<\/span><\/pre>\n
Listing 3: Prüfung auf Vorhandensein eines Wertes für einen String-Parameter<\/span><\/b><\/p>\n
  StringparameterVorhanden()\r\nFalsch<\/pre>\n
übergeben Sie einen Wert, liefert die Funktion den Wert True <\/b>zurück:<\/p>\n
  StringparameterVorhanden(\"bla\")\r\nWahr<\/pre>\n
Benannte Parameter<\/b><\/p>\n
Wenn eine Funktion ein oder mehrere optionale Parameter enthält, können Sie diese auf verschiedene Arten angeben:<\/p>\n