{"id":55000336,"date":"2022-08-01T00:00:00","date_gmt":"2023-03-02T17:00:02","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=336"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"VBA_Basics_Bedingungen","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/VBA_Basics_Bedingungen\/","title":{"rendered":"VBA Basics: Bedingungen"},"content":{"rendered":"

Wenn man in VBA-Routinen bestimmte Anweisungen in Abhängigkeit von einem Wert einer Variablen, einer Eingabe oder anderen Bedingungen ausführen lassen möchte, verwendet man sogenannte Bedingungen. Unter VBA gibt es dazu die If…Then-Bedingung und die Select Case-Bedingung. Streng genommen gibt es noch einige VBA-Funktionen, die auch Bedingungen enthalten. Diese schauen wir uns aber in einem anderen Artikel an. Hier geht es zunächst um die beiden genannten Konstrukte.<\/b><\/p>\n

Manche Prozeduren oder Funktionen unter VBA erfordern es, dass abhängig von bestimmten Voraussetzungen unterschiedliche Anweisungen ausgeführt werden sollen. Ein einfaches Beispiel: Wenn Du per MsgBox<\/b>-Funktion vom Benutzer einen der Werte vbYes <\/b>oder vbNo <\/b>abfragst, dann wirst Du im Code auch für die beiden Eingaben jeweils eigene Anweisungen ausführen wollen. Wenn nur diese beiden Möglichkeiten bestehen, bist Du mit einer einfachen If…Then<\/b>-Bedingung gut vorbereitet. Es kann auch sein, dass es noch mehr verschiedene Auswahlmöglichkeiten gibt. Dann würde man eine If…Then<\/b>-Bedingung mit mehr als nur zwei Zweigen verwenden – oder vielleicht sogar eine Select Case<\/b>-Bedingung, die das Verwalten mehrerer Zweige oft einfacher und übersichtlicher macht.<\/p>\n

Die If…Then-Bedingung<\/h2>\n

Eine If…Then<\/b>-Bedingung kann nur aus einem einzigen Zweig bestehen, dessen Anweisungen nur bei der Erfüllung der angegebenen Bedingung ausgeführt werden. Die Bedingung ist im einfachsten Fall wie folgt aufgebaut:<\/p>\n

If <\/span>[Bedingung] Then<\/span>\r\n     [Anweisungen]\r\nEnd If<\/span><\/pre>\n
[Bedingung]<\/b> kann dabei ein beliebiger Ausdruck sein,  der den Wert True <\/b>oder False <\/b>zurückliefert. Das Ergebnis des für [Bedingung] <\/b>angegebenen Ausdrucks muss also den Datentyp Boolean <\/b>aufweisen. Wenn [Bedingung] <\/b>den Wert True <\/b>ergibt, werden die zwischen If…Then <\/b>und End If <\/b>enthaltenen Anweisungen ausgeführt. Das sieht im einfachsten Fall wie folgt aus:<\/p>\n
Dim <\/span>bolBedingung As Boolean<\/span>\r\nbolBedingung = True<\/span>\r\nIf <\/span>bolBedingung Then<\/span>\r\n     MsgBox<\/span> \"bolBedingung ist True\"\r\nEnd If<\/span><\/pre>\n
Viele Entwickler schreiben die If…Then<\/b>-Zeile in diesem Fall wie folgt:<\/p>\n
If <\/span>bolBedingung = True<\/span> Then<\/span>\r\n...<\/pre>\n
Das ist nicht grundsätzlich falsch, aber bolBedingung <\/b>enthält bereits einen Boolean<\/b>-Wert, der Vergleich mit True <\/b>hat hier keinen zusätzlichen Nutzen und kostet lediglich Rechenzeit. Wenn Du allerdings im If…Then<\/b>-Zweig prüfen willst, ob die Bedingung nicht erfüllt ist, dann benötigen wir mindestens einen weiteren Operator. Die erste Möglichkeit ist der Vergleich mit dem Wert False<\/b>:<\/p>\n
If <\/span>bolBedingung = False<\/span> Then<\/span>\r\n     MsgBox<\/span> \"bolBedingung ist False\"\r\nEnd If<\/span><\/pre>\n
Die zweite Möglichkeit ist der Einsatz des Operators Not<\/b>:<\/p>\n
If <\/span>Not<\/span> bolBedingung Then<\/span>\r\n     MsgBox<\/span> \"bolBedingung ist False\"\r\nEnd If<\/span><\/pre>\n
In den folgenden Beispielen verwenden wir statt der Boolean<\/b>-Variable einen richtigen Vergleichsausdruck, dessen Ergebnis wir mithilfe einer MsgBox<\/b>-Anweisung ermitteln. Klickt der Benutzer auf Ja<\/b>, erscheint die nachfolgend definierte Meldung:<\/p>\n
Dim <\/span>lngResult As <\/span>VbMsgBoxResult\r\nlngResult = MsgBox<\/span>(\"Ja oder Nein?\", vbYesNo)\r\nIf <\/span>lngResult = vbYes Then<\/span>\r\n     MsgBox<\/span> \"Benutzer hat ''Ja'' angeklickt.\"\r\nEnd If<\/span><\/pre>\n
Der Else-Zweig<\/h2>\n
In einer If…Then<\/b>-Bedingung sind wir allerdings nicht darauf beschränkt, nur Anweisungen für die im If…Then<\/b>-Teil angegebene Bedingung auszuführen. Wir können auch Anweisungen ausführen, wenn die Bedingung nicht erfüllt ist. Die einfachste und universellste Variante dafür ist der Else<\/b>-Zweig.<\/p>\n
Im folgenden Beispiel behandeln wir den Fall, dass der Benutzer auf Nein <\/b>klickt, im Else<\/b>-Zweig:<\/p>\n
lngResult = MsgBox<\/span>(\"Ja oder Nein?\", vbYesNo)\r\nIf <\/span>lngResult = vbYes Then<\/span>\r\n     MsgBox<\/span> \"Benutzer hat ''Ja'' angeklickt.\"\r\nElse<\/span>\r\n     MsgBox<\/span> \"Benutzer hat ''Nein'' angeklickt.\"\r\nEnd If<\/span><\/pre>\n
Da lngResult <\/b>nur die beiden Werte vbYes <\/b>oder vbNo <\/b>enthalten kann, wird vbNo <\/b>im Else<\/b>-Zweig abgehandelt. Wenn wir neben Ja <\/b>und Nein <\/b>noch weitere Möglichkeiten anbieten, zum Beispiel Abbrechen<\/b>, würde der Else<\/b>-Zweig auch diese behandeln:<\/p>\n
lngResult = MsgBox<\/span>(\"Ja oder Nein?\", vbYesNoCancel)<\/pre>\n
Klickt der Benutzer also auf Abbrechen<\/b>, zeigt die vorherige If…Then<\/b>-Bedingung auch an, dass der Benutzer auf Nein<\/b> geklickt hat. Um dies zu behandeln, gibt es noch den ElseIf<\/b>-Zweig.<\/p>\n
Der ElseIf-Zweig<\/h2>\n
Wenn wir nicht nur zwei Möglichkeiten auswerten wollen, müssen wir entsprechend mehr Zweige anbieten. Im Falle von Ja<\/b>, Nein <\/b>und Abbrechen <\/b>fügen wir im folgenden Beispiel eine weitere Unterscheidung hinzu, die gezielt auf den Wert vbNo <\/b>untersucht. Alles, was nicht vbYes <\/b>oder vbNo <\/b>ist, wird im Else<\/b>-Teil behandelt, in diesem Fall also vbCancel<\/b>:<\/p>\n
lngResult = MsgBox<\/span>(\"Ja oder Nein?\", vbYesNoCancel)\r\nIf <\/span>lngResult = vbYes Then<\/span>\r\n     MsgBox<\/span> \"Benutzer hat ''Ja'' angeklickt.\"\r\nElse<\/span>If lngResult = vbNo Then\r\n     MsgBox<\/span> \"Benutzer hat ''Nein'' angeklickt.\"\r\nElse<\/span>\r\n     MsgBox<\/span> \"Benutzer hat ''Abbrechen'' angeklickt.\"\r\nEnd If<\/span><\/pre>\n
Wir könnten im Else<\/b>-Teil auch explizit auf vbCancel <\/b>prüfen, indem wir diesen wie folgt in einen ElseIf<\/b>-Zweig umwandeln:<\/p>\n
If <\/span>lngResult = vbYes Then<\/span>\r\n     MsgBox<\/span> \"Benutzer hat ''Ja'' angeklickt.\"\r\nElse<\/span>If lngResult = vbNo Then\r\n     MsgBox<\/span> \"Benutzer hat ''Nein'' angeklickt.\"\r\nElse<\/span>If lngResult = vbCancel Then\r\n     MsgBox<\/span> \"Benutzer hat ''Abbrechen'' angeklickt.\"\r\nEnd If<\/span><\/pre>\n
Das passt in diesem Fall, da wir genau drei Fälle behandeln wollen. <\/p>\n
Else-Zweig am Ende<\/h2>\n
Wenn Du einen Else<\/b>-Zweig verwendest, musst Du diesen hinter allen verwendeten ElseIf<\/b>-Zweigen einfügen. Anderenfalls wird beim Kompilieren der Fehler aus Bild 1 ausgelöst.<\/p>\n
\"Fehler,<\/p>\n
Bild 1: Fehler, wenn der Else-Zweig nicht am Ende steht<\/span><\/b><\/p>\n
Else-Zweig als Backup<\/h2>\n
In den meisten Fällen weiß man vorher, welche Werte in einer If…Then<\/b>-Bedingung verarbeitet werden sollen. Manchmal können jedoch auch Werte auftauchen, die man zuvor noch nicht kennt oder erwartet. In diesem Fall kann es sinnvoll sein, den Else<\/b>-Zweig mit einer entsprechenden Meldung oder einer anderen Aktion auszustatten, mit der sowohl der Benutzer als auch der Entwickler informiert werden, wenn es unbehandelte Fälle gibt.<\/p>\n
Performance optimieren durch richtige Reihenfolge<\/h2>\n
Wenn Du Schritt für Schritt durch eine solche If…Then<\/b>-Bedingung läufst, stellst Du fest, dass die Bedingungen von oben nach unten geprüft werden und dass nach dem Erreichen einer gültigen Bedingung die im entsprechenden Zweig enthaltenen Anweisungen ausgeführt werden und die nachfolgenden Zweige nicht mehr untersucht werden.<\/p>\n
Da auch das schlichte Untersuchen der Bedingungen in einem If…Then…ElseIf…Else<\/b>-Konstrukt Rechenzeit kostet und sich das beispielsweise bei vielen Wiederholungen in einer Schleife schnell auswirken kann, gibt es in manchen Fällen eine sinnvolle Strategie zur Optimierung der Performance. Bei diesen Fällen weiß man vorher, welche der Bedingungen öfter eintreten als die anderen. Diese trägt man dann einfach in absteigender Priorität von oben nach unten ein. Die wahrscheinlichste Bedingung landet also direkt im If…Then<\/b>-Zweig, die unwahrscheinlichste ganz unten.<\/p>\n
Einzeilige If…Then-Bedingung<\/h2>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Visual Basic Entwickler<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 200 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t
\n\n\t\t\n\t\t