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.

Come risposta data funzione restituisce false se l'argomento è Infinity , -Infinity , NaN o verrà 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 Da questa parte 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 variante non conta una stringa vuota, una stringa di spazi, null , Infinity , -Infinity , true e false come un numero.

2. Utilizzo tipo di operatore e funzioni isFinite, isNaN:

// funzione che controlla se il valore è un numero function isNumber(value) ( ​​restituisci tipodi valore === "(!LANG: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 anche se appartiene a uno dei valori speciali Infinito, -Infinito 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 controllare se un numero è pari o dispari 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 mostriamo i numeri primi da 2 a 100 usando Javascript.

// 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 una parte frazionaria maggiore o uguale a 0,5, quindi in alto, altrimenti la torsione è in basso.

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

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 sì, 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 viene convertito esattamente in binario.

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

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 built-in metodo JavaScript. Caratteristica distintiva di questo metodo è che il parametro preso in input non indica la precisione (il numero di cifre decimali), ma il numero totale di caratteri (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.

Molto spesso, i calcoli in JavaScript non danno esattamente i risultati che vogliamo. Ovviamente, possiamo fare qualsiasi cosa con i numeri: arrotondare per eccesso o per difetto, impostare intervalli, tagliare i numeri non necessari a un certo numero di cifre decimali, tutto dipende da cosa vuoi fare con questo numero in futuro.

Perché è necessario l'arrotondamento?

Uno degli aspetti curiosi di JavaScript è che in realtà non memorizza numeri interi, stiamo lavorando subito con numeri in virgola mobile. Questo, unito al fatto che molti valori frazionari non possono essere espressi con un numero finito di cifre decimali, in JavaScript possiamo ottenere risultati come questo:

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
Ai fini pratici questa imprecisione non ha importanza, nel nostro caso si tratta di un errore in quintilioni di azioni, tuttavia questo potrebbe deludere qualcuno. Possiamo anche ottenere risultati strani quando lavoriamo con numeri che rappresentano valute, percentuali o dimensioni di file. Per correggere queste imprecisioni, dobbiamo solo essere in grado di arrotondare i risultati, ed è sufficiente impostare la precisione decimale.

L'arrotondamento dei numeri ha un uso pratico, possiamo manipolare un numero in un intervallo, ad esempio vogliamo arrotondare un valore al numero intero più vicino invece di lavorare solo con la parte decimale.

Arrotondamento dei decimali

Per eliminare un numero decimale, utilizzare toFixed o il metodo toPrecision. Entrambi accettano un singolo argomento, che determina, rispettivamente, quante cifre significative (ovvero il numero totale di cifre utilizzate nel numero) o cifre decimali (il numero dopo la virgola) il risultato dovrebbe includere:

1. Se l'argomento non è definito per toFixed(), il valore predefinito sarà zero, il che significa 0 cifre decimali, l'argomento ha un valore massimo di 20.
2. Se non viene fornito alcun argomento a toPrecision, il numero non viene modificato

sia randNum = 6,25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" randNum = 87,335; randNum.toFixed(2); > "87.33" randNum = 87.337; randNum.toPrecision(3); > "87,3"
Entrambi i metodi toFixed() e toPrecision() restituiscono una rappresentazione in forma di stringa del risultato, non un numero. Ciò significa che quando si somma il valore arrotondato con randNum , le stringhe verranno concatenate, non i numeri aggiunti:

Sia randNum = 6,25; let round = randNum.toFixed(); // "6" console.log(randNum + arrotondato); > "6.256"
Se vuoi che il risultato sia di un tipo di dati numerico, dovrai usare parseFloat:

Sia randNum = 6,25; let round = parseFloat(randNum.toFixed(1)); log della console (arrotondato); > 6.3
Si noti che 5 valori sono arrotondati tranne in rari casi.

I metodi toFixed() e toPrecision() sono utili, perché non solo possono tagliare la parte frazionaria, ma anche riempire le posizioni decimali, il che è comodo quando si lavora con le valute:

Let wholeNum = 1 let dollarCents = wholeNum.toFixed(2); console.log(dollariCents); > "1.00"
Si noti che toPrecision restituirà il risultato in notazione esponenziale se il numero di numeri interi è maggiore della precisione stessa:

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

Come evitare errori di arrotondamento con i decimali

In alcuni casi, toFixed e toPrecision arrotonderanno il valore 5 per difetto e per eccesso:

Sia numTest = 1.005; numTest.toFixed(2); > "1.00"
Il risultato del calcolo di cui sopra avrebbe dovuto essere 1.01, non 1. Se vuoi evitare questo tipo di errore, possiamo utilizzare la soluzione suggerita da Jack L Moore, che utilizza numeri esponenziali per il calcolo:

Funzione round(value, decimals) ( return Number(Math.round(value+"e"+decimals)+"e-"+decimals); )
Adesso:

Rotondo(1.005,2); > 1.01
Se desideri una soluzione più robusta di quella mostrata sopra, puoi andare su MDN.

Arrotondatrice epsilon a macchina

Un metodo alternativo per arrotondare i numeri decimali è stato introdotto in ES6. L'arrotondamento epsilon della macchina 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
Usiamo Math.EPSILON nella nostra funzione per ottenere il confronto corretto:

Funzione epsEqu(x, y) ( return Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
La funzione accetta due argomenti: il primo è il calcolo corrente, il secondo è il risultato atteso. Restituisce un confronto tra i due:

EpsEqu(0.1 + 0.2, 0.3) > true
Tutti i browser moderni supportano già le funzioni matematiche ES6, ma se desideri il supporto in browser come IE 11 usa i polyfill .

Ritaglio frazionato

Tutti i metodi presentati sopra sono in grado di arrotondare ai numeri decimali. Per tagliare semplicemente un numero a due cifre decimali, devi prima moltiplicarlo per 100, quindi dividere il risultato per 100:

Funzione tronca(num) ( return Math.trunc(num * 100) / 100; ) tronca(3.1416) > 3.14
Se si desidera adattare il metodo a qualsiasi numero di cifre decimali, è possibile utilizzare la doppia negazione bit a bit:

Funzione tronca(num, decimalPlaces) ( let numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )
Adesso:

Sia randInt = 35.874993; troncato(randInt,3); > 35.874

Arrotondamento al numero più vicino

Per arrotondare un numero decimale per eccesso o per difetto al numero più vicino, a seconda di ciò a cui siamo più vicini, usa Math.round():

Math.round(4.3) > 4 Math.round(4.5) > 5
Si noti che "metà del valore", 0,5 è arrotondato secondo le regole della matematica.

Arrotondamento per difetto al numero intero più vicino

Se vuoi sempre arrotondare per difetto, usa Math.floor:

Math.floor(42.23); > 42 Math.floor(36.93); > 36
Tieni presente che l'arrotondamento per difetto funziona per tutti i numeri, inclusi quelli negativi. Immagina un grattacielo con un numero infinito di piani, inclusi i piani inferiori (che rappresentano numeri negativi). Se ti trovi in ​​un ascensore al livello inferiore tra 2 e 3 (che è un valore di -2,5), Math.floor ti porterà a -3:

Math.floor(-2.5); > -3
Ma se vuoi evitare questo tipo di situazione, usa Math.trunc , che è supportato in tutti i browser moderni (eccetto IE/Edge):

Math.trunc(-41.43); > -41
Su MDN troverai un polyfill che fornirà supporto per Math.trunc nei browser e IE/Edge.

Arrotondamento al numero intero più vicino

D'altra parte, se devi sempre arrotondare per eccesso, usa Math.ceil. Ancora una volta, ricordando l'ascensore infinito: Math.ceil andrà sempre "su", indipendentemente dal fatto che il numero sia negativo o meno:

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

Arrotonda per eccesso/per difetto se necessario

Se vogliamo arrotondare al multiplo di 5 più vicino, il modo più semplice è creare una funzione che divida un numero per 5, lo arrotonda per eccesso e poi lo moltiplichi per lo stesso importo:

Funzione roundTo5(num) ( return Math.round(num/5)*5; )
Adesso:

RoundTo5(11); > 10
Se vuoi arrotondare a multipli del tuo valore, usiamo una funzione più generale, passando il valore iniziale e un multiplo:

Funzione roundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )
Adesso:

Sia numeroiniziale = 11; sia multiplo = 10; roundToMultiple(initialNumber, multiplo); > 10;

Fissare un numero in un intervallo

Ci sono molti casi in cui vogliamo ottenere un valore x che rientri in un intervallo. Ad esempio, potremmo volere un valore compreso tra 1 e 100, ma alla fine abbiamo ottenuto un valore di 123. Per risolvere questo problema, possiamo usare min (restituisce il più piccolo di un insieme di numeri) e max (restituisce il più grande di qualsiasi insieme di numeri). Nel nostro esempio, l'intervallo va da 1 a 100:

Sia lowBound = 1; let highBound = 100; let numInput = 123; let clamped = Math.max(lowBound, Math.min(numInput, highBound)); log della console (bloccato); > 100;
Ancora una volta, possiamo riutilizzare l'operazione e racchiudere il tutto in una funzione, utilizzando la soluzione suggerita da Daniel X. Moore:

Number.prototype.clamp = function(min, max) ( return Math.min(Math.max(this, min), max); );
Adesso:

NumInput.clamp(limitebasso, limitealto); > 100;

Arrotondamento gaussiano

L'arrotondamento gaussiano, noto anche come arrotondamento del banchiere, è che l'arrotondamento per questo caso è al numero pari più vicino. Questo metodo di arrotondamento funziona senza errori statistici. La migliore soluzioneè stato suggerito da Tim Down:

Funzione 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; }
Adesso:

GaussArrotonda(2.5) > 2 gaussArrotonda(3.5) > 4 gaussArrotonda(2.57,1) > 2.6
Punto decimale in CSS:

Poiché JavaScript viene spesso utilizzato per creare trasformazioni posizionali per elementi HTML, potresti chiederti cosa succede se generiamo valori decimali per i nostri elementi:

#box ( larghezza: 63.667731993px; )
La buona notizia è che i browser moderni rispetteranno i valori decimali nel box model, inclusa la percentuale o le unità di pixel.

Ordinamento

Molto spesso abbiamo bisogno di ordinare alcuni elementi, ad esempio abbiamo una matrice di record di gioco, mentre questi devono essere organizzati in ordine decrescente di rango dei giocatori. Sfortunatamente, il metodo standard sort() ha alcune limitazioni sorprendenti: funziona bene con parole inglesi comuni, ma si interrompe immediatamente quando incontra numeri, caratteri univoci o parole maiuscole.

Ordina in ordine alfabetico

Sembrerebbe che ordinare un array in ordine alfabetico dovrebbe essere il compito più semplice:

Let fruit = ["zucca butternut", "albicocca", "melone"]; sort di frutta(); > "albicocca", "zucca butternut", "melone"]
Tuttavia, ci imbattiamo in un problema non appena uno degli elementi è in maiuscolo:

Let fruit = ["zucca butternut", "albicocca", "Cantalope"]; sort di frutta(); > "Cantalupo", "albicocca", "zucca Butternut"]
Questo perché, per impostazione predefinita, il sorter confronta il primo carattere rappresentato in Unicode . Unicode è un codice univoco per qualsiasi carattere, indipendentemente dalla piattaforma, dal programma e dalla lingua. Ad esempio, guardando la tabella dei codici, il carattere "a" ha il valore U+0061 (esadecimale 0x61), mentre il carattere "C" ha il codice U+0043 (0x43), che precede il carattere nell'Unicode tabella "a".

Per ordinare un array che può contenere lettere iniziali maiuscole e minuscole, è necessario convertire temporaneamente tutti gli elementi in minuscolo o definire il proprio ordinamento utilizzando il metodo localeCompare() con alcuni argomenti. Di norma, in tal caso, è meglio creare immediatamente una funzione per un uso multiplo:

Function alphaSort(arr) ( arr.sort(function (a, b) ( return a.localeCompare(b, "en", ("sensitivity": "base")); )); ) let fruit = ["butternut squash ", "albicocca", "Cantalupo"]; alphaSort(frutta) >
Se vuoi ottenere un array ordinato in ordine alfabetico inverso, basta scambiare le posizioni di a e b nella funzione:

