Methoden zum Runden von Zahlen in JavaScript. Mathe-Objekt in Javascript – Round-, Ceil- und Floor-Methoden – Runden von Bruchzahlen Js-Rundung

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.

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“

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.

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.

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

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.

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.

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

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;

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;

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.

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"]

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.

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.

In JavaScript Power-Funktion Als Math.pow() eingeführt, führte der neue ES7-Standard einen neuen Potenzierungsoperator ein, „ * * „.

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).

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.

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.

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

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.

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

Die Funktion Math.round() gibt den Wert einer Zahl zurück, gerundet auf die nächste ganze Zahl.

Die Quelle für dieses interaktive Beispiel ist in einem GitHub-Repository gespeichert. Wenn Sie zum interaktiven Beispielprojekt beitragen möchten, klonen Sie bitte https://github.com/mdn/interactive-examples und senden Sie uns eine Pull-Anfrage.

Der Wert der angegebenen Zahl, gerundet auf die nächste ganze Zahl.

Wenn der Bruchteil des Arguments größer als 0,5 ist, wird das Argument auf die ganze Zahl mit dem nächsthöheren Absolutwert gerundet. Wenn er kleiner als 0,5 ist, wird das Argument auf die Ganzzahl mit dem niedrigeren Absolutwert gerundet. Wenn der Bruchteil genau 0,5 beträgt, wird das Argument auf die nächste ganze Zahl in Richtung +∞ gerundet. Beachten Sie, dass sich dies von den Round()-Funktionen vieler Sprachen unterscheidet, die diesen Fall häufig auf die nächste Ganzzahl runden weg von Null, was bei negativen Zahlen mit einem Bruchteil von genau 0,5 zu einem anderen Ergebnis führt.

Da „round()“ eine statische Methode von „Math“ ist, verwenden Sie sie immer als „Math.round()“ und nicht als Methode eines von Ihnen erstellten „Math“-Objekts (Math hat keinen Konstruktor).

Unten finden Sie einen Codeausschnitt, der funktionell mit math.round gleichwertig ist, mit der Ausnahme, dass der folgende Codeausschnitt langsamer als Math.round ist. Der Zweck des folgenden Codeausschnitts besteht darin, zu demonstrieren, wie Math.round funktioniert.

