Qual è il migliore, numero (x) o parseFloat (x)?

Che è migliore?

Lo sto chiedendo solo per radere qualche byte, dato che posso usare + x invece del numero (x). Il parsefloat fa qualcosa di meglio?

La differenza tra parseFloat e Number

parseFloat/ parseIntè per l'analisi di una stringa, mentre Number/ +è per forzare un valore in un numero. Si comportano diversamente. Ma prima diamo un'occhiata a dove si comportano allo stesso modo:

parseFloat('3'); // => 3
Number('3'); // => 3
parseFloat('1.501'); // => 1.501
Number('1.501'); // => 1.501
parseFloat('1e10'); // => 10000000000
Number('1e10'); // => 10000000000

Quindi, finché hai un input numerico standard, non c'è differenza. Tuttavia, se l'input inizia con un numero e quindi contiene altri caratteri, parseFloattronca il numero fuori dalla stringa, mentre Numberdà NaN(non un numero):

parseFloat('1x'); // => 1
Number('1x'); // => NaN

Inoltre, Numbercomprende l'input esadecimale mentre parseFloatnon:

parseFloat('0x10'); // => 0
Number('0x10'); // => 16

Ma si Numbercomporta in modo strano con stringhe vuote o stringhe contenenti solo spazi bianchi:

parseFloat(''); // => NaN
Number(''); // => 0
parseFloat(' \r\n\t'); // => NaN
Number(' \r\n\t'); // => 0

Nel complesso, trovo Numberche sia più ragionevole, quindi uso quasi sempre Numberpersonalmente (e scoprirai che usano Numberanche molte funzioni JavaScript interne ). Se qualcuno digita '1x'preferisco mostrare un errore piuttosto che trattarlo come se avesse digitato '1'. L'unica volta che faccio davvero un'eccezione è quando sto convertendo uno stile in un numero, nel qual caso parseFloatè utile perché gli stili vengono in una forma come '3px', nel qual caso voglio rilasciare la 'px'parte e semplicemente ottenere la 3, quindi trovo parseFloatutile Qui. Ma davvero quale scegli tu dipende da te e quali forme di input vuoi accettare.

Si noti che l'utilizzo +dell'operatore unario è esattamente uguale all'utilizzo Numbercome funzione:

Number('0x10'); // => 16
+'0x10'; // => 16
Number('10x'); // => NaN
+'10x'; // => NaN
Number('40'); // => 40
+'40'; // => 40

Quindi di solito uso solo +in breve. Finché sai cosa fa, lo trovo facile da leggere.

La differenza è ciò che accade quando l'ingresso non è un "numero corretto". Numberritorna NaNmentre parseFloatanalizza "il più possibile". Se chiamato sulla stringa vuota Numberritorna 0mentre ritorna parseFloat NaN.

Per esempio:

Number("") === 0               // also holds for false
isNaN(parseFloat("")) === true // and null

isNaN(Number("32f")) === true
parseFloat("32f") === 32

In questi esempi puoi vedere la differenza:

Number('') = 0;
Number(false) = 0;
Number('1a') = NaN;

parseFloat('') = NaN;
parseFloat(false) = NaN;
parseFloat('1a') = 1;

parseFloat è un po 'più lento perché cerca la prima apparizione di un numero in una stringa, mentre il costatore Numero crea una nuova istanza numerica da stringhe che contiene valori numerici con spazi bianchi o che contiene valori falsi.

PS Se sei interessato ad alcune soluzioni universali di conversione dei tipi, puoi leggere il post sulla conversione dei tipi nel mio blog: http://justsimplejs.blogspot.com/2012/08/data-type-conversion.html

Per stringa vuota, sono diversi.

+""e Number("")restituisce 0, mentre parseFloat("")restituisce NaN.

Per quanto ne so, e questo è solo sentito dai colleghi, quindi potrebbe essere del tutto scarsamente informato, che parseFloat è leggermente più veloce.

Sebbene su ulteriori ricerche, sembrerebbe che questa differenza di prestazioni dipenda dal browser.

http://jsperf.com/parseint-vs-parsefloat/6

Dai un'occhiata a questi risultati di jsPerf e fatti chiamare. (include anche + x test)

Come notato nella risposta di @xdazz, +""e Number("")return 0while parseFloat("")restituisce NaNquindi di nuovo andrei con parseFloat, perché una stringa vuota NON significa il numero 0, solo una stringa con il carattere "0"in essa significa 0;