Wie ist eine Ganzzahl in js. Entfernen – Ganzzahlige Division mit Rest in JavaScript? Arbeiten mit Potenzfunktionen

Oftmals ergeben Berechnungen Ergebnisse, die nicht in die gewünschten Bereiche passen. Daher ist es notwendig JavaScript-Rundung bis zu einem bestimmten Wert.

Warum runde Zahlen?

JavaScript speichert keine Ganzzahlen, da ihre Werte als Gleitkommazahlen dargestellt werden. Viele Brüche können nicht durch eine Zahl mit einer bestimmten endlichen Anzahl von Dezimalstellen dargestellt werden, daher kann JavaScript Ergebnisse wie die folgenden generieren:

0.1 * 0.2; > 0.020000000000000004

In der Praxis wird dies keine Rolle spielen, da es sich um einen Fehler von 2 Trillionen handelt. Dies kann sich jedoch auf das Ergebnis auswirken, wenn mit Zahlen gearbeitet wird, die Währungswerte, Prozentsätze oder Dateigrößen darstellen. Daher müssen Sie oder bis zu einer bestimmten Dezimalstelle eingeben.

Dezimalzahlen runden

Schneiden" Dezimalzahl werden die Methoden toFixed() oder toPrecision() verwendet. Beide benötigen ein Argument, das die Anzahl der signifikanten und Dezimalstellen angibt, die in das Ergebnis einbezogen werden sollen:

• Wenn für toFixed() kein Argument angegeben ist, ist der Standardwert 0 , also keine Nachkommastellen; der maximale Wert des Arguments ist 20;
• Wenn toPrecision() kein Argument übergeben wird, wird die Zahl nicht geändert.

var randNum = 6,25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > „3“ var randNum = 87.335; randNum.toFixed(2); > „87,33“ var randNum = 87,337; randNum.toPrecision(3); > „87,3“

Notiz

Sowohl toFixed() als auch toPrecision geben eine gerundete String-Darstellung des Ergebnisses zurück, keine Zahl. Das bedeutet, dass das Hinzufügen von gerundet zu randNum zu einer Zeichenfolgenverkettung und nicht zu einer einzelnen Zahl führt:

console.log(randNum + gerundet); > „6.256“

Wenn Sie möchten, dass JavaScript auf Hundertstel rundet, verwenden Sie parseFloat() :

var randNum = 6,25; varrounded = parseFloat(randNum.toFixed(1)); Konsolenprotokoll (gerundet); > 6.3

toFixed() und toPrecision() sind ebenfalls nützliche Methoden zum Abschneiden einer großen Anzahl von Dezimalstellen. Dies ist nützlich, wenn Sie mit Zahlen arbeiten, die Geldeinheiten darstellen:

var WholeNum = 1 var DollarCents = WholeNum.toFixed(2); console.log(dollarsCents); > „1,00“

Beachten Sie, dass toPrecision das Ergebnis im wissenschaftlichen Format zurückgibt, wenn die Zahl mehr Ziffern als der Präzisionsparameter hat:

var num = 123.435 num.toPrecision(2); > „1.2e+2“

So vermeiden Sie Fehler beim Runden von Dezimalzahlen

In einigen Fällen ist dies bei toFixed und toPrecision der Fall JavaScript rundet 5 ab, und nicht mehr im Sinn:

var numTest = 1.005; numTest.toFixed(2); > 1;

Das Ergebnis des obigen Beispiels sollte 1,01 und nicht 1 sein. Wenn Sie diesen Fehler vermeiden möchten, empfehle ich die Verwendung von Exponentialzahlen:

Funktion round(value, decimals) ( return Number(Math.round(value+"e"+decimals)+"e-"+decimals); )

Anwendung:

rund(1.005,2); > 1.01

Wenn Sie eine noch robustere Lösung als das Runden benötigen, finden Sie diese unter MDN.

Runden mit Epsilon

Alternative Methode JavaScript-Rundung auf Zehntel wurde in ES6 eingeführt ( auch bekannt als JavaScript 2015). « Maschinen-Epsilon' bietet eine angemessene Fehlerquote beim Vergleich zweier Gleitkommazahlen. Ohne Rundung können Vergleiche zu Ergebnissen wie den folgenden führen:

0,1 + 0,2 === 0,3 > falsch

Math.EPSILON kann in einer Funktion verwendet werden, um einen gültigen Vergleich zu erhalten:

Funktion epsEqu(x, y) ( return Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }

Die Funktion benötigt zwei Argumente: Eines enthält die Berechnung, das Zweite ist das erwartete (gerundete) Ergebnis. Es gibt einen Vergleich dieser beiden Parameter zurück:

epsEqu(0,1 + 0,2, 0,3) > wahr

Alle modernen Browser unterstützen ES6-Mathefunktionen. Wenn Sie jedoch Unterstützung in älteren Browsern bereitstellen müssen, müssen Sie Polyfills verwenden.

Dezimalkürzung

Alle zuvor vorgestellten Methoden funktionieren JavaScript-Rundung auf Zehntel. Um eine positive Zahl auf zwei Dezimalstellen zu kürzen, multiplizieren Sie sie mit 100, kürzen Sie erneut und teilen Sie das Ergebnis dann durch 100:

Funktion truncated(num) ( return Math.trunc(num * 100) / 100; ) truncated(3.1416) > 3.14

Wenn Sie etwas Flexibleres benötigen, können Sie den bitweisen Operator verwenden:

function truncated(num, decimalPlaces) ( var numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )

Verwendung:

var randInt = 35,874993; abgeschnitten(randInt,3); > 35.874

Auf die nächste Zahl runden

Ausführen JavaScript rundet auf eine Ganzzahl, Math.round() wird verwendet:

Math.round(4.3) > 4 Math.round(4.5) > 5

Beachten Sie, dass " halbe Werte„, wie zum Beispiel .5 , werden aufgerundet.

Abrunden auf die nächste ganze Zahl

Wenn Sie abrunden möchten, verwenden Sie die Methode Math.floor():

Math.floor(42.23); > 42 Math.floor(36.93); > 36

Das Abrunden hat für alle Zahlen, auch für negative, eine Richtung. Man kann sich das wie einen Wolkenkratzer mit unendlich vielen Stockwerken vorstellen, auch unterhalb des Fundamentniveaus ( negative Zahlen darstellen). Wenn Sie sich in einem Aufzug zwischen Kellergeschoss 2 und 3 befinden ( was dem Wert -2,5 entspricht), Math.floor bringt Sie zur Etage -3:

