Parameterlisten mit Fehloptionen in VBA

Optionen

Als eine Option oder als optional bezeichnen wir etwas, das auch entfallen kann. Beispielsweise ist die Typangabe einer Parameterbeschreibung eine Option.

Etwas, das nicht entfallen kann, ist obligatorisch.

Eckige Klammern

Das Zeichen »[« heißt „eckige Klammer auf “.

Das Zeichen »]« heißt „eckige Klammer zu “.

Zusammenfassend werden jene beiden Zeichen auch als „eckige Klammern “ bezeichnet.

Parameterlisten mit Optionen

Eine Parameterliste mit Optionen ist eine Parameterliste, die eckige Klammern enthält.

Die Proklamation der Funktion »VBA.Math.Rnd« aus dem Objektkatalog enthält beispielsweise die Parameterliste »[Number]«. Dies ist eine Parameterliste mit Optionen, da sie eckige Klammern enthält.

»VBA.Math.Rnd« (vereinfachte Proklamation)

Function Rnd( [Number] ) As Double

Eine in eckigen Klammern eingeschlossener Parametername kennzeichnet ein optionales Argument, das heißt, daß das zu diesem Parameter gehörende Argument beim Aufruf auch entfallen kann.

Direktbereich

? VBA.Math.Rnd( 1 )
  0.7055475

Direktbereich

? VBA.Math.Rnd()
  0.7055475

Welche Bedeutung eine Angabe eines Arguments oder das Wegfallen dieser Angabe hat, muß in jedem Einzelfall einer Funktion jeweils der Dokumentation dieser Funktion entnommen werden. Im speziellen Falle der Funktion »VBA.Math.Rnd« hat der Aufruf »VBA.Math.Rnd( 1 )« beispielsweise genau dieselbe Bedeutung wie der Aufruf »VBA.Math.Rnd()«.

Parameterlisten mit Optionen bei zwei Parametern

Verwirrenderweise unterscheiden sich die Proklamationen des Objektkatalogs leider manchmal von denen der Dokumentation.

So findet man in der Proklamation der Funktion »VBA.Math.Round« im Objektkatalog ein Komma einmal in den eckigen Klammern und einmal außerhalb dieser.

Objektkatalog (Proklamation)

Function Round(Number, [NumDigitsAfterDecimal As Long])

Deutschsprachige Dokumentation (Proklamation)

Round(Ausdruck [,AnzahlAnDezimalpunkten])

In diesem Fall beschreibt die Dokumentation die tatsächlich möglichen Aufrufe besser, denn das Komma darf nur dann geschrieben werden, wenn ihm dann auch noch ein Ausdruck folgt!

Man kann also schreiben »Round( 8.877 )« oder »Round( 8.877, 2 )«, aber nicht »Round( 8.877, )«.

Mit der Standardfunktion »VBA.Math.Round« kann eine Zahl notiert werden, die durch Rundung aus dem ersten Parameter »Number« ermittelt wird.

Der zweite Parameter »NumDigitsAfterDecimal« gibt an, wie viele Nachkommastellen das Ergebnis haben soll.

Ist das zweite Argument der Ausdruck »2«, so ergibt sich beispielsweise eine Zahl mit zwei Nachkommastellen.

Direktbereich

? VBA.Math.Round( 54.65745, 2 )

 54,66

Es ist bei zwei Parameter mit einer Option typisch, daß das optionale Argument das zweite Argument ist, da optionale Argumente in der Regel den obligatorischen Argumenten folgen.

Zum Unterschied zwischen Parametern und Argumenten: Die Funktion »VBA.Math.Round« hat zwei Parameter (dies sind die Angaben der Dokumentation, selbst, wenn sie in eckigen Klammern stehen), Ein Aufruf von »VBA.Math.Round« kann ein oder zwei Argumente haben (dies sind die Ausdrücke im Aufruf).

Fehlwerte der Prosa

Ein Fehlwert (Vorgabewert, Standardwert ) für einen Parameter ist ein Wert, der an Stelle des Wertes des dem Parameter entsprechenden Argumentes verwendet wird, wenn das dem Parameter entsprechend Argument im Aufruf fehlt.

