Ejemplo de javascript parseInt

los parseInt() función analiza un string argumento y devuelve un número entero del especificado base (la base en los sistemas numéricos matemáticos).

Sintaxis

parseInt(string)parseInt(string, radix)

Parámetros

string

El valor para analizar. Si este argumento no es un string, luego se convierte en uno usando el ToString operación abstracta. Principal espacio en blanco en este argumento se ignora.

radixOpcional

Un entero entre 2 y 36 que representa el base (la base en los sistemas numéricos matemáticos) de la string. Tenga cuidado, esto no no predeterminado a 10! Si el valor de la base no es del Number tipo será coaccionado a un Number.

Advertencia: La descripción a continuación explica con más detalle lo que sucede cuando radix no se proporciona.

Valor devuelto

Un número entero analizado a partir de lo dado string.

O NaN cuando

• los radix es más pequeña que 2 o más grande que 36, o
• el primer carácter que no sea un espacio en blanco no se puede convertir en un número.

Descripción

los parseInt función convierte su primer argumento en un string, analiza eso string, luego devuelve un número entero o NaN.

Que no NaN, el valor de retorno será el entero que es el primer argumento tomado como un número en el especificado radix. (Por ejemplo, un radix de 10 convierte de un número decimal, 8 se convierte de octal, 16 desde hexadecimal, etc.)

Para radices arriba 10, las letras del alfabeto inglés indican números mayores que 9. Por ejemplo, para números hexadecimales (base 16), A mediante F son usados.

Si parseInt encuentra un carácter que no es un número en el especificado radix, lo ignora y todos los caracteres siguientes y devuelve el valor entero analizado hasta ese punto. parseInt trunca números a valores enteros. Se permiten espacios al principio y al final.

Porque algunos números usan el e carácter en su string representación (p. ej. 6.022e23 para 6.022 × 10²³), utilizando parseInt truncar números producirá resultados inesperados cuando se utilice en números muy grandes o muy pequeños. parseInt deberían no ser utilizado como sustituto de Math.floor().

parseInt entiende exactamente dos signos: + para positivo, y - para negativo (desde ECMAScript 1). Se realiza como un paso inicial en el análisis después de eliminar los espacios en blanco. Si no se encuentran signos, el algoritmo pasa al siguiente paso; de lo contrario, elimina el signo y ejecuta el análisis de números en el resto de string.

Un valor pasado como argumento de base se convierte en un Número (si es necesario), luego, si el valor es 0, NaN o Infinity (indefinido es coaccionado a NaN), JavaScript asume lo siguiente:

1. Si la entrada string empieza con “0x” o “0X“(un cero, seguido de una X minúscula o mayúscula), radix se supone que es 16 y el resto del string se analiza como un número hexadecimal.
2. Si la entrada string comienza con cualquier otro valor, la base es 10 (decimal).

De lo contrario, si el valor de la base (coaccionado si es necesario) no está en el rango [2, 36] (inclusivo) parseInt devoluciones NaN.

Si el primer carácter no se puede convertir en un número con la base en uso, parseInt devoluciones NaN.

Para fines aritméticos, el NaN valor no es un número en ninguna base. Puedes llamar al isNaN función para determinar si el resultado de parseInt es NaN. Si NaN se pasa a las operaciones aritméticas, el resultado de la operación también será NaN.

Para convertir un número a su string literal en una base particular, use thatNumber.toString(radix).

Advertencia:parseInt convierte un BigInt a un Number y pierde precisión en el proceso. Esto se debe a que los valores finales no numéricos, incluido “n“, se descartan.

Interpretaciones octales sin raíz

Tenga en cuenta que la siguiente información no se aplica a implementaciones recientes a partir de 2021.

Aunque ECMAScript 3 lo desaconseja, muchas implementaciones de ECMAScript 3 han interpretado una string comenzando con un líder 0 como octal. Lo siguiente podría haber tenido un resultado octal o podría haber tenido un resultado decimal.

parseInt('0e0')// 0parseInt('08')// 0, because '8' is not an octal digit.

La especificación ECMAScript 5 de la función parseInt ya no permite que las implementaciones traten las cadenas que comienzan con un 0 carácter como valores octales. Muchas implementaciones han adoptado este comportamiento a partir de 2021.

parseInt('0e0')// 0parseInt('08')// 8

Una función de análisis más estricta

A veces es útil tener una forma más estricta de analizar números enteros.

Las expresiones regulares pueden ayudar:

functionfilterInt(value)Infinity)$/.test(value))returnNumber(value)elsereturnNaN

console.log(filterInt('421'))// 421
console.log(filterInt('-421'))// -421
console.log(filterInt('+421'))// 421
console.log(filterInt('Infinity'))// Infinity
console.log(filterInt('421e+0'))// NaN
console.log(filterInt('421hop'))// NaN
console.log(filterInt('hop1.61803398875'))// NaN
console.log(filterInt('1.61803398875'))// NaN

Ejemplos de

Usando parseInt

Todos los ejemplos siguientes regresan 15:

parseInt('0xF',16)parseInt('F',16)parseInt('17',8)parseInt(021,8)parseInt('015',10)// but `parseInt(015, 8)` will return 13parseInt(15.99,10)parseInt('15,123',10)parseInt('FXX123',16)parseInt('1111',2)parseInt('15 * 3',10)parseInt('15e2',10)parseInt('15px',10)parseInt('12',13)

Los siguientes ejemplos regresan todos NaN:

parseInt('Hello',8)// Not a number at allparseInt('546',2)// Digits other than 0 or 1 are invalid for binary radix

Todos los ejemplos siguientes regresan -15:

parseInt('-F',16)parseInt('-0F',16)parseInt('-0XF',16)parseInt(-15.1,10)parseInt('-17',8)parseInt('-15',10)parseInt('-1111',2)parseInt('-15e1',10)parseInt('-12',13)

Los siguientes ejemplos regresan todos 4.

parseInt(4.7,10)parseInt(4.7*1e22,10)// Very large number becomes 4parseInt(0.00000000000434,10)// Very small number becomes 4

Si el número es mayor que 1e + 21 (incluido) o menor que 1e-7 (incluido), devolverá 1. (cuando se usa radix 10).

parseInt(0.0000001,10);parseInt(0.000000123,10);parseInt(1e-7,10);parseInt(1000000000000000000000,10);parseInt(123000000000000000000000,10);parseInt(1e+21,10);

El siguiente ejemplo devuelve 224:

parseInt('0e0',16)

BigInt los valores pierden precisión:

parseInt('900719925474099267n')// 900719925474099300

parseInt no funciona con separadores numéricos:

parseInt('123_456')// 123

La base se coacciona a un Number:

const obj =valueOf()return8;parseInt('11', obj);// 9

obj.valueOf=function()return1;parseInt('11', obj);// NaN

obj.valueOf=function()returnInfinity;parseInt('11', obj);// 11

Especificaciones

Compatibilidad del navegador

Ver también

• parseFloat()
• Number.parseFloat()
• Number.parseInt()
• isNaN()
• Number.toString()
• Object.valueOf