Math.floor(-2.5); > -3

Wenn Sie dies vermeiden müssen, verwenden Sie JavaScript Math Rounding mit Math.trunc() , das in allen modernen Browsern unterstützt wird (außer IE/Edge):

Math.trunc(-41.43); > -41

MDN bietet auch 3-zeiliges Polyfill zur Unterstützung von Math.trunc in älteren Browsern und IE/Edge.

Auf die nächste ganze Zahl aufrunden

Wenn Sie Dezimalzahlen aufrunden möchten, verwenden Sie Math.ceil . Sie können sich diese Methode auch als einen unendlichen Aufzug vorstellen: Math.ceil bringt Sie immer „nach oben“, unabhängig davon, ob die Zahl negativ oder positiv ist:

Math.ceil(42.23); > 43 Math.ceil(36.93); > 37 Math.ceil(-36,93); -36

Auf das nächste Vielfache runden

Wenn Sie einen Wert auf das nächste Vielfache von 5 runden möchten, erstellen Sie eine Funktion, die die Zahl durch 5 dividiert, aufrundet und dann das Ergebnis mit demselben Wert multipliziert:

Funktion RoundTo5(num) ( return Math.round(num/5)*5; )

Verwendung:

RoundTo5(11); > 10

Wenn Sie eine JavaScript-Rundung auf zwei Dezimalstellen durchführen müssen, können Sie sowohl den Startwert als auch die Multiplizität an die Funktion übergeben:

Funktion RoundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )

Um die Funktion zu verwenden, geben Sie beim Aufruf die zu rundende Zahl und die Multiplizität an:

var initialNumber = 11; var multiple = 10; RoundToMultiple(initialNumber, multiple); > 10;

Um Werte nur nach oben oder unten zu runden, ersetzen Sie die Rundungsfunktion durch ceil oder floor .

Bindung an einen Bereich

Manchmal müssen Sie den Wert von x ermitteln, der innerhalb eines bestimmten Bereichs liegen muss. Wir möchten beispielsweise einen Wert zwischen 1 und 100, erhalten aber einen Wert von 123. Um dies zu beheben, können Sie min() ( gibt die kleinste der Zahlen zurück) und max( gibt die maximal zulässige Anzahl zurück).

Verwendung:

var lowBound = 1; varhighBound = 100; varnumInput = 123; var clamp = Math.max(lowBound, Math.min(numInput, highBound)); Konsolenprotokoll (geklemmt); > 100;

Sie können eine Funktion oder Erweiterung der Number-Klasse erstellen.

Dies behebt, dass die Antwort von @MarkElliot auch für negative Zahlen funktioniert:

Vardiv = Math.trunc(y/x); var rem = y % x;

beachten Sie, dass Mathematische Methoden haben gegenüber bitweisen Operatoren den Vorteil, dass sie mit Zahlen größer als 2 31 arbeiten.

JavaScript berechnet das Geschlecht negativer Zahlen und den Rest nicht ganzzahliger Zahlen auf der rechten Seite und folgt dabei den mathematischen Definitionen dafür.

FLOOR ist definiert als „die größte Ganzzahl kleiner als der Parameter“, also:

• positive Zahlen: FLOOR(X) = ganzzahliger Teil von X;
• negative Zahlen: FLOOR(X) = ganzzahliger Teil von X minus 1 (weil er KLEINER als der Parameter, also negativer sein sollte!)

Der Rest ist definiert als der „Rest“ einer Division (euklidische Arithmetik). Wenn der Dividend keine ganze Zahl ist, ist der Faktor normalerweise auch keine ganze Zahl, d. h. es gibt keinen Rest, aber wenn der Faktor gezwungen ist, eine ganze Zahl zu sein (und das passiert, wenn man versucht, den Rest zu erhalten oder ein Gleitkomma zu modulieren). Punktnummer), offensichtlich wird es ein nicht ganzzahliges „Links“ geben.

JavaScript berechnet alles wie erwartet, daher muss der Programmierer darauf achten, die richtigen Fragen zu stellen (und die Leute müssen darauf achten, die gestellten Fragen zu beantworten!). Yarins erste Frage lautete stattdessen NICHT „Wie lautet die ganzzahlige Division von X durch Y?“. davon: „Die ganze Zahl, wie oft die angegebene ganze Zahl zu einer anderen geht.“ Für positive Zahlen Die Antwort ist für beide gleich, jedoch nicht für negative Zahlen, da die ganzzahlige Division (Dividende durch Divisor) um -1 kleiner ist, als die Zahl (Divisor) „zu einer anderen geht“ (Dividende). Mit anderen Worten: FLOOR gibt die richtige Antwort für die ganzzahlige Division einer negativen Zahl zurück, aber Yarin hat nicht danach gefragt!

gammax hat richtig geantwortet, dieser Code funktioniert nach Yarins Anweisungen. Andererseits hat Samuel Unrecht, er hat die Rechnung nicht gemacht, glaube ich, sonst hätte er gesehen, dass es tatsächlich funktioniert (er hat auch nicht gesagt, was der Teiler seines Beispiels war, aber ich hoffe, es war 3) :

Rest = X% Y = -100% 3 = -1

GoesInto = (X - Rest) / Y = (-100 - -1) / 3 = -99 / 3 = -33

Übrigens habe ich den Code unter Firefox 27.0.1 getestet. Er funktionierte wie erwartet mit positiven und negativen Zahlen sowie nicht ganzzahligen Werten, sowohl für Dividenden als auch für Divisoren. Beispiel:

100,34 / 3,57: GoesInto = -28, Rest = -0,3800000000000079

Ja, mir ist aufgefallen, dass es ein Problem mit der hohen Genauigkeit gibt, aber ich hatte keine Zeit, es zu überprüfen (ich weiß nicht, ob das Problem bei Firefox, Windows 7 oder der FPU meines Prozessors liegt). Für Yarins Frage, die nur Ganzzahlen enthält, funktioniert der Code von gammax jedoch einwandfrei.

Sie können die parseInt-Funktion verwenden, um ein abgeschnittenes Ergebnis zu erhalten.

ParseInt(a/b)

Um den Rest zu erhalten, verwenden Sie den Mod-Operator:

parseInt hat einige Fallstricke mit Zeichenfolgen, um die Verwendung von Basis-10-Basis-10-Basisparametern zu vermeiden

