In diesem Artikel gehen wir näher auf Zahlen, mathematische Operatoren, Möglichkeiten zur Umwandlung einer Zahl in eine Zeichenfolge und umgekehrt sowie auf viele andere wichtige Punkte ein.

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.

IsEndlich (73); // wahr isFinite(-1/0); // false isFinite(Infinity); // falsch isFinite(NaN); // false isFinite("Text"); // FALSCH

Neben der globalen Funktion isFinite verfügt JavaScript auch über die Methode Number.isFinite. Im Gegensatz zu isFinite erzwingt es nicht die Umwandlung des Arguments in eine Zahl.

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

isNaN-Funktion

Die isNaN-Funktion dient zum Bestimmen, ob ein Argument eine Zahl ist oder in eine umgewandelt werden kann. Wenn dies der Fall ist, gibt die Funktion isNaN false zurück. Andernfalls wird true zurückgegeben.

IsNaN(NaN); //true isNaN("25px"); // stimmt, 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 umgewandelt isNaN(false); //falsch, weil falscher Wert wird in 0 umgewandelt

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

Wie konvertiert man eine Zeichenfolge explizit in eine Zahl?

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

1. Verwenden unärer Operator + Der 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

Verwenden diese Methode Beachten Sie, dass eine leere Zeichenfolge oder eine Zeichenfolge, die aus Leerzeichen und \n besteht, in die Zahl 0 konvertiert wird. Außerdem werden auch der Datentyp Null und boolesche Werte in eine Zahl konvertiert.

Null; //0 +wahr; //1 +falsch; //0 +" "; //0

2. Funktion parseInt . Diese Funktion dient zum Konvertieren Argument zu einer Ganzzahl. Im Gegensatz zu verwenden 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 stößt, 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 arbeiten verschiedene Systeme Nummerierung (binär, oktal, dezimal, hexadezimal). Die Angabe der Basis des Zahlensystems erfolgt über 2 Argumente.

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

Neben der 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 das Argument in eine Bruchzahl umwandeln können.

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

Außerdem hat die Funktion parseFloat im Gegensatz zu parseInt keine 2 Argumente und versucht daher immer, den String als Zahl in Dezimalschreibweise zu behandeln.

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

Neben der 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

Sie können eine Zahl mit der toString-Methode in einen String umwandeln.

(12.8).toString(); //"12.8"

Mit der Methode toString können Sie auch die Basis des Zahlensystems angeben, wobei Sie berücksichtigen müssen, dass Sie die Zahl explizit in den String umwandeln müssen:

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

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

Sie können mit einer der folgenden Methoden 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 darauf gecastet werden );

Als eine Funktion:

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

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

2. Verwenden Art des Operators und Funktionen isFinite, isNaN:

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

Diese Funktion bestimmt, ob der angegebene Wert vom Typ Zahl ist und ob er zu einem der gehört besondere Werte Unendlich, -Unendlich und NaN. Wenn dies der Fall ist, gibt diese Funktion wahr zurück.

3. Verwenden der Methode ECMAScript 6 Number.isInteger(value). Mit dieser Methode können Sie bestimmen, ob der angegebene Wert eine ganze Zahl ist.

Number.isInteger("20"); //falsch, weil diese Methode übersetzt den String nicht in eine Zahl Number.isInteger(20); // stimmt, weil gegebenen Wert ist eine Zahl

Gerade und ungerade Zahlen

Sie können überprüfen, ob eine Zahl gerade oder ungerade ist, indem Sie folgende Funktionen:

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

Bevor Sie jedoch eine solche Überprüfung durchführen, sollten Sie 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 Primzahlen von 2 bis 100 mit Javascript anzeigen.

// Eine 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, eine Bruchzahl in JavaScript auf einen ganzzahligen Wert zu runden.

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

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

2. Verwenden 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 Nachkommastellen vorhanden sind, um die angegebene Genauigkeit der Zahl zu bilden, wird sie mit Nullen aufgefüllt.

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

3. Durch die Methode toPrecision(precision). Diese Methode stellt eine Zahl mit der angegebenen Genauigkeit dar. Gleichzeitig kann er nicht nur den Bruchteil, sondern auch den ganzen Teil der Zahl runden. Die resultierende Zahl kann mit dieser Methode je nach Ergebnis als Fixpunkt oder in 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. Verwenden von logischen NOT- oder OR-Operatoren.

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

Ganzzahl und Bruchteil einer Zahl

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

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

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

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

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

Var-Nummer = 7,21; var Bruchzahl = Zahl - Math.floor (Math.abs (Zahl)); console.log (bruchzahl); // 0.20999999999999996

Ist die Zahl teilbar

Mit dem Prozentoperator können Sie feststellen, ob eine Zahl ohne Rest teilbar ist:

Variablennummer = 9; // wenn der Rest der Division von Zahl durch 3 0 ist, dann ja, sonst 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 bietet die Methode toLocaleString() die Möglichkeit, die Ausgabe einer Zahl nach Locale (Spracheinstellungen des Betriebssystems) zu formatieren.

