Mehrere Parameter in VBA 

Einleitendes Beispiel

Neben den unären  Operatoren (wie Vorzeichen) gibt es ja auch binäre  Operatoren, welche zwei  Operanden akzeptieren. Genauso gibt es auch binäre Funktionen, welche zwei Argumente  akzeptieren.

Mit der folgenden Eingabe werden die fünf  ersten Zeichen der Zeichenfolge »abcdefghijklmnopqrstuvwxyz« ermittelt.

Direktbereich

? VBA.Strings.Left$( "abcdefghijklmnopqrstuvwxyz", 5 )

abcde

»VBA.Strings.Left$«

Die Funktion »VBA.Strings.Left$« ergibt so viele Zeichen vom ersten Argumentwert, wie durch den zweiten Argumentwert angegeben werden. Der erste Argumentwert ist also ein Text, während der zweite eine Zahl ist. Es ergibt sich also zunächst folgende Dokumentation mit zwei  Parameterbeschreibungen.

Left (Objektkatalog) (vereinfacht)

Function Left$( Text As String, Length As Integer )As String
    Element von VBA.Strings

Wir werden im folgenden die Syntax  solcher Parameterlisten  etwas detaillierter beschreiben.

Typangaben

Unter einer „Typangabe“ verstehen wir eine der lexikalischen Einheiten »Integer«, »Double« oder »String«.

Typangabe (Syntaxdiagramm)

Typangabe
           .-------.
-----.--->( Integer )---.--->
     |     '-------'    ^
     |     .------.     |
     '--->( Double )----'
     |     '------'     |
     |     .------.     |
     '--->( String )----'
           '------'

Parameterbeschreibung

In der Dokumentation von Funktionen findet man Beschreibungen von Parameter. In der folgenden Dokumentation der Funktion »Left$« finden sich beispielsweise zwei Parameterbeschreibungen, nämlich »Text As String« und »Length As Integer«.

Left (Objektkatalog) (vereinfacht)

Function Left$( Text As String, Length As Integer ) As String

Unter einer Parameterbeschreibung  verstehen wir einen Bezeichner, dem noch eine Typangabe folgen kann. Beispielsweise ist »Text As String« eine Parameterbeschreibungen, aber auch schon »Text« alleine wäre eine Parameterbeschreibung.

Parameterbeschreibung

Parameterbeschreibung
                     .------------------------.
    .------------.   |     .--.     .-----.   v
--->| Bezeichner |---'--->( As )--->| Typ |---'--->
    '------------'         '--'     '-----'

Parameterlisten

In der folgenden Dokumentation der Funktion »VBA.String.Left$« finden sich die Parameterliste »Text As String, Length As Integer«.

Left (Objektkatalog) (vereinfacht)

Function Left$( Text As String, Length As Integer ) As String

Als Parameterliste  bezeichnen wir eine kommagetrennte Liste  von Parameterbeschreibungen,

Parameterliste

Parameterliste
   .----------------------------------------.
   |                                        |
   |        .-----------------------.       V
---'---.--->| Parameterbeschreibung |---.---'--->
       ^    '-----------------------'   |
       |               .-.              |
       '--------------( , )-------------'
                       '-'

Parameterliste (Beispiel)

Text As String, Length As Integer

Es sind nicht nur Funktionen mit bis zu zwei  Parametern möglich, vielmehr können Funktionen beliebig viele  Parameter haben.

Parameter und Argumente

Beim Schreiben des Aufrufs der Funktion müssen genau so viele  Argumente angegeben werden wie Parameter in der Dokumentation stehen.

Die Zuordnung der Argumentwerte zu den Parametern erfolgt über deren gemeinsame Reihenfolge : Das erste  Argument wird dem ersten  Parameter zugeordnet, das zweite  dem zweiten  Parameter und so weiter. Bei der Inkarnation der Funktion wird dann der Wert jedes Parameters durch den Wert des entsprechenden Argumentausdrucks festgelegt. Der Aufruf »VBA.Strings.Left$( "abcdefghij", 5 )« legt beispielsweise den Wert »"abcdefghij"« für den Parameter »Text« und den Wert »5« für den Parameter »Length« fest.