ParseInt("09", 10)

In einigen Fällen kann die Zeichenfolgendarstellung einer Zahl in wissenschaftlicher Notation erfolgen. In diesem Fall führt parseInt zu einem falschen Ergebnis.

ParseInt(100000000000000000000000000000000, 10) // 1e+32

Dieser Aufruf gibt 1 zurück.

Die Berechnung der Seitenanzahl kann in einem Schritt erfolgen: Math.ceil(x/y)

Wenn Sie nur mit Zweierpotenzen teilen, können Sie bitweise Operatoren verwenden:

Exportfunktion „divideBy2(num)“ ( return ; ) Exportfunktion „divideBy4(num)“ ( return ; ) Exportfunktion „divideBy8(num)“ ( return ; )

(Das Erste ist das Besondere, das Zweite ist der Rest)

Dies wird immer in Richtung Null abgeschnitten. Ich bin mir nicht sicher, ob es zu spät ist, aber hier heißt es:

Funktion intdiv(Dividend, Divisor) ( Divisor = Divisor - Divisor % 1; if (Divisor == 0) throw new Error("division by zero"); Dividend = Dividend - Dividend % 1; var rem = Dividend % Divisor; return (Rest: rem, Quotient: (Dividende - rem) / Divisor ); )

Ich bin kein Experte für bitweise Operatoren, aber hier ist eine andere Möglichkeit, eine Ganzzahl zu erhalten:

Varnum = ~~(a / b);

Dies funktioniert auch gut für negative Zahlen, während sich Math.floor() in die falsche Richtung dreht.

Das scheint auch richtig zu sein:

Varnum = (a / b) >> 0;

Math.floor(operation) gibt den gerundeten Wert der Operation zurück.

Beispiel 1 Frage:

Var x = 5; variieren = 10,4; varz = Math.floor(x + y); Konsolenprotokoll(z);

Konsole:

Beispiel 2 Frage:

Var x = 14; variieren = 5; varz = Math.floor(x%y); Konsolenprotokoll(x);

Konsole:

Berechnen Sie für eine Zahl y und einen Teiler x den Quotienten und den Rest (Rest) als:

Var quotient = Math.floor(y/x); var rest = y % x;

Warum ist eine Rundung notwendig?

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
Aus praktischen Gründen spielt diese Ungenauigkeit keine Rolle. In unserem Fall sprechen wir von einem Fehler in Billionen-Anteilen. Dies kann jedoch jemanden enttäuschen. Wir können auch seltsame Ergebnisse erhalten, wenn wir mit Zahlen arbeiten, die Währungen, Prozentsätze oder Dateigrößen darstellen. Um diese Ungenauigkeiten zu korrigieren, müssen wir lediglich in der Lage sein, die Ergebnisse zu runden, und es reicht aus, die Dezimalgenauigkeit festzulegen.

Das Runden von Zahlen hat praktischer Nutzen können wir die Zahl in einem bestimmten Bereich manipulieren, zum Beispiel möchten wir den Wert auf die nächste ganze Zahl runden und nicht nur mit dem Dezimalteil arbeiten.

Dezimalzahlen runden

1. Wenn das Argument nicht für toFixed() definiert ist, wird es standardmäßig auf Null gesetzt, d. h. 0 Dezimalstellen, das Argument hat einen Maximalwert von 20.
2. Wenn toPrecision kein Argument übergeben wird, bleibt die Zahl unberührt

Sei randNum = 6,25; let Rounded = randNum.toFixed(); // "6" console.log(randNum + abgerundet); > „6.256“
Wenn das Ergebnis einen numerischen Datentyp haben soll, müssen Sie parseFloat verwenden:

Sei randNum = 6,25; let Rounded = parseFloat(randNum.toFixed(1)); Konsolenprotokoll (gerundet); > 6.3
Beachten Sie, dass 5 Werte außer in seltenen Fällen gerundet werden.

Die Methoden toFixed() und toPrecision() sind nützlich, da sie nicht nur den Bruchteil abschneiden, sondern auch die Dezimalstellen auffüllen können, was bei der Arbeit mit Währungen praktisch ist:

Let WholeNum = 1 Let DollarsCents = WholeNum.toFixed(2); console.log(dollarsCents); > „1,00“
Beachten Sie, dass toPrecision das Ergebnis in Exponentialschreibweise zurückgibt, wenn die Anzahl der Ganzzahlen größer als die Genauigkeit selbst ist:

Sei num = 123.435 num.toPrecision(2); > „1.2e+2“

So vermeiden Sie Rundungsfehler bei Dezimalzahlen

Sei numTest = 1.005; numTest.toFixed(2); > „1,00“
Das Ergebnis der obigen Berechnung hätte 1,01 und nicht 1 sein sollen. Wenn Sie diese Art von Fehler vermeiden möchten, können wir die von Jack L. Moore vorgeschlagene Lösung verwenden, die Exponentialzahlen für die Berechnung verwendet:

Funktion round(value, decimals) ( return Number(Math.round(value+"e"+decimals)+"e-"+decimals); )
Jetzt:

Rund(1.005,2); > 1.01
Wenn Sie eine robustere Lösung als die oben gezeigte wünschen, können Sie zu MDN gehen.

Maschinelle Epsilon-Rundung

0,1 + 0,2 === 0,3 > falsch
Wir verwenden Math.EPSILON in unserer Funktion, um den korrekten Vergleich zu erhalten:

Funktion epsEqu(x, y) ( return Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
Die Funktion benötigt zwei Argumente: Das erste ist die aktuelle Berechnung, das zweite ist das erwartete Ergebnis. Es wird ein Vergleich der beiden zurückgegeben:

EpsEqu(0,1 + 0,2, 0,3) > wahr
Alle modernen Browser unterstützen bereits ES6-Mathefunktionen. Wenn Sie jedoch Unterstützung in Browsern wie IE 11 wünschen, verwenden Sie Polyfills.

Bruchteilsausschnitt

Funktion truncated(num) ( return Math.trunc(num * 100) / 100; ) truncated(3.1416) > 3.14
Wenn Sie die Methode auf beliebig viele Nachkommastellen anpassen möchten, können Sie die bitweise Doppelnegation verwenden:

Funktion truncated(num, decimalPlaces) ( let numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )
Jetzt:

Sei randInt = 35,874993; abgeschnitten(randInt,3); > 35.874

Auf die nächste Zahl runden

Math.round(4.3) > 4 Math.round(4.5) > 5
Beachten Sie, dass der „halbe Wert“, 0,5, nach den Regeln der Mathematik aufgerundet wird.

Abrunden auf die nächste ganze Zahl

Math.floor(42.23); > 42 Math.floor(36.93); > 36
Beachten Sie, dass das Abrunden für alle Zahlen funktioniert, auch für negative. Stellen Sie sich einen Wolkenkratzer mit unendlich vielen Stockwerken vor, einschließlich der unteren Stockwerke (die negative Zahlen darstellen). Wenn Sie sich in einem Aufzug auf der untersten Ebene zwischen 2 und 3 befinden (was einem Wert von -2,5 entspricht), bringt Sie Math.floor zu -3:

Math.floor(-2.5); > -3
Wenn Sie eine solche Situation jedoch vermeiden möchten, verwenden Sie Math.trunc , das in allen modernen Browsern (außer IE/Edge) unterstützt wird:

Math.trunc(-41.43); > -41
Auf MDN finden Sie ein Polyfill, das Math.trunc in Browsern und IE/Edge unterstützt.

Auf die nächste ganze Zahl aufrunden

Math.ceil(42.23); > 43 Math.ceil(36.93); > 37 Math.ceil(-36,93); > -36

Runden Sie nach Bedarf auf/ab

Funktion RoundTo5(num) ( return Math.round(num/5)*5; )
Jetzt:

RoundTo5(11); > 10
Wenn Sie Ihren Wert auf ein Vielfaches runden möchten, verwenden wir eine allgemeinere Funktion und übergeben den Anfangswert und ein Vielfaches:

Funktion RoundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )
Jetzt:

Sei initialNumber = 11; sei ein Vielfaches = 10; RoundToMultiple(initialNumber, multiple); > 10;

Eine Zahl in einem Bereich festlegen

Sei lowBound = 1; let highBound = 100; sei numInput = 123; let Clamped = Math.max(lowBound, Math.min(numInput, highBound)); Konsolenprotokoll (geklemmt); > 100;
Auch hier können wir die Operation wiederverwenden und alles in eine Funktion packen, indem wir die von Daniel X. Moore vorgeschlagene Lösung verwenden:

Number.prototype.clamp = function(min, max) ( return Math.min(Math.max(this, min), max); );
Jetzt:

NumInput.clamp(lowBound, highBound); > 100;

Gaußsche Rundung

Funktion gaussRound(num, decimalPlaces) ( let d = decimalPlaces || 0, m = Math.pow(10, d), n = +(d ? num * m: num).toFixed(8), i = Math.floor (n), f = n - i, e = 1e-8, r = (f > 0,5 - e && f< 0.5 + e) ? ((i % 2 == 0) ? i: i + 1) : Math.round(n); return d ? r / m: r; }
Jetzt:

GaussRound(2.5) > 2 GaussRound(3.5) > 4 GaussRound(2.57,1) > 2.6
Dezimalpunkt in CSS:

Da JavaScript häufig zum Erstellen von Positionstransformationen für HTML-Elemente verwendet wird, fragen Sie sich möglicherweise, was passiert, wenn wir Dezimalwerte für unsere Elemente generieren:

#box (Breite: 63,667731993px;)
Die gute Nachricht ist, dass moderne Browser Dezimalwerte im Box-Modell berücksichtigen, einschließlich Prozent- oder Pixeleinheiten.

Sortierung

Alphabetisch sortieren

Let Fruit = ["Butternusskürbis", "Aprikose", "Melone"]; Fruchtsortierung(); > „Aprikose“, „Butternusskürbis“, „Melone“]
Allerdings stoßen wir auf ein Problem, sobald eines der Elemente in Großbuchstaben geschrieben ist:

Let Fruit = ["Butternusskürbis", "Aprikose", "Cantalope"]; Fruchtsortierung(); > „Melone“, „Aprikose“, „Butternusskürbis“]
Dies liegt daran, dass der Sortierer standardmäßig das erste in Unicode dargestellte Zeichen vergleicht. Unicode ist einzigartiger Code für jeden Charakter, unabhängig von der Plattform, unabhängig vom Programm, unabhängig von der Sprache. Wenn man sich beispielsweise die Codetabelle ansieht, hat das Zeichen „a“ den Wert U+0061 (hexadezimal 0x61), während das Zeichen „C“ den Code U+0043 (0x43) hat, der im Unicode vor dem Zeichen steht Tabelle. "a".

Um ein Array zu sortieren, das Anfangsbuchstaben in gemischter Groß- und Kleinschreibung enthalten kann, müssen wir entweder alle Elemente vorübergehend in Kleinbuchstaben umwandeln oder unsere eigene Sortierreihenfolge mithilfe der Methode localeCompare() mit einigen Argumenten definieren. In einem solchen Fall ist es in der Regel besser, gleich eine Funktion zur Mehrfachverwendung zu erstellen:

Funktion alphaSort(arr) ( arr.sort(function (a, b) ( return a.localeCompare(b, "en", ("sensitivity": "base")); )); ) let Fruit = ["Butternusskürbis „, „Aprikose“, „Kantaloupe“]; alphaSort(Frucht) >
Wenn Sie ein Array in umgekehrter alphabetischer Reihenfolge sortieren möchten, tauschen Sie einfach die Positionen von a und b in der Funktion aus:

Funktion alphaSort(arr) ( arr.sort(function (a, b) ( return b.localeCompare(a, "en", ("sensitivity": "base")); )); ) let Fruit = ["Butternusskürbis „, „Aprikose“, „Kantaloupe“]; alphaSort(fruit) > ["Cantaloupe", "Butternusskürbis", "Aprikose"]
Hier ist es erwähnenswert, dass localeCompare mit Argumenten verwendet wird. Wir müssen auch bedenken, dass es von IE11+ unterstützt wird. Für ältere Versionen von IE können wir es ohne Argumente und in Kleinbuchstaben verwenden:

Funktion caseSort(arr) ( arr.sort(function (a, b) ( return a.toLowerCase().localeCompare(b.toLowerCase()); )); ) let Fruit = ["Butternusskürbis", "Aprikose", "Cantaloup-Melone"]; caseSort(fruit) > ["Aprikose", "Butternusskürbis", "Melone"]

Numerische Sortierung

Sei highScores = ; Sortieren(); >
Tatsache ist, dass die Methode sort() einen lexikografischen Vergleich durchführt: Das bedeutet, dass die Zahlen in eine Zeichenfolge umgewandelt werden und erneut Vergleiche durchgeführt werden, indem das erste Zeichen dieser Zeichenfolge in der Reihenfolge der Zeichen der Unicode-Tabelle abgeglichen wird. Daher müssen wir erneut unsere Sortierreihenfolge definieren:

Sei highScores = ; highScores.sort(function(a,b) ( return a - b; )); >
Um die Zahlen in umgekehrter Reihenfolge zu sortieren, vertauschen Sie wiederum die Positionen von a und b in der Funktion.

Sortieren einer JSON-ähnlichen Struktur

Lassen Sie scores = [ ( "name": "Daniel", "score": 21768 ), ( "name": "Michael", "score": 33579 ), ( "name": "Alison", "score": 38395 )];
In ES6+ können Sie Pfeilfunktionen verwenden:

Scores.sort((a, b) => b.score - a.score));
Für ältere Browser, die diese Unterstützung nicht bieten:

Scores.sort(function(a, b) ( return a.score - b.score ));
Wie Sie sehen, ist das Sortieren in JavaScript eine eher nicht selbstverständliche Sache. Ich hoffe, diese Beispiele machen das Leben irgendwie einfacher.

Arbeiten mit Potenzfunktionen

In JavaScript wird die Exponentialfunktion als Math.pow() dargestellt, im neuen ES7-Standard wurde ein neuer Potenzierungsoperator eingeführt – „ * * „.

Potenzierung

Math.pow(3,2) > 9
Diese Notation bedeutet 3 zum Quadrat oder 3 × 3, was zu einem Ergebnis von 9 führt. Natürlich könnte man auch ein anderes Beispiel nennen:

Math.pow(5,3); > 125
Das heißt, 5 Würfel oder 5 × 5 × 5 ergeben 125.

ECMAScript 7 ist die nächste Version von JavaScript. Im Prinzip können wir den neuen vorgeschlagenen Potenzierungsoperator * * verwenden. Diese Schreibweise kann aussagekräftiger sein:

3 ** 2 > 9
An dieser Moment Die Unterstützung für diesen Operator ist eher begrenzt, daher wird seine Verwendung nicht empfohlen.

Die Power-Funktion kann in verschiedenen Situationen nützlich sein. Ein einfaches Beispiel zur Berechnung der Anzahl der Sekunden in einer Stunde: Math.pow(60,2).

Quadrat- und Kubikwurzel

Math.sqrt(9) > 3
Gleichzeitig ist die Kubikwurzel von a die Zahl, die kubiert a ergibt.

Math.cbrt(125) > 5
Math.cbrt() wurde erst vor kurzem in die JavaScript-Spezifikation eingeführt und wird daher nur in modernen Browsern unterstützt: Chrome 38+, Firefox und Opera 25+ und Safari 7.1+. Das werden Sie merken Internet Explorer ist nicht auf dieser Liste, Sie können jedoch ein Polyfill auf MDN finden.

Beispiele

Math.pow(1.25, 2); > 1,5625 Math.cbrt(56,57) > 3,8387991760286138
Beachten Sie, dass dies bei der Verwendung einwandfrei funktioniert negative Werte Argumente:

Math.pow(-5,2) > 25 Math.pow(10,-2) > 0,01
Für die Quadratwurzel funktioniert dies jedoch nicht:

Math.sqrt(-9) > NaN
Aus der mathematischen Analyse wissen wir, dass unter der imaginären Zahl die Quadratwurzel negativer Zahlen verstanden wird. Und das könnte uns zu einer anderen Technik für komplexe Zahlen führen, aber das ist eine andere Geschichte.

Sie können in Math.pow() Bruchwerte verwenden, um die Quadrat- und Kubikwurzeln von Zahlen zu ermitteln. Die Quadratwurzel verwendet einen Exponenten von 0,5:

Math.pow(5, 0.5); // = Math.sqrt(5) = 5 ** (1/2) > 2.23606797749979
Aufgrund der Launen der Gleitkommazahl können Sie jedoch nicht genau das richtige Ergebnis erraten:

Math.pow(2.23606797749979.2) > 5.000000000000001
In solchen Situationen müssen Sie darauf zurückgreifen, Vorzeichen von der Zahl abzuschneiden oder auf einen bestimmten Wert zu runden.

Einige verwechseln aus unerklärlichen Gründen in JavaScript die Funktion Math.pow() mit Math.exp() , bei der es sich im Allgemeinen um eine Exponentialfunktion für Zahlen handelt. Hinweis: in Englische Sprache„Exponent“ wird als „Exponent“ übersetzt und ist daher für englischsprachige Personen relevanter, obwohl es alternative Namen für den Exponenten gibt, wie z. B. Index, Potenz.

Mathematische Konstanten

Math.abs, parseInt, parseFloat

Math.abs()

Sei newVal = -57,64; Math.abs(newVal); > 57,64
Math.abs(0) gibt immer Null zurück, aber wenn wir vor der Funktion -Math.abs(NUM) ein Minuszeichen setzen, erhalten wir immer einen negativen Wert.

Math.abs(0); > -0

parseInt()

Syntax: parseInt(string, radix);

Die parseInt-Funktion konvertiert das erste übergebene Argument in einen String-Typ, interpretiert ihn und gibt einen Integer- oder NaN-Wert zurück. Das Ergebnis (falls nicht NaN) ist eine ganze Zahl und das erste Argument (Zeichenfolge), das als Zahl im angegebenen Zahlensystem (Basis) behandelt wird. Beispielsweise gibt die Basis 10 die Konvertierung von Dezimalzahlen an, 8 von Oktalzahlen, 16 von Hexadezimalzahlen und so weiter. Wenn die Basis größer als 10 ist, werden Zahlen größer als 9 mit Buchstaben bezeichnet. Beispielsweise verwenden Hexadezimalzahlen (Basis 16) die Buchstaben A bis F.

Betrachten Sie ein Beispiel für die Arbeit mit CSS-Eigenschaften, bei dem wir relativ gesehen den folgenden Wert erhalten können:

Sei elem = document.body; let centerPoint = window.getComputedStyle(elem).transformOrigin; > „454px 2087,19px“
Wir können Werte durch Leerzeichen trennen:

Let centres = centerPoint.split(" "); > ["454px", "2087,19px"]
Da jedoch jedes Element immer noch ein String ist, können wir dies mit unserer Funktion entfernen:

Sei centerX = parseInt(centers, 10); > 454 let centerY = parseInt(centers, 10); > 2087
Wie Sie sehen, geben wir als zweites Argument das Zahlensystem an, in das die Zahl umgewandelt wird. Dieser Parameter ist optional, es wird jedoch empfohlen, ihn zu verwenden, wenn Sie nicht wissen, welche Zeichenfolge eingegeben wird.

parseFloat()

Syntax: parseFloat(string)

LetFP = „33,33333 %“; console.log(parseFloat(FP)); > 33,33333
Beachten Sie, dass es in der parseFloat-Syntax kein zweites Argument gibt.

Wir verstehen, dass parseInt() und parseFloat() extrem sind nützliche Funktionen Es ist wichtig zu bedenken, dass Fehler auftreten können. Daher müssen Sie den Bereich der erwarteten Werte überprüfen und schließlich das Ergebnis analysieren, um sicherzustellen, dass die erhaltenen Werte korrekt sind.
Anonym senden

In diesem Artikel werfen wir einen genaueren Blick auf Zahlen, mathematische Operatoren, Möglichkeiten, eine Zahl in eine Zeichenfolge umzuwandeln und umgekehrt, sowie viele andere wichtige Punkte.

isFinite-Funktion

Mit der Funktion isFinite können Sie überprüfen, ob ein Argument eine endliche Zahl ist.

Als Antwort gegebene Funktion Gibt false zurück, wenn das Argument Infinity , -Infinity , NaN ist oder in einen dieser speziellen numerischen Werte umgewandelt wird. Andernfalls gibt diese Funktion true zurück.

IsFinite(73); // true isFinite(-1/0); // false isFinite(Infinity); // false isFinite(NaN); // false isFinite("Text"); // FALSCH

Außer globale Funktion isFinite JavaScript verfügt auch über die Methode Number.isFinite. Im Gegensatz zu isFinite erzwingt es nicht die Konvertierung des Arguments in eine Zahl.

IsFinite("73"); // true Number.isFinite("73"); // FALSCH

isNaN-Funktion

Die Funktion isNaN dient zur Bestimmung, ob ein Argument eine Zahl ist oder in eine Zahl umgewandelt werden kann. Wenn ja, gibt die isNaN-Funktion „false“ zurück. Andernfalls wird true zurückgegeben.

IsNaN(NaN); //true isNaN("25px"); //wahr, weil 20px ist keine Zahl isNaN(25.5); //false isNaN("25.5"); //false isNaN(" "); //falsch, weil ein Leerzeichen oder mehrere Leerzeichen werden in 0 umgewandelt isNaN(null); //falsch, weil Nullwert wird in 0 konvertiert isNaN(true); //falsch, weil true wird in 1 isNaN(false) konvertiert; //falsch, weil Der falsche Wert wird in 0 umgewandelt

Wenn diese Aktion ohne Typumwandlung ausgeführt werden muss, verwenden Sie die Methode Number.isNaN. Diese Methode wurde seit ECMAScript 6 in die Sprache eingeführt.

Wie konvertiere ich eine Zeichenfolge explizit in eine Zahl?

Mit den folgenden Methoden können Sie eine Zeichenfolge explizit in eine Zahl umwandeln:

1. Verwendung unärer Operator + Das muss vor dem Wert platziert werden.

+"7,35"; // 7.35 +"text"; // NaN

Diese Methode ignoriert Leerzeichen am Anfang und Ende der Zeile sowie \n (Zeilenvorschub).

+"7,35"; //7.35 +"7.35\n"; //7.35

Benutzen Hier entlang Darauf muss man achten leere Zeile oder eine aus Leerzeichen und \n bestehende Zeichenfolge wird in die Zahl 0 konvertiert. Darüber hinaus werden auch der Null-Datentyp und boolesche Werte in eine Zahl konvertiert.

Null; //0 +true; //1 +false; //0 +" "; //0

2. Funktion parseInt . Diese Funktion dient der Konvertierung Argument für eine Ganzzahl. Im Gegensatz zur Verwendung unärer Operator +, diese Methode ermöglicht es Ihnen, eine Zeichenfolge in eine Zahl umzuwandeln, in der Nicht alle Zeichen sind numerisch. Es beginnt mit der Konvertierung der Zeichenfolge, beginnend mit dem ersten Zeichen. Und sobald sie auf ein Zeichen trifft, das kein numerisches Zeichen ist, stoppt diese Funktion ihre Arbeit und gibt die resultierende Zahl zurück.

ParseInt("18px"); //18 parseInt("33,3%"); //33

Diese Funktion kann mit verschiedenen Zahlensystemen (binär, oktal, dezimal, hexadezimal) arbeiten. Die Angabe der Basis des Zahlensystems erfolgt mittels 2 Argumenten.

ParseInt("18px", 10); //18 parseInt("33,3%", 10); //33 parseInt("101",2); //5 parseInt("B5",16); //181

Zusätzlich zur Funktion parseInt verfügt JavaScript über die Methode Number.parseInt. Diese Methode unterscheidet sich nicht von der Funktion parseInt und wurde mit der Spezifikation ECMASCRIPT 2015(6) in JavaScript eingeführt.

3. Funktion parseFloat . Die Funktion parseFloat ähnelt parseInt , außer dass Sie damit das Argument in eine Bruchzahl umwandeln können.

ParseFloat("33,3%"); //33.3

Darüber hinaus verfügt die Funktion parseFloat im Gegensatz zu parseInt nicht über zwei Argumente und versucht daher immer, die Zeichenfolge als Zahl in Dezimalschreibweise zu behandeln.

ParseFloat("3.14"); parseFloat("314e-2"); parseFloat("0.0314E+2");

Zusätzlich zur Funktion parseFloat verfügt JavaScript über die Methode Number.parseFloat. Diese Methode unterscheidet sich nicht von der Funktion parseFloat und wurde mit der Spezifikation ECMASCRIPT 2015(6) in JavaScript eingeführt.

Konvertieren Sie eine Zahl in eine Zeichenfolge

Mit der toString-Methode können Sie eine Zahl in eine Zeichenfolge umwandeln.

(12.8).toString(); //"12,8"

Mit der toString-Methode können Sie auch die Basis des Zahlensystems angeben und dabei berücksichtigen, dass Sie die Zahl explizit in die Zeichenfolge umwandeln müssen:

(255).toString(16); //"ff"

So überprüfen Sie, ob eine Variable eine Zahl ist

Mit einer der folgenden Methoden können Sie feststellen, ob der Wert einer Variablen eine Zahl ist:

1. Verwendung der Funktionen isNaN und isFinite:

// myVar ist eine Variable if (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //myVar ist eine Zahl oder kann in sie umgewandelt werden );

Als eine Funktion:

// Funktion function isNumeric(value) ( ​​​​return !isNaN(parseFloat(value)) && isFinite(parseFloat(value)); ) // Verwendung var myVar = "12px"; console.log(isNumeric(myVar)); //WAHR

Mit dieser Methode können Sie feststellen, ob der angegebene Wert eine Zahl ist oder in diese umgewandelt werden kann. Diese Variante zählt keine leere Zeichenfolge, eine Zeichenfolge aus Leerzeichen, null , Infinity , -Infinity , true und false als Zahl.

2. Unter Verwendung des Operators „typeof“ und der Funktionen „isFinite“ und „isNaN“:

// Funktion, die prüft, ob der Wert eine Zahl ist Funktion isNumber(value) ( ​​​​return typeof value === "number" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

Diese Funktion ermittelt, ob der angegebene Wert vom Typ Zahl ist und nicht einer der Sonderwerte Infinity, -Infinity und NaN ist. Wenn ja, gibt diese Funktion true zurück.

3. Verwendung der ECMAScript 6 Number.isInteger(value)-Methode. Mit dieser Methode können Sie feststellen, ob der angegebene Wert eine Ganzzahl ist.

Number.isInteger("20"); //falsch, weil Diese Methode übersetzt die Zeichenfolge nicht in eine Zahl Number.isInteger(20); //wahr, weil Der angegebene Wert ist eine Zahl

Gerade und ungerade Zahlen

Mit den folgenden Funktionen können Sie überprüfen, ob eine Zahl gerade oder ungerade ist:

// Funktion zum Überprüfen, ob eine Zahl gerade ist function isEven(n) ( return n % 2 == 0; ) // Funktion zum Überprüfen, ob eine Zahl ungerade ist function isOdd(n) ( return Math.abs(n % 2) == 1; )

Bevor Sie eine solche Prüfung durchführen, sollten Sie jedoch sicherstellen, dass der angegebene Wert eine Zahl ist:

Wert=20; if (Number.isInteger(value)) ( if (isEven(value)) ( console.log("Number " + value.toString() + " - even"); ) )

Primzahlen in Javascript

Betrachten Sie ein Beispiel, in dem wir ableiten Javascript Primzahlen von 2 bis 100.

// Eine Funktion, die prüft, ob eine Zahl eine Primzahlfunktion ist isPrime(value) ( ​​​​if (isNaN(value) || !isFinite(value) || value%1 || value< 2) return false; var max=Math.floor(Math.sqrt(value)); for (var i = 2; i< = max; i++) { if (value%i==0) { return false; } } return true; } // создать массив, который будет содержать простые числа от 2 до 100 var primaryNumber = ; for (var i = 2; i <= 100; i++) { if(isPrime(i)) primaryNumber.push(i); } // вывести в консоль простые числа от 2 до 100 console.log(primaryNumber);

Runden einer Zahl in Javascript

Es gibt verschiedene Möglichkeiten, eine Bruchzahl in JavaScript auf einen ganzzahligen Wert zu runden.

1. Verwendung der speziell dafür entwickelten Methoden Math.floor , Math.ceil und Math.round. Die Math.floor-Methode rundet eine Bruchzahl auf die nächste ganze Zahl ab, d. h. verwirft einfach den Bruchteil. Math.ceil rundet eine Bruchzahl auf die nächste ganze Zahl auf. Math.round rundet eine Zahl abhängig vom Wert des Bruchteils auf oder ab. Wenn der Bruchteil größer oder gleich 0,5 ist, dann nach oben, andernfalls nach unten.

Console.log(Math.floor(7.9)); //7 console.log(Math.ceil(7.2)); //8 console.log(Math.round(7.5)); //8

2. Verwendung der toFixed(precision)-Methode. Diese Methode rundet den Bruchteil einer Zahl auf die angegebene Genauigkeit. Das Rundungsergebnis wird als String zurückgegeben.

Console.log(7.987.toFixed(2)); //"7,99"

Wenn nicht genügend Dezimalstellen vorhanden sind, um die angegebene Genauigkeit der Zahl zu erreichen, wird sie mit Nullen aufgefüllt.

Console.log(7.987.toFixed(5)); //"7.98700"

3. Durch die toPrecision(precision)-Methode. Diese Methode stellt eine Zahl mit der angegebenen Genauigkeit dar. Dabei kann er nicht nur den Bruchteil, sondern auch den ganzen Teil einer Zahl runden. Die resultierende Zahl kann mit dieser Methode je nach Ergebnis in Festkomma- oder Exponentialform dargestellt werden.

Console.log((1001).toPrecision(2)); //"1.0e+3" console.log((1001).toPrecision(5)); //"1001.0" console.log((12.4).toPrecision(1)); //"1e+1" console.log((12.4).toPrecision(2)); //"12" console.log((12.4).toPrecision(3)); //"12.4" console.log((12.4).toPrecision(5)); //"12.400"

4. Verwendung logischer NOT- oder OR-Operatoren.

//über doppelte logische Negation console.log(~~7.9); //7 // durch logisches ODER mit Null: console.log(7.9^0); //7

Ganzzahliger und gebrochener Teil einer Zahl

Sie können den ganzzahligen Teil einer Zahl mit den Methoden Math.floor() und parseInt() ermitteln:

Console.log(Math.floor(7.21)); // 7 console.log(parseInt(7.21)); // 7

Sie können den Bruchteil einer Zahl mithilfe des Prozentoperators (%) ermitteln. Dieser Operator gibt den Rest zurück, der sich aus der Division der ersten Zahl durch die zweite ergibt. In diesem Fall sollte 1 als 2. Zahl verwendet werden.

Console.log(7.21%1); // 0,20999999999999996 // auf 2 Dezimalstellen genau console.log((7.21%1).toFixed(2)); // "0,21"

Darüber hinaus kann der Bruchteil auch durch Berechnungen ermittelt werden:

Var-Nummer = 7,21; var FractionNumber = Zahl - Math.floor(Math.abs(Zahl)); console.log(fractionNumber); // 0,20999999999999996

Ist die Zahl teilbar?

Mit dem Prozentoperator können Sie feststellen, ob eine Zahl gleichmäßig teilbar ist:

Varnummer = 9; // wenn der Rest der Division von Zahl durch 3 0 ist, dann ja, andernfalls nein if (Zahl%3==0) ( console.log ("Die Zahl " + Zahl + " ist durch 3 teilbar"); ) else ( console. log("Zahl " + Zahl + " ist nicht durch 3 teilbar"); )

Zahlenformatierung

In JavaScript können Sie mit der Methode toLocaleString() die Ausgabe einer Zahl entsprechend dem Gebietsschema (Spracheinstellungen des Betriebssystems) formatieren.

Formatieren wir beispielsweise eine Zahl gemäß den regionalen Standards, die standardmäßig im System installiert sind:

Var-Nummer = 345,46; console.log(number.toLocaleString()); //"345,46"

Formatieren wir beispielsweise eine Zahl gemäß den regionalen Standards Russlands (ru):

Console.log((108.1).toLocaleString("ru-RU")); //"108,1"

Diese Methode kann auch verwendet werden, um eine Zahl als Währung zu formatieren:

Console.log((2540.125).toLocaleString("ru-RU",(style:"currency", Währung:"RUB"))); //"2.540,13 ₽" console.log((89.3).toLocaleString("ru-RU",(style:"currency", Währung:"USD"))); //"$89.30" console.log((2301.99).toLocaleString("ru-RU",(style:"currency", payment:"EUR"))); //"2.301,99 €"

Darstellung einer Zahl als Prozentsatz:

Console.log((0.45).toLocaleString("ru-RU",(style:"percent"))); //"45%"

Teilen Sie die Zahl in Ziffern auf (useGrouping-Eigenschaft):

Console.log((125452.32).toLocaleString("ru-RU",(useGrouping:true))); //"125 452,32"

Geben Sie eine Zahl mit einer bestimmten Anzahl von Nachkommastellen (2) aus:

Console.log((1240.4564).toLocaleString("ru-RU",(minimumFractionDigits:2, maximumFractionDigits:2))); //"1240.46"

Zahlenvergleich

Die folgenden Operatoren werden zum Vergleichen von Zahlen in JavaScript verwendet: == (gleich), != (ungleich), > (größer als),< (меньше), >= (größer oder gleich),<= (меньше или равно).

Vergleichen wir zum Beispiel zwei Zahlen:

Console.log(2>3); //false console.log(5>=3); //WAHR

Beim Vergleich von Zahlen mit einem Bruchteil müssen die Fehler berücksichtigt werden, die bei diesen Berechnungen auftreten können.

In JavaScript ist beispielsweise die Summe der Zahlen (0,2 + 0,4) nicht gleich 0,6:

Console.log((0.2+0.4)==0.6); //FALSCH

Es treten Fehler auf, da alle Berechnungen am Computer oder auf anderem Wege erfolgen elektronisches Gerät produziert im 2-Zahlensystem. Diese. Bevor irgendwelche Aktionen ausgeführt werden, muss der Computer zunächst die im Ausdruck dargestellten Zahlen in das 2-Zahlensystem umwandeln. Allerdings lässt sich im 2. Zahlensystem nicht jede gebrochene Dezimalzahl exakt darstellen.

Zum Beispiel die Zahl 0,25 10 Zoll binäres System exakt umgerechnet.

0,125 × 2 = 0,25 | 0 0,25 × 2 = 0,5 | 0 0,5 × 2 = 1 | 1 0,125 10 = 0,001 2

Beispielsweise lässt sich die Zahl 0,2 · 10 nur mit einer gewissen Genauigkeit in das 2er-System umrechnen:

0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 ... 0,2 · 10 = 0,001100110011... 2

Infolgedessen wirken sich diese Fehler auf die Berechnung der Summe zweier Zahlen und die Vergleichsergebnisse aus. Diese. Es stellt sich heraus, dass JavaScript diesen Eintrag tatsächlich wie folgt sieht:

0.6000000000000001==0.6

Beim Berechnen oder Darstellen von Zahlen mit Nachkommastellen müssen Sie immer angeben, mit welcher Genauigkeit dies erfolgen soll.

Vergleichen Sie beispielsweise Zahlen bis zu zwei Dezimalstellen mit den Methoden toFixed() und toPrecision():

//Methode toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //toPrecision()-Methode console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //WAHR

Grundlegende mathematische Operationen

JavaScript verfügt über die folgenden mathematischen Operatoren: + (Addition), - (Subtraktion), * (Multiplikation), / (Division), % (Rest der Division), ++ (Wert um 1 erhöhen), -- (Wert um 1 verringern ).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, d.h. 6:3=2 => 6-3*2 => rest(0) 5%2 //1, d.h. 5:2=2(.5) => 5-2*2 => rest(1) 7,3%2 //1,3, d.h. 7.3:2=3(.65) => 7.3-2*3 => rest(1.3) //das Vorzeichen des Operationsergebnisses % ist gleich dem Vorzeichen des ersten Wertes -9%2.5 //-1.5, d.h. 9:2,5=3(.6) => 9-2,5*3 => rest(1,5) -9%-2,5 //-1,5, d.h. 9:2,5=3(.6) => 9-2,5*3 => rest(1,5) -2%5 //-2, d.h. 2:5=0(.4) => 2-5*0 => rest(2) x = 3; Konsolenprotokoll(x++); //zeigt 3 an und setzt dann y auf 4 console.log(x); //4 x = 3; Konsolenprotokoll(++x); // setzt 4 und gibt x = 5 aus; Konsolenprotokoll(x--); //gibt 5, y aus und setzt dann 4 console.log(x); //4 x = 5; Konsolenprotokoll(--x); //wird auf 4 gesetzt und ausgegeben. Darüber hinaus gibt es in JavaScript kombinierte Operatoren: x+=y (x=x+y), x-=y (x=x-y), x*=y (x=x*y), x/= y (x=x/y), x%=y (x=x%y). x=3; y=6; x+=y; Konsolenprotokoll(x); //9 x = 3; y=6; x-=y; Konsolenprotokoll(x); //-3 x = 3; y=6; x*=y; Konsolenprotokoll(x); //18 x = 3; y=6; x/=y; Konsolenprotokoll(x); //0,5 x = 3; y=6; x%=y; Konsolenprotokoll(x); //3