¿Cuál es mejor, número (x) o parseFloat (x)?

¿Cual es mejor?

Estoy preguntando esto solo por afeitar unos pocos bytes, ya que puedo usar + x en lugar de número (x). ¿Parsefloat hace algo mejor?

La diferencia entre parseFloat y Number

parseFloat/ parseIntes para analizar una cadena, mientras que Number/ +es para forzar un valor a un número. Se comportan de manera diferente. Pero primero veamos dónde se comportan igual:

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

Entonces, siempre que tenga una entrada numérica estándar, no hay diferencia. Sin embargo, si su entrada comienza con un número y luego contiene otros caracteres, parseFloattrunca el número de la cadena, mientras Numberda NaN(no un número):

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

Además, Numbercomprende la entrada hexadecimal mientras parseFloatque no:

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

Pero Numberactúa de forma extraña con cadenas vacías o cadenas que contienen solo espacios en blanco:

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

En general, considero Numberque es más razonable, por lo que casi siempre lo uso Numberpersonalmente (y verás que muchas de las funciones internas de JavaScript también se usan Number). Si alguien escribe '1x', prefiero mostrar un error en lugar de tratarlo como si hubiera escrito '1'. La única vez que realmente hago una excepción es cuando estoy convirtiendo un estilo en un número, en cuyo caso parseFloates útil porque los estilos vienen en una forma como '3px', en cuyo caso quiero soltar la 'px'parte y simplemente obtener el 3, así que me parece parseFloatútil aquí. Pero realmente cuál elija usted depende de usted y qué formas de entrada desea aceptar.

Tenga en cuenta que usar el +operador unario es exactamente lo mismo que usar Numbercomo función:

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

Por lo general, solo uso +para abreviar. Mientras sepa lo que hace, me resulta fácil de leer.

La diferencia es lo que sucede cuando la entrada no es un "número apropiado". Numbervuelve NaNmientras parseFloatanaliza "tanto como puede". Si se llama, la cadena vacía Numbervuelve 0mientras que parseFloat regresa NaN.

Por ejemplo:

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

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

En estos ejemplos puedes ver la diferencia:

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

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

parseFloat es un poco más lento porque busca la primera aparición de un número en una cadena, mientras que el constructor de números crea una nueva instancia de número a partir de cadenas que contiene valores numéricos con espacios en blanco o que contiene valores falsos.

PD Si está interesado en algunas soluciones de conversión de tipo universal, puede leer la publicación sobre conversión de tipo en mi blog: http://justsimplejs.blogspot.com/2012/08/data-type-conversion.html

Para la cadena vacía, son diferentes.

+""y Number("")devuelve 0, mientras que parseFloat("")devuelve NaN.

Hasta donde yo sé, y esto solo lo escuchan los colegas, por lo que podría estar completamente mal informado, que parseFloat es marginalmente más rápido.

Aunque en futuras investigaciones, parece que esta diferencia de rendimiento depende del navegador.

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

Echa un vistazo a estos resultados de jsPerf y haz que te llamen. (incluye + x pruebas también)

Como se señaló en la respuesta de @xdazz, +""y Number("")regresar 0mientras parseFloat("")regresa, de NaNnuevo, iría con parseFloat, porque una cadena vacía NO significa el número 0, solo una cadena con el carácter "0"significa 0;