Conversión implícita de tipos de datos en javascript. Conversión de tipos de datos en JavaScript. Métodos de JavaScript para convertir cadenas en números

En JavaScript, los valores se pueden convertir con bastante libertad (explícita e implícitamente) de un tipo a otro. Por ejemplo, si un operador espera recibir un valor de un determinado tipo y se le pasa un valor de otro tipo, el intérprete intentará automáticamente realizar conversiones al tipo deseado:

Console.log(10 + "máquinas"); // "10 coches". El número se convierte implícitamente en una cadena console.log("7" * "4"); // 28. Ambas cadenas se convierten implícitamente a números

Conversión implícita- aquí es cuando el intérprete realiza automáticamente la conversión de tipos, es decir, sin la participación del programador. Conversión explícita- aquí es cuando la conversión la realiza el propio programador. La conversión explícita también se llama tipo de fundición:

Consola.log("7" * "4"); // 28. Conversión implícita console.log(Número("7") * Número("4")); // 28. Conversión explícita

La siguiente tabla describe cómo JavaScript convierte valores de un tipo a otro. Las celdas vacías corresponden a situaciones en las que no se requiere conversión:

Significado	Convertir a:
	Cadena	Número	Booleano	Un objeto
indefinido nulo	"indefinido" "nulo"	Yaya 0	FALSO FALSO	tipo de errorError tipo de errorError
verdadero FALSO	"verdadero" "FALSO"	1 0		nuevo booleano (verdadero) nuevo booleano (falso)
"" (línea vacía) "1.2" "uno" "-10" "+10" "011" "0xff"		0 1.2 Yaya -10 10 11 255	FALSO verdadero verdadero verdadero verdadero verdadero verdadero	nueva cadena ("") nueva cadena ("1.2") nueva cadena ("uno") nueva cadena ("-10") nueva cadena("+10") nueva cadena ("011") nueva cadena ("0xff")
0 -0 Yaya Infinidad -Infinidad 3	"0" "0" "Yaya" "Infinidad" "-Infinidad" "3"		FALSO FALSO FALSO verdadero verdadero verdadero	nuevo número(0) nuevo número(-0) nuevo número (NaN) nuevo número (infinito) nuevo número (-infinito) nuevo número(3)
() (cualquier objeto) (matriz vacía) (1 elemento numérico) arr (cualquier otra matriz) función()() (cualquier función)	ver Convertir objetos "" "9" ver Convertir objetos ver Convertir objetos	ver Convertir objetos 0 9 Yaya Yaya	verdadero verdadero verdadero verdadero verdadero

Para la conversión explícita a tipos simples, se utilizan las siguientes funciones: Boolean(), Number(), String(). Para la conversión implícita, el intérprete utiliza las mismas funciones que se utilizan para la conversión explícita.

Para una conversión explícita, puede utilizar operadores en lugar de funciones. Por ejemplo, si uno de los operandos del operador + es una cadena, el otro operando también se convierte en una cadena. El operador unario + convierte su operando en un número. Operador unario! convierte el operando a un valor booleano y lo invierte. Todo esto fue la razón del surgimiento de los siguientes métodos únicos de conversión de tipos que se pueden encontrar en la práctica:

X + "" // Igual que String(x) +x // Igual que Number(x). También puedes ver x - 0 !!x // Igual que Boolean(x)

Convertir a números

La función Number() convierte valores de acuerdo con las siguientes reglas:

• Los valores booleanos verdadero y falso se convierten a 1 y 0 respectivamente.
• Los números se devuelven sin cambios.
• El valor nulo se convierte en 0 .
• El valor indefinido se convierte a NaN.

Existen reglas especiales para cadenas:

• Si una cadena contiene solo dígitos con un signo + o - inicial, o sin signo, siempre se convierte a un número decimal entero. Los ceros a la izquierda se ignoran; por ejemplo, "0011" se convierte en 11.
• Si la cadena es un número de punto flotante con un signo + o - inicial o sin signo, se convierte al número de punto flotante correspondiente (los ceros iniciales también se ignoran).
• Si la cadena es un número hexadecimal, se convierte al entero decimal correspondiente.
• Si la cadena está vacía, se convierte a 0.
• Si la cadena contiene algo diferente a las opciones anteriores, se convierte a NaN.
• El método valueOf() se llama en objetos y el valor que devuelve se convierte automáticamente de acuerdo con las reglas anteriores. Si esta conversión da como resultado NaN , se llama al método toString() y se aplican las reglas para convertir cadenas en números.

