Hallo, JavaScript-Liebhaber. Sie haben bereits bemerkt, dass diese Sprache sehr außergewöhnlich ist und sich in jedem Abschnitt durch ihre Funktionen und ungewöhnlichen technischen Lösungen auszeichnet. 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 ausführen und was die Division durch 0 auszeichnet. Ohne meine Prinzipien zu ändern, werde ich Beispiele zu den wichtigsten Punkten beifü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) zum Typ gehören Nummer. Darüber hinaus sind sie alle 64-Bit, da sie im „Double Precision“-Format gespeichert sind, das auch als IEEE-754-Standard bekannt ist.

Numerische Variablen werden wie gewohnt erstellt:

var numb = 35; // natürliche Zahl

var drob = 0,93; //Dezimaldarstellung

var numb16 = 0xFF; //Hexadezimales Zahlensystem

Unterstützt andere numerische Darstellungen. Sie können also auch Gleitkommazahlen erstellen (manchmal werden sie auch „wissenschaftliche Zahlen“ genannt).

Es gibt jetzt Unterstützung für eine sehr interessante Methode toLocaleString(), das alle numerischen Parameter gemäß den in ECMA 402 vorgeschriebenen Spezifikationen formatiert. Dadurch können große Zahlen, Telefonnummern, Währungen und sogar Prozentsätze werden im Dialogfeld wunderschön angezeigt.

Varnum = 714000,80;

alarm(num.toLocaleString());

Um mit Elementen vom Typ Zahl zu arbeiten, wurde ein ganzes globales Objekt mit einer Reihe verschiedener mathematischer Funktionen versehen, deren Namen Mathe.

Darüber hinaus gibt es weitere Methoden, die numerische Werte auf ganze Zahlen, Zehntel, Hundertstel usw. runden. Schauen wir sie uns alle genauer an.

Die große und mächtige Mathematik

Das globale Math-Objekt umfasst eine große Vielfalt an mathematischen und trigonometrische Funktionen. Dies ist ein sehr notwendiges Objekt und hilft Entwicklern oft bei der Arbeit mit digitalen Daten.

Es gibt Analoga von Mathe auf anderen Plattformen. In gängigen Sprachen wie Java und C# ist Math beispielsweise eine Klasse, die dieselben Standardfunktionen unterstützt. Wie Sie sehen, ist dieses Instrument wirklich großartig und kraftvoll.

Jetzt möchte ich die spezifischen Methoden, die für das Runden verantwortlich sind, durchgehen und im Detail darauf eingehen.

Math.floor()

Ich fange damit an Mathe.Boden. Achten Sie auf den Namen der Methode. Logischerweise wird klar, dass es sich um Rundungen handelt und die wörtliche Übersetzung des Wortes „Boden“ „Boden“ bedeutet dieses Werkzeug rundet die verarbeiteten Werte ab.

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

alarm(Math.floor(4.5));

Die Antwort wird Nummer 4 sein.

Math.ceil()

Schauen Sie sich noch einmal den Namen an (auf diese Weise zieht das Material schneller ein). Falls es jemand nicht weiß: „Ceil“ bedeutet „Decke“. Dies bedeutet, dass numerische Daten mithilfe einer nicht strikten Ungleichung (>=) aufgerundet werden.

alarm(Math.ceil(4.5));

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

Math.round()

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

alarm(Math.round(4.5));

Ich hoffe, dass jeder gedacht oder gesagt hat, dass die richtige Antwort 5 ist.

Noch ein paar Methoden

JavaScript verfügt außerdem über zwei weitere Methoden, die sich mit dem Runden numerischer Darstellungen befassen. Allerdings sind sie etwas anders.

Wir werden über Tools sprechen wie toFixed() Und toPrecision(). Sie sind nicht nur für das Runden verantwortlich, sondern auch für die Genauigkeit auf bestimmte Zeichen. Lassen Sie uns tiefer graben.

toFixed()

Durch die Verwendung dieser Mechanismus Sie können festlegen, auf wie viele Dezimalstellen der Wert gerundet werden soll. Die Methode gibt das Ergebnis als String zurück. Unten habe ich eine Option mit drei verschiedenen Optionen angehängt. 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 im vierten wurden aufgrund des Parameters „7“ drei weitere Nullen hinzugefügt.

toPrecision()

Diese Methode funktioniert etwas anders. Anstelle des Arguments können Sie entweder ein Leerzeichen lassen oder einen Parameter festlegen. Letzteres rundet Zahlen jedoch unabhängig vom Komma auf die angegebene Anzahl von Stellen. Hier sind die vom Programm erzeugten Ergebnisse, neu geschrieben aus dem vorherigen Beispiel:

Varnum = 5656,9393;

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

document.writeln(num.toPrecision(2)); // 5,7e+3

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

Merkmal der Division durch 0 in js

Wie Sie aus dem Mathematikunterricht wissen, können Sie nicht durch Null dividieren. Diese Regel wurde von den meisten Entwicklern von Programmiersprachen zugrunde gelegt. Daher erzeugen alle Programme bei der Division durch Null einen Fehler.