Lassen Sie uns beispielsweise eine Zahl gemäß den regionalen Standards formatieren, die standardmäßig im System installiert sind:

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

Lassen Sie uns beispielsweise eine Zahl gemäß den regionalen Standards Russlands (ru) formatieren:

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", currency:"RUB"))); //"2.540,13 ₽" console.log((89.3).toLocaleString("ru-RU",(style:"currency", currency:"USD"))); //"$89.30" console.log((2301.99).toLocaleString("ru-RU",(style:"currency", currency:"EUR"))); //"2.301,99 €"

Zahlen in Prozent darstellen:

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

Teilen Sie die Nummer 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 Ziffern (2) nach dem Komma 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); //Stimmt

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

Beispielsweise ist in JavaScript 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 Computer oder andere sind elektronisches Gerät produziert im 2-Zahlensystem. Diese. Bevor irgendwelche Aktionen ausgeführt werden, muss der Computer zuerst die im Ausdruck präsentierten Zahlen in das 2-Zahlensystem umwandeln. Aber nicht jede gebrochene Dezimalzahl kann im 2. Zahlensystem exakt dargestellt werden.

Beispielsweise wird die Zahl 0,25 10 exakt in binär umgewandelt.

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

Folglich 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

Bei der Berechnung oder Darstellung von Zahlen mit Nachkommastellen müssen Sie immer angeben, mit welcher Genauigkeit dies erfolgen soll.

Vergleichen Sie beispielsweise Zahlen mit bis zu 2 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)); //Stimmt

Grundlegende mathematische Operationen