Der Fehlwert eines Parameters wird für jeden optionalen Parameter jeder Funktion individuell festgelegt und kann der Dokumentation der Funktion entnommen werden.

Der Parameter »NumDigitsAfterDecimal« hat den Fehlwert »0«, und daher kann das Argument für diesen Parameter bei der Bildung des Funktionsausdrucks auch weggelassen werden, wenn überhaupt keine (»0«) Nachkommastellen gewünscht sind.

Wenn das zweite Argument weggelassen wird, dann wird der Fehlwert »0« angenommen und es ergibt sich eine Zahl ohne Nachkommastellen.

Direktbereich

? VBA.Math.Round( 54.65745 )

Fehlwerte finden sich manchmal schon in der Proklamation einer Funktion festgelegt. Im Falle der Funktion »VBA.Math.Round« findet sich eine Angabe zum Fehlerwert »0« aber erst in der Prosa.

Kennzahlen

Wir erinnern an dieser Stelle daran, daß sich hinter Namen, wie »VBA.VbDayOfWeek.vbSunday« Kennzahlen verbergen können.

Direktbereich

? VBA.VbDayOfWeek.vbSunday

Die Bedeutung einer bestimmten Kennzahl hängt von der Stelle ihrer Verwendung ab.

Kalenderwochen

Der erste Tag der Woche in der Bundesrepublik Deutschland ist der Montag (seit 1976 nach DIN 1355, später DIN EN 28601).

Die erste Kalenderwoche ist diejenige Woche, welche den vierten Januar enthält.

Die Funktion »`VBA.DateTime.DatePart`«

Die Funktion »VBA.DateTime.DatePart« erlaubt es, die Kalenderwoche eines Datums auszudrücken. Das erste Argument muß dabei die Zeichenfolge »"ww"« sein und das zweite Argument ist eine Zeichenfolge mit dem zwischen Nummernzeichen »#« geschriebene Datum (ohne Anführungszeichen).

»VBA.DateTime.DatePart« (Dokumentation) (vereinfacht)

Function DatePart
( Interval As String, Date )

Das folgende Beispiel gibt die Kalenderwoche des 6. Januar 2052 aus.

Direktbereich