Los operadores unarios + y - siguen las mismas reglas que la función Número().

Conversión a valores booleanos

La función booleana() convierte un valor a su equivalente booleano:

• Los siguientes valores se convierten a falso: indefinido, nulo, 0, -0, NaN, "".
• False se devuelve sin cambios.
• Todos los demás valores se convierten a verdadero.

Convertir a cadenas

La función String() convierte valores de acuerdo con las siguientes reglas:

• Para todos los valores distintos de nulo e indefinido, se llama automáticamente al método toString() y se devuelve una representación de cadena del valor.
• Para nulo, se devuelve la cadena "nulo".
• Para el valor indefinido, se devuelve la cadena "indefinido".

Convertir tipos simples en objetos

Para convertir valores simples en objetos, se utilizan los constructores Boolean() , Number() , String():

Var oNum = nuevo Número(3); var oStr = nueva cadena ("1.2"); var oBool = nuevo booleano (verdadero); alerta(tipo de oNum); // alerta "objeto" (tipo de oStr); // alerta "objeto" (tipo de oBool); // "objeto"

Convertir objetos a valores simples

Todos los objetos heredan dos métodos de conversión: toString() y valueOf() .

El método toString() devuelve la representación en cadena del objeto. Por defecto no devuelve nada interesante:

Alerta((x: 1).toString()); // ""

Algunos tipos tienen versiones más especializadas del método toString(). Por ejemplo, el método toString() en una matriz convierte todos sus elementos en cadenas y luego los concatena en una sola cadena, insertando comas entre ellos:

Alerta(.toString()); // "1,2,3"

El propósito del método valueOf() está menos claramente definido: se supone que convierte un objeto al valor simple que lo representa, si tal valor existe. Los objetos son valores inherentemente compuestos y la mayoría de los objetos no se pueden representar como un único valor simple, por lo que, de forma predeterminada, el método valueOf() devuelve una referencia a ellos en lugar de un valor simple:

Alerta (tipo de (x: 2). valor de ()); // "objeto"

Al convertir un objeto en una cadena, el intérprete de JavaScript hace lo siguiente:

• Si el objeto tiene un método toString(), el intérprete lo llama. Si devuelve un valor simple, el intérprete convierte el valor en una cadena (si no es una cadena) y devuelve el resultado de la conversión.
• Si el objeto no tiene un método toString() o el método no devuelve un valor simple, entonces el intérprete comprueba la presencia de un método valueOf(). Si este método está definido, el intérprete lo llama. Si devuelve un valor simple, el intérprete convierte ese valor en una cadena (si no es una cadena) y devuelve el resultado de la conversión.

Al convertir un objeto en un número, el intérprete hace lo mismo, pero prueba primero el método valueOf():

• Si un objeto tiene un método valueOf() que devuelve un valor simple, el intérprete convierte (si es necesario) ese valor en un número y devuelve el resultado.
• Si el objeto no tiene un método valueOf() o el método no devuelve un valor simple, entonces el intérprete comprueba la presencia de un método toString(). Si el objeto tiene un método toString() que devuelve un valor simple, el intérprete realiza la conversión y devuelve el valor resultante.
• De lo contrario, el intérprete concluye que ni toString() ni valueOf() pueden obtener un valor simple y genera un TypeError.

Los métodos toString() y valueOf() son de lectura/escritura, por lo que puedes anularlos y especificar explícitamente qué se devolverá al convertir:

Var obj = (); obj.toString = función() ( devuelve "objeto"; ); alerta("Esto es " + obj); // "Esto es un objeto"

No importa qué tipo de variable se utilice en la expresión. Si la expresión es matemática, todas sus variables automáticamente se interpretarán como numéricas. Si se procesan cadenas, todos los "participantes" de la expresión se tratan como cadenas. Sin embargo, el desafío de la conversión de cadena a número en JavaScript existe en un contexto mucho más amplio.

Métodos de JavaScript para convertir cadenas en números

El arsenal de métodos para convertir cadenas en números no es grande, pero es suficiente en todos los casos simples. Aquí JavaScript (especialmente para principiantes) es el camino de lo simple a lo complejo utilizando ejemplos prácticos.

Te podría interesar:

El ejemplo describe cuatro cadenas diferentes. En el primer bloque de salida, la función typeof define el tipo de cada variable como cadena. Luego, cada cadena se convierte de manera muy sencilla en un número. En el segundo bloque de salida son visibles los cambios en las variables después de la conversión, su tipo se ha convertido en un número. El ejemplo de conversión de JavaScript parseFloat es particularmente ilustrativo: era "12e+3" y se convirtió en "12000".