Dokumentation der Semantik

Die Dokumentation einer Funktion beschreibt auch, wie der Wert des Aufrufs einer festgelegt wird. Sie gibt also die Semantik eines Aufrufs dieser Funktion an. Der Wert des Aufrufs einer Funktion hängt oft von den Werten der Argumente ab und manchmal auch von anderen Umständen. Die Dokumentation beschreibt, wie  der Wert des Aufrufs der Funktion von den Werten der Argumente und von anderen Umständen abhängt.

Im Falle der Funktion »VBA.Strings.Left$« wird die Semantik beispielsweise durch den Text „Gibt einen Wert vom Typ String zurück, der eine bestimmte Anzahl von … [u.s.w]“ (gekürzt) aus ihrer Dokumentation bekannt gemacht.

Syntax

Das folgende Syntaxdiagramm für Aufrufe stellt die Möglichkeit mehrerer durch ein Komma getrennter Argumente dar.

Mehrere Argumente werden als Ausdruckliste in die runden Aufrufklammern geschrieben und durch ein Komma getrennt. Dieses Komma stellt eine lexikalische Einheit dar, wie man auch dem folgenden Syntaxdiagramm entnehmen kann.

Aufrufausdruck (Syntaxdiagramm)

Ausdruckliste
   .---------------------------.            
   |        .----------.       v
---'---.--->| Ausdruck |---.---'--->
       ^    '----------'   |
       |        .-.        |
       '-------( , )<------'
                '-'
Ausdruck
    .-------.     .-.     .---------------.     .-.    
--->| Name  |--->( ( )--->| Ausdruckliste |--->( ) )--->
    '-------'     '-'     '---------------'     '-'

Ausdruckliste (Beispiel)

"abcdefghijklmnopqrstuvwxyz", 5

Aufrufausdruck (Beispiel)

VBA.Strings.Left$( "abcdefghijklmnopqrstuvwxyz", 5 )

Semantik

Bei der Auswertung eines Aufrufausdrucks werden zuerst alle Argumentausdrücke von links nach rechts ausgewertet. Anschließend wird die durch den Funktionsnamen angegebenen Funktion mit den im vorigen Schritt ermittelten Werten der Argumente verbunden. Solch eine Verbindung einer Funktion mit konkreten Argumentwerten  zur Laufzeit (nicht bloß mit den Argumentausdrücken ) wird auch eine Inkarnation  (der Funktion) genannt, genauso wird auch die Herstellung dieser Verbindung genannt. Die Inkarnation wird dann ausgeführt (also als Programm gestartet), diese Ausführung der Inkarnation wird hier auch Funktionsoperation  genannt.

Aussprache

Im allgemeinen spricht man »f(x,y)« als „f von x und y.“.

Typregeln

Der Typ des Aufrufs einer Funktion steht – wie schon früher behandelt – in der Dokumentation vor dem Namen der Funktion.

Damit eine Argumentliste mit einer Parameterliste verträglich ist, müssen die beisen Listen gleich viele Einträge haben und die Typen der Argumente müssen mit den Typen der jeweiligen Parameter verträglich sein (so wie dies bei einem Aufruf mit einem Argument schon behandelt wurde).

Im Aufruf »VBA.Strings.Left$( "abcdefghij", 5 )« wird beispielsweise das Argument »"abcdefghij"« zur Festlegung des Wertes des Parameters »Text« verwendet. Der Parameter »Text« hat den Typ »String«. Daher muß der Argumenttyp nun so mit dem Parametertyp verträglich sein, wie dies zuvor schon bei der Behandlung von Funktionen mit einem  Parameter erklärt wurde. Der Datentyp des Arguments »"abcdefghij"« ist »String«, der Datentyp des Paramters »Text« ist ebenfalls »String«. Für den zweiten Parameter gilt Entsprechendes. Daher erfüllt der Aufrufausdruck »VBA.Strings.Left$( "abcdefghij", 5 )« die dokumentierten Typanforderungen der Funktion.

Ausdrücke (Zusammenfassung)