? VBA.DateTime.DatePart( "ww", #2052-01-06# )

Wie der folgenden Kalender für den Januar 2052 zeigt, ist die Ausgabe in diesem Fall auch richtig.

Januar 2052

Januar 2052

Mo Di Mi Do Fr Sa So KW

1 2 3 4 5 6 7 1
8 9 10 11 12 13 14 2
15 16 17 18 19 20 21 3
22 23 24 25 26 27 28 4
29 30 31 5

Wir werden allerdings in den nächsten Abschitten noch erfahren, daß ein einfacher Aufruf der Funktion »VBA.DateTime.DatePart« mit zwei Argumenten nicht immer das richtige Ergebnis liefert!

Der erste Tag der Woche

Die Funktion »VBA.DateTime.DatePart« nimmt als ersten Tag der Woche den Sonntag an (Fehlwert). Durch Angabe eines optionalen dritten Arguments kann aber auch ein anderer Tag für diese Rolle angegeben werden.

VBA.DateTime.DatePart (Proklamation) (überarbeitet und vereinfacht)

Function DatePart
( Interval As String,
  Date, 
  [FirstDayOfWeek As VBA.VbDayOfWeek] )

Als drittes Argument kann ein Name aus der Aufzählung »VBA.VbDayOfWeek« verwendet werden. Das folgende Beispiel zeigt, wie die Funktion so aufgerufen werden kann, daß sie den Montag als ersten Tag der Wochen ansieht.

Direktbereich

? VBA.DateTime.DatePart( "ww", #2052-01-06#, VBA.VbDayOfWeek.vbMonday )

Im Falle des 6. Januar 2052 ändert die Angabe des Montags nichts am Ergebnis der Funktion, aber bei anderen Kalenderdaten könnte sich die Angabe des Montags auf das Ergebnis auswirken.

Wir erinnern an dieser Stelle daran, daß die Voranstellung von Modulnamen in der Regel nicht nötig ist, weswegen die voranstehende Eingabe in der Regel auch kürzer erfolgen kann, wie das nächste Beispiel zeigt.

Direktbereich

? DatePart( "ww", #2052-01-06#, VBA.VbDayOfWeek.vbMonday )

Fehlwerte der Proklamation

Wir hatte mit »VBA.Math.Round« schon eine Funktion mit einem Fehlwert (»0«) kennengelernt. Im Falle jener Funktion »VBA.Math.Round« war der Fehlwert aber nicht in der Proklamation zu lesen. Er wurde in der Prosa beschrieben.

Der Fehlwert des dritten Arguments von »VBA.DateTime.DatePart« kann der Proklamation jener Funktion entnommen werden.

»VBA.DateTime.DatePart« (Proklamation) (überarbeitet und vereinfacht)

Function DatePart
( Interval As String,
  Date, 
  [FirstDayOfWeek As VBA.VbDayOfWeek = VBA.VbDayOfWeek.vbSunday] )

In der Proklamation findet man Fehlwerte optionaler Argumente of am Ende der Parameterbeschreibung, wo der Fehlwert durch ein Gleichheitszeichen »=« eingeleitet wird. Im Falle des dritten Parameters der Funktion »VBA.DateTime.DatePart« kann man der Proklamation beispielsweise entnehmen, daß der Fehlwert »VBA.VbDayOfWeek.vbSunday« ist. Das heißt, daß diese Funktion, falls beim Aufruf nichts anderes angegeben wird, davon ausgeht, daß der Sonntag der erste Tag der Woche ist.

Parameterbeschreibungen hinter eingeklammerten Parameterbeschreibungen

Um festzulegen, welche Regel zur Kalenderwoche verwendet werden soll, dient beim Aufruf der Funktion »VBA.DateTime.DatePart« ein viertes Argument, dessen Wert unter anderem der Wert «VBA.VbFirstWeekOfYear.vbFirstFullWeek», der Wert «VBA.VbFirstWeekOfYear.vbFirstFourDays» oder der Wert «VBA.VbFirstWeekOfYear.vbFirstJan1» sein kann.

Bei dieser Funktion sind alle der folgenden vier Möglichkeiten zulässig.

Die Funktion kann ohne das drittes und ohne das vierte Argument aufgerufen werden. (Dies wurde schon gezeigt.)
Die Funktion kann mit dem dritten, aber ohne das vierte Argument aufgerufen werden. (Dies wurde schon gezeigt.)
Die Funktion kann ohne das dritte, aber mit dem vierten Argument aufgerufen werden. (Wir werden erst im nächsten Abschnitt sehen, wie das geht.)
Die Funktion kann mit dem dritten und mit dem vierten Argument aufgerufen werden.

In der Dokumentation wird die Proklamation dieser Funktion wie folgt angegeben.

»VBA.DateTime.DatePart« (Objektkatalog) (überarbeitet)

Function DatePart
( Interval As String, 
  Date, 
  [FirstDayOfWeek As VbDayOfWeek = vbSunday], 
  [FirstWeekOfYear As VbFirstWeekOfYear = vbFirstJan1] )

»VBA.DateTime.DatePart« (Dokumentation) (überarbeitet)

DatePart( interval, date[, firstdayofweek[, firstweekofyear]] )

Normalerweise bedeuten eckige Klammern ja, daß das darin enthaltene auch weggelassen werden kann. Im Falle dieser Funktion ist deren Verwendung sowohl im Objektkatalog als auch in der Dokumentation aber nicht ganz korrekt! Dies liegt vermutlich daran, daß die Autoren die tatsächlichen Möglichkeiten vereinfacht darstellen mußten oder wollten.

Nach der Beschreibung im Objektkatalog müßte man die Funktion »VBA.DateTime.DatePart« eigentlich immer mit allen drei Kommas aufrufen, da sich keines der Kommas in eckigen Klammern befindet. Wir haben aber schon gesehen, daß man diese Funktion auch mit nur einem Komma aufrufen kann (»VBA.DateTime.DatePart( "ww", #2052-01-06# )«).

Nach der Beschreibung in der Dokumentation müßte man das dritte Argument eigentlich immer angeben, wenn man das vierte angeben will. Wir werden aber im nächsten Abschnitt sehen, daß man das dritte Argument auch weglassen und das vierte trotzdem angeben kann.

Auslassung eines inneren Parameters

Für das folgende Beispiel wird aber angenommen, daß der Vorgabewert „Sonntag“ als erster Tag der Woche verwendet werden soll. Das Argument für den dritten Parameter braucht also nicht angegeben zu werden. Das folgende Argument für den vierten Parameter soll dann wieder angegeben werden. Es muß dann aber erkennbar werden, daß das Argument zum vierten Parameter gehören soll, obwohl es ja nach Weglassen des dritten Argumentes nun selber an dritter Stelle steht.

Dazu kann die Stelle des dritten Parameters einfach leer gelassen werden, so daß dann dort zwei Kommas direkt hintereinander folgen. Auf diese Weise ist dann weiterhin erkennbar, daß das auf das dritte Komma folgenden Argument zum vierten Parameter gehört.

Es ist also möglich, Kommas zu verwenden, um weggelassene Argumente zu kennzeichnen, wenn nach diesen noch weitere Argumente folgen sollen.

Angabe des vierten Argumentes durch leeres drittes Argument

? DatePart( "ww", #2052-01-06#,, vbFirstFourDays )

? DatePart( "ww", #2052-01-06#,, vbFirstFullWeek )

Ein Argumentliste darf allerdings nicht mit einem Komma enden.

Wir können die Syntax des Aufrufs daher folgendermaßen beschreiben:

»VBA.DateTime.DatePart« (Syntaxdiagramm)

    .----------.     .-.     .------.
--->| Interval |--->( , )--->| Date |---.
    '----------'     '-'     '------'   |
                                        |
                                        |
.---------------------------------------'
|
|
|
'--->.----------------------------------------------------------------------------.--->
     |                                                                            ^
     |     .-.          .----------------.                                        |
     '--->( , )--->.--->| FirstDayOfWeek |--->.---------------------------------->'
           '-'     |    '----------------'    |                                   |
                   |                          V     .-.     .-----------------.   |
                   '------------------------->'--->( , )--->| FirstWeekOfYear |---'
                                                    '-'     '-----------------'

Diese komplexe Syntax kann vermutlich nicht einfach nur durch Verwendung eckiger Klammern dargestellt werden.

Verwendung von Parameternamen

Das Argument zu einem Parameter kann auch mit dem Namen jenes Parameters benannte werden, um es jenem Parameter zuzuordnen. Das folgende Beispiel verwendet eine Mischform, in der die Parameter der ersten beiden Argument durch ihre Position bestimmt sind und der Parameter des letzten Arguments durch Angabe des Namens bestimmt ist.

Angabe des vierten Argumentes durch Benennung

? DatePart( "ww", #2002-01-06#, Firstweekofyear := vbFirstFullWeek )

Hinter einem benannten Parameter kann kein unbenannter Parameter mehr angegeben werden.

Es können auch alle Argumentausdrücke benannt werden. Dann ist ihre Reihenfolge ganz ohne Bedeutung.

Benennung aller Argumente

? DatePart( Interval := "ww", Date := #2002-01-06#, Firstweekofyear := vbFirstFullWeek )

? DatePart( Date := #2002-01-06#, Firstweekofyear := vbFirstFullWeek, Interval := "ww" )

In Aufrufen von Funktionen mit mehreren Parametern, verbessern Parameternamen die Lesbarkeit (Verständlich des Quelltextes des Aufrufs).

»`VBA.DateTime.DatePart`« in der Bundesrepublik

Die Situation der Bundesrepublik Deutschland im Jahre 2019 wird durch die folgenden beiden Parameterfestlegungen beschrieben.

Einstellungen für die Bundesrepublik Deutschland des Jahres 2017

FirstDayOfWeek := VBA.VbDayOfWeek.vbMonday

FirstWeekOfYear := VBA.vbFirstWeekOfYear.vbFirstFourDays

Beispiel zur Berechnung einer Kalenderwoche für die Bundesrepublik Deutschland des Jahres 2017

? DatePart _
  ( _
    Interval        := "ww", _
    Date            := #2017-06-15#, _
    FirstDayOfWeek  := VBA.VbDayOfWeek.vbMonday, _
    FirstWeekOfYear := VBA.vbFirstWeekOfYear.vbFirstFourDays )

Optionale Parameter vor obligatorischen Parametern

Die Funktion »VBA.Strings.InStr« erlaubt es, die Position einer Zeichenfolge in einer anderen Zeichenfolge zu ermitteln.

Die Funktion »VBA.Strings.Instr«

? VBA.Strings.Instr( "xyaxyaxya", "a" )

Der Rückgabewert »3« bei der Funktion »VBA.Strings.InStr« bedeutet, daß das zweite Argument an der Position »3« im ersten Argument gefunden wurde. Tatsächlich befindet sich das erste »a« bei Position »3«. Um auch die Position des zweiten »a« zu finden, kann am Anfang der Argumentliste noch ein numerischer Ausdruck angegeben werden, der die Position angibt, ab der gesucht werden soll.

Die Funktion »VBA.Strings.Instr«

? VBA.Strings.Instr( 4, "xyaxyaxya", "a" )

Nun gibt die Funktion die Position des zweiten »a«, also »6«, zurück.

Normalerweise sollten optionale Parameter den obligatorischen Parametern folgen, denn wenn Argumente am Anfang einer Argumentliste weggelassen werden könnten, dann wäre es nicht immer erkennbar, zu welchen Parametern die folgenden Argumente gehören sollen.

Bei der Funktion »VBA.Strings.Instr« kann aber ein führendes Argument weggelassen werden. Solche Funktionen sind selten, und vielleicht dem Bemühen um Kompatibilität mit älteren BASIC -Versionen zu verdanken. Die Funktion »VBA.Strings.Instr« hat darüberhinaus auch noch einen weiteren optionalen Parameter am Ende, also insgesamt vier Parameter.

Wir wollen hier diverse Details solcher Funktionen nicht zu ausführlich behandeln. Der interessierte Leser kann bei Bedarf selber die Dokumentation und die Beschreibung im Objektkatalog zu jener Funktion lesen und verschiedene mögliche Aufrufe ausprobieren.

Zur Vermeidung von Mißverständnissen bietet es sich bei solchen Funktionen besonders an, benannte Argumente zu verwenden oder alle vier möglichen Argumente anzugeben.

Fehler in »`VBA.DateTime.DatePart`«

Die Funktion »VBA.DateTime.DatePart« liefert laut einigen Quellen für einige Kalenderdaten, wie 1975-12-29, 2003-12-29, 2031-12-29, 2059-12-29 und so weiter (alle 28 Jahre) den falschen Wert »53«, wo er »1« sein sollte (aber vielleicht nur bei Verwendung von »vbSunday«?). Trotzdem wurde sie hier behandelt, da sie als Beispiel für optionale Argumente gut geeignet ist.

2059

January

Su Mo Tu We Th Fr Sa KW

29 30 31 1 2 3 4 1

5 6 7 8 9 10 11 2

12 13 14 15 16 17 18 3

19 20 21 22 23 24 25 4

26 27 28 29 30 31 01 5

Konsole

? VBA.DateTime.DatePart( "ww", #2059-12-30#, vbSunday, vbFirstFourDays )

Um wirklich Kalenderwochen zu berechnen, sollte die Funktion »VBA.DateTime.DatePart« wegen ihrer Fehler mit Vorsicht verwendet werden. Als Alternative kommt beispielsweise eine vom Programmierer definierte Funktion zur Berechnung von Kalenderwochen in Frage. Vom Programmierer definierte Funktionen werden wir aber erst später behandeln.

Neue erweiterte Syntax

Die neue erweiterte Syntax drückt nun noch die Möglichkeit aus, zwischen Argumentangaben in bestimmten Fällen mehrere Kommas zu schreiben.

Aufrufausdruck (Syntaxdiagramm)

anonyme Liste
          .----------.      
---.----->| Ausdruck |---.--->
   ^      '----------'   |   
   |        .-.          |   
   '---.---( , )<---.----'   
       |    '-'     ^ 
       |            |
       '------------'
benannte Liste
        .------------.     .-.      .-.     .----------.
---.--->| Bezeichner |--->( : )--->( = )--->| Ausdruck |---.--->
   ^    '------------'     '-'      '-'     '----------'   |
   |                           .-.                         |
   '--------------------------( , )<-----------------------' 
                               '-'
Ausdruckliste
   .-------------------------------------------------------------------------------.
   |                                                                               |
   |                            .----------------------------------------------.   |
   |                            |                                              |   |
   |        .---------------.   |         .-.             .----------------.   v   v
---'---.--->| anonyme Liste |---'---.--->( , )---.---.--->| benannte Liste |---'---'--->
       |    '---------------'       ^     '-'    |   ^    '----------------' 
       |                            |            |   |
       |                            '------------'   |
       |                                             |
       '---------------------------------------------'

Ausdruck
    .-------.     .-.     .---------------.     .-.    
--->| Name  |--->( ( )--->| Ausdruckliste |--->( ) )--->
    '-------'     '-'     '---------------'     '-'

Übungsaufgaben

/ Übungsaufgabe

Ermitteln Sie die aktuelle Kalenderwoche einmal mit VBA und einmal mit Hilfe einer anderen Quelle.

DatePart (Proklamation)

Function DatePart
( Interval As String, 
  Date, 
  [FirstDayOfWeek As VbDayOfWeek = vbSunday], 
  [FirstWeekOfYear As VbFirstWeekOfYear = vbFirstJan1] )

Element von VBA.DateTime

Für den Parameter »Interval« kann »ww« zur Ermittlung der Kalenderwochen angegeben werden.

Für den Parameter »Date« kann ein Datum mit einer Schreibweise wie »#2048-12-10#« (ohne zusätzliche Anführungszeichen) angegeben werden.

Für den Parameter »FirstDayOfWeek« soll unter den folgenden Namen der richtige ausgesucht und angegeben werden.

Parameter »FirstDayOfWeek«: »VBA.VbDayOfWeek.vbSunday« Erster Tag der Woche ist Sonntag (Fehlwert); »VBA.VbDayOfWeek.vbMonday« Erster Tag der Woche ist Montag; »VBA.VbDayOfWeek.vbTuesday« Erster Tag der Woche ist Dienstag; »VBA.VbDayOfWeek.vbWednesday« Erster Tag der Woche ist Mittwoch; »VBA.VbDayOfWeek.vbThursday« Erster Tag der Woche ist Donnerstag; »VBA.VbDayOfWeek.vbFriday« Erster Tag der Woche ist Freitag; »VBA.VbDayOfWeek.vbSaturday« Erster Tag der Woche ist Sonnabend; »VBA.VbDayOfWeek.vbUseSystem« Systemeinstellungen für den ersten Tag der Woche verwenden

Für den Parameter »FirstWeekOfYear« soll unter den folgenden Namen der richtige ausgesucht und angegeben werden.

Parameter »FirstWeekOfYear«: »vbFirstJan1« Jahr beginnt mit Woche mit erstem Januar (Fehlwert); »vbFirstFourDays« Jahr beginnt mit Woche mit mindestens vier Tagen im neuen Jahr; »vbFirstFullWeek« Jahr beginnt mit erster voller Woche im Jahr; »vbUseSystem« Systemeinstellungen für die Regel verwenden

Parameterlisten mit Fehloptionen in VBA

Optionen

Eckige Klammern

Parameterlisten mit Optionen

Parameterlisten mit Optionen bei zwei Parametern

Fehlwerte der Prosa

Kennzahlen

Kalenderwochen

Die Funktion »VBA.DateTime.DatePart«

Der erste Tag der Woche

Fehlwerte der Proklamation

Parameterbeschreibungen hinter eingeklammerten Parameterbeschreibungen

Auslassung eines inneren Parameters

Verwendung von Parameternamen

»VBA.DateTime.DatePart« in der Bundesrepublik

Optionale Parameter vor obligatorischen Parametern

Fehler in »VBA.DateTime.DatePart«

Neue erweiterte Syntax

Übungsaufgaben

/ Übungsaufgabe

Die Funktion »`VBA.DateTime.DatePart`«

»`VBA.DateTime.DatePart`« in der Bundesrepublik

Fehler in »`VBA.DateTime.DatePart`«