Ciao amanti di JavaScript. Hai già notato che questo linguaggio è davvero straordinario e si distingue in ogni sezione con le sue caratteristiche e soluzioni tecniche insolite. Pertanto, la pubblicazione odierna è dedicata all'argomento: "Arrotondamento JavaScript".

Dopo aver letto l'attuale articolo, scoprirai perché è necessario arrotondare i numeri, quali metodi e proprietà in js svolgono questa funzione e cosa distingue la divisione per 0. Senza cambiare i miei principi, allegherò esempi ai punti chiave del materiale e descrivere ogni azione in dettaglio. Ora iniziamo ad imparare!

Note importanti sui numeri

Innanzitutto, ricorda che in js tutti i tipi di numeri (frazionari e interi) sono di tipo numero. Inoltre, sono tutti a 64 bit, poiché sono memorizzati nel formato "doppia precisione", noto anche come standard IEEE-754.

Le variabili numeriche vengono create nel solito modo:

var numb = 35; // numero naturale

vardrob = 0,93; //rappresentazione decimale

var numb16 = 0xFF; //sistema numerico esadecimale

Supporta anche altre rappresentazioni numeriche. Quindi, puoi ancora creare numeri in virgola mobile (a volte sono chiamati "numeri in formato scientifico").

Aggiunto il supporto per un metodo molto interessante toLocaleString(), che formatta tutti i parametri numerici secondo le specifiche prescritte in ECMA 402. Per questo motivo, i numeri grandi, numeri di telefono, valute e persino percentuali sono ben visualizzate nella finestra di dialogo.

varnum = 714000,80;

alert(num.toLocaleString());

Per lavorare con elementi del tipo Numero, è stato fornito un intero oggetto globale con una serie di varie funzioni matematiche, il cui nome è Matematica.

Inoltre, esistono altri metodi che arrotondano i valori numerici a numeri interi, a decimi, centesimi e così via. Consideriamoli tutti in modo più dettagliato.

Grande e potente matematica

L'oggetto Math globale include un'enorme varietà di funzioni matematiche e trigonometriche. Questo è un oggetto molto necessario e spesso aiuta gli sviluppatori quando lavorano con dati digitali.

Su altre piattaforme, ci sono analogie con Math. Ad esempio, in linguaggi popolari come Java e C#, Math è una classe che supporta tutte le stesse funzioni standard. Quindi, come puoi vedere, questo strumento è davvero eccezionale e potente.

Ora voglio esaminare i metodi di arrotondamento specifici e parlarne in dettaglio.

Math.floor()

Inizierò con Matematica.pavimento. Prestare attenzione al nome del metodo. Diventa logicamente chiaro che poiché stiamo parlando di arrotondamento e la traduzione letterale della parola "pavimento" significa "pavimento", allora questo strumento arrotonderà per difetto i valori elaborati.

È anche possibile che il numero elaborato utilizzando questa funzione rimanga lo stesso. Questo perché l'arrotondamento viene effettuato secondo una disuguaglianza non stretta (<=). Таким образом, при отработке этой строчки кода:

alert(Math.floor(4.5));

la risposta sarà la numero 4.

Math.ceil()

Di nuovo, guarda il titolo (in questo modo il materiale viene assorbito più velocemente). Se qualcuno non lo sa, allora "ceil" significa "soffitto". Ciò significa che i dati numerici verranno arrotondati utilizzando una disuguaglianza non rigorosa (>=).

alert(Math.ceil(4.5));

Come avrai intuito, la risposta sarà il numero 5.

turno di matematica()

Questo metodo arrotonda un numero frazionario all'intero più vicino. Pertanto, se la parte frazionaria è compresa tra 0 e 0,5 inclusi, l'arrotondamento avviene a un valore inferiore. E se la parte frazionaria è compresa tra 0,5 inclusi e il numero intero successivo, viene arrotondata per eccesso a un numero intero più grande.

alert(Math.round(4.5));

Spero che tutti abbiano pensato o detto che la risposta corretta è 5.

Qualche altro metodo

