¿Cuál es la diferencia entre parseInt () y Number ()?

¿Cómo hacer parseInt()y Number()comportarse de manera diferente al convertir cadenas en números?

Bueno, son semánticamente diferentes , el Numberconstructor llamado como función realiza la conversión de tipos y parseIntrealiza el análisis , por ejemplo:

// parsing:
parseInt("20px");       // 20
parseInt("10100", 2);   // 20
parseInt("2e1");        // 2

// type conversion
Number("20px");       // NaN
Number("2e1");        // 20, exponential notation

Tenga en cuenta que si parseIntdetecta un cero a la izquierda en la cadena, analizará el número en base octal, esto ha cambiado en ECMAScript 5, la nueva versión del estándar, pero tomará mucho tiempo ingresar a las implementaciones del navegador (es una incompatibilidad con ECMAScript 3), también parseIntignorará los caracteres finales que no se corresponden con ningún dígito de la base utilizada actualmente.

El Numberconstructor no detecta los octales:

Number("010");         // 10
parseInt("010");       // 8, implicit octal
parseInt("010", 10);   // 10, decimal radix used

Pero puede manejar números en notación hexadecimal, como parseInt:

Number("0xF");   // 15
parseInt("0xF"); //15

Además, una construcción ampliamente utilizada para realizar la conversión de tipo numérico, es el Operador Unario +(p. 72) , es equivalente a usar el Numberconstructor como una función:

+"2e1";   // 20
+"0xF";   // 15
+"010";   // 10

typeof parseInt("123") => number
typeof Number("123") => number
typeof new Number("123") => object (Number primitive wrapper object)

los dos primeros le darán un mejor rendimiento ya que devuelve un primitivo en lugar de un objeto

Si está buscando rendimiento, entonces probablemente obtendrá los mejores resultados con el desplazamiento a la derecha a nivel de bits "10">>0. También multiplique ( "10" * 1) o no ( ~~"10"). Todos ellos son mucho más rápidos de Numbery parseInt. Incluso tienen "característica" que devuelve 0 para el argumento no numérico. Aquí hay pruebas de rendimiento .

He encontrado dos enlaces de rendimiento comparan entre varias formas de convertir stringa int.

parseInt(str,10)    
parseFloat(str)
str << 0
+str
str*1 
str-0
Number(str)

http://jsben.ch/#/zGJHM

http://phrogz.net/js/string_to_number.html

Una diferencia menor es de qué se convierten undefinedo null,

Number() Or Number(null) // returns 0

mientras

parseInt() Or parseInt(null) // returns NaN

Resumen:

parseInt():

• Toma una cadena como primer argumento, la raíz (un número entero que es la base de un sistema numérico, por ejemplo, decimal 10 o binario 2) como segundo argumento
• La función devuelve un número entero, si el primer carácter no se puede convertir a un número NaN, se devolverá.
• Si la parseInt()función encuentra un valor no numérico, cortará el resto de la cadena de entrada y solo analizará la parte hasta el valor no numérico.
• Si la raíz es undefinedo 0, JS asumirá lo siguiente:
  • Si la cadena de entrada comienza con "0x" o "0X", la raíz es 16 (hexadecimal), el resto de la cadena se analiza en un número.
  • Si el valor de entrada comienza con un 0, la raíz puede ser 8 (octal) o 10 (decimal). La raíz elegida depende de la implementación del motor JS. ES5especifica que 10 debe usarse entonces. Sin embargo, esto no es compatible con todos los navegadores, por lo tanto , siempre especifique radix si sus números pueden comenzar con un 0.
  • Si el valor de entrada comienza con cualquier número, la raíz será 10

Number():

• El Number()constructor puede convertir cualquier entrada de argumento en un número. Si el Number()constructor no puede convertir la entrada en un número, NaNse devolverá.
• El Number()constructor también puede manejar el número hexadecimal, tienen que comenzar con 0x.

Ejemplo:

console.log(parseInt('0xF', 16));  // 15

// z is no number, it will only evaluate 0xF, therefore 15 is logged
console.log(parseInt('0xFz123', 16));

// because the radix is 10, A is considered a letter not a number (like in Hexadecimal)
// Therefore, A will be cut off the string and 10 is logged
console.log(parseInt('10A', 10));  // 10

// first character isnot a number, therefore parseInt will return NaN
console.log(parseInt('a1213', 10));


console.log('\n');


// start with 0X, therefore Number will interpret it as a hexadecimal value
console.log(Number('0x11'));

// Cannot be converted to a number, NaN will be returned, notice that
// the number constructor will not cut off a non number part like parseInt does
console.log(Number('123A'));

// scientific notation is allowed
console.log(Number('152e-1'));  // 15.21

Siempre uso parseInt, pero tenga cuidado con los ceros a la izquierda que lo forzarán en modo octal .

parseInt() -> Analiza un número para redix especificado.

Number()-> Convierte el valor especificado a su equivalente numérico o NaN si no lo hace.

Por lo tanto, para convertir algún valor no numérico en número, siempre debemos usar la función Number ().

p.ej.

Number("")//0
parseInt("")//NaN

Number("123")//123
parseInt("123")//123

Number("123ac") //NaN,as it is a non numeric string
parsInt("123ac") //123,it parse decimal number outof string

Number(true)//1
parseInt(true) //NaN

Hay varias mayúsculas y minúsculas para las parseInt()funciones, ya que hace la conversión de redix, por lo tanto, debemos evitar usar la función parseInt () para fines de coerción.

Ahora, para verificar el clima, el valor proporcionado es Numérico o no, debemos usar la isNaN()función nativa

parseInt se convierte en un número entero, es decir, elimina los decimales. El número no se convierte en entero.

Es una buena idea mantenerse alejado de parseInt y usar Number y Math.round a menos que necesite hexadecimal u octal. Ambos pueden usar cadenas. ¿Por qué mantenerse alejado de eso?

parseInt(0.001, 10)
0

parseInt(-0.0000000001, 10)
-1

parseInt(0.0000000001, 10)
1

parseInt(4000000000000000000000, 10)
4

Es completamente carnicero números realmente grandes o muy pequeños. Por extraño que parezca, funciona normalmente si estas entradas son una cadena.

parseInt("-0.0000000001", 10)
0

parseInt("0.0000000001", 10)
0

parseInt("4000000000000000000000", 10)
4e+21

En lugar de arriesgarme a encontrar errores con este y los otros problemas que mencionaron las personas, simplemente evitaría parseInt a menos que necesite analizar algo que no sea base 10. Number, Math.round, Math.foor y .toFixed (0) pueden todos haga lo mismo para usar parseInt sin tener este tipo de errores.

Si realmente quiere o necesita usar parseInt para algunas de sus otras cualidades, nunca lo use para convertir flotadores en ints.