Mehrere Parameter in JavaScript

Einleitendes Beispiel

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

Die folgende Auswertung zeigt die Berechnung des Produkts ‹ 2 × 5 › (gesprochen: „Zwei hoch Fünf“) mit einem Operator.

Auswertung

2 * 5

Genauso gibt es auch binäre Funktionen, welche zwei Argumente akzeptieren.

Die folgende Auswertung zeigt die Berechnung der Potzenz ‹ 2⁵ › mit einer Funktion.

Auswertung

Math.imul( 2, 5 )

Die Funktion ≫Math.imul≪ akzeptiert zwei Argumente: der Wert eines Aufrufes jener Funktion ist dann der Wert der des Produktes mit den Werten der beiden Argumente als Faktoren.

Wie man sieht, ist es eine mehr oberflächliche Unterscheidung, ob eine Operation (ein Rechenschritt) nun mit einer Funktion oder mit einem Operator geschrieben wird

≫Math.imul( 2, 5 )≪ auf deutsch

„der Wert des Aufrufs der Funktion ≫Math.imul≪ mit den Argumentausdrücken »2« und »5«“,
„≫Math.imul≪ von »2« und »5«“ oder
„Zwei mal Fünf“

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

Syntax

Das folgende Syntaxdiagramm für Aufrufausdrücke ist nun gegenüber einer frühere Version erweitert, um die Möglichkeit mehrerer durch ein Komma getrennter Argumente darzustellen.

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, vereinfacht)

Aufrufausdruck (Ecma 262 2015, 12.3.4)
       .------------------.    .----------------.
   --->| Eintragsausdruck |--->| Argumentangabe |--->
       '------------------'    '----------------'
Argumentangabe (Ecma 262 2015, 12.3)
         .-.                            .-.    
---.--->( ( )------------------------->( ) )---.--->
   |     '-'                            '-'    ^
   |     .-.     .----------------.     .-.    |
   '--->( ( )--->| Ausdruckliste  |--->( ) )---'
         '-'     '----------------'     '-'
Ausdruckliste  (Ecma 262 2015, 12.3)
        .----------------.
---.--->| Ausdruck       |---.--->
   ^    '----------------'   |
   |           .-.           |
   '----------( , )<---------'
               '-'

Ausdruckliste (Beispiel)

2, 5

Aufrufausdruck (Beispiel)

Math.imul( 2, 5 )

Eine in den Argumentklammern eines Funktionsnaufrufs verwendete Ausdruckliste wird auch Argumentliste genannt.

Eine parametrisierte Funktion ist eine Funktion mit mindestens einem Para̲meter. Eine Funktion ohne Parameter nennen wir auch parameterlos.

Semantik

Bei der Auswertung eines Aufrufausdrucks werden zuerst alle Argumentausdrücke ausgewertet.

Anschließend wird die durch den Funktionsnnamen 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 Operation [Programm] gestartet), diese Ausführung der Inkarnation wird hier auch Funktionsoperation genannt.

Die Reihenfolge der Argument kann im allgemeinen eine Rolle spielen. Die Funktion ≫Math.pow≪ potenziert beispielsweise den Wert des ersten Arguments mit dem Wert des zweiten Arguments.

Auswertung

Math.pow( 2, 5 )

Auswertung

Math.pow( 5, 2 )

Dokumentation

Dieser Abschnitt stellt die Dokumentation der Funktion ≫Math.pow≪ als Beispiel der Dokumentation einer Funktion mit mehreren Parametern vor. Mehrere Parameter werden in der Dokumentation in den runden Klammern jeweils durch ein Komma getrennt.

ECMAScript 2016 (20.2.2.26, vereinfacht und übersetzt)

Math.pow( base, exponent )

Ergibt die Potenzierung von »base« mit »exponent«.

Die voranstehende Dokumentation stellt klar, daß zwei Argumente erwartet werden und daß ein Ergebnis geliefert wird.

In der Dokumentation finden sich die Parameter in den runden Klammern hinter dem Funktionsnamen aufgelistet, diese Liste der Parameter wird auch Parameterliste genannt.

Parameterliste (Beispiel)

base, exponent

Es sind nicht nur Funktionen mit bis zu zwei Parametern möglich, vielmehr können Funktionen beliebig viele Parameter haben. 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 ≫Math.pow( 2, 3 )≪ legt beispielsweise den Wert »2« für den Parameter »base« und den Wert »3« für den Parameter »exponent« fest. Dementsprechend bedeutete dieser Aufruf dann „»2« hoch »3«“.

