JavaScript/Operatoren/Rechenoperatoren

Aus SELFHTML-Wiki
Wechseln zu: Navigation, Suche

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

  • JavaScript 1.0
  • Chrome
  • Firefox
  • IE
  • Opera
  • Safari

Notieren Sie zwischen den Operanden

  • zum Addieren das Pluszeichen +
  • zum Subtrahieren das Minuszeichen -
  • zum Multiplizieren den Stern *
  • zum Dividieren den Schrägstrich /
  • für Modulo-Berechnungen das Prozentzeichen %.

Es gelten die üblichen Rechenregeln (Punkt- vor Strichrechnung etc.). Wie in der Mathematik üblich, müssen Sie Klammern setzen, um eine andere Rangfolge der Operationen zu bestimmen.

Beispiel: für Berechnungen
var 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.

[Bearbeiten] 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, so dass 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
Multiplikaktion a *= b a = a * b
Division a /= b a = a / b
Rest bei Division a %= b a = a % b
Beispiel
var 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.

[Bearbeiten] Inkrementoren und Dekrementoren

Inkrementoren und Dekrementoren vergrößern bzw. verkleinern den Wert einer Variablen um genau 1. Sie finden vor allem in Schleifen Verwendung, bei denen ein Indexwert schrittweise hoch bzw. runtergezählt werden soll. Dabei ist der Wert, den ein Operator als Ergebnis der Operation zurückgibt, nicht immer identisch mit dem neu zugewiesenen Wert.

Beispiel
var 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 (--).
Beachten Sie: Diese Operatoren geben entweder den Wert der Variablen vor der Berechnung als Ergebnis zurück oder den neuen Wert nach der Berechnung, je nachdem, ob sie rechts oder links vom Operanden notiert werden:
  • Steht der Operator links vom Operanden, dann wird der neue Wert berechnet und als Ergebnis zurückgegeben.
  • Steht der Operator rechts vom Operanden, dann wird der alte Wert als Ergebnis zurückgegeben und erst dann der neue Wert berechnet.
Schreibweise Operation Ergebnis neuer Wert
++a Inkrementierung a + 1 a + 1
--a Dekrementierung a - 1 a - 1
a++ Inkrementierung a a + 1
a-- Dekrementierung 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
var 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
}

[Bearbeiten] Der Modulo-Operator

Für Modulo-Berechnungen existiert ein 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“ als Ergebnis. 6 % 3 ergibt dagegen 0, weil 6 duch 3 restlos teilbar ist.

Beispiel
var jahr = 2100,                // Anno Domini
    tage = 365;                 // normales Jahr
 
if (jahr % 4 == 0) ++tage;      // Schaltjahr
 
if (jahr % 100 == 0) {          // Säkularjahr
   if (jahr % 400 != 0) --tage; // kein Schaltjahr
}
 
alert(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).

Die Ergebnis des Ausdrucks a % m entspricht dem Rückgabewert folgender JavaScript-Funktion mod(a, m):

Beispiel
function mod(a, m) {
 
   if( m == 0                        || 
       isNaN(m)                      || 
       isNaN(a)                      || 
       a == Number.POSITIVE_INFINITY || 
       a == Number.NEGATIVE_INFINITY ) return Number.NaN;
 
   if( m == Number.POSITIVE_INFINITY || 
       m == Number.NEGATIVE_INFINITY ) return a;
 
   var float = a / m;
 
   if( float == 0 ) return 0;
   if( float  > 0 ) return a - m * Math.floor(float);
   if( float  < 0 ) return a - m * Math.ceil (float);
}


Meine Werkzeuge
Namensräume

Varianten
Aktionen
Übersicht
Index
Mitmachen
Werkzeuge
Spenden
SELFHTML