JavaScript verfügt über die folgenden mathematischen Operatoren: + (Addition), - (Subtraktion), * (Multiplikation), / (Division), % (Modulo), ++ (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, setzt dann y auf 4 console.log(x); //4 x = 3; Konsolenprotokoll (++x); // setzt 4 und gibt x = 5 aus; Konsolenprotokoll (x--); //gibt 5 aus, y setzt dann 4 console.log(x); //4 x = 5; Konsolenprotokoll (--x); //Setzt auf 4 und gibt aus Außerdem 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

Hallo. Heute schauen wir uns in der Kolumne über Javascript an, wie man die Anzahl der Nachkommastellen in Fließkommazahlen in Javascript setzt. Beispielsweise müssen Sie bei der Ausgabe 3 Nachkommastellen lassen oder nur zwei.

Aufgabe: Javascript Anzahl der Dezimalstellen

Wir stehen also vor einer Aufgabe: Es gibt ein Rechenergebnis, bei dem Zahlen vor dem Komma und hinter dem Komma stehen. Dezimal. Nehmen wir an, das Ergebnis ist 1538,9891200153. Bei der Ausgabe sollten Sie jedoch eine Zahl erhalten, die den Betrag widerspiegelt, wobei vor dem Dezimalkomma die Anzahl der Banknoten und danach die Kopeken stehen.

Es gibt mehrere Möglichkeiten, dieses Problem zu lösen.

Lösung 1: Javascript-Anzahl der Dezimalstellen mit toFixed-Methode

toFixed ist eine eingebaute Javascript-Methode, die auf eine beliebige Zahl angewendet wird, sie nimmt die Rundungsgenauigkeit (d. h. die Anzahl der Dezimalstellen) als Parameter.

Varnum=1538,9891200153; num_str=num.toFixed(); //num_str=1538; num_str=num.toFixed(2); //num_str=1538.98; num_str=num.toFixed(5); //num_str=1538.98912;

Der Genauigkeitsparameter in dieser Funktion muss mindestens 0 (nimmt keine negativen Werte an) und darf höchstens 20 sein.

Sie können auch auf eine Variable verzichten, wie folgt:

Num_str=(1538.9891200153).toFixed(2); //num_str=1538.98;

Lösung 2: Javascript-Anzahl der Dezimalstellen mit toPrecision-Methode

Diese Lösung basiert auf dem gleichen eingebauten Javascript-Methode. Unterscheidungsmerkmal Bei dieser Methode gibt der als Eingabe genommene Parameter nicht die Genauigkeit (die Anzahl der Dezimalstellen) an, sondern die Gesamtzahl der Zeichen (sowohl vor als auch nach dem Dezimalkomma).

Varnum=1538,9891200153; num_str=num.toPrecision(5); //num_str=1538.9; num_str=num.toPrecision(7); //num_str=1538.989;

Lösung ohne Nachkommastellen: Javascript Anzahl der Nachkommastellen

Wenn die Nachkommastellen komplett weggelassen werden müssen, also eine Bruchzahl auf eine ganze Zahl gerundet werden muss, dann können Sie die Funktionen der Math-Klasse verwenden: round, ceil und floor.
Round - rundet auf oder ab (abhängig von der Zahl). Wenn der Wert nach dem Komma mehr als die Hälfte beträgt, wird aufgerundet, wenn er kleiner ist, wird abgerundet. Das heißt, wenn 0,51 - wird es 1, wenn 0,49 - 0.

Decke - aus dem Englischen. die Obergrenze wird immer aufgerundet.

Boden - aus dem Englischen. Das Geschlecht wird immer abgerundet.

Warnum = 1538,9891200153; num_str=math.round(num); //num_str=1539; num_str=Math.floor(num); //num_str=1538; num_str=Math.ceil(num); //num_str=1539;

Das ist alles. Ich hoffe, dieser Hinweis hat Ihnen geholfen, Ihr Problem zu lösen. Wenn etwas nicht geklappt hat, stellen Sie Fragen über die grüne Schaltfläche „Stellen Sie eine Frage an einen Spezialisten“ oder in den Kommentaren.

Sehr oft liefern Berechnungen in JavaScript nicht genau die Ergebnisse, die wir wollen. Natürlich können wir mit Zahlen alles machen - auf- oder abrunden, Bereiche festlegen, unnötige Zahlen auf eine bestimmte Anzahl von Dezimalstellen abschneiden, es hängt alles davon ab, was Sie in Zukunft mit dieser Zahl machen möchten.

Warum muss gerundet werden?

Einer der merkwürdigen Aspekte von JavaScript ist, dass es eigentlich keine ganzen Zahlen speichert, wir arbeiten sofort mit Fließkommazahlen. Dies, kombiniert mit der Tatsache, dass viele Bruchwerte nicht mit einer endlichen Anzahl von 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 Quintillionen-Aktien, dies kann jedoch jemanden enttäuschen. Wir können auch einige 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 nur in der Lage sein, die Ergebnisse zu runden, und es reicht aus, die Dezimalgenauigkeit einzustellen.

Das Runden von Zahlen hat einen praktischen Nutzen, wir können eine Zahl in einem bestimmten Bereich manipulieren, zum Beispiel möchten wir einen Wert auf die nächste ganze Zahl runden, anstatt nur mit dem Dezimalteil zu arbeiten.

Rundung von Dezimalstellen

Um eine Dezimalzahl zu kürzen, verwenden Sie die toFixed- oder die toPrecision-Methode. Beide nehmen ein einziges Argument, das bestimmt, wie viele signifikante Ziffern (d. h. die Gesamtzahl der in der Zahl verwendeten Ziffern) oder Dezimalstellen (die Zahl nach dem Komma) das Ergebnis enthalten soll:

1. Wenn das Argument nicht für toFixed() definiert ist, wird es standardmäßig auf Null gesetzt, was 0 Dezimalstellen bedeutet, das Argument hat einen maximalen Wert von 20.
2. Wenn toPrecision kein Argument übergeben wird, bleibt die Zahl unverändert

sei randNum = 6,25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" randNum = 87.335; randNum.toFixed(2); > "87.33" randNum = 87.337; randNum.toPrecision(3); > "87.3"
Sowohl die Methoden toFixed() als auch toPrecision() geben eine Zeichenfolgendarstellung des Ergebnisses zurück, keine Zahl. Dies bedeutet, dass beim Summieren des gerundeten Werts mit randNum Zeichenfolgen verkettet und keine Zahlen hinzugefügt werden:

Sei randNum = 6,25; gerundet lassen = randNum.toFixed (); // "6" console.log(randNum + gerundet); > "6.256"
Wenn Sie möchten, dass das Ergebnis einen numerischen Datentyp hat, müssen Sie parseFloat verwenden:

Sei randNum = 6,25; gerundet lassen = 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 dollarCents = 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:

Lassen Sie 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:

Lassen Sie numTest = 1,005; numTest.toFixed(2); > "1.00"
Das Ergebnis der obigen Berechnung sollte 1,01 sein, nicht 1. 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:

Runde (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

Eine alternative Methode zum Runden von Dezimalzahlen wurde in ES6 eingeführt. Die maschinelle Epsilon-Rundung bietet eine angemessene Fehlerspanne beim Vergleich zweier Gleitkommazahlen. Ohne Rundung können Vergleiche zu ähnlichen Ergebnissen wie den folgenden führen:

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

Funktion epsEqu(x, y) (gibt Math.abs(x - y) zurück< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
Die Funktion nimmt zwei Argumente entgegen: das erste ist die aktuelle Berechnung, das zweite das erwartete Ergebnis. Es gibt einen Vergleich der beiden zurück:

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

Teilbeschneidung

Alle oben vorgestellten Methoden können auf Dezimalzahlen runden. Um eine Zahl einfach auf zwei Dezimalstellen abzuschneiden, musst du sie zunächst mit 100 multiplizieren und dann das 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 doppelte Negation verwenden:

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

Lassen Sie randInt = 35.874993; abgeschnitten (randInt, 3); > 35.874

Rundung auf die nächste Zahl

Um eine Dezimalzahl auf die nächste Zahl auf- oder abzurunden, verwenden Sie Math.round(), je nachdem, was wir am nächsten kommen:

Math.Runde(4.3) > 4 Math.Runde(4.5) > 5
Beachten Sie, dass "halber Wert", 0,5 nach den Regeln der Mathematik aufgerundet wird.

Abrunden auf die nächste ganze Zahl

Wenn Sie immer abrunden möchten, verwenden Sie Math.floor:

Math.Etage(42.23); > 42 Math.Boden (36,93); > 36
Beachten Sie, dass das Abrunden für alle Zahlen funktioniert, einschließlich negativer Zahlen. 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.Boden (-2,5); > -3
Aber wenn Sie diese Art von Situation 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.

Aufrunden auf die nächste ganze Zahl

Wenn Sie dagegen immer aufrunden müssen, verwenden Sie Math.ceil. Denken Sie noch einmal 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

Runden Sie nach Bedarf auf/ab

Wenn wir auf das nächste Vielfache von 5 aufrunden möchten, ist es am einfachsten, eine Funktion zu erstellen, die eine Zahl durch 5 teilt, aufrundet und dann mit demselben Betrag multipliziert:

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

RoundTo5(11); > 10
Wenn Sie auf Vielfache Ihres Werts runden möchten, verwenden wir eine allgemeinere Funktion, bei der der Anfangswert und ein Vielfaches übergeben werden:

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

Lassen Sie initialNumber = 11; lass mehrere = 10; roundToMultiple(initialNumber, multiple); > 10;

Festlegen einer Zahl in einem Bereich

Es gibt viele Fälle, in denen wir einen x-Wert erhalten möchten, der innerhalb eines Bereichs liegt. Zum Beispiel möchten wir vielleicht einen Wert von 1 bis 100, aber wir haben am Ende einen Wert von 123 erhalten. Um dies zu beheben, können wir min (gibt die kleinste einer Reihe von Zahlen zurück) und max (gibt die größte einer beliebigen Menge zurück von Zahlen). In unserem Beispiel reicht der Bereich von 1 bis 100:

Lassen Sie lowBound = 1; lassen Sie highBound = 100; Lassen Sie numInput = 123; Lassen Sie geklemmt = 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

Die Gaußsche Rundung, auch als Bankrundung bekannt, bedeutet, dass in diesem Fall auf die nächste gerade Zahl gerundet wird. Diese Rundungsmethode funktioniert ohne statistische Fehler. Die beste Lösung es 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:

GaussRunde(2,5) > 2 GaussRunde(3,5) > 4 GaussRunde(2,57,1) > 2,6
Dezimalpunkt in CSS:

Da JavaScript häufig verwendet wird, um Positionstransformationen für HTML-Elemente zu erstellen, fragen Sie sich vielleicht, 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

Sehr oft müssen wir einige Elemente sortieren, zum Beispiel haben wir eine Reihe von Spielaufzeichnungen, während sie in absteigender Reihenfolge des Ranges der Spieler organisiert werden müssen. Leider hat die Standardmethode sort() einige überraschende Einschränkungen: Sie funktioniert gut mit häufig verwendeten englischen Wörtern, bricht aber sofort zusammen, wenn sie auf Zahlen, Sonderzeichen oder Großbuchstaben stößt.

Alphabetisch sortieren

Es scheint, dass das alphabetische Sortieren eines Arrays die einfachste Aufgabe sein sollte:

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

Lassen Sie Frucht = ["Butternusskürbis", "Aprikose", "Cantalope"]; Obstsorte (); > "Cantaloupe", "Aprikose", "Butternusskürbis"]
Dies liegt daran, dass der Sortierer standardmäßig das erste in Unicode dargestellte Zeichen vergleicht. Unicode ist ein eindeutiger Code für jedes Zeichen, unabhängig von der Plattform, unabhängig vom Programm, unabhängig von der Sprache. Betrachtet man beispielsweise die Codetabelle, 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 gemischte Anfangsbuchstaben 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 der Regel ist es für einen solchen Fall besser, gleich eine Funktion zur Mehrfachnutzung anzulegen:

Funktion alphaSort(arr) ( arr.sort(function (a, b) ( return a.localeCompare(b, "en", ("sensitivity": "base")); )); ) let fruit = ["Butternusskürbis ", "Aprikose", "Cantaloupe"]; alphaSort(Obst) >
Wenn Sie ein Array in umgekehrter alphabetischer Reihenfolge sortiert haben möchten, tauschen Sie einfach die Positionen von a und b in der Funktion:

Funktion alphaSort(arr) ( arr.sort(function (a, b) ( return b.localeCompare(a, "en", ("sensitivity": "base")); )); ) let fruit = ["Butternusskürbis ", "Aprikose", "Cantaloupe"]; alphaSort(fruit) > ["Cantaloupe", "Butternusskürbis", "Aprikose"]
Hier ist es erwähnenswert, dass localeCompare mit Argumenten verwendet wird, wir müssen auch daran denken, 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", "Cantaloupe"]

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 das Sortieren ganz gut, aber irgendwann kann das Ergebnis unvorhersehbar sein:

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

Lass highScores = ; highScores.sort(function(a,b) ( return a - b; )); >
Nochmals, um die Zahlen einzuordnen umgekehrte Reihenfolge, vertausche 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 Spielaufzeichnungen dargestellt wird:

Let 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 können, ist das Sortieren in JavaScript eine eher nicht offensichtliche Sache, ich hoffe, diese Beispiele machen das Leben irgendwie einfacher.

Arbeiten mit Power-Funktionen

Potenzierung ist eine Operation, die ursprünglich als Ergebnis der Multiplikation einer natürlichen Zahl mit sich selbst definiert wurde. Die Quadratwurzel von a ist die Zahl, die a ergibt, wenn sie quadriert wird. Diese Funktionen könnten wir im Alltag im Mathematikunterricht ständig nutzen, etwa bei der Berechnung von Flächen, Volumen oder sogar bei der physikalischen Modellierung.

In JavaScript wird die Power-Funktion als Math.pow() dargestellt, die im neuen ES7-Standard eingeführt wurde neuer Betreiber Potenzierung - " * * ".

Potenzierung

Um eine Zahl in die n-te Potenz zu erheben, verwenden Sie die Funktion Math.pow(), wobei das erste Argument die zu potenzierende Zahl und das zweite Argument der Exponent ist:

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 noch ein anderes Beispiel geben:

Math.pow(5,3); > 125
Das heißt, 5 Kubik oder 5 × 5 × 5 ist gleich 125.

ECMAScript 7 ist die nächste Version von JavaScript, im Prinzip können wir den neu vorgeschlagenen Exponentiationsoperator verwenden - * *, diese Schreibweise kann aussagekräftiger sein:

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

Die Power-Funktion kann sich in einer Vielzahl von Situationen als nützlich erweisen. Ein einfaches Beispiel, das die Anzahl der Sekunden in einer Stunde berechnet: Math.pow(60,2).

Quadrat- und Kubikwurzel

Math.sqrt() und Math.cbrt() sind das Gegenteil von Math.pow(). Wie wir uns erinnern, ist die Quadratwurzel von a die Zahl, die a quadriert ergibt.

Math.sqrt(9) > 3
Gleichzeitig ist die Kubikwurzel von a die Zahl, die a ergibt, wenn sie in drei Würfel geteilt wird.

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+ und Safari 7.1+. Das werden Sie merken Internet Explorer ist nicht auf dieser Liste, aber Sie können ein Polyfill auf MDN finden.

Beispiele

Natürlich können wir in einer dieser Funktionen auch nicht ganzzahlige Werte verwenden:

Math.pow(1.25, 2); > 1,5625 Math.cbrt(56,57) > 3,8387991760286138
Beachten Sie, dass dies genauso gut funktioniert, wenn Sie negative Argumentwerte verwenden:

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 man unter der imaginären Zahl die Quadratwurzeln negativer Zahlen versteht. Und das könnte uns zu einer anderen komplexen Zahlentechnik führen, aber das ist eine andere Geschichte.

Sie können Bruchwerte 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 von Gleitkommazahlen können Sie das richtige Ergebnis jedoch nicht genau erraten:

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

Einige verwechseln, unerklärlicherweise in JavaScript, die Funktion Math.pow() mit Math.exp() , das eine Exponentialfunktion für Zahlen im Allgemeinen ist. Hinweis: Im Englischen wird "exponent" als "exponent" übersetzt, daher ist dies für englischsprachige Personen relevanter, obwohl es alternative Namen für den Exponenten gibt, z. B. Index, Potenz.

Mathematische Konstanten

Die Arbeit mit Mathematik in JavaScript wird durch eine Reihe eingebauter Konstanten erleichtert. Diese Konstanten sind Eigenschaften des Math-Objekts. Es ist erwähnenswert, dass die Konstanten in Großbuchstaben geschrieben werden, nicht in CamelCase-Notation.

Math.abs, parseInt, parseFloat

Das Arbeiten mit Zahlen in JavaScript kann viel komplizierter sein, als Sie denken. Die erhaltenen Werte liegen nicht immer in den erwarteten Bereichen, manchmal ist das Ergebnis möglicherweise überhaupt nicht das, was wir erwartet haben.

Math.abs()

Die Methode Math.abs() gibt den Absolutwert einer Zahl zurück, was uns an die analoge mathematische Modulo-a-Funktion erinnert.

Sei newVal = -57,64; Math.abs(newVal); > 57,64
Math.abs(0) gibt immer Null zurück, aber wenn wir ein Minuszeichen vor die Funktion -Math.abs(NUM) setzen, haben 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 parsen oder einen Wert aus einem nicht vorbereiteten Array abrufen, können sich unsere Ergebnisse als unvorhersehbar herausstellen. Als Eingabe könnten wir eine Zeichenfolge erhalten, die als "17px" dargestellt wird, und dies ist für uns nicht ungewöhnlich. Die Frage ist, wie diese Zeichenfolge in den tatsächlichen Wert konvertiert und in weiteren Berechnungen verwendet werden kann.

Syntax: parseInt(string, radix);

Die parseInt-Funktion konvertiert das erste an sie übergebene Argument in einen Zeichenfolgentyp, interpretiert es und gibt einen Integer- oder NaN-Wert zurück. Das Ergebnis (falls nicht NaN) ist eine Ganzzahl und wird als erstes Argument (String) im angegebenen Zahlensystem (Radix) als Zahl behandelt. Beispielsweise steht die Basis 10 für die Umwandlung von Dezimalzahlen, 8 von Oktalzahlen, 16 von Hexadezimalzahlen usw. Wenn die Basis größer als 10 ist, werden Zahlen verwendet, die größer als 9 sind. 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:

Lassen Sie elem = document.body; let centerPoint = window.getComputedStyle(elem).transformOrigin; > "454px 2087.19px"
Wir können Werte durch Leerzeichen trennen:

Let center = centerPoint.split(" "); > ["454px", "2087.19px"]
Allerdings ist jedes Element immer noch ein String, den wir mit unserer Funktion loswerden können:

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

parseFloat()

Aus dem obigen Beispiel ist Ihnen vielleicht aufgefallen, dass parseInt den Bruchteil verwirft. In unserem Fall kann parseFloat mit Fließkommazahlen arbeiten. Auch dies kann beim CSS-Parsing und anderen Aufgaben nützlich sein, insbesondere wenn es um Gleitkommaprozentsätze geht.

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, ist es wichtig zu bedenken, dass dies nicht fehlerfrei ist, also 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 versenden

JavaScript mathematische Rundung auf zwei Dezimalstellen (9)

Ich habe die folgende JavaScript-Syntax:

Vardiscount = Math.round(100 - (Preis / Listenpreis) * 100);

Dies rundet auf eine ganze Zahl auf. Wie kann ich ein Ergebnis mit zwei Dezimalstellen zurückgeben?

Hier ist ein funktionierendes Beispiel

varvalue=200.2365455; result=Math.round(value*100)/100 //Ergebnis wird 200,24 sein

Um auf eine beliebige Anzahl von Dezimalstellen zu runden, reicht für die meisten Anforderungen eine Funktion mit 2 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 ist " + 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

Function round(value, decimals) ( return Number(Math.round(value+"e"+decimals)+"e-"+decimals); ) round(1.005, 2); // 1.01

Eine leichte Abweichung von der akzeptierten Antwort. toFixed(2) gibt einen String zurück und Sie erhalten immer zwei Dezimalstellen. Es kann Null sein. Wenn Sie nachgestellte Nullen unterdrücken möchten, tun Sie dies einfach:

Var Rabatt = + ((Preis / Listenpreis).toFixed(2));

Bearbeitet: Ich habe gerade entdeckt, was ein Fehler in Firefox 35.0.1 zu sein scheint, was bedeutet, dass das Obige NaN einige Werte geben könnte.
Ich habe meinen Code auf geändert

Vardiscount = Math.round(Preis / Listenpreis * 100) / 100;

Dies ergibt eine Zahl mit einer Genauigkeit von zwei Dezimalstellen. Wenn du drei brauchst, multiplizierst und dividierst du durch 1000 und so weiter.
OP will immer zwei Dezimalstellen, aber wenn toFixed() in Firefox kaputt ist, muss man es zuerst reparieren.
Siehe https://bugzilla.mozilla.org/show_bug.cgi?id=1134388

Um das Ergebnis mit 2 Dezimalstellen zu erhalten, können Sie Folgendes tun:

Vardiscount = Math.round((100 - (Preis / Listenpreis) * 100) * 100) / 100;

Der zu rundende Wert wird mit 100 multipliziert, um die ersten beiden Ziffern beizubehalten, dann teilen wir durch 100, um das tatsächliche Ergebnis zu erhalten.

Ich denke Der beste Weg Die, die ich gesehen habe, ist mit 10 durch die Anzahl der Ziffern zu multiplizieren, dann Math.round zu machen und dann schließlich durch 10 durch die Anzahl der Ziffern zu dividieren. Hier 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(value, digits) ( if(!digits)( digits = 2; ) value = value * Math.pow(10, digits); value = Math.round(value); value = value / Math.pow(10 , Ziffern); Rückgabewert; )

HINWEIS. - Siehe Bearbeiten 4, wenn 3-stellige Genauigkeit wichtig ist.

Vardiscount = (Preis / Listenpreis).toFixed(2);

toFix rundet für Sie je nach Wert größer als 2 Dezimalstellen auf oder ab.

Veränderung. Wie von anderen erwähnt, wird dadurch das Ergebnis in eine Zeichenfolge konvertiert. Um es zu umgehen:

Vardiscount = +((Preis / Listenpreis).toFixed(2));

Bearbeiten 2- Wie in den Kommentaren erwähnt, wird diese Funktion nicht mit einiger Genauigkeit ausgeführt, z. B. wird im Fall von 1,005 1,00 anstelle von 1,01 zurückgegeben. Wenn Genauigkeit so wichtig ist, habe ich diese Antwort gefunden: https://.com/a/32605063/1726511 Was bei allen Tests, die ich ausprobiert habe, gut zu funktionieren scheint.

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 anstelle von 99,00 zurückgibt, was für die Anzeige von Preisen nicht ideal ist.

Bearbeiten 3- Es scheint, dass toFixed bei der eigentlichen STILL-Rückgabe einige Zahlen vermasselt hat, diese letzte Bearbeitung scheint zu funktionieren. Meine Güte, so viele Wiedergutmachungen!

Vardiscount = roundTo((price / listprice), 2); function roundTo(n, digits) ( if (digits === undefined) ( digits = 0; ) var multiplicator = Math.pow(10, digits); n = parseFloat((n * multiplicator).toFixed(11)); var test =(Math.round(n) / multiplicator); return +(test.toFixed(digits)); )

Bearbeiten 4- Ihr bringt mich um. Bearbeiten 3 schlägt bei negativen Zahlen fehl, ohne zu untersuchen, warum es einfacher ist, eine negative Zahl vor dem Runden positiv zu machen und sie dann zurückzugeben, bevor das Ergebnis zurückgegeben wird.

Funktion roundTo(n, digits) ( var negativ = false; if (digits === undefined) ( digits = 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 DEKALYLE

x = .123456 Ergebnis = Math.round(x * 100) / 100 // Ergebnis .12

DREI DEZIMALSTELLEN

x = .123456 Ergebnis = Math.round(x * 1000) / 1000 // Ergebnis .123

Funktion round(num,dec) ( num = Math.round(num+"e"+dec) return Number(num+"e-"+dec) ) //Auf eine Dezimalzahl Ihrer Wahl runden: round(1.3453,2)

Hallo JavaScript-Liebhaber. Sie haben bereits bemerkt, dass diese Sprache sehr außergewöhnlich ist und in jedem Abschnitt durch ihre eigenen Merkmale und Ungewöhnlichkeiten auffällt technische Lösungen. Daher widmet sich die heutige Veröffentlichung dem Thema: „JavaScript-Rundung“.

Nachdem Sie den aktuellen Artikel gelesen haben, erfahren Sie, warum es notwendig ist, Zahlen zu runden, welche Methoden und Eigenschaften in js diese Funktion erfüllen und was die Division durch 0 auszeichnet. Ohne meine Prinzipien zu ändern, werde ich Beispiele zu den wichtigsten Punkten der hinzufügen Material und beschreiben Sie jede Aktion im Detail. Jetzt fangen wir an zu lernen!

Wichtige Hinweise zu Zahlen

Denken Sie zunächst daran, dass in js alle Arten von Zahlen (Bruchzahlen und Ganzzahlen) vom Typ sind Nummer. Außerdem sind sie alle 64-Bit, da sie im „Double Precision“-Format gespeichert werden, das auch als IEEE-754-Standard bekannt ist.

Numerische Variablen werden auf die übliche Weise erstellt:

var numb = 35; // natürliche Zahl

Wardrob = 0,93; // Dezimaldarstellung

var numb16 = 0xFF; //Hexadezimales Zahlensystem

Unterstützt auch andere numerische Darstellungen. Sie können also immer noch Gleitkommazahlen erstellen (sie werden manchmal als "Zahlen im wissenschaftlichen Format" bezeichnet).

Unterstützung für eine sehr interessante Methode hinzugefügt toLocaleString(), das alle numerischen Parameter nach den Vorgaben der ECMA 402 formatiert. Dadurch können große Zahlen, Telefonnummern, Währungen und sogar Prozentsätze werden schön im Dialogfeld angezeigt.

varnum = 714000,80;

alert(num.toLocaleString());

Um mit Elementen vom Typ Number zu arbeiten, wurde ein ganzes globales Objekt mit einer Reihe von verschiedenen bereitgestellt mathematische Funktionen, dessen Name Mathematik.

Darüber hinaus gibt es weitere Methoden, die numerische Werte auf ganze Zahlen, auf Zehntel, Hundertstel und so weiter runden. Betrachten wir sie alle genauer.

Große und mächtige Mathe

Das globale Math-Objekt enthält eine große Vielfalt mathematischer und trigonometrischer Funktionen. Dies ist ein sehr notwendiges Objekt und hilft Entwicklern oft bei der Arbeit mit digitalen Daten.

Auf anderen Plattformen gibt es Analogien zu Math. Beispielsweise ist Math in populären Sprachen wie Java und C# eine Klasse, die alle dieselben Standardfunktionen unterstützt. Wie Sie sehen können, ist dieses Tool wirklich großartig und leistungsfähig.

Jetzt möchte ich die spezifischen Rundungsmethoden durchgehen und im Detail darauf eingehen.

Math.floor()

Ich beginne mit Mathematik.Boden. Achten Sie auf den Namen der Methode. Logischerweise wird das klar wir reden runden, und die wörtliche Übersetzung des Wortes "Boden" bedeutet "Boden", dann rundet dieses Tool die verarbeiteten Werte ab.

Es ist auch möglich, dass die verarbeitete Anzahl mit dieser Funktion gleich bleibt. Denn die Rundung erfolgt nach einer nicht strengen Ungleichung (<=). Таким образом, при отработке этой строчки кода:

alarm(Math.floor(4.5));

Die Antwort wird Nummer 4 sein.

Math.ceil()

Schauen Sie sich noch einmal den Titel an (so wird das Material schneller aufgenommen). Wenn es jemand nicht weiß, dann bedeutet "Ceil" "Decke". Das bedeutet, dass numerische Daten mit einer nicht strengen Ungleichung (>=) gerundet werden.

alert(Math.ceil(4.5));

Wie Sie vielleicht erraten haben, wird die Antwort die Zahl 5 sein.

Matherunde ()

Diese Methode rundet eine Bruchzahl auf die nächste ganze Zahl. Wenn also der Bruchteil im Bereich von 0 bis einschließlich 0,5 liegt, wird auf einen kleineren Wert gerundet. Und wenn der Bruchteil im Bereich von einschließlich 0,5 bis zur nächsten ganzen Zahl liegt, dann wird er auf eine größere ganze Zahl aufgerundet.

alert(Math.round(4.5));

Ich hoffe, jeder dachte oder sagte, die richtige Antwort sei 5.

Noch ein paar Methoden

JavaScript hat auch 2 andere Methoden, die sich mit dem Runden numerischer Darstellungen befassen. Sie sind jedoch etwas anders.

Die Rede ist von Tools wie z toFixed() und toPräzision(). Sie sind nicht nur für die Rundung verantwortlich, sondern auch für deren Genauigkeit auf bestimmte Vorzeichen. Lassen Sie uns tiefer graben.

toFixed()

Mit diesem Mechanismus können Sie festlegen, auf wie viele Nachkommastellen der Wert gerundet werden soll. Die Methode gibt das Ergebnis als String zurück. Unten habe ich eine Variante mit drei angehängt verschiedene Optionen. Analysieren Sie die erhaltenen Antworten.

Varnum = 5656,9393;

document.writeln(num.toFixed()); // 5657

document.writeln(num.toFixed(2)); // 5656,94

document.writeln(num.toFixed(7)); // 5656.9393000

Wie Sie sehen können, rundet toFixed()) den Bruchwert, wenn Sie kein Argument angeben zum Ganzen Zahlen. Die dritte Zeile ist gerundet bis zu 2 Zeichen, und in der vierten wurden wegen des Parameters „7“ drei weitere Nullen hinzugefügt.

toPräzision()

Diese Methode funktioniert etwas anders. Anstelle des Arguments können Sie sowohl ein Leerzeichen lassen als auch einen Parameter setzen. Letzteres rundet Zahlen jedoch unabhängig vom Komma auf die angegebene Anzahl von Ziffern. Hier sind die Ergebnisse des Programms, das aus dem vorherigen Beispiel umgeschrieben wurde:

Varnum = 5656,9393;

document.writeln(num.toPrecision()); // 5656.9393

document.writeln(num.toPrecision(2)); // 5.7e+3

document.writeln(num.toPrecision(7)); // 5656.939

Das Feature der Division durch 0 in js

Wie du aus dem Matheunterricht kennst, darfst du nicht durch Null dividieren. Diese Regel wurde von den meisten Entwicklern von Programmiersprachen zugrunde gelegt. Daher erzeugen alle Programme beim Teilen durch Null einen Fehler.

Aber auch hier hat sich JavaScript hervorgetan. Während der Ausführung einer solchen Operation treten also keine Fehlerberichte auf ... weil eine solche Operation zurückkehrt "Unendlichkeit"!

Warum so? Wie aus denselben mathematischen Wissenschaften bekannt, ist das Ergebnis umso kleiner, je kleiner der Divisor ist mehr. Deshalb haben sich die Macher dieser prototypbasierten Sprache dazu entschieden, Vorlagen aufzugeben und eigene Wege zu gehen.

Für diejenigen, denen die Bedeutung der Unendlichkeit neu ist, habe ich ihre Eigenschaften unten erklärt.

Unendlich - bedeutet unendlich und entspricht vollständig dem mathematischen Zeichen ∞.

Kann negativ sein. Alle Standardregeln für die Arbeit mit arithmetischen Operatoren bleiben ebenfalls erhalten.

alarm(12/0); // Unendlichkeit

Alarm (12.34/0); // Unendlichkeit

Alarm (-3/0); // -Unendlichkeit

Damit werde ich vielleicht enden. Wenn Ihnen der Beitrag gefallen hat, abonnieren Sie unbedingt meinen Blog. Fühlen Sie sich frei, interessante Artikel zu verlinken und sie mit Ihren Freunden zu teilen. Tschüss!