Funktion vanilla_round(x) ( var y = Math.abs(x) + 0.5; // so dass weniger als die Hälfte abrundet; größere Aufrundungen geben Math.floor(x+0.5) zurück)

Der obige Moduloperator ermittelt den Dezimalteil von x. Darüber hinaus könnte der obige Codeausschnitt geändert werden, um eine Zahl auf eine bestimmte Genauigkeit zu runden:

Funktion Round_to_Precision(x, Präzision) ( var y = +x + (Präzision === undefiniert ? 0,5: Präzision/2); return y - (y % (Präzision === undefiniert ? 1: +Präzision)); )

Round_to_precision(11, 2); // gibt 12 aus round_to_precision(11, 3); // gibt 12 aus round_to_precision(11, 4); // gibt 12 aus round_to_precision(11, 5); // gibt 10 aus round_to_precision(11, 6); // gibt 12 aus round_to_precision(11, 7); // gibt 14 aus round_to_precision(11, 8); // gibt 8 Round_to_precision(3.7, 0.5) aus; // gibt 3,5 Round_to_precision(3,75, 0,5) aus; // gibt 4 Round_to_precision(3.8, 0.5) aus; // gibt 4 aus

Die Kompatibilitätstabelle auf dieser Seite wird aus strukturierten Daten generiert. Wenn Sie zu den Daten beitragen möchten, schauen Sie sich bitte https://github.com/mdn/browser-compat-data an und senden Sie uns eine Pull-Anfrage.

Kompatibilitätsdaten auf GitHub aktualisieren

Schauen wir uns nun die Bodenmethode an (übersetzt als Geschlecht), die im Gegensatz zur Ceil-Methode funktioniert, d. h. es rundet einen Bruch ab.

var Alter = 35,97 ;

age = Math.floor(age); /* Den Wert der Altersvariablen abrunden */

document.write(age);

Wie Sie sehen, hat die Floor-Methode die Zahl 35,97 auf 35 gerundet, also abgerundet. Trotz der Tatsache, dass 0,97 größer als 0,5 ist (cm. ).

In dieser Lektion wurden die Methoden des Math-Objekts zum Runden von Dezimalbruchzahlen untersucht.

Jetzt müssen Sie Ihre Hausaufgaben machen.

Ihre Aufgabe besteht darin, eine Funktion zu schreiben, die zwei Parameter akzeptiert.
1. Ein Array bestehend aus Zahlen mit Brüchen.
2. Rundungsmethode „rund“, „Decke“ oder „Boden“.

Am Ausgang soll die Funktion das gleiche Array ausgeben, aber gleichzeitig alle Array-Elemente, muss mit der im zweiten Parameter angegebenen Math-Objektmethode gerundet werden.

Quellarray:

var numberArray = ;

Auf den ersten Blick scheint die Lösung dieser Aufgabe fast identisch mit der Lösung von Hausaufgaben zu sein die ersten drei Unterricht dieses Thema. Aber nicht alles ist so einfach...

Lösung Nr. 1 – Achtung

Je nach den Bedingungen der Aufgabe muss die Funktion zwei Parameter annehmen – das ursprüngliche Array und eine der Methoden: „round“, „ceil“ oder „floor“ . Auf dieser Grundlage habe ich versucht, dies zu tun ...

Funktion dezimal (anyArray, Methode) /* Erstellen Sie eine Funktion mit zwei Parametern */
{

für (i = 0 ; ich< anyArray .length ; i ++ )

{
document.write(anyArray
" )

anyArray = Math.method(anyArray); /* Mit einer der Methoden des Math-Objekts runden wir das aktuelle Element des Arrays */

document.write(anyArray + "

" )
}

decimal (numberArray, Round ) /* Rufen Sie die Funktion auf und geben Sie zwei Parameter dafür an. Sie können die Methode NAME jedoch NICHT als Funktionsparameter angeben */

In dieser Lösung erstellen wir eine Funktion mit zwei Parametern und versuchen beim Aufruf, das Quellarray und den NAMEN einer Methode als Funktionsparameter anzugeben:
decimal(numberArray, Round) – in diesem Fall rund.

Wir erhalten jedoch kein Ergebnis, da Sie den Methodennamen NICHT als Funktionsparameter angeben können.

Bitte beachten Sie: Es ist kein Zufall, dass in der Problemstellung die Namen der Methoden „round“, „ceil“ und „floor“ in Anführungszeichen gesetzt sind.

dezimal (numberArray, „round“) – aber auch eine solche Schreibweise wird nicht korrekt sein!!!

Lösung Nr. 2 – Korrektur der vorherigen Lösung

Sie können das Problem lösen, indem Sie einen Parameter für die Funktion angeben.

var numberArray = ;

Funktion dezimal (anyArray) /* Eine Funktion mit einem Parameter erstellen */
{

für (i = 0 ; ich< anyArray .length ; i ++ ) /* Перебираем элементы массива */

{
document.write(anyArray + " – Quell-Array-Element
" ) /* Das aktuelle Element des Arrays ausgeben */

/* Mit der Round-Methode des Math-Objekts runden wir das aktuelle Element des Arrays */

document.write(anyArray + " – Abgerundetes Element

" ) /* Das ROUNDED-Array-Element ausgeben */
}

dezimal (numberArray) /* Rufen Sie die Funktion auf und geben Sie einen Parameter an – das ursprüngliche Array */

35 - Abgerundetes Element

13 - Abgerundetes Element

17 - Abgerundetes Element

79 - Abgerundetes Element

Hier ist es uns gelungen, das gewünschte Ergebnis zu erzielen: Die Rundungsmethode rundete alle Zahlen um . Die Bedingung ist jedoch nicht erfüllt, da die Funktion nur einen Parameter benötigt.

Lösung Nr. 3 – Funktion mit zwei Parametern

Hier ist das Problem richtig gelöst. Dazu musste ich mich erinnern Thema „Javascript-Bedingungen“. und bewerben mehrere Bedingungen gleichzeitig.

var numberArray = ;

Funktion dezimal(anyArray,Methode)
{
für (i = 0 ; i< anyArray .length ; i ++ )
{
document.write(anyArray + " – Quell-Array-Element
" );

if (Methode
{
anyArray = Math.round(anyArray);
document.write(anyArray + " – Standardrundung

" )
}

Else if(Methode
{

document.write (anyArray + " - aufrunden

" )
}

else if(Methode
{

document.write (anyArray + " - abrunden

" )
}

}
}
dezimal (numberArray, „ceil“) /* Der zweite Parameter der Funktion – in Anführungszeichen den Namen einer der Methoden angeben */

34,82 – Anfangselement des Arrays
35 - aufrunden

12.9 – anfängliches Array-Element
13 - aufrunden

17.01 – Anfangselement des Arrays
18 - aufrunden

78,51 – Anfangselement des Arrays
79 - aufrunden

Das ist die richtige Entscheidung Hausaufgaben. Hier werden je nach Bedingung zwei Parameter für die Funktion angegeben.

Probieren Sie es aus letzte Linie diese Lösung:
decimal(numberArray, „ceil“) Geben Sie als zweiten Parameter der Funktion die Namen der anderen Methoden „round“ und „floor“ des Math-Objekts an.

Lösung Nr. 4 – Funktion mit zwei Parametern + Eingabeaufforderungsmethode

Ich beschloss, die bisherige Lösung ein wenig zu optimieren und fügte hinzu prompte Methode was verursacht Modales Fenster, enthält ein Feld zur Eingabe von Informationen.

Dank dessen können Sie nun den Namen einer der Methoden rund, Boden oder Decke in das Eingabefeld eingeben und erhalten das entsprechende Ergebnis.

var numberArray = ;

Funktion dezimal(anyArray,Methode)
{
für (i = 0 ; i< anyArray .length ; i ++ )
{
document.write(anyArray + " – Quell-Array-Element
" );

if (method == "round" ) /* 1. Bedingung */
{
anyArray = Math.round(anyArray);
document.write(anyArray + "

" )
}

Else if(method == "ceil" ) /* 2. Bedingung */
{
anyArray = Math.ceil(anyArray);
document.write(anyArray + "

" )
}

else if(method == "floor" ) /* 3. Bedingung */
{
anyArray = Math.floor(anyArray);
document.write(anyArray + "

" )
}

/* Eingabeaufforderungsmethode hinzufügen */

var method = prompt ("Geben Sie eine der Methoden ein: Rund, Decke oder Boden" );

if (method == "floor" ) /* 1. Bedingung */
{
document.write("Sie haben eine Methode " + method + " eingegeben, die Zahlen ABWÄRTS rundet

" )
}

else if (method == "round" ) /* 2. Bedingung */
{
document.write("Sie haben eine Methode " + method + " eingegeben, die Zahlen gemäß Standardregeln rundet

" )
}

else if (method == "ceil" ) /* 3. Bedingung */
{
document.write("Sie haben eine Methode " + method + " eingegeben, die Zahlen aufrundet

" )
}

else /* Sonst... */
{
document.write("Sie haben eine Methode nicht oder falsch eingegeben

" )
}

dezimal (numberArray, Methode) /* Rufen Sie die Funktion auf */

So funktionieren die Round-, Floor- oder Ceil-Methoden des Math-Objekts, die Bruchzahlen runden.

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.

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

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.

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

1. Verwenden Sie den unären +-Operator, der 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 dazu, ein Argument in eine Ganzzahl umzuwandeln. Im Gegensatz zur Verwendung des unären +-Operators diese Methode ermöglicht Ihnen, eine Zeichenfolge in eine Zahl umzuwandeln, in der nicht alle Zeichen numerisch sind. 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.

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"

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

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"); ) )

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 (больше), < (меньше), >= (größer oder gleich), 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

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