JavaScript/Operatoren/Rechenoperatoren

Aus SELFHTML-Wiki
Wechseln zu: Navigation, Suche

Numerische Berechnungen führen Sie mit Hilfe von Rechenoperatoren durch.

Notieren Sie zwischen den Operanden (den Werten, mit denen Sie rechnen möchten):

  • zum Addieren das Pluszeichen +
  • zum Subtrahieren das Minuszeichen -
  • zum Multiplizieren den Stern *
  • zum Dividieren den Schrägstrich /
  • für den Rest einer Division (Modulo) das Prozentzeichen %.
  • zum Potenzieren einen doppelten Stern **

In Ausdrücken, die mehrere Operatoren enthalten, muss JavaScript die Reihenfolge festlegen, in der die Operatoren berechnet werden. Grundsätzlich wird dabei den Grundregeln der Mathematik gefolgt (zuerst **, dann *, % und /, danach + und -). Wenn Sie von dieser Reihenfolge abweichen wollen, können Sie Klammern setzen.

für Berechnungen 
let zwei           = 1 + 1,
    nix            = 2 - 2,
    auchNix        = 81 / 3 - 27,
    wenigerAlsNix  = 81 / (3 - 27),
    SinnDesLebens  = 6 * 7,
    ergibtAuchSinn = 84 / 2,
    wiederNix      = 36 * 37 % 666;

Im Beispiel werden verschiedene Variablen definiert und jeweils ein Rechenergebnis zugewiesen.


Hinweis:
Der ** Operator wurde mit ECMAScript 2016 eingeführt und ist in alten Browsern nicht vorhanden. Sie können alternativ die Funktion Math.pow() verwenden.

Assoziativität

In der Mathematik gilt für einige Operatoren das Assoziativgesetz, wonach diese Operatoren in beliebiger Reihenfolge berechnet werden dürfen, wenn sie hintereinander in einem Ausdruck stehen. JavaScript nimmt sich diese Freiheit nicht, sondern legt die Auswertungsreihenfolge für Operatoren streng fest. Die hier genannten mathematischen Operatoren werden innerhalb ihrer Rangstufe - mit Ausnahme der Potenz - streng von links nach rechts ausgewertet. Die Potenz bildet eine Ausnahme, weil in der Mathematik gilt, dass Potenzen „von oben nach unten“ ausgerechnet werden. Deswegen ist a ** b ** c gleichbedeutend mit a ** (b ** c).

Eine ausführliche Darstellung aller Operatorrangstufen und ihrer Assoziativität finden Sie im Artikel Operatorenrangfolge.

Rechenoperationen mit Zuweisung

Oft will man den Wert von Variablen nur umrechnen, d. h. das Rechenergebnis wieder in derselben Variablen speichern. Hierfür gibt es spezielle Rechenoperatoren, die außer der eigentlichen Rechnung auch die Neuzuweisung vornehmen, sodass Sie den Variablennamen nicht mehrfach notieren müssen. Wenn Sie z. B. bei jedem Durchlauf 3 addieren wollen, können Sie statt ausführlich a = a + 3; einfach nur a += 3; schreiben.


Operation verkürzte Schreibweise ausführliche Schreibweise
Addition a += b a = a + b
Subtraktion a -= b a = a - b
Multiplikation a *= b a = a * b
Division a /= b a = a / b
Rest bei Division a %= b a = a % b
Beispiel 
let zahl = 0;

zahl +=  3; //  3
zahl -=  2; //  1
zahl *= 18; // 18
zahl /=  3; //  6 
zahl %=  5; //  1

Im Beispiel wird eine Variable namens zahl definiert und ihr der Wert 0 zugewiesen. Dieser wird dann jeweils neu berechnet: Der Reihe nach wird 3 addiert, 2 subtrahiert, mit 18 multipliziert, durch 3 dividiert, der Rest bei Division durch 5 berechnet.


Weil diese Rechenoperatoren eine Zuweisung an den linken Operanden durchführen, muss dort zwingend eine Variable stehen. Rechts können Sie beliebige fixe Werte, Variablen oder Ausdrücke notieren.

