javascript - valor - parseint typescript

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

Question

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

Answer 1

Resumen:

parseInt() :

• Toma una cadena como primer argumento, la raíz (un 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, se devolverá NaN .
• Si la parseInt() 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 el radix undefined está undefined o es 0, JS asumirá lo siguiente:
  • Si la cadena de entrada comienza con "0x" o "0X", el radix es 16 (hexadecimal), el resto de la cadena se analiza en un número.
  • Si el valor de entrada comienza con un 0, el radix puede ser 8 (octal) o 10 (decimal). El radix elegido depende de la implementación del motor JS. ES5 especifica que 10 deberían 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, el radix será 10

Number() :

• El constructor Number() puede convertir cualquier entrada de argumento en un número. Si el constructor de Number() no puede convertir la entrada en un número, se devolverá NaN .
• El constructor de Number() también puede manejar números hexadecimales, 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

Answer 2

Bueno, son semánticamente diferentes , el constructor de Number llamado como una función realiza la conversión de tipos y el análisis de parseInt , 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 parseInt detecta un cero parseInt 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 llegar a las implementaciones del navegador ( es una incompatibilidad con ECMAScript 3), además, parseInt ignorará los caracteres finales que no se corresponden con ningún dígito de la base utilizada actualmente.

El constructor de Number no detecta 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 constructor de Number como una función:

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

Answer 3

Encontré dos enlaces de comparación de rendimiento entre varias formas de convertir string a 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

Answer 4

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

Answer 5

Siempre uso parseInt, pero ten cuidado con los ceros iniciales que lo forzarán en modo octal .

Answer 6

Una pequeña diferencia es lo que convierten de undefined o null ,

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

mientras

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

Answer 7

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

Answer 8

parseInt() -> Analiza un número a la redix especificada. Number() -> Convierte el valor especificado en 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 utilizar la función Número ().

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 varios casos de esquina para las funciones parseInt() , ya que realiza la conversión redix, por lo tanto, debemos evitar el uso de la función parseInt () para fines de coersión. Ahora, para verificar el clima, el valor proporcionado es numérico o no, debemos usar la función nativa isNaN()

Answer 9

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 una primitiva en lugar de un objeto.