¡Los cambios al convertir una cadena en un número pueden ser significativos! Pero sólo importan los primeros caracteres: deben ser numéricos. Si no hay caracteres numéricos, el resultado será NaN.

La conversión inversa de una cadena que "se convierte" en un número no siempre es la misma cadena. Este punto se puede utilizar para comprobar la exactitud de la introducción de información numérica.

El parseInt() La función analiza un argumento de cadena y devuelve un número entero de la base especificada (la base en los sistemas numéricos matemáticos).

La fuente de este ejemplo interactivo está almacenada en un repositorio de GitHub. Si desea contribuir al proyecto de ejemplos interactivos, clone https://github.com/mdn/interactive-examples y envíenos una solicitud de extracción.

Sintaxis

parseInt(cadena, base)

Parámetros

cadena El valor a analizar. Si este argumento no es una cadena, se convierte en uno mediante la operación abstracta ToString. Se ignoran los espacios en blanco iniciales en este argumento. radix Opcional Un número entero entre 2 y 36 que representa la base (la base en los sistemas numéricos matemáticos) de la cadena. Tenga cuidado, esto no no por defecto es 10! Explica con más detalle qué sucede cuando no se proporciona radix.

Valor de retorno

Un número entero analizado a partir de la cadena dada.

Si la base es menor que 11 y el primer carácter que no sea un espacio en blanco no se puede convertir en un número, se devuelve NaN.

Descripción

La función parseInt convierte su primer argumento en una cadena, analiza esa cadena y luego devuelve un número entero o NaN.

Si no es NaN, el valor de retorno será el número entero que sea el primer argumento tomado como un número en la base especificada. (Por ejemplo, una base de 10 se convierte de un número decimal, 8 se convierte de octal, 16 de hexadecimal, etc.)

Para radices superiores a 10, las letras del alfabeto inglés indican números mayores que 9. Por ejemplo, para números hexadecimales (base 16), se utilizan de la A a la F.

Si parseInt encuentra un carácter que no es un número en la base especificada, 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 iniciales y finales.

Debido a que algunos números usan el carácter e en su representación de cadena (p. ej. 6.022e23 para 6.022 × 10 23), usar parseInt para truncar números producirá resultados inesperados cuando se use en números muy grandes o muy pequeños. parseInt debería no usarse como sustituto de Math.floor() .

parseInt entiende exactamente dos signos: + para positivo y - para negativo (desde ECMAScript 1). Se realiza como 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 numérico en el resto de la cadena.

Si radix no está definido, 0 o no está especificado, JavaScript asume lo siguiente:

1. Si la cadena de entrada comienza con "0x" o "0X" (un cero, seguido de una X minúscula o mayúscula), se supone que la base es 16 y el resto de la cadena se analiza como un número hexadecimal.
2. Si la cadena de entrada comienza con "0" (un cero), se supone que la base es 8 (octal) o 10 (decimal). La base exacta que se elige depende de la implementación. ECMAScript 5 aclara que 10 (decimal) debería Se puede utilizar, pero no todos los navegadores lo admiten todavía. Por esta razón, siempre especifique una base cuando use parseInt.
3. Si la cadena de entrada comienza con cualquier otro valor, la base es 10 (decimal).

Si el primer carácter no se puede convertir en un número, parseInt devuelve NaN a menos que la base sea mayor que 10.

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

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

Ejemplos

Usando parseInt

Todos los siguientes ejemplos devuelven 15:

ParseInt("0xF", 16) parseInt("F", 16) parseInt("17", 8) parseInt(021, 8) parseInt("015", 10) // pero `parseInt(015, 10)` devolver 13 parseInt(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)

Todos los siguientes ejemplos devuelven NaN:

ParseInt("Hello", 8) // No es un número en absoluto parseInt("546", 2) // Los dígitos distintos de 0 o 1 no son válidos para la base binaria

Todos los siguientes ejemplos devuelven -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)

Todos los siguientes ejemplos devuelven 4:

ParseInt(4.7, 10) parseInt(4.7 * 1e22, 10) // Un número muy grande se convierte en 4 parseInt(0.00000000000434, 10) // Un número muy pequeño se convierte en 4

El siguiente ejemplo devuelve 224:

ParseInt("0e0", 16) parseInt("123_456") // 123