Function alphaSort(arr) ( arr.sort(function (a, b) ( return b.localeCompare(a, "en", ("sensitivity": "base")); )); ) let fruit = ["butternut squash ", "albicocca", "Cantalupo"]; alphaSort(frutta) > ["Cantalupo", "zucca butternut", "albicocca"]
Qui vale la pena notare che localeCompare viene utilizzato con argomenti, dobbiamo anche ricordare che è supportato da IE11+, per le versioni precedenti di IE, possiamo usarlo senza argomenti e in minuscolo:

Function caseSort(arr) ( arr.sort(function (a, b) ( return a.toLowerCase().localeCompare(b.toLowerCase()); )); ) let fruit = ["butternut squash", "albicocca", "Cantalupo"]; caseSort(frutta) > ["albicocca", "zucca butternut", "Cantalupo"]

Ordinamento numerico

Tutto ciò non si applica all'esempio di cui abbiamo parlato sopra sull'array di record di gioco. Con alcuni array numerici, l'ordinamento funziona bene, ma a un certo punto il risultato può essere imprevedibile:

Sia highScores = ; ordinare(); >
Il fatto è che il metodo sort() esegue un confronto lessicografico: il che significa che i numeri verranno convertiti in una stringa e i confronti verranno nuovamente effettuati confrontando il primo carattere di questa stringa nell'ordine dei caratteri della tabella Unicode. Pertanto, dobbiamo nuovamente definire il nostro ordinamento:

Sia highScores = ; highScores.sort(function(a,b) ( return a - b; )); >
Di nuovo, per ordinare i numeri ordine inverso, scambiare le posizioni di a e b nella funzione.

Ordinamento di una struttura simile a JSON

E infine, se abbiamo una struttura dati simile a JSON rappresentata come un array di record di gioco:

Let scores = [ ( "name": "Daniel", "score": 21768 ), ( "name": "Michael", "score": 33579 ), ( "name": "Alison", "score": 38395 )];
In ES6+, puoi usare le funzioni freccia:

Scores.sort((a, b) => b.score - a.score));
Per i browser meno recenti che non dispongono di questo supporto:

Scores.sort(function(a, b) ( return a.score - b.score ));
Come puoi vedere, l'ordinamento in JavaScript è una cosa piuttosto non ovvia, spero che questi esempi semplifichino la vita in qualche modo.

Lavorare con le funzioni di potenza

L'elevamento a potenza è un'operazione originariamente definita come il risultato della moltiplicazione di un numero naturale per se stesso, la radice quadrata di a è il numero che al quadrato dà a. Potremmo utilizzare queste funzioni costantemente nella vita di tutti i giorni nelle lezioni di matematica, anche durante il calcolo di aree, volumi o persino nella modellazione fisica.

In JavaScript, la funzione di potenza è rappresentata come Math.pow(), nel nuovo standard ES7 è stato introdotto nuovo operatore esponenziale - " * * ".

Esponenziamento

Per elevare un numero all'ennesima potenza, utilizzare la funzione Math.pow(), dove il primo argomento è il numero da elevare alla potenza e il secondo argomento è l'esponente:

Math.pow(3,2) > 9
Questa notazione significa 3 al quadrato, o 3 × 3, risultando in un risultato di 9. Un altro esempio potrebbe essere fornito, ovviamente:

Math.pow(5,3); > 125
Cioè, 5 al cubo, o 5 × 5 × 5, è uguale a 125.