JavaScript ha anche altri 2 metodi che si occupano dell'arrotondamento delle rappresentazioni numeriche. Tuttavia, sono in qualche modo diversi.

Stiamo parlando di strumenti come aFisso() E toPrecision(). Sono responsabili non solo dell'arrotondamento, ma anche della sua accuratezza rispetto a determinati segni. Scaviamo più a fondo.

aFisso()

Usando questo meccanismo puoi specificare a quante cifre decimali arrotondare il valore. Il metodo restituisce il risultato come stringa. Di seguito ho allegato una variante con tre diverse opzioni. Analizzare le risposte ricevute.

varnum = 5656,9393;

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

document.writeln(num.toFixed(2)); // 5656.94

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

Come puoi vedere, se non specifichi un argomento, allora toFixed ()) arrotonderà il valore frazionario al tutto numeri. La terza riga è arrotondata fino a 2 caratteri, e nel quarto sono stati aggiunti altri tre 0 a causa del parametro "7".

toPrecision()

Questo metodo funziona in modo leggermente diverso. Al posto dell'argomento, puoi lasciare uno spazio vuoto e impostare un parametro. Tuttavia, quest'ultimo arrotonderà i numeri al numero di cifre specificato, indipendentemente dalla virgola. Ecco i risultati del programma riscritto dall'esempio precedente:

varnum = 5656,9393;

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

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

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

La caratteristica della divisione per 0 in js

Come sai dalle lezioni di matematica, non puoi dividere per zero. Questa regola è stata presa come base dalla maggior parte dei creatori di linguaggi di programmazione. Pertanto, quando si divide per zero, tutti i programmi generano un errore.

Tuttavia, anche qui JavaScript eccelleva. Quindi, durante l'esecuzione di tale operazione, non si verificano segnalazioni di bug ... perché tale operazione ritorna "Infinito"!

Perchè così? Come è noto dalle stesse scienze matematiche, più piccolo è il divisore, maggiore è il risultato. Ecco perché i creatori di questo linguaggio basato su prototipi hanno deciso di abbandonare i modelli e seguire la propria strada.

Per coloro che sono nuovi al significato di Infinito, ho spiegato le sue caratteristiche di seguito.

Infinito - significa infinito e corrisponde pienamente al segno matematico ∞.

Può essere negativo. Vengono mantenute anche tutte le regole standard per lavorare con gli operatori aritmetici.

avviso(12/0); // Infinito

allerta(12.34/0); // Infinito

allerta(-3/0); // -Infinito

Su questo, forse, finirò. Se ti è piaciuto il post, assicurati di iscriverti al mio blog. Sentiti libero di collegarti ad articoli interessanti e condividerli con i tuoi amici. Ciao ciao!

In questo articolo daremo un'occhiata più da vicino a numeri, operatori matematici, modi per convertire un numero in una stringa e viceversa, oltre a molti altri punti importanti.

funzione isFinite

La funzione isFinite consente di verificare se un argomento è un numero finito.

Questa funzione restituisce false come risposta se l'argomento è Infinity , -Infinity , NaN o verrebbe eseguito il cast su uno di questi valori numerici speciali. In caso contrario, questa funzione restituirà true .

ÈFinito(73); // true isFinite(-1/0); // false isFinite(Infinity); // false isFinite(NaN); // false isFinite("Testo"); // falso

Oltre alla funzione globale isFinite, JavaScript dispone anche del metodo Number.isFinite. A differenza di isFinite, non forza la conversione dell'argomento in un numero.

ÈFinito("73"); // true Number.isFinite("73"); // falso

funzione isNaN

La funzione isNaN serve a determinare se un argomento è un numero o può essere convertito in uno. In tal caso, la funzione isNaN restituisce false. Altrimenti restituisce true.

IsNaN(NaN); //true isNaN("25px"); //vero, perché 20px non è un numero isNaN(25.5); //false isNaN("25.5"); //falso isNaN(" "); //falso, perché uno o più spazi vengono convertiti in 0 isNaN(null); //falso, perché il valore nullo viene convertito in 0 isNaN(true); //falso, perché true viene convertito in 1 isNaN(false); //falso, perché il valore falso viene convertito in 0

