JavaScript – Das Handbuch für die Praxis. David Flanagan
4. Ein Ausdruck ist eine Phrase in JavaScript, die zu einem Wert ausgewertet werden kann. Beispielsweise ist die Verwendung von . und [], um auf den Wert einer Objekteigenschaft oder eines Array-Elements zu verweisen, ein Ausdruck.
Am häufigsten bildet man Ausdrücke in JavaScript, indem man Operatoren verwendet:
// Operatoren agieren auf Werten (den Operanden), um einen neuen Wert zu erzeugen.
// Arithmetische Operatoren gehören zu den einfachsten Operatoren:
3 + 2 // => 5: Addition
3 - 2 // => 1: Subtraktion
3 * 2 // => 6: Multiplikation
3 / 2 // => 1.5: Division
points[1].x - points[0].x // => 1: Auch komplexere Operanden sind möglich.
"3" + "2" // => "32": + addiert Zahlen, verkettet Strings.
// JavaScript bietet einige arithmetische Kurzoperatoren:
let count = 0; // Variable definieren.
count++; // Variable inkrementieren.
count--; // Variable dekrementieren.
count += 2; // 2 addieren, entspricht count = count + 2;.
count *= 3; // Mit 3 multiplizieren, entspricht count = count * 3;.
count // => 6: Variablennamen sind ebenfalls Ausdrücke.
// Gleichheits- und Relationsoperatoren prüfen, ob zwei Werte gleich, ungleich,
// kleiner als, größer als usw. sind. Sie werden zu true oder false ausgewertet.
let x = 2, y = 3; // Diese =-Zeichen sind Zuweisungen, keine
// Gleichheitstests.
x === y // => false: Gleichheit.
x !== y // => true: Ungleichheit.
x < y // => true: kleiner als.
x <= y // => true: kleiner als oder gleich.
x > y // => false: größer als.
x >= y // => false: größer als oder gleich.
"two" === "three" // => false: Die beiden Strings sind verschieden.
"two" > "three" // => true: "tw" ist alphabetisch größer als "th".
false === (x > y) // => true: false ist gleich false.
// Logische Operatoren kombinieren oder invertieren boolesche Werte:
(x === 2) && (y === 3) // => true: Beide Vergleiche sind wahr. && ist AND (UND).
(x > 3) || (y < 3) // => false: Keiner der Vergleiche ist wahr.
// || ist OR (ODER).
!(x === y) // => true: ! invertiert einen booleschen Wert.
Betrachtet man JavaScript-Ausdrücke als Phrasen, wären JavaScript-Anweisungen ganze Sätze. Anweisungen sind das Thema von Kapitel 5. Ein Ausdruck ist, vereinfacht gesagt, etwas, das einen Wert liefert, aber nichts tut. Anweisungen hingegen liefern keinen Wert (zumindest keinen, der uns interessiert), ändern aber den Zustand. Oben haben Sie Variablendeklarationen und Zuweisungsanweisungen gesehen. Die andere große Kategorie von Anweisungen sind Kontrollstrukturen wie z.B. Bedingungen und Schleifen. Beispiele finden Sie weiter unten, nachdem wir die Funktionen behandelt haben.
Eine Funktion ist ein benannter und parametrisierter Block mit JavaScript-Code, den Sie einmal definieren und dann immer wieder aufrufen können. Funktionen werden formal erst in Kapitel 8 behandelt, aber wie Objekte und Arrays werden sie Ihnen auch vorher schon immer wieder mal begegnen. Hier ein paar einfache Beispiele:
// Funktionen sind parametrisierte Blöcke mit JavaScript-Code, die wir aufrufen
// können.
function plus1(x) { // Funktion mit dem Namen "plus1" und dem
// Parameter "x" definieren.
return x + 1; // Wert zurückgeben, der um eins größer ist
// als der übergebene Wert.
} // Funktionen sind in geschweifte Klammern
// eingeschlossen.
plus1(y) // => 4: y ist (immer noch) 3, also gibt
// dieser Aufruf 3+1 zurück.
let square = function(x) { // Funktionen sind Werte und können Variablen
// zugewiesen werden.
return x * x; // Funktionswert berechnen.
}; // Semikola kennzeichnen das Ende der Zuweisung.
square(plus1(y)) // => 16: Zwei Funktionen in einem Ausdruck aufrufen.
In ES6 und späteren Versionen gibt es eine Kurzschriftsyntax für die Definition von Funktionen. Diese prägnante Syntax verwendet =>, um die Argumentliste vom Funktionskörper zu trennen, daher werden auf diese Weise definierte Funktionen als Pfeilfunktionen bezeichnet. Pfeilfunktionen werden am häufigsten eingesetzt, wenn eine unbenannte Funktion als Argument an eine andere Funktion übergeben werden soll. Verwendet man Pfeilfunktionen, sieht der vorhergehende Code so aus:
const plus1 = x => x + 1; // Die Eingabe x wird auf die Ausgabe x + 1 abgebildet.
const square = x => x * x; // Die Eingabe x wird auf die Ausgabe x * x abgebildet.
plus1(y) // => 4: Funktionen werden wie sonst auch aufgerufen.
square(plus1(y)) // => 16
Wenn wir Funktionen mit Objekten verwenden, erhalten wir Methoden:
// Werden Funktionen den Eigenschaften eines Objekts zugewiesen, nennen wir sie
// "Methoden". Alle JavaScript-Objekte (einschließlich Arrays) besitzen Methoden:
let a = []; // Ein leeres Array anlegen.
a.push(1,2,3); // Die Methode push() fügt einem Array Elemente hinzu.
a.reverse(); // Eine weitere Methode: die Reihenfolge der Elemente
// umkehren.
// Wir können auch eigene Methoden definieren. Das Schlüsselwort "this" bezieht
// sich auf das Objekt, für das die Methode definiert ist: hier das Array points
// aus einem vorhergehenden Beispiel.
points.dist = function() { // Methode zum Berechnen des Abstands zwischen
// Punkten definieren.
let p1 = this[0]; // Erstes Element des Arrays, auf dem die Methode
// aufgerufen wird.
let p2 = this[1]; // Zweites Element des Arrays "this".
let a = p2.x-p1.x; // Differenz der x-Koordinaten.
let b = p2.y-p1.y; // Differenz der y-Koordinaten.
return Math.sqrt(a*a + // Der Satz des Pythagoras.
b*b); // Math.sqrt() zieht die Wurzel.
};
points.dist() // => Math.sqrt(2): Abstand zwischen unseren
// zwei Punkten.
Hier erhalten Sie nun wie versprochen einige Funktionen, in denen als Anweisungen häufig genutzte JavaScript-Kontrollstrukturen vorkommen:
// Zu den JavaScript-Anweisungen gehören auch bedingte Anweisungen