Dokumentation der Semantik

Die Dokumentation einer Funktion beschreibt auch, wie der Wert des Aufrufs einer Funktion 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 ≫Math.pow≪ wird die Semantik beispielsweise durch den Text „Ergibt die Potenzierung von »base« mit »exponent«.“ (durch die Prosa ) aus ihrer Dokumentation bekannt gemacht.

Funktionen als Verzeichnisse

Funktionen sind auch Verzeichnisse, das heißt: sie enthalten Einträge, die man mit einem Punkt ».« ausdrücken kann.

Der Eintrag »length« einer Funktion gibt – etwas vereinfacht gesagt – an, wie viele Parameter sie hat.

Auswertung

Math.random.length

Auswertung

Math.abs.length

Auswertung

Math.pow.length

Zur Verträglichkeit von Parameterliste und Argumentwerten

Wenn ein Funktion mehrere Parameter hat, so sollten immer so viele Argumente wie Parameter angegeben werden.

Welcher Wert sich ergibt, falls weniger Argumentwerte übergeben werden als Parameter vorhanden sind, hängt von der jeweiligen Funktion ab und muß dann ihrer Dokumentation entnommen werden.

Als Wert eines fehlenden Argumentes kann dabei oft »undefined« angenommen werden (dies ist aber nicht immer so). Daher ist ≫Math.pow( 2 )≪ beispielsweise gleich ≫Math.pow( 2, undefined )≪.

Im Falle dieses Funktion wird das Verfahren „ToNumber“ verwendet, um die Argumentwerte in Zahlen zu wandeln. Dieses Verfahren ersetzt ≪undefined≫ dann durch ≪NaN≫. Schließlich wurde für diese Funktion festgelegt, daß eine Potenzierung mit dem Exponenten ≪NaN≫ immer den Wert ≪NaN≫ ergibt.

Auswertung

Math.pow( 2 )

NaN

Math.pow( 2, undefined )

NaN

Math.pow( 2, NaN )

NaN

Falls mehr Argumente angegeben werden als Parameter vorhanden sind, so werden die überzähligen Argumente in der Regel ignoriert.

Auswertung

Math.pow( 2, 5, 9 )

Ausdrücke (Zusammenfassung)

Ein Ausdruck ist

ein Literal,
ein Name,
eine Operatorausdruck oder
ein 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.: Math
| (Name eines Verzeichnisses)
|
.------------------'------------------.
| |
| |
Aufruf Aufruf
ohne Argumentausdruecke mit Argumentausdruecken
(einfacher Ausdruck), (komplexer Ausdruck),
z.B.: f() z.B.: f( 2 )

Übersicht

In der folgenden Übersicht steht »this« für das globale Verzeichnis.

Übersicht der Namen

Name Art Bedeutung

this.Infinity Zahl Unendlich
this.Math.PI Zahl die Kreiszahl Pi
this.Math.abs Funktion Betrag
this.Math.floor Funktion Boden
this.Math.isNaN Funktion "ist NaN"
this.Math.parseFloat Funktion Zahl eines Textes
this.Math.pow Funktion Potenzieren
this.Math.random Funktion Zufallszahl
this.Math.sin Funktion Sinus
this.Math.sqrt Funktion Quadratwurzel
this.undefined Wert "kein Wert"
this.NaN Zahl "keine Zahl"

Übungsfragen

? Verständnis von Fachbegriffen

Zu einer (hypothetischen) Funktion mit zwei Parametern und dem Namen »k« wird erklärt: „Der Wert eines Aufrufs 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 ))«?

? Dokumentation verstehen

ECMAScript 2015 (20.2.2.26, vereinfacht und übersetzt)

Math.hypot( x, y )

Ergibt √(x² + y²).

Wie viele Parameter hat die Funktion ≫Math.hypot≪?
Welche Namen haben die Parameter dieser Funktion?
Kann sich der Wert eines Aufrufs dieser Funktion mit zwei Argumenten ändern, wenn die beiden Argumente vertauscht werden?

Übungsaufgaben

/ Ausgabe eines Ergebnisses

Schreiben Sie einen Aufruf der Funktion ≫Math.hypot≪. Verwenden Sie darin Argumentwerte, die es Ihnen erlauben, das richtige Ergebnis auch im Kopf auszurechnen, um dann sehen zu können, ob die Funktion auch tatsächlich das in der Dokumentation beschriebene Ergebnis liefert.

Funktionen als Werte ⃗

