Conversión de tipos ECMAScript

Una de las características más importantes de todos los lenguajes de programación es la capacidad de realizar conversión de tipo.

ECMAScript proporciona a los desarrolladores una gran cantidad de métodos de conversión de tipo simples.

La mayoría de los tipos tienen métodos para realizar conversiones simples, y hay varios métodos globales que se pueden usar para conversiones más complejas. En cualquier caso, en ECMAScript, la conversión de tipo es una operación breve y sencilla.

Convertir a cadena

Lo interesante de los valores primitivos de Boolean, números y cadenas en ECMAScript es que son objetos pseudo, lo que significa que realmente tienen propiedades y métodos.

Por ejemplo, para obtener la longitud de una cadena, puedes usar el siguiente código:

var sColor = "red";
alert(sColor.length); // salida "3"

A pesar de que "red" es una cadena primitiva, aún tiene la propiedad length, que se utiliza para almacenar el tamaño de la cadena.

En resumen, los 3 tipos principales de tipos primitivos Boolean, números y cadenas tienen el método toString(), que puede convertir sus valores en cadenas.

Consejo:Tal vez te preguntes, ¿tienen los cadenas el método toString(), ¿no es esto redundante? Sí, es así, ECMAScript define que todos los objetos tienen el método toString(), ya sea un objeto pseudo o un objeto verdadero. Porque el tipo String es un objeto pseudo, por lo que necesariamente tiene el método toString().

Boolean 类型的 toString() 方法只是输出 "true" 或 "false"，结果由变量的值决定：

var bFound = false;
alert(bFound.toString());	//输出 "false"

Number 类型的 toString() 方法比较特殊，它有两种模式，即默认模式和基数模式。采用默认模式，toString() 方法只是用相应的字符串输出数字值（无论是整数、浮点数还是科学计数法），如下所示：

var iNum1 = 10;
var iNum2 = 10.0;
alert(iNum1.toString());	//输出 "10"
alert(iNum2.toString());	//输出 "10"

Notas:在默认模式中，无论最初采用什么表示法声明数字，Number 类型的 toString() 方法返回的都是数字的十进制表示。因此，以八进制或十六进制字面量形式声明的数字输出的都是十进制形式的。

采用 Number 类型的 toString() 方法的基数模式，可以用不同的基数输出数字，例如二进制的基数是 2，八进制的基数是 8，十六进制的基数是 16。

基数这只是要转换成的基数的另一种加法而已，它是 toString() 方法的参数：

var iNum = 10;
alert(iNum.toString(2));	//输出 "1010"
alert(iNum.toString(8));	//输出 "12"
alert(iNum.toString(16));	//输出 "A"

在前面的示例中，以 3 种不同的形式输出了数字 10，即二进制形式、八进制形式和十六进制形式。HTML 采用十六进制表示每种颜色，在 HTML 中处理数字时这种功能非常有用。

Notas:对数字调用 toString(10) 与调用 toString() 相同，它们返回的都是该数字的十进制形式。

参阅：

Ver Manual de referencia de JavaScript提供有关 toString() 方法的详细信息：

Convertir a número

ECMAScript proporciona dos métodos para convertir valores originales no numéricos en números, es decir, parseInt() y parseFloat().

Como es de esperar, el primero convierte el valor en entero y el segundo en número flotante. Solo se pueden ejecutar correctamente llamando a estos métodos a tipos String; para otros tipos, regresan NaN.

parseInt()

Antes de determinar si una cadena es un valor numérico, parseInt() y parseFloat() analizan minuciosamente la cadena.

El método parseInt() primero verifica el carácter en la posición 0, para determinar si es un número válido; si no lo es, el método regresará NaN y no continuará con otras operaciones. Pero si el carácter es válido, el método verifica el carácter en la posición 1, realizando el mismo test. Este proceso continuará hasta que se encuentre un carácter no válido, momento en el que parseInt() convertirá la cadena hasta ese carácter en un número.

Por ejemplo, si se debe convertir la cadena "12345red" en un entero, el método parseInt() regresará 12345, porque cuando detecta el carácter r, detiene el proceso de detección.

Los números literales que contienen la cadena se convertirán correctamente en números, por ejemplo, "0xA" se convertirá correctamente en el número 10. Sin embargo, la cadena "22.5" se convertirá en 22, porque el punto decimal es un carácter inválido para los enteros.

A continuación se presentan algunos ejemplos:

var iNum1 = parseInt("12345red");	//regresa 12345
var iNum1 = parseInt("0xA");	//regresa 10
var iNum1 = parseInt("56.9");	//regresa 56
var iNum1 = parseInt("red");	//regresa NaN

El método parseInt() también tiene un modo de base, que puede convertir cadenas de binario, octal, hexadecimal u otros sistemas de numeración en enteros. La base se especifica mediante el segundo parámetro del método parseInt(), por lo que para analizar valores hexadecimales, se debe llamar al método parseInt() de la siguiente manera:

var iNum1 = parseInt("AF", 16);	//regresa 175

Claro, para el binario, octal e incluso decimal (modo predeterminado), se puede llamar al método parseInt() de esta manera:

var iNum1 = parseInt("10", 2);	//regresa 2
var iNum2 = parseInt("10", 8);	//devuelve 8
var iNum3 = parseInt("10", 10);	//devuelve 10

Si el número decimal contiene un cero inicial, es mejor usar la base 10 para evitar obtener valores octales inesperados. Por ejemplo:

var iNum1 = parseInt("010");	//devuelve 8
var iNum2 = parseInt("010", 8);	//devuelve 8
var iNum3 = parseInt("010", 10);	//devuelve 10

En este código, ambas líneas de código interpretan la cadena "010" como un número. La primera línea considera esta cadena como un valor octal, interpretándola de la misma manera que la segunda línea (declarando la base como 8). La última línea declara la base como 10, por lo que iNum3 finalmente es igual a 10.

Ver

Ver Manual de referencia de JavaScriptDetalles proporcionados sobre el método parseInt():parseInt().

parseFloat()

El método parseFloat() maneja de manera similar al método parseInt(), observando cada carácter desde la posición 0 hasta encontrar el primer carácter no válido, y luego convirtiendo la cadena antes de ese carácter en un entero.

Sin embargo, para este método, el primer punto decimal es un carácter válido. Si hay dos puntos decimales, el segundo punto decimal se considerará inválido. parseFloat() convertirá los caracteres antes de este punto decimal en números. Esto significa que la cadena "11.22.33" se interpretará como 11.22.

Otra diferencia del uso del método parseFloat() es que la cadena debe representar el número de coma flotante en forma decimal, no en octal o hexadecimal. Este método ignora los ceros iniciales, por lo que el número octal 0102 se interpretará como 102. Para el número hexadecimal 0xA, este método devolverá NaN, ya que en los números de coma flotante, x no es un carácter válido).Notas:Pruebas realizadas muestran que la implementación específica del navegador devuelve 0 en lugar de NaN).

Además, el método parseFloat() no tiene un patrón base.

A continuación se presentan algunos ejemplos del uso del método parseFloat():

var fNum1 = parseFloat("12345red");	//devuelve 12345
var fNum2 = parseFloat("0xA");	//devuelve NaN
var fNum3 = parseFloat("11.2");	//devuelve 11.2
var fNum4 = parseFloat("11.22.33");	//devuelve 11.22
var fNum5 = parseFloat("0102"); // devuelve 102
var fNum1 = parseFloat("red"); // devuelve NaN

prueba por ti mismo

Ver

Ver Manual de referencia de JavaScriptAquí tienes detalles detallados sobre el método parseFloat():parseFloat().

conversión forzada

También puedes usarConversión forzada (type casting)para manejar el tipo de los valores a convertir. La conversión forzada permite acceder a valores específicos, incluso si son de otro tipo.

Nota del editor:El término 'cast' tiene el significado de 'fundir', lo que se ajusta perfectamente al significado de 'conversión forzada'.

Hay 3 tipos de conversión forzada disponibles en ECMAScript:

  • Boolean(value) - convierte el valor dado en un tipo Boolean;
  • Number(value) - convierte el valor dado en un número (puede ser un entero o un flotante);
  • String(value) - convierte el valor dado en una cadena;

Usar uno de estos tres funciones para convertir valores crea un nuevo valor que almacena el valor directamente convertido. Esto puede causar consecuencias inesperadas.

La función Boolean()

Cuando el valor a convertir es una cadena con al menos un carácter, un número no cero o un objeto, la función Boolean() devuelve true. Si el valor es una cadena vacía, el número 0, undefined o null, devuelve false.

Puedes probar la conversión forzada de tipo Boolean con el siguiente código:

var b1 = Boolean(""); //false - cadena vacía
var b2 = Boolean("hello"); //true - cadena no vacía
var b1 = Boolean(50); //true - número no cero
var b1 = Boolean(null); //false - null
var b1 = Boolean(0); //false - cero
var b1 = Boolean(new object()); //true - objeto

La función Number()

La conversión de tipo forzada de la función Number() es similar a la forma en que los métodos parseInt() y parseFloat() manejan, pero convierte todo el valor, no solo una parte.

¿Recuerdas? Los métodos parseInt() y parseFloat() solo convierten la cadena hasta el primer carácter inválido, por lo que "1.2.3" se convertirá respectivamente en "1" y "1.2".

Al realizar la conversión de tipo forzado con Number(), "1.2.3" devolverá NaN, ya que el valor de la cadena completa no se puede convertir en un número. Si el valor de la cadena se puede convertir completamente, Number() determinará si se debe llamar al método parseInt() o parseFloat().

La siguiente tabla explica lo que ocurre al llamar al método Number() con diferentes valores:

Uso Resultados
Number(false) 0
Number(true) 1
Number(undefined) NaN
Number(null) 0
Number("1.2") 1.2
Number("12") 12
Number("1.2.3") NaN
Number(new object()) NaN
Number(50) 50

Función String()

El último método de conversión de tipo forzado String() es el más simple, ya que puede convertir cualquier valor a una cadena.

Para realizar esta conversión de tipo forzado, simplemente llame al método toString() del valor pasado como parámetro, es decir, convierte 12 a "12", convierte true a "true", convierte false a "false", y así sucesivamente.

La única diferencia entre la conversión de tipo forzado a cadena y la llamada al método toString() es que la conversión de tipo forzado de valores null y undefined puede generar una cadena sin generar errores:

var s1 = String(null); // "null"
var oNull = null;
var s2 = oNull.toString(); // Generará un error

En el manejo de lenguajes de tipo débil como ECMAScript, la conversión de tipo forzado es muy útil, pero debe asegurarse de usar valores correctos.