Interpretaciones octales sin base.

Aunque ECMAScript 3 lo desaconseja y lo prohíbe ECMAScript 5, muchas implementaciones interpretan una cadena numérica que comienza con un 0 inicial como octal. Lo siguiente puede tener un resultado octal o puede tener un resultado decimal. Especifique siempre una base para evitar este comportamiento poco confiable.

ParseInt("0e0") // 0 parseInt("08") // 0, porque "8" no es un dígito octal.

ECMAScript 5 elimina la interpretación octal

La especificación ECMAScript 5 de la función parseInt ya no permite que las implementaciones traten cadenas que comiencen con un carácter 0 como valores octales. ECMAScript 5 dice:

La función parseInt produce un valor entero dictado por la interpretación del contenido del argumento de cadena de acuerdo con la base especificada. Se ignoran los espacios en blanco iniciales en la cadena. Si la base no está definida o es 0, se supone que es 10, excepto cuando el número comienza con los pares de caracteres 0x o 0X, en cuyo caso se supone una base de 16.

Esto difiere de ECMAScript 3, que se desaconsejó pero permitió la interpretación octal.

Muchas implementaciones no han adoptado este comportamiento a partir de 2013 y, debido a que se deben admitir navegadores más antiguos, siempre especifique una base.

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

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

Las expresiones regulares pueden ayudar:

Función filterInt(valor) ( ​​if (/^[-+]?(\d+|Infinity)$/.test(valor)) ( devuelve Número(valor) ) else ( devuelve NaN ) ) 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")) // Consola NaN .log (filterInt("1.61803398875")) // NaN

Especificaciones

Especificación	Estado	Comentario
ECMAScript 1.ª edición (ECMA-262)	Estándar	Definición inicial.
ECMAScript 5.1 (ECMA-262)	Estándar
ECMAScript 2015 (6.a edición, ECMA-262) La definición de "parseInt" en esa especificación.	Estándar
Último borrador de ECMAScript (ECMA-262) La definición de "parseInt" en esa especificación.	Borrador

Compatibilidad del navegador

La tabla de compatibilidad de esta página se genera a partir de datos estructurados. Si desea contribuir con los datos, consulte https://github.com/mdn/browser-compat-data y envíenos una solicitud de extracción.

Actualizar datos de compatibilidad en GitHub

	Escritorio						Móvil						Servidor
	Cromo	Borde	Firefox	explorador de Internet	Ópera	Safari	Vista web de Android	Chrome para Android	Firefox para Android	Ópera para Android	Safari en iOS	internet samsung	Nodo.js
parseInt	Soporte completo de Chrome 1	Soporte completo de borde 12	Soporte completo para Firefox 1	Es decir, soporte completo 3	Opera soporte completo Sí	Safari Soporte completo Sí	WebView Android Soporte completo 1	Chrome Android Soporte completo 18	Firefox Android Soporte completo 4		Safari iOS Soporte completo Sí	Samsung Internet Android Soporte completo 1.0	nodejs Soporte completo Sí
Las cadenas de ceros iniciales son decimales, no octales	Soporte completo de Chrome 23	Soporte completo de borde 12	Soporte completo para Firefox 21	Es decir, soporte completo 9	Opera soporte completo Sí	Safari Soporte completo 6	WebView Android Soporte completo 4.4	Chrome Android Soporte completo 25	Firefox Android Soporte completo 21	Opera Android Soporte completo Sí	Safari iOS Soporte completo 6	Samsung Internet Android Soporte completo Sí	nodejs Soporte completo Sí

Hola queridos lectores. Hoy escribiré cómo se convierte en javascript cadena a número. Esto se hace usando la función Número, ahora mostraré su uso con un ejemplo.
También sugiero ver la versión en video de este artículo:

Un poco sobre tipos de datos

Como sabes, javascript tiene tipos de datos numéricos y de cadena. Intentemos crear dos variables en las que almacenaremos los números y luego mostraremos el resultado en la pantalla.

Var a = 5; var b = 12; documento.write(a + b);

¿Cuál será el resultado? 17, que es lo que nos mostró el navegador. Estos son datos numéricos, por lo que el navegador los ha sumado correctamente. Ahora creemos otras dos variables, en las que pondremos los mismos valores, pero entre comillas. Permítanme recordarles que todas las líneas de JavaScript están escritas entre comillas.