ECMAScript 7 è la prossima versione di JavaScript, in linea di principio, possiamo utilizzare il nuovo operatore di esponenziazione proposto - * *, questa forma di scrittura può essere più descrittiva:

3 ** 2 > 9
Sul questo momento il supporto per questo operatore è piuttosto limitato, quindi se ne sconsiglia l'uso.

La funzione di alimentazione può tornare utile in una varietà di situazioni. Un semplice esempio, calcolando il numero di secondi in un'ora: Math.pow(60,2).

Radice quadrata e cubica

Math.sqrt() e Math.cbrt() sono l'opposto di Math.pow(). Come ricordiamo, la radice quadrata di a è il numero che dà a al quadrato.

Math.sqrt(9) > 3
Allo stesso tempo, la radice cubica di a è il numero che dà a al cubo.

Math.cbrt(125) > 5
Math.cbrt() è stato introdotto molto recentemente nelle specifiche JavaScript ed è quindi supportato solo nei browser moderni: Chrome 38+, Firefox e Opera 25+ e Safari 7.1+. Lo noterai Internet Explorer non è in questo elenco, tuttavia puoi trovare un polyfill su MDN.

Esempi

Ovviamente possiamo anche utilizzare valori non interi in una di queste funzioni:

Math.pow(1.25, 2); > 1.5625 Math.cbrt(56.57) > 3.8387991760286138
Si noti che funziona altrettanto bene quando si utilizzano valori di argomenti negativi:

Math.pow(-5,2) > 25 Math.pow(10,-2) > 0.01
Tuttavia, per la radice quadrata questo non funzionerà:

Math.sqrt(-9) > NaN
Dall'analisi matematica, sappiamo che il numero immaginario è inteso come le radici quadrate dei numeri negativi. E questo potrebbe portarci a un'altra tecnica di numeri complessi, ma questa è un'altra storia.

Puoi usare valori frazionari in Math.pow() per trovare le radici quadrate e cubiche dei numeri. La radice quadrata utilizza un esponente di 0,5:

Math.pow(5, 0.5); // = Math.sqrt(5) = 5 ** (1/2) > 2.23606797749979
Tuttavia, a causa dei capricci della virgola mobile, non puoi indovinare esattamente il risultato corretto:

Math.pow(2.23606797749979.2) > 5.000000000000001
In tali situazioni, dovrai ricorrere all'eliminazione dei segni dal numero o all'arrotondamento a un valore.

Alcuni, inspiegabilmente in JavaScript, confondono la funzione Math.pow() con Math.exp() , che è una funzione esponenziale per i numeri in generale. Nota: in inglese, "esponente" è tradotto come "esponente", quindi questo è più rilevante per gli anglofoni, sebbene ci siano nomi alternativi per l'esponente, come indice, potenza.

Costanti matematiche

Lavorare con la matematica in JavaScript è facilitato da una serie di costanti integrate. Queste costanti sono proprietà dell'oggetto Math. Vale la pena notare che le costanti sono scritte in maiuscolo, non in notazione CamelCase.

Math.abs, parseInt, parseFloat

Lavorare con i numeri in JavaScript può essere molto più complicato di quanto pensi. I valori ottenuti non sempre rientrano nei range previsti, a volte il risultato potrebbe non essere affatto quello che ci aspettavamo.

Matematica.abs()

Il metodo Math.abs() restituisce il valore assoluto di un numero, che ci ricorda l'analoga funzione matematica modulo a.

Sia newVal = -57.64; Math.abs(newVal); > 57,64
Math.abs(0) restituisce sempre zero, ma se mettiamo un segno meno davanti alla funzione -Math.abs(NUM), avremo sempre un valore negativo.

Matematica.abs(0); > -0

analisiInt()

Sappiamo che JavaScript comprende che "15" è una stringa, non un numero e, ad esempio, quando si analizzano le proprietà CSS utilizzando JavaScript o si ottiene un valore da un array non preparato, i nostri risultati possono rivelarsi imprevedibili. Potremmo ottenere una stringa rappresentata come "17px" come input, e questo non è raro per noi. La domanda è come convertire questa stringa in valore effettivo e utilizzarla in ulteriori calcoli.

