Come faccio a convertire un numero float in un numero intero in JavaScript?

Vorrei convertire un float in un numero intero in JavaScript. In realtà, vorrei sapere ENTRAMBI le conversioni standard: troncando e arrotondando. E in modo efficiente, non tramite la conversione in stringa e l'analisi.

var intvalue = Math.floor( floatvalue );
var intvalue = Math.ceil( floatvalue ); 
var intvalue = Math.round( floatvalue );

// `Math.trunc` was added in ECMAScript 6
var intvalue = Math.trunc( floatvalue );

Riferimenti a oggetti matematici

Esempi

// value=x        //  x=5          5<x<5.5      5.5<=x<6  

Math.floor(value) //  5            5            5
Math.ceil(value)  //  5            6            6
Math.round(value) //  5            5            6
Math.trunc(value) //  5            5            5
parseInt(value)   //  5            5            5
~~value           //  5            5            5
value | 0         //  5            5            5
value >> 0        //  5            5            5
value >>> 0       //  5            5            5
value - value % 1 //  5            5            5

// value=x        // x=-5         -5>x>=-5.5   -5.5>x>-6

Math.floor(value) // -5           -6           -6
Math.ceil(value)  // -5           -5           -5
Math.round(value) // -5           -5           -6
Math.trunc(value) // -5           -5           -5
parseInt(value)   // -5           -5           -5
value | 0         // -5           -5           -5
~~value           // -5           -5           -5
value >> 0        // -5           -5           -5
value >>> 0       // 4294967291   4294967291   4294967291
value - value % 1 // -5           -5           -5

// x = Number.MAX_SAFE_INTEGER/10 // =900719925474099.1

// value=x            x=900719925474099    x=900719925474099.4  x=900719925474099.5

Math.floor(value) //  900719925474099      900719925474099      900719925474099
Math.ceil(value)  //  900719925474099      900719925474100      900719925474100
Math.round(value) //  900719925474099      900719925474099      900719925474100
Math.trunc(value) //  900719925474099      900719925474099      900719925474099
parseInt(value)   //  900719925474099      900719925474099      900719925474099
value | 0         //  858993459            858993459            858993459
~~value           //  858993459            858993459            858993459
value >> 0        //  858993459            858993459            858993459
value >>> 0       //  858993459            858993459            858993459
value - value % 1 //  900719925474099      900719925474099      900719925474099

// x = Number.MAX_SAFE_INTEGER/10 * -1 // -900719925474099.1

// value = x      // x=-900719925474099   x=-900719925474099.5 x=-900719925474099.6

Math.floor(value) // -900719925474099     -900719925474100     -900719925474100
Math.ceil(value)  // -900719925474099     -900719925474099     -900719925474099
Math.round(value) // -900719925474099     -900719925474099     -900719925474100
Math.trunc(value) // -900719925474099     -900719925474099     -900719925474099
parseInt(value)   // -900719925474099     -900719925474099     -900719925474099
value | 0         // -858993459           -858993459           -858993459
~~value           // -858993459           -858993459           -858993459
value >> 0        // -858993459           -858993459           -858993459
value >>> 0       //  3435973837           3435973837           3435973837
value - value % 1 // -900719925474099     -900719925474099     -900719925474099

Operatore OR bit a bit

È possibile utilizzare un bit per bit o un operatore per troncare le cifre in virgola mobile e funziona sia per i positivi che per i negativi:

function float2int (value) {
    return value | 0;
}

risultati

float2int(3.1) == 3
float2int(-3.1) == -3
float2int(3.9) == 3
float2int(-3.9) == -3

Confronto delle prestazioni?

Ho creato un test JSPerf che confronta le prestazioni tra:

• Math.floor(val)
• val | 0 ^{bit a bit OR}
• ~~val ^{NON bit a bit}
• parseInt(val)

funziona solo con numeri positivi. In questo caso sei sicuro di usare le operazioni bit a bit oltre alla Math.floorfunzione.

Ma se hai bisogno che il tuo codice funzioni con aspetti positivi e negativi , allora un'operazione bit a bit è la più veloce (O essendo quella preferita). Questo altro test JSPerf confronta lo stesso dove è abbastanza ovvio che a causa del controllo dei segni aggiuntivi Math è ora il più lento dei quattro.

Nota

Come indicato nei commenti, gli operatori BITWISE operano su numeri interi a 32 bit con segno, pertanto verranno convertiti grandi numeri, ad esempio:

1234567890  | 0 => 1234567890
12345678901 | 0 => -539222987