Se questa azione deve essere eseguita senza un cast di tipo, utilizzare il metodo Number.isNaN. Questo metodo è stato introdotto nel linguaggio da ECMAScript 6.

Come convertire esplicitamente una stringa in un numero?

Puoi convertire esplicitamente una stringa in un numero utilizzando i seguenti metodi:

1. Usa operatore unario + Il da mettere prima del valore.

+"7.35"; // 7.35 +"testo"; // NaN

Questo metodo ignora gli spazi all'inizio e alla fine della riga, nonché \n (line feed).

+"7.35"; //7.35 +"7.35\n"; //7.35

Usando questo metodo si noti che una stringa vuota o una stringa composta da spazi e \n viene convertita nel numero 0. Inoltre, converte anche il tipo di dati null e booleani in un numero.

Nullo; //0 +vero; //1 +falso; //0 +" "; //0

2. Funzione parseInt . Questa funzione è progettata per convertire argomento a un numero intero. Al contrario di utilizzare operatore unario +, questo metodo consente di convertire una stringa in un numero, in cui non tutti i caratteri sono numerici. Inizia a convertire la stringa, partendo dal primo carattere. E non appena incontra un carattere che non è un carattere numerico, questa funzione interrompe il suo lavoro e restituisce il numero risultante.

AnalisiInt("18px"); //18 parseInt("33.3%"); //33

Questa funzione può funzionare con sistemi diversi numerazione (binaria, ottale, decimale, esadecimale). L'indicazione della base del sistema di numerazione si effettua per mezzo di 2 argomenti.

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

Oltre alla funzione parseInt, JavaScript ha il metodo Number.parseInt. Questo metodo non è diverso dalla funzione parseInt ed è stato introdotto in JavaScript con la specifica ECMASCRIPT 2015(6).

3. Funzione parseFloat . La funzione parseFloat è simile a parseInt , tranne per il fatto che consente di convertire l'argomento in un numero frazionario.

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

Inoltre la funzione parseFloat, a differenza di parseInt, non ha 2 argomenti, e quindi cerca sempre di trattare la stringa come un numero in notazione decimale.

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

Oltre alla funzione parseFloat, JavaScript ha il metodo Number.parseFloat. Questo metodo non è diverso dalla funzione parseFloat ed è stato introdotto in JavaScript con la specifica ECMASCRIPT 2015(6).

Converti numero in stringa

Puoi trasformare un numero in una stringa usando il metodo toString.

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

Il metodo toString consente inoltre di specificare la base del sistema numerico, tenendo conto del quale è necessario eseguire il cast esplicito del numero alla stringa:

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

Come verificare se una variabile è un numero

È possibile determinare se il valore di una variabile è un numero utilizzando uno dei seguenti metodi:

1. Utilizzando le funzioni isNaN e isFinite:

// myVar è una variabile if (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //myVar è un numero o può essere convertito in esso );

Come una funzione:

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

Questo metodo consente di determinare se il valore specificato è un numero o può essere convertito in esso. Questa opzione non conta una stringa vuota, una stringa di spazi, null , Infinity , -Infinity , true e false come un numero.

2. Utilizzando l'operatore typeof e le funzioni isFinite, isNaN:

// funzione che controlla se il valore è un numero function isNumber(value) ( ​​restituisci tipodi valore === "number" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

Questa funzione determina se il valore specificato è di tipo Number e non è uno dei valori speciali Infinity, -Infinity e NaN. In tal caso, questa funzione restituisce true.

3. Utilizzo del metodo ECMAScript 6 Number.isInteger(value). Questo metodo consente di determinare se il valore specificato è un numero intero.

Numero.èIntero("20"); //falso, perché questo metodo non traduce la stringa in un numero Number.isInteger(20); //vero, perché dato valore è un numero

Numeri pari e dispari

Puoi verificare se un numero è pari o dispari utilizzando le seguenti funzioni:

// Funzione per verificare se un numero è pari function isEven(n) ( return n % 2 == 0; ) // Funzione per verificare se un numero è dispari function isOdd(n) ( return Math.abs(n % 2) == 1;)