Sintassi: parseInt(stringa, radice);

La funzione parseInt converte il primo argomento passato in un tipo stringa, lo interpreta e restituisce un valore intero o NaN. Il risultato (se non NaN) è un numero intero ed è il primo argomento (stringa) trattato come un numero nel sistema numerico specificato (radix). Ad esempio, la base 10 indica la conversione da decimale, 8 da ottale, 16 da esadecimale e così via. Se la base è maggiore di 10, le lettere vengono utilizzate per indicare i numeri maggiori di 9. Ad esempio, i numeri esadecimali (base 16) utilizzano le lettere dalla A alla F.

Considera un esempio di lavoro con le proprietà CSS, dove, relativamente parlando, possiamo ottenere il seguente valore:

Sia elem = document.body; let centerPoint = window.getComputedStyle(elem).transformOrigin; > "454px 2087.19px"
Possiamo separare i valori per spazi:

Sia centri = centerPoint.split(" "); > ["454px", "2087.19px"]
Tuttavia, ogni elemento è ancora una stringa, possiamo sbarazzarcene usando la nostra funzione:

Sia centerX = parseInt(centri, 10); > 454 let centroY = parseInt(centri, 10); > 2087
Come puoi vedere, come secondo argomento specifichiamo il sistema numerico in cui verrà convertito il numero, questo parametro è facoltativo, ma si consiglia di utilizzarlo se non si sa quale stringa verrà inserita.

parseFloat()

Dall'esempio sopra, potresti aver notato che parseInt scarta la parte frazionaria. Nel nostro caso, parseFloat può funzionare con numeri in virgola mobile. Ancora una volta, questo può essere utile nell'analisi CSS e in altre attività, specialmente quando si tratta di percentuali in virgola mobile.

Sintassi: parseFloat(stringa)

LetFP = "33,33333%"; console.log(parseFloat(FP)); > 33.33333
Si noti che non esiste un secondo argomento nella sintassi parseFloat.

Comprendiamo che parseInt() e parseFloat() sono estremamente caratteristiche utili, è importante tenere presente che ci sono sicuramente errori, quindi è necessario controllare l'intervallo di valori previsti ed eventualmente analizzare il risultato per assicurarsi che i valori ottenuti siano corretti.
Invia in forma anonima

Matematica JavaScript arrotondamento a due cifre decimali (9)

Ho la seguente sintassi JavaScript:

Vardiscount = Math.round(100 - (prezzo / listino) * 100);

Questo arrotonda a un numero intero. Come posso restituire un risultato con due cifre decimali?

Ecco un esempio funzionante

valorevar=200.2365455; result=Math.round(value*100)/100 //il risultato sarà 200.24

Per gestire l'arrotondamento a qualsiasi numero di cifre decimali, una funzione con 2 righe di codice sarà sufficiente per la maggior parte delle esigenze. Ecco un codice di esempio per il gioco.

vartestNum = 134,9567654; var decPL = 2; var testRes = roundDec(testNum,decPl); alert (testNum + " arrotondato a " + decPl + " i decimali sono " + testRes); funzione roundDec(nbr,dec_places)( var mult = Math.pow(10,dec_places); return Math.round(nbr * mult) / mult; )

La soluzione migliore e più semplice che ho trovato è

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

Una leggera variazione sulla risposta accettata. toFixed(2) restituisce una stringa e otterrai sempre due cifre decimali. Può essere zero. Se vuoi sopprimere i null finali, fai così:

Var sconto = + ((prezzo / prezzo di listino).toFisso(2));

Modificato: ho appena scoperto quello che sembra essere un bug in Firefox 35.0.1, il che significa che quanto sopra potrebbe dare a NaN alcuni valori.
Ho cambiato il mio codice in

Vardiscount = Math.round(prezzo / listino * 100) / 100;