Inkrementoren und Dekrementoren

Der Inkrement-Operator ++ erhöht den Wert einer Variablen um genau 1. Sein Gegenstück, der Dekrement-Operator --, vermindert sie um 1. Sie finden vor allem in Schleifen Verwendung, bei denen ein Indexwert schrittweise hoch bzw. heruntergezählt werden soll.

Die Namen der Operatoren leiten sich von den lateinischen Begriffen incrementum (Wachstum) und decrementum (Verminderung) her.

Der Wert, den sie zurückgeben, hängt davon ab, ob man sie vor oder hinter der Variablen notiert. Steht die Variable vor dem Operator, gibt der Operator den alten Wert zurück. Steht sie hinter dem Operator, erhält man den neuen Wert.

Achtung!

Ein nachgestelltes ++ oder -- muss in der gleichen Programmzeile stehen wie die Variable, auf die es wirken soll.

Stellen Sie sich die Verarbeitung dieser Operatoren so vor, dass JavaScript von links nach rechts vorgeht:

  • Findet es die Variable, so liest es ihren Wert und stellt ihn als Rückgabewert des Operators bereit.
  • Findet es den Operator, so führt es ihn durch.

Deswegen erhält man den alten Wert, wenn die Variable links steht und den neuen Wert, wenn sie rechts steht.

Beispiel 
let zahl = 42;

alert(zahl++); // Ausgabe: 42
               // zahl ist jetzt 43
alert(zahl--); // Ausgabe: 43
               // zahl ist jetzt 42
alert(++zahl); // zahl ist jetzt 43
               // Ausgabe: 43
alert(--zahl); // zahl ist jetzt 42
               // Ausgabe: 42

Im Beispiel wird der Wert der Variablen zahl jeweils um 1 erhöht (++) oder verringert (--).


Üblicherweise ergänzt man die Bezeichnung für diese Operatoren durch die Vorsilbe Prä (lat. vorher) oder Post (lat. 'nachher'), um die Platzierung zu beschreiben.

Bezeichnung Schreibweise Ergebnis neuer Wert
Prä-Inkrement ++a a + 1 a + 1
Prä-Dekrement --a a - 1 a - 1
Post-Inkrement a++ a a + 1
Post-Dekrement a-- a a - 1

Die speziellen Operationen mit Zuweisung sind stets durch normale Rechenoperatoren und separate Zuweisungen ersetzbar. Kurzschreibweisen, Inkrementoren und Dekrementoren finden sich vor allem bei bedingten Anweisungen, Schleifen und in komplexen Ausdrücken, weil sich damit der Code übersichtlicher gestalten lässt und man Variablen sozusagen im Vorbeigehen neu belegen kann, z. B. im Zuge eines Vergleichs:

Beispiel 
let jahre = 17, geburtstag = true;

if(geburtstag) {
    if(++jahre == 18) alert("Gralutiere! Sie sind jetzt volljährig!");

    --jahre; //wieder auf 17 stellen oder auch jahre--

    if (jahre++ < 18) alert("Leider sind Sie noch nicht volljährig!"); 
        // jahre wird erst nach der Abfrage erhöht
}

Division und Rest

Dividieren durch Null, Unendlich und die negative Null

Das von JavaScript verwendete IEEE 754 Zahlenformat kennt drei ungewöhnliche Werte. Es handelt sich um "positiv unendlich" (Infinity), "negativ unendlich" (-Infinity) und -0. Das Verhalten der arithmetischen Operatoren für diese Sonderwerte ist eindeutig festgelegt. Die Vorzeichen folgen dabei den gleichen Regeln wie beim Rechnen mit endlichen (finiten) Werten.

  • Addition von Infinity ergibt Infinity
  • Subtraktion von Infinity ergibt -Infinity
  • Infinity - Infinity ergibt NaN
  • Multiplikation mit Infinity ergibt Infinity
  • Multiplikation von 0 mit Infinity ergibt NaN
  • Division eines Wertes durch 0 ergibt Infinity oder -Infinity
  • Division von Infinity durch einen finiten Wert ergibt Infinity
  • Division eines finiten Wertes durch Infinity ergibt 0
  • Division von Infinity durch Infinity ergibt NaN