Ma prima di eseguire tale controllo, è opportuno assicurarsi che il valore specificato sia un numero:

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

Numeri primi in Javascript

Considera un esempio in cui visualizziamo usando Javascript numeri primi da 2 a 100.

// Una funzione che controlla se un numero è primo 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);

Arrotondamento di un numero in Javascript

Esistono vari modi per arrotondare un numero frazionario a un valore intero in JavaScript.

1. Utilizzando i metodi Math.floor , Math.ceil e Math.round appositamente progettati per questo. Il metodo Math.floor arrotonda un numero frazionario all'intero più vicino, ad es. scarta semplicemente la parte frazionaria. Math.ceil arrotonda un numero frazionario all'intero più vicino. Math.round arrotonda un numero per eccesso o per difetto a seconda del valore della parte frazionaria. Se la parte frazionaria è maggiore o uguale a 0,5, allora verso l'alto, altrimenti lo scorrimento è verso il basso.

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

2. Utilizzando il metodo toFixed(precisione). Questo metodo arrotonda la parte frazionaria di un numero alla precisione specificata. Il risultato dell'arrotondamento viene restituito come stringa.

Console.log(7.987.toFixed(2)); //"7.99"

Se non ci sono abbastanza cifre decimali per formare la precisione specificata del numero, viene riempito con zeri.

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

3. Attraverso il metodo toPrecision(precision). Questo metodo rappresenta un numero con la precisione specificata. Allo stesso tempo, può arrotondare non solo la parte frazionaria, ma anche l'intera parte del numero. Il numero risultante può essere rappresentato con questo metodo a seconda del risultato in un punto fisso o in forma esponenziale.

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. Utilizzo degli operatori logici NOT o OR.

//tramite doppia negazione logica console.log(~~7.9); //7 // utilizzando l'OR logico con zero: console.log(7.9^0); //7

Parte intera e frazionaria di un numero

Puoi ottenere la parte intera di un numero usando i metodi Math.floor() e parseInt():

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

È possibile ottenere la parte frazionaria di un numero utilizzando l'operatore percentuale (%). Questo operatore restituisce il resto che si otterrà dividendo il primo numero per il secondo. In questo caso, 1 dovrebbe essere usato come 2° numero.

Console.log(7.21%1); // 0.209999999999999996 // accurato fino a 2 cifre decimali console.log((7.21%1).toFixed(2)); // "0.21"

Inoltre, la parte frazionaria può essere ottenuta anche mediante calcoli:

numero var = 7,21; var numerofrazione = numero - Math.floor(Math.abs(numero)); console.log(numerofrazione); // 0.209999999999999996

È il numero divisibile

Puoi determinare se un numero è divisibile uniformemente utilizzando l'operatore percentuale:

numerovar = 9; // se il resto della divisione numero per 3 è 0, allora si, altrimenti no if (numero%3==0) ( console.log ("Il numero " + numero + " è divisibile per 3"); ) else ( console.log("Numero " + numero + " non è divisibile per 3"); )

Formattazione dei numeri

In JavaScript, il metodo toLocaleString() consente di formattare l'output di un numero in base alle impostazioni locali (impostazioni della lingua del sistema operativo).

Ad esempio, formattiamo un numero in base agli standard regionali installati nel sistema per impostazione predefinita:

numero var = 345,46; console.log(number.toLocaleString()); //"345,46"

Ad esempio, formattiamo un numero in conformità con gli standard regionali della Russia (ru):

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

Questo metodo può essere utilizzato anche per formattare un numero come valuta:

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

Rappresentare un numero in percentuale:

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

Dividi il numero in cifre (proprietà useGrouping):

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

Stampa un numero con un certo numero di cifre (2) dopo la virgola:

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

Confronto numerico

I seguenti operatori vengono utilizzati per confrontare i numeri in JavaScript: == (uguale a), != (diverso da), > (maggiore di),< (меньше), >= (maggiore o uguale),<= (меньше или равно).

Ad esempio, confrontiamo due numeri:

Console.log(2>3); //falso console.log(5>=3); //VERO