Varc = "5"; var d = "12"; documento.escribir("
"+c+d);

Ahora el navegador considera que nuestros datos son cadenas y si los sumamos, entonces simplemente se agregarán dos líneas y obtendremos 512, que no es el resultado correcto si se sumaron números, pero es correcto si juntamos dos líneas.

¿Cómo convertir una cadena a un número en javascript?

Aquí todo es sencillo, creemos las siguientes dos variables, en las que escribiremos el mismo valor que especifican las variables c y d, pero pasándolas por el método Número:

Var e = Número(c); var f = Número(d); documento.write(e + f);

Si ahora intenta mostrar el resultado de esta suma en la pantalla, mostrará 17. Esto se debe a que nuestro método funcionó con éxito y convirtió la cadena en un número. Me gustaría señalar que si lo escribes así:

Documento.escribir("
" + mi + f);

Entonces se mostrará 512 en la pantalla, porque al agregar cadenas y números SIEMPRE el resultado se convierte en una cadena. Si desea agregar un salto de línea y aún así mantener el resultado correcto, puede escribir todo en dos líneas o en una como esta:

Documento.escribir("
" + (e + f));

Si coloca números entre paréntesis, no se convertirán en cadenas y conservarán sus propiedades con éxito. Este es mi breve artículo de hoy. Espero que javascript te haya quedado un poco más claro.

JavaScript tiene 2 funciones integradas para convertir cadenas en números: parseFloat() y parseInt().

parseFloat() toma como argumento una cadena para convertirla a un tipo numérico y devuelve un número flotante. El número debe aparecer al principio de la línea. Si hay otros caracteres en la línea después del número, se cortan. La parte fraccionaria de un número debe escribirse separada por un punto (la coma no se percibe como separador). Si parseFloat() no puede convertir la cadena, devuelve NaN.

La función también puede procesar “el número n multiplicado por 10 elevado a x”, que en programación suele escribirse con la letra E, por ejemplo: 0.5E6 o 0.5E+6. El grado también puede ser negativo: 0,5E-6, que es igual a 0,5*10^-6 o 0,5/1000000.

ParseFloat(""3.78kg"") // 3.78 parseFloat(""kg33"") // NaN parseFloat(""0004.111"") // 4.111 parseFloat(""0x66"") // 0 parseFloat("". 5"") // 0.5 parseFloat(""-.5"") // -0.5 parseFloat(""0.5e6"") // 500000 parseFloat(""0.03E+2"") // 3 parseFloat(" "3E-4"") // 0.0003 parseFloat(""-3E-4"") // -0.0003

La función parseInt(string[, radix]) toma una cadena como primer argumento, la analiza y devuelve un número entero (tipo entero). La función intenta analizar el sistema numérico en el que está escrito el número en la cadena de origen (por ejemplo, decimal, octal o hexadecimal, pero no sólo estos). También puede especificar el sistema numérico explícitamente pasándolo como la base del segundo parámetro. El parámetro base puede tomar cualquier número del 2 al 36 (en sistemas superiores a 10 se utilizan letras del alfabeto inglés, de la A a la Z).

La función no procesa números como 1.5e6 como parseFloat() .

Lea los ejemplos a continuación para no tropezar con los errores ocultos en el funcionamiento de la función parseInt().

ParseInt(""25"") // 25 parseInt(""-25"") // -25 parseInt(""45.12"") // 45 parseInt(""045"",10) // 45 parseInt( ""70"",8) // 56 (70 en octal es 56 en decimal) parseInt(""070"") // 56 (IMPORTANTE!!! cero primero hará que la función analice la cadena como un número octal ) parseInt(" "88"",8) // NaN (no hay el dígito 8 en el sistema octal) parseInt(""a1"") // NaN (¡¡IMPORTANTE!!! La función predeterminada no trata el número como hexadecimal si no se agrega al principio de las líneas 0x) parseInt(""a1"",16) // 161 (el sistema numérico se especifica explícitamente aquí) parseInt(""0xa1"") // 161 (formato numérico hexadecimal correcto) , no es necesario especificar el segundo parámetro) parseInt( ""099"") // 0 (¡¡IMPORTANTE!!! El número se trata como octal, pero contiene caracteres no válidos) parseInt(""0.5e6"") / / 0 (IMPORTANTE!!! no funciona como parseFloat) parseInt("" ZZ"",36) // 1295 parseInt(""-FF"") // NaN parseInt(""-FF"",16) / / -255

Si está analizando la entrada del usuario desde un campo de texto, use siempre parseInt() junto con un segundo parámetro de base para proteger su código de resultados inesperados.