Ein Ausdruck ist

• ein Literal,
• ein Name,
• eine Operatorausdruck oder
• ein Aufruf (Funktionsaufruf).

Begriffshierarchie der Ausdrücke

                                                           Ausdruck
                                                              |
                                                              |
           .--------------------------:-------------------------------------.-------------------------------------.
           |                          |                                     |                                     |
        Literal                Operatorausdruck                           Aufruf                                Name
 (einfacher Ausdruck),       (komplexer Ausdruck),                          |                            (einfacher Ausdruck)
 z.B.: 65 oder "abc"         z.B.: -65 oder 2 + 3        .------------------'------------------.               z.B.: x
                                                         |                                     |
                                                       Aufruf                                Aufruf
                                              ohne Argumentausdruecke                 mit Argumentausdruecken
                                                (einfacher Ausdruck),                  (komplexer Ausdruck),
                                                     z.B.: f()                             z.B.: f( x ) 

Übungsfragen

?   Verständnis von Fachbegriffen

Zu einer (hypothetischen) binären Funktion »k« wird erklärt: „Der Wert von »k« ist der Wert des ersten Arguments.“. Welchen Wert hat demnach »k( 3, 2 )«? Welchen Wert hat »k( k( 5, 1 ), k( 4, 9 ))«?

?   Reihenfolge von Operationen

In welcher Reihenfolge werden die vier Operationen (Funktionen oder Operatoren) bei der Auswertung des folgenden Ausdrucks ausgeführt?

Ausdruck

VBA.Strings.Left$( VBA.Strings.UCase$( "abcdef" ), VBA.Math.Sqr( 2 + 2 ))

?   Verträglichkeit von Parameterlisten und Argumentlisten

Welche der folgenden Paare von Parameterlisten und Argumentlisten sind verträglich?

(Das heißt: Welche der folgenden Argumentlisten sind beim Aufruf einer Funktion möglich, deren Dokumentation die darüberstehende Parameterliste hat?)

Paar 0

Parameterliste

A As Integer, X As Double

Argumentliste

2, 3

Paar 1

Parameterliste

A As Integer, X As String

Argumentliste

2, "3", 3

Paar 2

Parameterliste

A As Integer, X As Double, C As Integer

Argumentliste

2, "double", 2

?   Dokumentation verstehen

Dokumentation von »VBA.Math.Round« (vereinfacht)

Function Round( Number as Double, Digits As Integer ) As Double

Element von VBA.Math

Rundet auf Digits  Nachkommastellen.

Die folgenden Frage sollen an Hand der obenstehenden Dokumentation beantwortet werden:

• Wie viele Parameter hat die Funktion »VBA.Math.Round«?
• Welche Namen haben die Parameter der Funktion »VBA.Math.Round«?
• Welche Typen haben die Parameter der Funktion »VBA.Math.Round«?
• Welchen Typ hat ein Aufruf der Funktion »VBA.Math.Round«?
• Ändert sich der Wert eines Aufrufs der Funktion »VBA.Math.Round« im allgemeinen, wenn die Argumente vertauscht werden?

Übungsaufgaben

/   Ausgabe eines Ergebnisses

Schreiben Sie eine VBA-Eingabe, welche das Ergebnis eines Aufrufs der Funktion »VBA.Math.Round« ausgibt. Ist das Ergebnis mit der Dokumentation verträglich?

Reserveaufgaben

/   Ermittlung der Hypotenuse zweier Katheten

Schreiben Sie eine VBA-Eingabe, welch mit der Funktion »VBA.Strings.Right$« die fünf am weitesten rechts stehenden Zeichen aus der Zeichenfolge »abcdefg« ausgibt.

/   Ermittlung des RGB-Wertes dreier Werte

Schreiben Sie eine VBA-Eingabe, welche mit der Funktion »VBA.Information.RGB« den RGB-Wert für die Werte 1, 2 und 3 ausgibt. (Die genaue Bedeutung dieses Wertes ist bei dieser Aufgabe nicht wichtig, es geht nur darum, den Aufruf korrekt zu schreiben.)