Funktionsaufrufe in JavaScript
Einführendes Beispiel
Die folgende Auswertung ergibt eine mehr oder weniger zufällig ausgewählte Zahl (möglicherweise mit Nachkommastellen) zwischen 0 (einschließlich) und 1 (ausschließlich) aus.
- Auswertung
Math.random()
0.5630878568955987
(Eine mögliche Aussprache von “math random ” ist /ˈmæθ.ˈræn.dm/.)
Bei der Auswertung des Ausdrucks ≫Math.random()≪ wird das Programm ≫Math.random≪ gestartet. Dieses legt für den Aufrufausdruck ≫Math.random()≪ dann einen Wert zwischen 0 und 1 fest.
Genauer gesagt: Der Wert des Aufrufausdrucks ≫Math.random()≪ ist ein number-Wert, der bei jeder seiner Auswertungen zwischen 0 (einschließlich) und meist einem Wert wie ‹ 1−2⁻⁵³ › (also 0,99999999999999988897769753748434595763683319091796875) (einschließlich) liegt; man sagt auch, er liege zwischen 0 (einschließlich) und 1 (ausschließlich). Mehrere Auswertungen ergeben mehr oder weniger zufällige Werte, die gleichmäßig über diesen Bereich verteilt sind, die sogenannten Pseudozufallszahlen.
Die Schreibweise von Aufrufen
Wir führen in dieser Lektion eine neue Art von Ausdruck ein, den Aufruf. Ein Aufruf besteht aus einem Eintragsausdruck (dem Funktionsausdruck), dem ein Paar rundern Klammern »(« »)« folgt. Beispielsweise ist ≫Math.random()≪ ein Aufruf mit dem Funktionsausdruck ≫Math.random≪ und einem folgenden Paar runder Klammern »()«.
- Syntax eines Aufrufs (ECMAScript 2016, 12.3.4; 11.9)
Ausdruck
.------------------. .-. .-.
--->| Eintragsausdruck |--->· ( ·-->· ) ·-->
'------------------' '-' '-'
Es handelt sich hierbei um mindestens drei lexikalischen Einheiten: die lexikalischen Einheiten des Funktionsausdrucks, eine runde Klammer auf »(« und eine runde Klammer zu »)«.
Im Falle dieser hier neu vorgestellten Schreibweise nennen wir die runden Klammern auch Aufrufklammern und den damit geschrieben Ausdruck einen Aufrufausdruck.
Die Aussprache von Aufrufen
Den Aufrufoperator »()« kann als „Aufruf “ gesprochen werden, »random()« also beispielsweise als „random-Aufruf “.
Da »random« eine andere Bedeutung hat als »random()«, sollten beide nicht gleich ausgesprochen werden!
Funktionsnamen
Der eben neu eingeführte Aufrufausdruck beginnt mit einem Eintragsausdruck, allerdings sind nur bestimmte Eintragsausdrücke erlaubt. Wir zeigen hier zunächst ein Beispiel mit dem Eintragsausdruck ≫Math.random≪.
- Auswertung
Math.random()
0.5630878568955987
Der Name ≫Math.random≪ steht für ein Programm, welches zur Laufzeit bei der Auswertung des Aufrufsausdrucks ≫Math.random()≪ gestartet wird.
Solch ein Programm, das von einem anderen Programm aus aufgerufen wird, wird auch als Unterprogramm bezeichnet. Insbesondere in JavaScript nennt man solch ein Unterprogramm eine Funktion.
Als Eintragsausdrücke im Aufrufausdruck sind nur Ausdrück erlaubt, die auch eine Funktion bezeichnen. Solche Ausdrücke bezeichnen wir als Funktionsausdrücke. Ein Funktionsausdruck ist ein Ausdruck, dessen Wert eine Funktion ist.
Die Schreibweise eines Ausdrucks mit einem Funktionsausdruck und einem folgenden Paar runder Klammern nennen wir einen Funktionsaufrufausdruck oder – kurz – einen Aufrufausdruck.
Der Ausdruck ≫Math.random()≪ ist ein Aufruf der Funktion »Math.random«.
Der Ausdruck »Math.random« steht für die Funktion selber.
Die Bedeutung von Aufrufausdrücken
Die Funktion ≫Math.random≪ legt beim Ablauf des obenstehenden Programms den Wert des Aufrufausdrucks ≫Math.random()≪ fest. Jener Wert wird dann von unserer Konsole ausgegeben.
≫Math.random()≪ bedeutet: „Der Wert dieses Ausdrucks soll zum Zeitpunkt der Auswertung dieses Ausdrucks von der Funktion ≫Math.random≪ festgelegt werden.“
Die Bedeutung eines Operators ist wie auch die Bedeutung eines Literals bereits durch die Programmiersprache JavaScript definiert, während die Bedeutung der in dieser Lektion neu vorgestellten Funktionen und der schon behandelten Einträge, wie »this.Math.random« manchmal bereits durch die Programmiersprache JavaScript ist, aber manchmal auch durch Zusatzbibliotheken oder Programme definiert ist, die nicht zur eigentlichen Programmiersprache gehören, beispielsweise weil sie nicht in jeder JavaScript -Implementation vorhanden sind.
Der Typ einer Funktion
Mit dem schon früher behandelten Operator »typeof« können wir sehen, daß der Typ einer Funktion »function« lautet.
- Auswertung
typeof Math.random
"function"
Der Typ einer Funktion selber darf nicht mit dem Typ des Ergebnisses einer Funktion verwechselt werden. Dieser hängt von der jeweiligen Funktion ab.
- Auswertung
typeof Math.random()
"number"
In ECMAScript gibt es keinen Typ »function«. Der ECMAScript -Typ sowohl eines Verzeichnisses als auch einer Funktion ist „Object“. Wir müssen daher zwischen den typeof-Typ und dem ECMAScript -Typ unterscheiden. Diese stimmen oft – aber nicht immer – überein.
Funktionsnamen als Ausdrücke
Man kann einen Ausdruck in der Regel daran erkennen, daß man ihn einklammern kann, ohne die Bedeutung eines Ausdrucks zu verändern.
Funktionsname sind Ausdrücke. Der Wert eines Funktionsnamens ist eine Funktion. Die Auswertung eines Funktionsnamens ergibt eine Funktion. Bei der Ausgabe einer Funktion erscheint in der Regel das Wort »function« und eine symbolische Darstellung der Funktion durch ihren Namen und/oder weitere Symbole.
- Auswertung
Math.random
function random()
Wir können die Tatsache, daß Funktionsnamen Ausdrücke sind, auch dadurch illustrieren, daß wir Funktionsnamen einklammern können.
- Auswertung
( Math.random )()
0.1559563068987858
- Auswertung
typeof( Math.random )
"function"
Ü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.random Funktion Zufallszahl
this.undefined Wert "kein Wert"
this.NaN Zahl "keine Zahl"
Übungsfragen
? Typen (0)
Was ist ≫Math.random≪ für ein Wert?
- Text
- Zahl
- Verzeichnis
- Funktion
Was ist ≫Math.random()≪ für ein Wert?
- Text
- Zahl
- Verzeichnis
- Funktion
Was ist ≫Math≪ für ein Wert?
- Text
- Zahl
- Verzeichnis
- Funktion
? Typen (1)
Welchen Wert hat der folgende Ausdruck?
- Ausdruck
typeof Math.random
? Typen (2)
Welchen Wert hat der folgende Ausdruck?
- Ausdruck
typeof Math.random()
? Lexikalische Einheiten zählen ⃗
Wie viele lexikalische Einheiten enthält der Aufrufausdruck ≫Math.random()≪?
? Bereiche
In welchem Bereich liegt der Wert des Ausdrucks ≫Math.random() + 10≪?
In welchem Bereich liegt der Wert des Ausdrucks »10 * Math.random()«?
In welchem Bereich liegt der Wert des Ausdrucks »10 * Math.random() + 10«?
Übungsaufgaben
/ Aufruf schreiben
Rufen Sie die Funktion ≫Date≪ auf.
- Es soll also ein Aufruf der Funktion ≫Date≪ geschrieben werden. Dieser Aufruf soll dann von einer JavaScript -Implementation ausgewertet werden.
/ Aufruf schreiben
Rufen Sie die Funktion ≫Date.now≪ auf und versuchen Sie herauszufinden, was das Ergebnis bedeutet.
Die neue, erweiterte Syntax von Ausdrücken ⃗
- Neue, erweiterte Syntax
Ausdruck
.------------------.
---.----------------->| Primaerausdruck |-------------------------------.---->
| '------------------' ^
| .------------------. |
'----------------->| Eintragsausdruck |-------------------------------'
| '------------------' |
| .------------------. .-. .-. |
'----------------->| Eintragsausdruck |--->· ( ·-->· ) ·--------------'
| '------------------' '-' '-' |
| .-. .------------------. |
'-------->( - )--->| 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 |--->( ) )---'
'-' '----------' '-'
Prioritäten *
Ein Operator, der hinter seinen Operanden geschrieben wird, wir „Postfix-Operator“ genannt.
Der Postfix-Operator zum Funktionsaufruf hat eine der höchsten Prioritäten, gleich nach der Einklammerung.
- Eigenschaften von Operatoren
A P A (A = Aritaet, P = Position [Zirkumfix, P=Praefix, Infix, O=Postfix], A = Assoziativitaet)
() 1 Z Eingeklammerter Ausdruck
() 1 O Funktionsaufruf
+ - typeof 1 P Unaere vorangestellte Operatoren (Vorzeichen)
* / 2 I L "Punktrechnung": Multiplikation, Division
+ - 2 I L "Strichrechnung": Addition, Subtraktion
in 2 I L Enthaltensein
< 2 I L Kleiner
=== !== 2 I L Gleichheit, Ungleichheit
Vergleich mit dem Zirkumfixoperator »(« »)« ⃗
Die hier neu vorgestellte Schreibweise von Aufrufen mit Klammern »(« »)« ist nicht mit dem früher eingeführten Zirkumfixoperator »(« »)« zu verwechseln, dessen Klammern wir auch als „Ausdruckklammern“ bezeichnet hatten.
- Syntax des schon früher behandelten Zirkumfixoperators »(« »)«
Ausdruck
.-. .----------. .-.
--->· ( ·--->| Ausdruck |--->· ) ·-->
'-' '----------' '-'
Die hier neu behandelten Aufrufklammern stehen immer direkt hinter einem Funktionsnamen, wie beispielsweise in »this.Math.random()« und bilden mit ihm zusammen einen Ausdruck, während die früher behandelten Ausdruckklammern um einen Ausdruck herum geschrieben werden und mit diesem einen neuen Ausdruck, wie beispielsweise »( 65 )«, bilden.
(Wir sagen, daß Klammern leer seien und direkt hinter einen Namen stehen, auch wenn die Klammern noch Leerraum enthalten oder von dem voranstehenden Namen durch Leeraum getrennt sind, da Leerraum hier keine Rolle spielt.)
Funktionen ⃗
Im Quelltext eines JavaScript -Ausdrucks erscheinen nicht die Funktionen selber, sondern nur Funktionsausdrücke.
Dennoch stellt man sich vor, daß es bei der Auswertung des Ausdrucks Funktionen gibt.
Eine Funktion kann man dadurch definieren, daß es Ausdrücke gibt, die sie als Wert haben, und daß sie bei einem Aufruf mit solch einem Funktionsausdruck einen Wert liefert, der gewissen Anforderungen genügt.
Aufrufvorgänge ⃗
Bei der Auswertung eines Aufrufausdrucks wird das von dem Funktionsnamen angegebene Programm (die Funktion) gestartet (denn nur dann kann jenes Programm den Wert des Aufrufausdrucks festlegen). Bei der Auswertung des Ausdrucks »this.Math.random()« wird beispielsweise das Programm »this.Math.random« gestartet und ausgeführt. Dabei wird das aufrufende Programm suspendiert (es ruht vorübergehend) und die aufgerufene Funktion wird gestartet und läuft. Das aufrufende Programm läuft erst weiter, wenn die aufgerufenen Funktion fertig ist, solange hat die aufgerufene Funktion die Kontrolle über den Computer.
Man sagt aber meistens dazu nicht „das Programm »this.Math.random« wird gestartet.“, sondern „die Funktion »this.Math.random« wird aufgerufen.“. Programme, die auf die hier gezeigte Weise gestartet und ausgeführt werden können, nennt man ja, wie gesagt, Funktionen. Den Start eines solchen Programms bezeichnet man auch als Vorgang des Aufrufs der Funktion oder Aufrufvorgang.
Aufrufausdrücke und Aufrufvorgänge ⃗
Die Auswertung eines Aufrufausdrucks des Quelltextes bewirkt den Aufrufvorgang.
Wenn es dem Zusammenhang entnommen werden kann, ob ein Aufrufausdruck oder ein Aufrufvorgang gemeint ist, oder wenn die Unterscheidung nicht wichtig ist, spricht man einfach nur von einem Aufruf.
Das Wort „Aufruf“ hat also zwei Bedeutungen:
- den Aufrufausdruck im Quelltext des Programms, beispielsweise »this.Math.random()« und
- den Aufrufvorgang .
Wir hatten zuvor bereits Operatoren kennengelernt, auch hinter diesen verbergen sich eigentlich Programme, die bei der Auswertung eines Operatorausdruck gestartet werden.
Einfache und komplexe Ausdrücke ⃗
Wir bezeichnen einen Ausdruck, der einen Funktionsaufruf oder einen Operator enthält als einen komplexen Ausdruck. Alle anderen Ausdrücke (wie Literale und Namen) nennen wir einfach.
Klienten ⃗
Ein Programm, das eine Funktion aufruft oder eine Bibliothek benutzt, wird auch als ein Klient dieser Funktion beziehungsweise Bibliothek bezeichnet. Das Wort „Klient“ bedeutet hier so viel wie „Benutzer“, aber man möchte das Wort „Benutzer“ nur für Menschen verwenden.