Nota: non è possibile utilizzare Math.floor()come sostituto di troncato, perché Math.floor(-3.1) = -4e non -3!!

Una sostituzione corretta per troncare sarebbe:

function truncate(value)
{
    if (value < 0) {
        return Math.ceil(value);
    }

    return Math.floor(value);
}

Un doppio operatore bit per bit non può essere utilizzato per troncare i float. Le altre operazioni che hai citato sono disponibili attraverso Math.floor, Math.ceile Math.round.

> ~~2.5
2
> ~~(-1.4)
-1

Maggiori dettagli per gentile concessione di James Padolsey.

Per troncare:

var intvalue = Math.floor(value);

Per round:

var intvalue = Math.round(value);

È possibile utilizzare il metodo parseInt per nessun arrotondamento. Prestare attenzione all'input dell'utente a causa delle opzioni del prefisso 0x (esadecimale) e 0 (ottale).

var intValue = parseInt(floatValue, 10);

Spostamento bit di 0 che equivale alla divisione per 1

// >> or >>>
2.0 >> 0; // 2
2.0 >>> 0; // 2

Nel tuo caso, quando vuoi una stringa alla fine (per inserire le virgole), puoi anche semplicemente usare la Number.toFixed()funzione, tuttavia, questo eseguirà l'arrotondamento.

Ci sono molti suggerimenti qui. L'OR bit a bit sembra di gran lunga il più semplice. Ecco un'altra breve soluzione che funziona anche con numeri negativi utilizzando l'operatore modulo. Probabilmente è più facile da capire rispetto all'OR bit a bit:

intval = floatval - floatval%1;

Questo metodo funziona anche con numeri di valore elevato in cui né '| 0' né '~~' né '>> 0' funzionano correttamente:

> n=4294967295;
> n|0
-1
> ~~n
-1
> n>>0
-1
> n-n%1
4294967295

Per troncare :

// Math.trunc() is part of the ES6 spec
Math.trunc( 1.5 );  // returns 1
Math.trunc( -1.5 ); // returns -1
// Math.floor( -1.5 ) would return -2, which is probably not what you wanted

Per arrotondare :

Math.round( 1.5 );  // 2
Math.round( 1.49 ); // 1
Math.round( -1.6 ); // -2
Math.round( -1.3 ); // -1

Un altro modo possibile: utilizzare l'operazione XOR:

console.log(12.3 ^ 0); // 12
console.log("12.3" ^ 0); // 12
console.log(1.2 + 1.3 ^ 0); // 2
console.log(1.2 + 1.3 * 2 ^ 0); // 3
console.log(-1.2 ^ 0); // -1
console.log(-1.2 + 1 ^ 0); // 0
console.log(-1.2 - 1.3 ^ 0); // -2

La priorità delle operazioni bit per bit è inferiore alla priorità delle operazioni matematiche, è utile. Prova su https://jsfiddle.net/au51uj3r/

Se si esamina l' Mathoggetto nativo in JavaScript, si ottiene che l'intero gruppo di funzioni funzioni su numeri e valori, ecc.

Fondamentalmente quello che vuoi fare è abbastanza semplice e nativo in JavaScript ...

Immagina di avere il numero seguente:

const myValue = 56.4534931;

e ora se vuoi arrotondarlo al numero più vicino, fai semplicemente:

const rounded = Math.floor(myValue);

e ottieni:

56

Se vuoi arrotondarlo al numero più vicino, fai semplicemente:

const roundedUp = Math.ceil(myValue);

e ottieni:

57

Anche Math.roundsolo arrotondarlo al numero più alto o più basso dipende da quale è più vicino al numero del flot.

Inoltre puoi usare ~~dietro il numero float, che convertirà un float in un numero intero.

Puoi usarlo come ~~myValue...

Voglio solo sottolineare che monetariamente vuoi arrotondare e non troncare. Essere fuori di un centesimo è molto meno probabile, dato che 4.999452 * 100 arrotondati ti darà 5, una risposta più rappresentativa.

E soprattutto, non dimenticare l'arrotondamento del banchiere , che è un modo per contrastare il pregiudizio leggermente positivo che dà l'arrotondamento diretto - la tua applicazione finanziaria potrebbe richiederlo.

Arrotondamento gaussiano / banchiere in JavaScript

Se si utilizza angularjs, la soluzione semplice è la seguente in Binding modello HTML

{{val | number:0}}

convertirà val in numero intero

vai avanti con questo link docs.angularjs.org/api/ng/filter/number