Aber auch hier zeichnet sich JavaScript aus. Während der Ausführung einer solchen Operation treten also keine Fehlermeldungen auf, da eine solche Operation zurückkehrt "Unendlichkeit"!

Warum ist das so? Wie aus denselben mathematischen Wissenschaften bekannt ist, ist die resultierende Zahl umso größer, je kleiner der Teiler ist. Aus diesem Grund haben sich die Entwickler dieser prototyporientierten Sprache entschieden, auf Vorlagen zu verzichten und ihren eigenen Weg zu gehen.

Für diejenigen, die zum ersten Mal auf den Infinity-Wert stoßen, habe ich seine Eigenschaften unten erklärt.

Unendlich – bedeutet Unendlichkeit 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

Ich schätze, ich werde hier enden. Wenn Ihnen die Veröffentlichung gefallen hat, abonnieren Sie unbedingt meinen Blog. Seien Sie nicht geizig mit Links zu interessanten Artikeln und teilen Sie diese mit Ihren Freunden. Tschüss!

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 gibt diese Funktion „false“ zurück, wenn das Argument Infinity, -Infinity oder 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

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

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

isNaN-Funktion

Die Funktion isNaN 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 Beachten Sie, dass eine leere Zeichenfolge oder eine Zeichenfolge, die aus Leerzeichen und \n besteht, in die Zahl 0 konvertiert wird. Darüber hinaus werden auch der Null-Datentyp und boolesche Werte in eine Zahl konvertiert.

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

Mit dieser Funktion kann gearbeitet werden verschiedene Systeme Zahlen (binär, oktal, dezimal, hexadezimal). 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 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, in dem wir mit Javascript anzeigen 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 der 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

Die folgenden mathematischen Operatoren gibt es in JavaScript: + (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 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?

0.1 * 0.2; > 0.020000000000000004

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, daher kann JavaScript Ergebnisse wie die folgenden generieren:

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 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“

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 Trimmen große Menge 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 hat:

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. Um eine positive Zahl auf zwei Dezimalstellen zu kürzen, multiplizieren Sie sie mit 100, kürzen Sie sie erneut und teilen Sie das Ergebnis dann durch 100:

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

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

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

Verwendung:

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

Runden Sie auf die nächste Zahl

Umsetzen 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 die JavaScript-Mathe-Rundung mit Math.trunc() , die in allen unterstützt wird moderne Browser(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 Ziffern 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.

Hallo. Heute schauen wir uns in der Kolumne über Javascript an, wie man die Anzahl der Dezimalstellen in Gleitkommazahlen in Javascript festlegt. Beispielsweise müssen Sie bei der Ausgabe drei oder nur zwei Dezimalstellen belassen.

Aufgabe: Anzahl der Dezimalstellen in Javascript

Wir stehen also vor einer Aufgabe: Es gibt ein Ergebnis von Berechnungen, in denen es Zahlen vor dem Komma und nach dem Komma gibt. Dezimal. Nehmen wir an, das Ergebnis sieht so aus: 1538.9891200153. Bei der Ausgabe sollten Sie jedoch eine Zahl erhalten, die den Betrag widerspiegelt, wobei vor dem Dezimalpunkt die Anzahl der Banknoten und nach der Anzahl der Kopeken steht.

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

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

toFixed ist eine integrierte Javascript-Methode, die auf jede Zahl angewendet werden kann und die Rundungsgenauigkeit (d. h. die Anzahl der Dezimalstellen) als Parameter verwendet.

Var num=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 Präzisionsparameter in dieser Funktion darf nicht kleiner als 0 (akzeptiert keine negativen Werte) und nicht größer als 20 sein.

Sie können auch auf eine Variable verzichten, zum Beispiel so:

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

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

Diese Lösung basiert auf derselben integrierten Javascript-Methode. Eine Besonderheit dieser Methode besteht darin, dass der als Eingabe verwendete Parameter nicht die Genauigkeit (die Anzahl der Dezimalstellen), sondern die Gesamtzahl der Dezimalstellen (sowohl vor als auch nach dem Dezimalpunkt) angibt.

Var num=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 Sie die Dezimalstellen vollständig entfernen müssen, also einen Bruch auf eine ganze Zahl runden müssen, können Sie die Funktionen der Math-Klasse verwenden: Round, Ceil und Floor.
Runden – rundet auf oder ab (abhängig von der Zahl). Beträgt der Nachkommawert mehr als die Hälfte, wird aufgerundet, bei weniger wird abgerundet. Das heißt, wenn 0,51 zu 1 wird, wird 0,49 zu 0.

Ceil - aus dem Englischen. Die Decke rundet immer nach oben ab.

Boden - aus dem Englischen. Der Boden wird immer abgerundet.

Var-Nummer = 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 bei der Lösung Ihres Problems geholfen. Wenn etwas nicht klappt, stellen Sie Fragen über den grünen „Frag einen Experten“-Button oder in den Kommentaren.