Quando si confrontano i numeri con una parte frazionaria, è necessario tenere conto degli errori che possono verificarsi durante questi calcoli.

Ad esempio, in JavaScript, la somma dei numeri (0,2 + 0,4) non è uguale a 0,6:

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

Gli errori si verificano perché tutti i calcoli sono computer o altro dispositivo elettronico produce nel sistema a 2 numeri. Quelli. prima di eseguire qualsiasi azione, il computer deve prima convertire i numeri presentati nell'espressione nel sistema a 2 numeri. Ma nessun numero decimale frazionario può essere rappresentato esattamente nel secondo sistema numerico.

Ad esempio, il numero 0,25 10 in sistema binario convertito esattamente.

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

Ad esempio, il numero 0,2 10 può essere convertito nel sistema 2 solo con una certa precisione:

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

Di conseguenza, questi errori influiranno sul calcolo della somma di due numeri e sui risultati del confronto. Quelli. si scopre che in realtà JavaScript vedrà questa voce come segue:

0.6000000000000001==0.6

Quando si calcolano o si visualizzano numeri con una parte frazionaria, è necessario specificare sempre la precisione con cui questo deve essere fatto.

Ad esempio, confronta i numeri fino a 2 cifre decimali utilizzando i metodi toFixed() e toPrecision():

//metodo toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //metodo toPrecision() console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //VERO

Operazioni matematiche di base

JavaScript ha i seguenti operatori matematici: + (addizione), - (sottrazione), * (moltiplicazione), / (divisione), % (resto della divisione), ++ (aumenta il valore di 1), -- (diminuisce il valore di 1 ).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, cioè 6:3=2 => 6-3*2 => resto(0) 5%2 //1, cioè 5:2=2(.5) => 5-2*2 => resto(1) 7.3%2 //1.3, cioè 7.3:2=3(.65) => 7.3-2*3 => rest(1.3) //il segno del risultato dell'operazione % è uguale al segno del primo valore -9%2.5 //-1.5, cioè 9:2.5=3(.6) => 9-2.5*3 => resto(1.5) -9%-2.5 //-1.5, cioè 9:2.5=3(.6) => 9-2.5*3 => resto(1.5) -2%5 //-2, cioè 2:5=0(.4) => 2-5*0 => resto(2) x = 3; log della console(x++); //visualizza 3, quindi imposta y su 4 console.log(x); //4 x = 3; log della console(++x); //imposta 4 e restituisce x = 5; log della console(x--); // restituisce 5, y quindi imposta 4 console.log(x); //4 x = 5; log della console(--x); //imposta su 4 e restituisce Inoltre, ci sono operatori combinati in JavaScript: 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; log della console(x); //9 x = 3; y=6; x-=y; log della console(x); //-3 x = 3; y=6; x*=y; log della console(x); //18 x = 3; y=6; x/=y; log della console(x); //0,5 x = 3; y=6; x%=y; log della console(x); //3

Spesso i calcoli danno risultati che non rientrano negli intervalli desiderati. Di conseguenza, è necessario Arrotondamento JavaScript fino a un certo valore.

Perché i numeri tondi?

JavaScript non memorizza numeri interi perché i loro valori sono rappresentati come numeri in virgola mobile. Molte frazioni non possono essere rappresentate da un numero con un certo numero finito di cifre decimali, quindi JavaScript può generare risultati come i seguenti:

0.1 * 0.2; > 0.020000000000000004

In pratica, questo non avrà importanza, poiché stiamo parlando di un errore di 2 quintilioni. Ma questo può influire sul risultato quando si lavora con numeri che rappresentano valori di valuta, percentuali o dimensioni di file. Pertanto, è necessario eseguire o fino a un determinato decimale.

Arrotondamento dei decimali

Per "tagliare" un numero decimale, utilizzare i metodi toFixed() o toPrecision(). Entrambi accettano un argomento, che specifica il numero di cifre significative e decimali da includere nel risultato:

• se non viene specificato alcun argomento per toFixed() , il valore predefinito è 0 , ovvero nessuna cifra decimale; il valore massimo dell'argomento è 20 ;
• se non viene fornito alcun argomento a toPrecision(), il numero non viene modificato.

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"