Der Wert -0 kann auch durch einen arithmetischen Fließkomma-Unterlauf bei negativen Zahlen entstehen (-1E-322 / 100 ergibt -0. Man kann -0 allerdings nicht durch einen Vergleich abfragen, weil JavaScript festlegt, dass 0 === -0 gilt. Wenn man wissen will, ob eine Variable -0 enthält, kann man aber testen, ob 1/a == -Infinity erfüllt ist.

Der Modulo-Operator

Die Modulo-Berechnung, bei der der Rest einer Division bestimt wird, ist bei vielen Programmieraufgaben nützlich. Ein Divisionsrest lässt sich auch ohne einen eigenen Operator bestimmen, das ist aber sehr umständlich: 

  let rest = wert - Math.trunc(wert / teiler) * teiler;

Deshalb existiert ein eigener Modulo-Operator, der als Prozentzeichen % notiert wird. Er liefert den verbleibenden Rest bei der Division zweier Zahlen.

5 % 3 ergibt 2, weil 5 nicht ganzzahlig durch 3 teilbar ist: „3 passt 1 mal in 5 und es bleibt ein Rest von 2“ 6 % 3 ergibt dagegen 0, weil 6 duch 3 restlos teilbar ist.

Beispiel 
let jahr = 2100,    // Anno Domini
    tage = 365;                 // normales Jahr

if (jahr % 4 == 0) ++tage;      // Jahr durch 4 teilbar: Schaltjahr

if (jahr % 100 == 0) {          // Jahr durch 100 teilbar: Säkularjahr, kein Schaltjahr
   if (jahr % 400 != 0) --tage; // es sei denn, es ist durch 400 teilbar
}

console.log(tage);              // Tage anzeigen

Im Beispiel werden zwei Variable namens jahr und tage definiert und ihnen die Zahlen 2100 bzw. 365 zugewiesen. Mit Hilfe des Modulo-Operators % und des Vergleichsoperators == wird in bedingten Anweisungen nach den Schaltregeln des gregorianischen Kalenders geprüft, ob die Jahreszahl restlos durch 4, durch 100 und ggf. durch 400 teilbar ist. Mit Hilfe der Zuweisungsoperatoren ++ bzw. -- wird der Inhalt der Variablen tage ggf. um einen Schalttag vergrößert bzw. verkleinert. Zur Kontrolle wird die Anzahl der Tage ausgegeben.

Beachten Sie: Im Unterschied zu manchen anderen Programmiersprachen wie Ruby, Python oder Perl verwendet JavaScript die sogenannte „symmetrische Variante“ des Modulo-Algorithmus, die für negative Operanden andere Ergebnisse liefert als die „mathematische Variante“. Für JavaScript gilt:
  • a % m hat stets dasselbe Vorzeichen wie a
  • (-a) % m === -(a % m), aber im Allgemeinen (a + k * m) % m !== a % m (mit k ε N).

Wenn man auch die besonderen Werte NaN und Infinity beachtet, entspricht das Ergebnis des Ausdrucks wert % divisor dem Rückgabewert folgender JavaScript-Funktion mod(wert, divisor):

Beispiel 
function mod(wert, divisor) {

   if( divisor == 0                     || 
       isNaN(divisor)                   || 
       isNaN(wert)                      || 
       wert == Number.POSITIVE_INFINITY || 
       wert == Number.NEGATIVE_INFINITY ) return Number.NaN;

   if( divisor == Number.POSITIVE_INFINITY || 
       divisor == Number.NEGATIVE_INFINITY ) return wert;

   let quotient = wert / divisor;

   if( quotient == 0 )
      return 0;
   else
      return wert - divisor * Math.trunc(quotient);
}


Abgerufen von „http://wiki.selfhtml.org/index.php?title=JavaScript/Operatoren/Rechenoperatoren&oldid=98657“