Wir kennen jetzt zwei verschiedene Arten von Verzeichnissen: Solche, deren Typ »object« ist, und solche, deren Typ »function« ist. Beide sind Werte.

Wir geben im folgenden die behandelten Arten von Metawerten wieder.

Arten von Werten: Metawerte
- uneigentliche Werte (»undefined«)
- eigentliche Werte (nicht »undefined«)
- Fundamentalwerte (keine Verzeichnisse)
- Metazahlen (Typ »number«)
- uneigentliche Zahlen (»NaN«)
- eigentliche Zahlen (»isNaN« ergibt »false«)
- Zeichenfolgen (Typ »string«)
- Wahrheitswerte (Typ »boolean«)
- Verzeichnisse (können Einträge enthalten)
- Verzeichnisse vom Typ »object«
- Verzeichnisse vom Typ »function«

Syntax der Parameterliste *

Parameterliste

Parameterliste
    .-----------------------------.
    |                             |
    |        .------------.       v
----'---.--->| Bezeichner |---.---'--->
        ^    '------------'   |
        |          .-.        |
        '---------( , )<------'
                   '-'

Aktualisierte Syntax von Ausdrücken *

Neue, erweiterte Syntax

Ausdruck
                      .------------------.
---.----------------->| Primaerausdruck  |-------------------------------.---->
   |                  '------------------'                               ^
   |                  .------------------.                               |
   '----------------->| Eintragsausdruck |-------------------------------'
   |                  '------------------'                               |
   |                  .------------------.                               |
   '----------------->| Aufrufausdruck   |-------------------------------'
   |                  '------------------'                               |
   |          .-.     .------------------.                               |
   '-------->( - )--->| Ausdruck         |-------------------------------'
   |          '-'     '------------------'                               |
   |          .-.     .------------------.                               |
   '-------->( + )--->| Ausdruck         |-------------------------------'
   |          '-'     '------------------'                               |
   |     .------.     .------------------.                               |
   '--->( typeof )--->| Ausdruck         |-------------------------------'
   |     '------'     '------------------'                               |
   |                  .------------------.     .---.     .----------.    |
   '----------------->| Ausdruck         |--->(  *  )--->| Ausdruck |----'
   |                  '------------------'     '---'     '----------'    |
   |                  .------------------.     .---.     .----------.    |
   '----------------->| Ausdruck         |--->(  /  )--->| Ausdruck |----'
   |                  '------------------'     '---'     '----------'    |
   |                  .------------------.     .---.     .----------.    |
   '----------------->| Ausdruck         |--->(  +  )--->| Ausdruck |----'
   |                  '------------------'     '---'     '----------'    |
   |                  .------------------.     .---.     .----------.    |
   '----------------->| Ausdruck         |--->(  -  )--->| Ausdruck |----'
   |                  '------------------'     '---'     '----------'    |
   |                  .------------------.     .---.     .----------.    |
   '----------------->| Ausdruck         |--->( in  )--->| Ausdruck |----'
   |                  '------------------'     '---'     '----------'    |
   |                  .------------------.     .---.     .----------.    |
   '----------------->| Ausdruck         |--->( === )--->| Ausdruck |----'
                      '------------------'     '---'     '----------'
Eintragsausdruck
    .------------------. 
--->| Primaerausdruck  |--->
    '------------------'
Eintragsausdruck
    .------------------.    .-.     .----------------. 
--->| Eintragsausdruck |-->( . )--->| Bezeichnername |--->
    '------------------'    '-'     '----------------'
Primaerausdruck
                    .----.      
---.-------------->( this )--------------.--->
   |                '----'               ^
   |            .------------.           |
   '----------->| Bezeichner |-----------'
   |            '------------'           |
   |             .---------.             |
   '------------>| Literal |-------------'
   |             '---------'             |
   |     .-.     .----------.     .-.    |
   '--->( ( )--->| Ausdruck |--->( ) )---'
         '-'     '----------'     '-'
Aufrufausdruck
       .------------------.    .----------------.
   --->| Eintragsausdruck |--->| Argumentangabe |--->
       '------------------'    '----------------'
Argumentangabe
         .-.                            .-.    
---.--->( ( )------------------------->( ) )---.--->
   |     '-'                            '-'    ^
   |     .-.     .----------------.     .-.    |
   '--->( ( )--->| Ausdruckliste  |--->( ) )---'
         '-'     '----------------'     '-'
Ausdruckliste
        .----------------.
---.--->| Ausdruck       |---.--->
   ^    '----------------'   |
   |           .-.           |
   '----------( , )<---------'
               '-'