Nota

Sia toFixed() che toPrecision restituiscono una rappresentazione in forma di stringa arrotondata del risultato, non un numero. Ciò significa che l'aggiunta di arrotondamento a randNum risulterà in una concatenazione di stringhe piuttosto che in un singolo numero:

console.log(randNum + arrotondato); > "6.256"

Se vuoi che JavaScript arrotondi al centesimo, usa parseFloat() :

var randNum = 6,25; var arrotondato = parseFloat(randNum.toFixed(1)); log della console (arrotondato); > 6.3

toFixed() e toPrecision() sono anche metodi utili per il troncamento un largo numero decimali. Questo è utile quando si lavora con numeri che rappresentano unità monetarie:

var Numintero = 1 var DollarCents = Numintero.toFixed(2); console.log(dollariCents); > "1.00"

Si noti che se il numero ha più cifre del parametro precision, toPrecision restituirà il risultato in formato scientifico:

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

Come evitare errori durante l'arrotondamento dei decimali

In alcuni casi, toFixed e toPrecision lo fanno JavaScript arrotonda 5 per difetto, e non fino a più:

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

Il risultato dell'esempio sopra dovrebbe essere 1.01, non 1. Se vuoi evitare questo errore, ti consiglio di usare numeri esponenziali:

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

Applicazione:

tondo(1.005,2); > 1.01

Se hai bisogno di una soluzione ancora più robusta dell'arrotondamento, è disponibile su MDN.

Arrotondamento con Epsilon

Metodo alternativo Arrotondamento JavaScript ai decimiè stato introdotto in ES6 ( noto anche come JavaScript 2015). « Macchina epsilon' fornisce un ragionevole margine di errore quando si confrontano due numeri in virgola mobile. Senza arrotondamento, i confronti possono produrre risultati simili ai seguenti:

0.1 + 0.2 === 0.3 > falso

Math.EPSILON può essere utilizzato in una funzione per ottenere un confronto valido:

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

La funzione accetta due argomenti: uno contiene il calcolo, il secondo è il risultato atteso (arrotondato). Restituisce un confronto di questi due parametri:

epsEqu(0.1 + 0.2, 0.3) > vero

Tutti i browser moderni supportano le funzioni matematiche ES6. Ma se devi fornire supporto nei browser meno recenti, devi utilizzare i polyfill.

Troncamento decimale

Tutti i metodi presentati in precedenza funzionano Arrotondamento JavaScript ai decimi. Per troncare un numero positivo a due cifre decimali, moltiplicalo per 100 , tronca nuovamente e poi dividi il risultato per 100 :

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

Se hai bisogno di qualcosa di più flessibile, puoi usare l'operatore bit a bit:

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

Utilizzo:

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

Arrotondamento al numero più vicino

Portare fuori JavaScript arrotondato a numero intero, viene utilizzato Math.round():

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

Notare che " mezzi valori“, come .5 , sono arrotondati per eccesso.

Arrotondamento per difetto al numero intero più vicino

Se vuoi arrotondare per difetto, usa il metodo Math.floor() :

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

L'arrotondamento "per difetto" ha una direzione per tutti i numeri, compresi quelli negativi. Questo può essere immaginato come un grattacielo con un numero infinito di piani, anche al di sotto del livello delle fondamenta ( rappresentare numeri negativi). Se ti trovi in ​​un ascensore tra i piani interrati 2 e 3 ( che corrisponde al valore -2,5), Math.floor ti porterà al piano -3 :

Math.floor(-2.5); > -3

Se è necessario evitarlo, utilizzare l'arrotondamento JavaScript Math con Math.trunc() , che è supportato in tutti browser moderni(tranne IE/Bordo):

Math.trunc(-41.43); > -41

MDN fornisce anche Polyfill a 3 righe per fornire supporto per Math.trunc nei browser meno recenti e IE/Edge.

Arrotondamento al numero intero più vicino

Se vuoi arrotondare i numeri decimali, usa Math.ceil . Puoi anche pensare a questo metodo come a un ascensore infinito: Math.ceil ti porta sempre "su", indipendentemente dal fatto che il numero sia negativo o positivo:

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

