JavaScript-Mathematik, Runden auf zwei Dezimalstellen (9)
Ich habe die folgende JavaScript-Syntax:
Var discount = Math.round(100 - (Preis / Listenpreis) * 100);
Dies wird auf die nächste ganze Zahl gerundet. Wie kann ich das Ergebnis mit zwei Dezimalstellen zurückgeben?
Hier ist ein funktionierendes Beispiel
Var-Wert=200,2365455; result=Math.round(value*100)/100 //result wird 200,24 sein
Um das Runden auf eine beliebige Anzahl von Dezimalstellen zu ermöglichen, reicht für die meisten Anforderungen eine Funktion mit zwei Codezeilen aus. Hier ist ein Beispielcode für das Spiel.
Var testNum = 134.9567654; var decPl = 2; var testRes = RoundDec(testNum,decPl); Alert(testNum + " gerundet auf " + decPl + " Dezimalstellen sind " + testRes); function RoundDec(nbr,dec_places)( var mult = Math.pow(10,dec_places); return Math.round(nbr * mult) / mult; )
Die beste und einfachste Lösung, die ich gefunden habe, ist diese
Funktion round(value, decimals) ( return Number(Math.round(value+"e"+decimals)+"e-"+decimals); ) Round(1.005, 2); // 1.01
Leichte Abweichung von der akzeptierten Antwort. toFixed(2) gibt einen String zurück und Sie erhalten immer zwei Dezimalstellen. Dies könnten Nullen sein. Wenn Sie nachgestellte Nullen unterdrücken möchten, gehen Sie einfach wie folgt vor:
Var Rabatt = + ((Preis / Listenpreis).toFixed(2));
Bearbeitet: Ich habe gerade einen scheinbaren Fehler in Firefox 35.0.1 entdeckt, was bedeutet, dass das oben Gesagte möglicherweise einige NaN-Werte liefert.
Ich habe meinen Code geändert in
Var discount = Math.round(price / listprice * 100) / 100;
Dies gibt die Zahl auf zwei Dezimalstellen genau an. Wenn Sie drei benötigen, multiplizieren und dividieren Sie mit 1000 und so weiter.
Das OP möchte immer zwei Dezimalstellen, aber wenn toFixed() in Firefox kaputt ist, muss es zuerst repariert werden.
Siehe https://bugzilla.mozilla.org/show_bug.cgi?id=1134388
Um ein Ergebnis mit zwei Nachkommastellen zu erhalten, können Sie Folgendes tun:
Var discount = Math.round((100 - (price / listprice) * 100) * 100) / 100;
Der zu rundende Wert wird mit 100 multipliziert, um die ersten beiden Ziffern beizubehalten. Anschließend dividieren wir durch 100, um das tatsächliche Ergebnis zu erhalten.
Ich denke Der beste Weg Das, was ich gesehen habe, besteht darin, die Anzahl der Ziffern mit 10 zu multiplizieren, dann Math.round auszuführen und schließlich durch die Anzahl der Ziffern durch 10 zu dividieren. Hier ist eine einfache Funktion, die ich in Typoskript verwende:
Funktion RoundToXDigits(Wert: Zahl, Ziffern: Zahl) ( Wert = Wert * Math.pow(10, Ziffern); Wert = Math.round(Wert); Wert = Wert / Math.pow(10, Ziffern); Rückgabewert; )
Oder einfaches Javascript:
Funktion RoundToXDigits(Wert, Ziffern) ( if(!digits)( Ziffern = 2; ) Wert = Wert * Math.pow(10, Ziffern); Wert = Math.round(Wert); Wert = Wert / Math.pow(10 , Ziffern); Rückgabewert; )
NOTIZ. - Siehe Edit 4, wenn die 3-stellige Genauigkeit wichtig ist.
Var discount = (price / listprice).toFixed(2);
toFixed rundet für Sie auf oder ab, abhängig von Werten, die größer als 2 Dezimalstellen sind.
Ändern. Wie andere bereits erwähnt haben, wird dadurch das Ergebnis in eine Zeichenfolge konvertiert. Um es zu umgehen:
Var Rabatt = +((Preis / Listenpreis).toFixed(2));
Bearbeiten 2– Wie in den Kommentaren erwähnt, führt diese Funktion nicht mit einiger Präzision aus, zum Beispiel gibt sie im Fall von 1,005 1,00 statt 1,01 zurück. Wenn Genauigkeit so wichtig ist, habe ich diese Antwort gefunden: https://.com/a/32605063/1726511. Sie scheint bei allen Tests, die ich ausprobiert habe, gut zu funktionieren.
Eine geringfügige Änderung ist erforderlich, aber die Funktion in der obigen Antwort gibt ganze Zahlen zurück, wenn sie auf eins gerundet wird, sodass beispielsweise 99,004 99 statt 99,00 zurückgibt, was für die Preisanzeige nicht ideal ist.
Bearbeiten 3- Es scheint, dass toFixed bei der eigentlichen STILL-Rückgabe einige Zahlen durcheinander gebracht hat, diese letzte Änderung scheint zu funktionieren. Meine Güte, so viele Wiedergutmachungen!
Var Rabatt = RoundTo((Preis / Listenpreis), 2); function RoundTo(n, Ziffern) ( if (Ziffern === undefiniert) ( Ziffern = 0; ) var multiplicator = Math.pow(10, Ziffern); n = parseFloat((n * multiplicator).toFixed(11)); var test =(Math.round(n) / multiplikator); return +(test.toFixed(digits)); )
Bearbeiten 4- Ihr bringt mich um. Bearbeitung 3 schlägt bei negativen Zahlen fehl, ohne zu untersuchen, warum es einfacher ist, die negative Zahl vor dem Runden einfach positiv zu machen und sie dann wieder zu ändern, bevor das Ergebnis zurückgegeben wird.
Funktion RoundTo(n, Ziffern) ( var negativ = false; if (Ziffern === undefiniert) ( Ziffern = 0; ) if(n< 0) { negative = true; n = n * -1; } var multiplicator = Math.pow(10, digits); n = parseFloat((n * multiplicator).toFixed(11)); n = (Math.round(n) / multiplicator).toFixed(2); if(negative) { n = (n * -1).toFixed(2); } return n; }
Der schnellste Weg- schneller als toFixed():
ZWEI AUFKLEBER
x = .123456 result = Math.round(x * 100) / 100 // result .12DREI DEZIMALITÄT
x = .123456 result = Math.round(x * 1000) / 1000 // result .123Funktion Round(num,dec) ( num = Math.round(num+"e"+dec) return Number(num+"e-"+dec) ) //Runde auf eine Dezimalzahl deiner Wahl: Round(1.3453,2)
Sehr oft liefern Berechnungen in JavaScript nicht genau die gewünschten Ergebnisse. Natürlich können wir mit Zahlen machen, was wir wollen – auf- oder abrunden, Bereiche festlegen, unnötige Zahlen auf eine bestimmte Anzahl von Dezimalstellen abschneiden, alles hängt davon ab, was Sie in Zukunft mit dieser Zahl machen möchten.Warum ist eine Rundung notwendig?
Einer der interessanten Aspekte von JavaScript ist, dass es eigentlich keine Ganzzahlen speichert, sondern wir arbeiten direkt mit Gleitkommazahlen. In Kombination mit der Tatsache, dass viele Bruchwerte nicht mit endlich vielen Dezimalstellen ausgedrückt werden können, können wir in JavaScript Ergebnisse wie diese erhalten: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 Teilen, was jedoch einige enttäuschen könnte. Wir können auch etwas 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, manipulieren wir möglicherweise eine Zahl innerhalb eines bestimmten Bereichs, beispielsweise möchten wir den Wert auf die nächste ganze Zahl runden, anstatt nur mit dem Dezimalteil zu arbeiten.
Dezimalzahlen runden
Um abzuschneiden Dezimalzahl, verwenden Sie toFixed oder die toPrecision-Methode. Beide benötigen ein einziges Argument, das jeweils bestimmt, wie viele bedeutende Zahlen(d. h. die Gesamtzahl der in der Zahl verwendeten Ziffern) oder Dezimalstellen (die Zahl nach dem Komma) müssen das Ergebnis enthalten:- Wenn für toFixed() kein Argument definiert ist, wird es standardmäßig auf Null gesetzt, was 0 Dezimalstellen bedeutet, das Argument hat einen Maximalwert von 20.
- Wenn toPrecision kein Argument übergeben wird, bleibt die Zahl unberührt
Sowohl die Methoden toFixed() als auch toPrecision() geben eine Zeichenfolgendarstellung des Ergebnisses zurück, keine Zahl. Das bedeutet, dass beim Summieren eines gerundeten Werts mit randNum eine Verkettung von Zeichenfolgen und nicht eine Summe von Zahlen entsteht:
Sei randNum = 6,25; let Rounded = randNum.toFixed(); // "6" console.log(randNum + abgerundet); > „6.256“
Wenn das Ergebnis ein numerischer Datentyp sein soll, müssen Sie parseFloat verwenden:
Sei randNum = 6,25; let Rounded = parseFloat(randNum.toFixed(1)); console.log(gerundet); > 6.3
Bitte beachten Sie, dass Werte von 5 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 Dezimalstellen hinzufügen 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 wissenschaftlicher Notation liefert, 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
In einigen Fällen runden toFixed und toPrecision den Wert 5 ab und auf:Sei numTest = 1.005; numTest.toFixed(2); > „1,00“
Das Ergebnis der obigen Berechnung hätte 1,01 und nicht 1 sein müssen. Wenn Sie einen ähnlichen 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
In ES6 wurde eine alternative Methode zum Runden von Dezimalzahlen eingeführt. Die maschinelle Epsilon-Rundung bietet eine angemessene Fehlerspanne beim Vergleich zweier Gleitkommazahlen. Ohne Rundung können Vergleiche zu Ergebnissen wie den folgenden führen:0,1 + 0,2 === 0,3 > falsch
Wir verwenden Math.EPSILON in unserer Funktion, 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: 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.
Trimmen des Bruchteils
Alle oben vorgestellten Methoden können auf Dezimalzahlen runden. Um eine Zahl einfach auf zwei Dezimalstellen zu reduzieren, müssen Sie sie zunächst mit 100 multiplizieren und dann das resultierende Ergebnis durch 100 dividieren: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
Runden Sie auf die nächste Zahl
Um eine Dezimalzahl auf die nächste Zahl nach oben oder unten zu runden, je nachdem, welcher Zahl am nächsten liegt, verwenden Sie Math.round():Math.round(4.3) > 4 Math.round(4.5) > 5
Bitte beachten Sie, dass beim „halben Wert“ 0,5 nach den Regeln der Mathematik aufgerundet wird.
Runden Sie auf die nächste ganze Zahl ab
Wenn Sie immer abrunden möchten, verwenden Sie Math.floor:Math.floor(42.23); > 42 Math.floor(36.93); > 36
Bitte beachten Sie, dass das Abrunden für alle Zahlen funktioniert, auch für negative Zahlen. Stellen Sie sich einen Wolkenkratzer mit unendlich vielen Stockwerken vor, einschließlich der Stockwerke auf der untersten Ebene (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 diese 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.
Runden Sie auf die nächste ganze Zahl auf
Wenn Sie hingegen immer aufrunden müssen, verwenden Sie Math.ceil. Denken Sie auch hier an den unendlichen Aufzug: Math.ceil wird immer „nach oben“ gehen, unabhängig davon, ob die Zahl negativ ist oder nicht:Math.ceil(42.23); > 43 Math.ceil(36.93); > 37 Math.ceil(-36,93); > -36
Auf-/Abrunden auf die erforderliche Zahl
Wenn wir auf das nächste Vielfache von 5 runden möchten, ist es am einfachsten, eine Funktion zu erstellen, die die Zahl durch 5 dividiert, sie rundet und sie dann mit demselben Betrag multipliziert: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 das Vielfache:
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
Es gibt viele Fälle, in denen wir einen Wert von x erhalten möchten, der innerhalb eines Bereichs liegt. Beispielsweise benötigen wir möglicherweise einen Wert zwischen 1 und 100, am Ende haben wir jedoch einen Wert von 123 erhalten. Um dies zu beheben, können wir „min“ (gibt die kleinste Zahl aus einer Reihe von Zahlen zurück) und „max“ (gibt die größte aus einer Reihe von Zahlen zurück) verwenden von Zahlen). In unserem Beispiel liegt der Bereich zwischen 1 und 100:Sei lowBound = 1; let highBound = 100; sei numInput = 123; let Clamped = Math.max(lowBound, Math.min(numInput, highBound)); console.log(geklemmt); > 100;
Auch hier können wir die Operation wiederverwenden und das Ganze 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
Bei der Gaußschen Rundung, auch Bankrundung genannt, wird auf die nächste gerade Zahl gerundet. Diese Rundungsmethode funktioniert ohne statistische Fehler. Die beste Entscheidung wurde von Tim Down vorgeschlagen: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
Dezimal in CSS:
Da JavaScript häufig zum Erstellen von Positionszuordnungen für HTML-Elemente verwendet wird, fragen Sie sich möglicherweise, was passieren würde, wenn wir Dezimalwerte für unsere Elemente generieren würden:
#box (Breite: 63,667731993px;)
Die gute Nachricht ist, dass moderne Browser Dezimalwerte im Blockmodell berücksichtigen, einschließlich Prozent- oder Pixeleinheiten.
Sortierung
Sehr oft müssen wir einige Elemente sortieren, zum Beispiel haben wir eine Reihe von Spielaufzeichnungen, und diese müssen in absteigender Reihenfolge des Spielerrangs organisiert werden. Leider weist die Standardmethode sort() einige überraschende Einschränkungen auf: Sie funktioniert gut mit häufig verwendeten Methoden in englischen Worten, bricht jedoch sofort ab, wenn auf Zahlen, eindeutige Zeichen oder Wörter gestoßen wird Großbuchstaben.Alphabetisch sortieren
Es scheint, dass das alphabetische Sortieren eines Arrays eine einfache Aufgabe sein sollte:Let Fruit = ["Butternusskürbis", "Aprikose", "Melone"]; obst.sort(); > „Aprikose“, „Butternusskürbis“, „Melone“]
Allerdings stoßen wir auf ein Problem, sobald eines der Elemente groß geschrieben ist:
Let Fruit = ["Butternusskürbis", "Aprikose", "Cantalope"]; obst.sort(); > „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 jedes Symbol, unabhängig von der Plattform, unabhängig vom Programm, unabhängig von der Sprache. Wenn Sie sich beispielsweise die Codetabelle ansehen, hat das Zeichen „a“ den Wert U+0061 (im Hexadezimalformat 0x61), während das Zeichen „C“ den Code U+0043 (0x43) hat, der im Unicode früher steht Tabelle als das Zeichen „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 Sortierreihenfolge mithilfe der Methode localeCompare() mit einigen Argumenten definieren. In einem solchen Fall ist es in der Regel besser, sofort eine Funktion zur wiederholten Verwendung 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 möchten, dass das Array in umgekehrter alphabetischer Reihenfolge sortiert wird, 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", "Kantalupe"]; caseSort(fruit) > ["Aprikose", "Butternusskürbis", "Melone"]
Numerische Sortierung
All dies gilt nicht für das Beispiel, über das wir oben über die Reihe von Spielaufzeichnungen gesprochen haben. Bei einigen numerischen Arrays funktioniert die Sortierung einwandfrei, aber irgendwann kann das Ergebnis unvorhersehbar sein:Sei highScores = ; highScores.sort(); >
Die Sache ist, dass die Methode sort() einen lexikografischen Vergleich durchführt: Das bedeutet, dass die Zahlen in eine Zeichenfolge umgewandelt werden und die Vergleiche erneut durchgeführt werden, indem das erste Zeichen dieser Zeichenfolge in der Reihenfolge der Zeichen in der Unicode-Tabelle abgeglichen wird . Daher müssen wir erneut unsere Sortierreihenfolge definieren:
Sei highScores = ; highScores.sort(function(a,b) ( return a - b; )); >
Um Zahlen in umgekehrter Reihenfolge zu sortieren, vertauschen Sie wiederum die Positionen von a und b in der Funktion.
Sortieren einer JSON-ähnlichen Struktur
Und schließlich, wenn wir eine JSON-ähnliche Datenstruktur haben, die als Array von Spieldatensätzen dargestellt wird: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 haben:
Scores.sort(function(a, b) ( return a.score - b.score ));
Wie Sie sehen, ist das Sortieren in JavaScript eine eher obskure Sache. Ich hoffe, dass diese Beispiele das Leben irgendwie einfacher machen.
Arbeiten mit Leistungsfunktionen
Potenzierung ist eine Operation, die ursprünglich als Ergebnis der wiederholten Multiplikation einer natürlichen Zahl mit sich selbst definiert wurde; die Quadratwurzel von a ist die Zahl, die quadriert a ergibt. Wir könnten diese Funktionen im Alltag im Mathematikunterricht ständig nutzen, etwa bei der Berechnung von Flächen, Volumina oder auch bei der physikalischen Modellierung.IN JavaScript-Leistung Die Funktion wird als Math.pow() dargestellt. Im neuen ES7-Standard wurde ein neuer Potenzierungsoperator eingeführt – „ * * “.
Potenzierung
Um eine Zahl auf die n-te Potenz zu erhöhen, verwenden Sie die Funktion Math.pow(), wobei das erste Argument die Zahl ist, die zur Potenz erhoben wird, und das zweite Argument der Exponent ist:Math.pow(3,2) > 9
Diese Schreibweise bedeutet 3 zum Quadrat, also 3 × 3, was zum Ergebnis 9 führt. Natürlich kann man noch ein anderes Beispiel nennen:
Math.pow(5,3); > 125
Das heißt, 5 Würfel oder 5 × 5 × 5 sind gleich 125.
ECMAScript 7 ist die nächste Version von JavaScript. Im Prinzip können wir den neuen vorgeschlagenen Potenzierungsoperator * * verwenden. Diese Notationsform ist möglicherweise aussagekräftiger:
3 ** 2
> 9
An dieser Moment Die Unterstützung für diesen Operator ist recht 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 Kubikwurzeln
Math.sqrt() und Math.cbrt() sind das Gegenteil von Math.pow(). Wie wir uns erinnern, ist die Quadratwurzel von a die Zahl, die quadriert a ergibt.Math.sqrt(9) > 3
Gleichzeitig ist die Kubikwurzel von a eine Zahl, die a ergibt, wenn man sie zur Kubik erhöht.
Math.cbrt(125) > 5
Math.cbrt() wurde erst kürzlich in die JavaScript-Spezifikation eingeführt und wird daher nur in modernen Browsern unterstützt: Chrome 38+, Firefox und Opera 25+ sowie Safari 7.1+. Das werden Sie merken Internet Explorer ist nicht auf dieser Liste, aber Sie finden eine Polyfüllung auf MDN.
Beispiele
Natürlich können wir in einer dieser Funktionen nicht ganzzahlige Werte verwenden:Math.pow(1.25, 2); > 1,5625 Math.cbrt(56,57) > 3,8387991760286138
Bitte beachten Sie, dass dies bei der Verwendung recht gut funktioniert negative Werte Argumente:
Math.pow(-5,2) > 25 Math.pow(10,-2) > 0,01
Dies funktioniert jedoch nicht für die Quadratwurzel:
Math.sqrt(-9) > NaN
Aus der mathematischen Analyse wissen wir, dass sich eine imaginäre Zahl auf die Quadratwurzeln negativer Zahlen bezieht. Und das führt uns vielleicht zu einer anderen Technik für die Arbeit mit komplexen Zahlen, aber das ist eine andere Geschichte.
Sie können Brüche in Math.pow() verwenden, um die Quadrat- und Kubikwurzeln von Zahlen zu finden. 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.
Aus unbekannten Gründen verwechseln einige Leute in JavaScript die Funktion Math.pow() mit Math.exp() , der Exponentialfunktion für Zahlen im Allgemeinen. Hinweis: in Englische Sprache„Exponent“ wird mit „Exponent“ übersetzt, daher trifft dies eher auf Englischsprachige zu, obwohl es alternative Namen für Exponenten gibt, wie z. B. Index, Potenz.
Mathematische Konstanten
Die Arbeit mit Mathematik in JavaScript wird durch eine Reihe integrierter Konstanten erleichtert. Diese Konstanten sind Eigenschaften des Math-Objekts. Es ist zu beachten, dass Konstanten in Großbuchstaben und nicht in der CamelCase-Notation geschrieben werden.Math.abs, parseInt, parseFloat
Die Arbeit mit Zahlen in JavaScript kann viel komplizierter sein, als es scheint. Die erhaltenen Werte liegen nicht immer innerhalb der erwarteten Bereiche; manchmal entspricht das Ergebnis überhaupt nicht unseren Erwartungen.Math.abs()
Die Methode Math.abs() gibt den Absolutwert einer Zahl zurück, was uns an eine ähnliche mathematische Funktion für den Modul einer Zahl erinnert.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()
Wir wissen, dass JavaScript versteht, dass „15“ eine Zeichenfolge und keine Zahl ist, und wenn wir beispielsweise CSS-Eigenschaften mit JavaScript analysieren oder einen Wert aus einem unvorbereiteten Array empfangen, können unsere Ergebnisse unvorhersehbar sein. Wir könnten als Eingabe eine Zeichenfolge erhalten, die als „17px“ dargestellt wird, und das ist für uns nicht ungewöhnlich. Die Frage ist, wie man diese Zeichenfolge in einen tatsächlichen Wert umwandelt und in weiteren Berechnungen verwendet.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 Ganzzahl und das erste Argument (Zeichenfolge), das als Zahl in der angegebenen 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 Buchstaben verwendet, um Zahlen größer als 9 darzustellen. Beispielsweise werden für Hexadezimalzahlen (Basis 16) die Buchstaben A bis F verwendet.
Schauen wir uns ein Beispiel für die Arbeit mit CSS-Eigenschaften an, 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 die Werte durch Leerzeichen aufteilen:
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 mit dem zweiten 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 als Eingabe empfangen wird.
parseFloat()
Anhand des obigen Beispiels ist Ihnen wahrscheinlich aufgefallen, dass parseInt den Bruchteil verwirft. In unserem Fall kann parseFloat mit Gleitkommazahlen arbeiten. Auch dies kann beim Parsen von CSS und anderen Aufgaben nützlich sein, insbesondere beim Arbeiten mit Gleitkomma-Prozentsätzen.Syntax: parseFloat(string)
Sei FP = „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 beachten, dass immer noch einige Fehler vorliegen. Daher ist es notwendig, den Bereich der erwarteten Werte zu überprüfen und letztendlich das Ergebnis zu analysieren, um sicherzustellen, dass die erhaltenen Werte korrekt sind.
Anonym senden
Häufig führen Berechnungen zu Ergebnissen, die außerhalb der gewünschten Bereiche liegen. Daher ist eine Umsetzung erforderlich 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 als Zahl mit einer bestimmten endlichen Anzahl von Dezimalstellen dargestellt werden, sodass JavaScript Ergebnisse wie die folgenden generieren kann:
0.1 * 0.2; > 0.020000000000000004
In der Praxis wird dies keinen Unterschied machen, da wir von einem Fehler von 2 Trillionsteln sprechen. Dies kann sich jedoch auf die Ergebnisse auswirken, wenn mit Zahlen gearbeitet wird, die Währungswerte, Prozentsätze oder Dateigrößen darstellen. Daher müssen Sie oder auf eine bestimmte Dezimalstelle genau eingeben.
Dezimalzahlen runden
Um eine Dezimalzahl zu „schneiden“, verwenden Sie die Methoden toFixed() oder toPrecision(). Beide benötigen ein Argument, das die Anzahl der signifikanten Stellen und Dezimalstellen angibt, die in das Ergebnis einbezogen werden sollen:
- Wenn für toFixed() kein Argument angegeben ist, ist der Standardwert 0 , also keine Dezimalstellen; der maximale Argumentwert 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 statt einer Zahl zurück. Das bedeutet, dass das Hinzufügen von gerundet zu randNum zu einer Verkettung von Zeichenfolgen und nicht zu einer einzelnen Zahl führt:
console.log(randNum + gerundet); > „6.256“
Wenn Sie möchten, dass JavaScript eine Zahl auf das nächste Hundertstel rundet, verwenden Sie parseFloat() :
var randNum = 6,25; varrounded = parseFloat(randNum.toFixed(1)); console.log(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 ausgibt, wenn eine Zahl mehr Ziffern als die angegebene Genauigkeit aufweist:
var num = 123.435 num.toPrecision(2); > „1.2e+2“
So vermeiden Sie Fehler beim Runden von Dezimalzahlen
In einigen Fällen werden toFixed und toPrecision implementiert JavaScript rundet 5 ab, und nicht zu mehr:
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 Fehlerspanne 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 Berechnungen, das Zweite 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.
Kürzung von Dezimalzahlen
Alle zuvor vorgestellten Methoden funktionieren JavaScript-Rundung auf Zehntel. Zum Abschneiden positive Zahl auf zwei Dezimalstellen, multiplizieren Sie es mit 100, kürzen Sie es erneut und dividieren Sie das Ergebnis dann durch 100. Sie benötigen:
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
Runden Sie auf die nächste Zahl
Implementieren JavaScript-Rundung auf die nächste ganze Zahl, 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.
Runden Sie auf die nächste ganze Zahl ab
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 im Aufzug zwischen Kellergeschoss 2 und 3 befinden ( was einem Wert von -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 dreizeiliges Polyfill zur Unterstützung von Math.trunc in älteren Browsern und IE/Edge.
Runden Sie auf die nächste ganze Zahl auf
Wenn Sie Dezimalzahlen aufrunden möchten, verwenden Sie Math.ceil . Diese Methode kann man sich 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
Runden Sie auf das nächste Vielfache
Wenn Sie einen Wert auf das nächste Vielfache von 5 runden müssen, erstellen Sie eine Funktion, die die Zahl durch 5 dividiert, sie rundet und dann das Ergebnis mit demselben Wert multipliziert:
Funktion RoundTo5(num) ( return Math.round(num/5)*5; )
Verwendung:
RoundTo5(11); > 10
Wenn Sie JavaScript zum Runden auf zwei Dezimalstellen benötigen, können Sie sowohl den Startwert als auch das Vielfache an die Funktion übergeben:
Funktion RoundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )
Um die Funktion zu verwenden, geben Sie die zu rundende Zahl und das Vielfache in den Aufruf ein:
var initialNumber = 11; var multiple = 10; RoundToMultiple(initialNumber, multiple); > 10;
Um Werte nur nach oben oder unten zu runden, ersetzen Sie in der Funktion „round“ durch „ceil“ oder „floor“.
Bereichsbindung
Manchmal müssen Sie einen Wert für x ermitteln, der innerhalb eines bestimmten Bereichs liegen muss. Wir benötigen zum Beispiel einen Wert von 1 bis 100, erhalten aber den Wert 123. Um dies zu beheben, können Sie min() ( gibt die kleinste Zahl zurück) und max ( gibt die maximal zulässige Anzahl zurück).
Verwendung:
var lowBound = 1; var highBound = 100; var numInput = 123; var clamp = Math.max(lowBound, Math.min(numInput, highBound)); console.log(geklemmt); > 100;
Sie können eine Funktion oder Erweiterung der Number-Klasse erstellen.
In diesem Artikel werden wir uns ausführlich mit Zahlen, mathematischen Operatoren, Möglichkeiten zur Umwandlung einer Zahl in eine Zeichenfolge und umgekehrt sowie vielen anderen wichtigen Punkten befassen.
isFinite-Funktion
Mit der Funktion isFinite können Sie überprüfen, ob ein Argument eine endliche Zahl ist.
Als Antwort diese 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 eine Methode namens 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 soll bestimmen, 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 null wird in 0 konvertiert isNaN(true); //falsch, weil true wird in 1 isNaN(false) konvertiert; //falsch, weil false wird in 0 konvertiert
Wenn diese Aktion ohne Typumwandlung ausgeführt werden muss, verwenden Sie die Methode Number.isNaN. Diese Methode wurde ab 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 +, die vor dem Wert stehen muss.
+"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 diese Methode Darauf muss man achten leere Zeile oder eine Zeichenfolge bestehend aus Leerzeichen und \n wird in die Zahl 0 umgewandelt. Darüber hinaus werden auch der Null-Datentyp und boolesche Werte in eine Zahl umgewandelt.
Null; //0 +true; //1 +false; //0 +" "; //0
2. ParseInt-Funktion. Diese Funktion dient der Konvertierung Argument zu 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 nicht numerisches Zeichen stößt, 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 Basis des Zahlensystems wird mit 2 Argumenten angegeben.
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. parseFloat-Funktion. 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 im Dezimalschreibsystem 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 einer 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, welche Zahl Sie explizit in einen String konvertieren 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)); ) // use var myVar = "12px"; console.log(isNumeric(myVar)); //WAHR
Mit dieser Methode können Sie feststellen, ob der angegebene Wert eine Zahl ist oder in eine Zahl umgewandelt werden kann. Diese Option zählt die leere Zeichenfolge, die Leerzeichenfolge, null, Infinity, -Infinity, true und false nicht 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 ob es sich um einen der Sonderwerte Infinity, -Infinity und NaN handelt. 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 wandelt einen String nicht in eine Zahl um. Number.isInteger(20); //wahr, weil Dieser 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 Prüfen einer Zahl auf gerade Parität function isEven(n) ( return n % 2 == 0; ) // Funktion zum Prüfen einer Zahl auf ungerade Parität function isOdd(n) ( return Math.abs(n % 2) == 1; )
Bevor eine solche Prüfung durchgeführt wird, empfiehlt es sich jedoch sicherzustellen, dass es sich bei dem angegebenen Wert um eine Zahl handelt:
Wert = 20; if (Number.isInteger(value)) ( if (isEven(value)) ( console.log("Number " + value.toString() + " - even"); ) )
Primzahlen in Javascript
Schauen wir uns ein Beispiel an, aus dem wir ableiten mit Javascript Primzahlen von 2 bis 100.
// Funktion, die prüft, ob eine Zahl eine Primzahl ist function 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, einen Bruch in JavaScript auf eine ganze Zahl zu runden.
1. Verwendung der speziell dafür entwickelten Methoden Math.floor, Math.ceil und Math.round. Die Math.floor-Methode rundet einen Bruch auf die nächste ganze Zahl ab, d. h. verwirft einfach den Bruchteil. Math.ceil rundet einen Bruch 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 eine 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. Verwendung der toPrecision(accuracy)-Methode. Diese Methode stellt eine Zahl mit einer angegebenen Genauigkeit dar. Dabei kann er nicht nur den Bruchteil, sondern auch den ganzen Teil einer Zahl runden. Abhängig vom Ergebnis kann diese Methode die resultierende Zahl mit einem Festkomma oder in Exponentialform darstellen.
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 der logischen Operatoren NOT oder OR.
//ü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 müssen Sie als 2. Zahl 1 verwenden.
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 durch eine ganze Zahl teilbar?
Ob eine Zahl durch eine ganze Zahl teilbar ist, können Sie mit dem Prozentoperator ermitteln:
Var-Nummer = 9; // wenn der Rest der Zahl dividiert durch 3 0 ist, dann ja, andernfalls nein if (Zahl%3==0) ( console.log ("Die Zahl " + Zahl + " ist durch 3 teilbar"); ) else ( console. log("Die Zahl " + Zahl + " ist nicht durch 3 teilbar"); )
Zahlen formatieren
In JavaScript können Sie mit der Methode toLocaleString() die Ausgabe einer Zahl gemäß regionalen Standards (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 die Zahl beispielsweise 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%"
Zerlegen Sie eine Zahl in Ziffern (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))); //"1.240,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
Fehler treten auf, weil alle Berechnungen per Computer oder auf andere Weise durchgeführt werden 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 umrechnen. Aber nicht jede gebrochene Dezimalzahl lässt sich im 2. Zahlensystem 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
Wenn Sie Zahlen mit Bruchteilen berechnen oder anzeigen, müssen Sie immer angeben, mit welcher Genauigkeit Sie dies tun möchten.
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 //method toPrecision() console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //WAHR
Grundlegende mathematische Operationen
In JavaScript gibt es die folgenden mathematischen Operatoren: + (Addition), - (Subtraktion), * (Multiplikation), / (Division), % (Modulo), ++ (Wert um 1 erhöhen), -- (Wert um verringern). 1 ).
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 Ergebnisses der %-Operation ist gleich dem Vorzeichen des ersten Werts -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; console.log(x++); //gibt 3 aus und setzt dann 4 console.log(x); //4 x = 3; console.log(++x); // setzt 4 und gibt x = 5 aus; console.log(x--); //gibt 5 aus und setzt dann 4 console.log(x); //4 x = 5; console.log(--x); // setzt 4 und gibt aus. Darüber hinaus verfügt JavaScript über Kombinationsoperatoren: 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; console.log(x); //9 x = 3; y = 6; x-=y; console.log(x); //-3 x = 3; y = 6; x*=y; console.log(x); //18 x = 3; y = 6; x/=y; console.log(x); //0,5 x = 3; y = 6; x%=y; console.log(x); //3