Questo dà un numero con una precisione di due cifre decimali. Se hai bisogno di tre, moltiplichi e dividi per 1000 e così via.
OP vuole sempre due cifre decimali, ma se toFixed() non funziona in Firefox, è necessario risolverlo prima.
Vedi https://bugzilla.mozilla.org/show_bug.cgi?id=1134388

Per ottenere il risultato con 2 cifre decimali puoi fare quanto segue:

Vardiscount = Math.round((100 - (prezzo / listino) * 100) * 100) / 100;

Il valore da arrotondare viene moltiplicato per 100 per mantenere le prime due cifre, quindi dividiamo per 100 per ottenere il risultato effettivo.

penso che Il modo migliore Quello che ho visto è moltiplicare per 10 per il numero di cifre, quindi eseguire Math.round e infine dividere per 10 per il numero di cifre. Qui funzione semplice, che uso nel dattiloscritto:

Funzione roundToXDigits(value: number, digits: number) ( value = value * Math.pow(10, digits); value = Math.round(value); value = value / Math.pow(10, digits); return value; )

O semplice javascript:

Funzione roundToXDigits(value, digits) ( if(!digits)( digits = 2; ) value = value * Math.pow(10, digits); value = Math.round(value); value = value / Math.pow(10 , cifre); valore restituito; )

NOTA. - Vedere Modifica 4 se la precisione a 3 cifre è importante.

Vardiscount = (prezzo / listino).toFixed(2);

toFixed arrotonda per eccesso o per difetto a seconda dei valori maggiori di 2 cifre decimali.

Modificare. Come accennato da altri, questo convertirà il risultato in una stringa. Per evitare questo:

Vardiscount = +((prezzo / listino).toFixed(2));

Modifica 2- Come accennato nei commenti, questa funzione non viene eseguita con una certa precisione, ad esempio nel caso di 1.005 restituirà 1.00 invece di 1.01. Se la precisione è così importante, ho trovato questa risposta: https://.com/a/32605063/1726511 che sembra funzionare bene con tutti i test che ho provato.

È necessaria una piccola modifica, ma la funzione nella risposta precedente restituisce numeri interi quando viene arrotondata a uno, quindi ad esempio 99.004 restituirà 99 invece di 99.00, che non è l'ideale per visualizzare i prezzi.

Modifica 3- Sembra che toFixed sull'effettivo ritorno STILL stesse sbagliando alcuni numeri, questa modifica finale sembra funzionare. Accidenti quante riparazioni!

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

Modifica 4- Ragazzi, mi state uccidendo. La modifica 3 fallisce sui numeri negativi senza approfondire il motivo per cui è più semplice rendere positivo un numero negativo prima di eseguire l'arrotondamento e quindi rilanciarlo prima di restituire il risultato.

Funzione roundTo(n, digits) ( var negative = false; if (digits === undefined) ( digits = 0; ) if(n< 0) { negative = true; n = n * -1; } var multiplicator = Math.pow(10, digits); n = parseFloat((n * multiplicator).toFixed(11)); n = (Math.round(n) / multiplicator).toFixed(2); if(negative) { n = (n * -1).toFixed(2); } return n; }

Il modo più veloce- più veloce di toFixed():

DUE DECALILI

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

TRE DECIMALI

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

Funzione round(num,dec) ( num = Math.round(num+"e"+dec) return Number(num+"e-"+dec) ) //Arrotonda al decimale di tua scelta: round(1.3453,2)

Ciao amanti di JavaScript. Hai già notato che questa lingua è davvero straordinaria e si distingue in ogni sezione con caratteristiche proprie e insolite soluzioni tecniche. 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 un mucchio di vari 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. Logicamente, diventa chiaro che noi stiamo parlando sull'arrotondamento e la traduzione letterale della parola "pavimento" significa "pavimento", 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()

Utilizzando questo meccanismo, è possibile specificare a quante cifre decimali deve essere arrotondato 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, il risultato è Di più. 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!