Arrotondamento al multiplo più vicino

Se desideri arrotondare un valore al multiplo più vicino di 5 , crea una funzione che divida il numero per 5 , lo arrotonda per eccesso e quindi moltiplichi il risultato per lo stesso valore:

funzione roundTo5(num) ( return Math.round(num/5)*5; )

Utilizzo:

roundTo5(11); > 10

Se devi eseguire l'arrotondamento JavaScript a due cifre decimali, puoi passare sia il seme che la molteplicità alla funzione:

funzione roundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )

Per utilizzare la funzione, includi il numero da arrotondare e la molteplicità nella sua chiamata:

var Numeroiniziale = 11; var multiplo = 10; roundToMultiple(initialNumber, multiplo); > 10;

Per arrotondare i valori solo per eccesso o per difetto, sostituire la funzione round con ceil o floor .

Associazione a un intervallo

A volte è necessario ottenere il valore di x, che deve rientrare in un certo intervallo. Ad esempio, vogliamo un valore compreso tra 1 e 100 , ma otteniamo un valore di 123 . Per risolvere questo problema, puoi usare min() ( restituisce il più piccolo dei numeri) e massimo( restituisce il numero massimo consentito).

Utilizzo:

var Limitebasso = 1; varhighBound = 100; varnumInput = 123; var bloccato = Math.max(lowBound, Math.min(numInput, highBound)); log della console (bloccato); > 100;

È possibile creare una funzione o un'estensione della classe Number.

Ciao. Oggi nella colonna su Javascript vedremo come impostare il numero di cifre decimali nei numeri in virgola mobile in javascript. Ad esempio, è necessario lasciare 3 cifre decimali durante l'output o solo due.

Compito: numero javascript di cifre decimali

Quindi, ci troviamo di fronte a un compito: c'è un risultato di calcolo in cui ci sono numeri prima della virgola decimale e dopo la virgola decimale. Decimale. Diciamo che il risultato è così 1538.9891200153. Ma quando emetti, dovresti ottenere un numero che rifletta l'importo, dove prima del punto decimale c'è il numero di banconote e dopo - copechi.

Esistono diversi modi per risolvere questo problema.

Soluzione 1: numero javascript di cifre decimali con il metodo toFixed

toFixed è un metodo integrato javascript che viene applicato a qualsiasi numero, accetta la precisione di arrotondamento (ovvero il numero di cifre decimali) come parametro.

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;

Il parametro di precisione in questa funzione deve essere almeno 0 (non accetta valori negativi) e al massimo 20.

Puoi anche fare a meno di una variabile, in questo modo:

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

Soluzione 2: numero javascript di cifre decimali con il metodo toPrecision

Questa soluzione si basa sullo stesso metodo javascript integrato. Una caratteristica distintiva di questo metodo è che il parametro di input non indica la precisione (il numero di cifre decimali), ma il numero totale di cifre decimali (sia prima che dopo la virgola).

Varnum=1538.9891200153; num_str=num.toPrecision(5); //num_str=1538.9; num_str=num.toPrecision(7); //num_str=1538.989;

Soluzione senza cifre decimali: numero javascript di cifre decimali

Se le posizioni decimali devono essere completamente scartate, ovvero è necessario arrotondare un numero frazionario a un numero intero, è possibile utilizzare le funzioni della classe Math: round, ceil e floor.
Arrotonda - arrotonda per eccesso o per difetto (a seconda del numero). Se il valore dopo la virgola è superiore alla metà, verrà arrotondato per eccesso, se è inferiore, verrà arrotondato per difetto. Cioè, se 0,51 - diventerà 1, se 0,49 - 0.

Ceil - dall'inglese. il soffitto si arrotonda sempre per eccesso.

Pavimento - dall'inglese. Il genere viene sempre arrotondato per difetto.

Varnum = 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;

È tutto. Spero che questa nota ti abbia aiutato a risolvere il tuo problema. Se qualcosa non ha funzionato, fai domande utilizzando il pulsante verde "Fai una domanda a uno specialista" o nei commenti.