JavaScript convertir cadena en número

Introducción

La gestión de datos es uno de los conceptos fundamentales de la programación. Convertir un número en una cadena es una operación común y simple. Lo mismo ocurre al revés, convirtiendo una cadena en un número.

Conversión de cadena en número

Al igual que con los métodos mostrados anteriormente, JavaScript también proporciona funciones para transformar fácilmente una cadena en un número primitivo. Estos son parseInt(), parseFloat(), Math.floor(), Math.ceil(), Unary Operator / Multiply by 1.

• .parseInt() toma un String como primer argumento y una base a la que se convertirá ese String. Este método siempre devuelve un número entero.
• .parseFloat() toma una cadena como argumento y devuelve el número de punto flotante equivalente.
• Math.floor() se utiliza para redondear un número entero o de coma flotante. Devuelve el número entero más cercano redondeado hacia abajo.
• Math.ceil() se puede utilizar para redondear un número entero o de coma flotante.
• Unary Operator Añadiendo un + firmar antes de una Cadena, se convertirá en un número si sigue el formato correcto.
• Multiply by 1
  Si una cadena se multiplica por el número primitivo 1, la cadena se convertirá en un número.

.parseInt ()

La base se puede definir agregando prefijos a los números que queremos analizar:

• Sin prefijo – Si no hay prefijo, la base es 10 (decimal).
• 0 – Si el prefijo es 0, entonces la base es 8 (octal). Sin embargo, esta función está obsoleta.
• 0x – Si el prefijo es 0x, entonces la base es 16 (hexadecimal).

Aunque, simplemente podemos agregar un argumento opcional a la llamada al método, definiendo la base:

let str="353";
let fltStr="353.56";
let binStr="7";
let nanStr="hello";

parseInt(str);       // 353
parseInt(fltStr);    // 353
parseInt(binStr, 2); // 111 (Binary)
parseInt(nanStr);    // NaN (Not a Number)

.parseFloat ()

let str="100";
let fltStr="100.21";
let nanStr="bye";

parseFloat(str);    // 353
parseFloat(fltStr); // 353.21
parseFloat(nanStr); // NaN

Math.floor ()

Sorprendentemente, este método también puede aceptar cadenas, lo que lo convierte en una forma de convertir una cadena en un número entero.

let str="100";
let fltStr="99.89";
let nanStr="bye";

Math.floor(str);    // 100
Math.floor(fltStr); // 99
Math.floor(nanStr); // NaN

Math.ceil ()

Muy similar al método anterior, sin embargo, esta vez devuelve el entero más cercano redondeado.

El método puede aceptar cadenas, lo que también lo convierte en una forma de convertir una cadena en un número:

let str="100";
let fltStr="100.21";
let nanStr="bye";

Math.ceil(str);    // 100
Math.ceil(fltStr); // 101
Math.ceil(nanStr); // NaN

Tenga en cuenta que si necesita analizar flotantes, ambos Math.floor y Math.ceil probablemente no sean buenas opciones ya que siempre convertirán las cadenas al equivalente entero más cercano.

Operador unario

Al igual que con la concatenación de una cadena vacía, también hay una solución alternativa que tiene un mejor rendimiento pero carece de legibilidad.

let str="100";
let fltStr="100.21";
let nanStr="greetings";

+str    // 100
+fltStr // 100.21
+nanStr // NaN
+'1000' // 1000
+10.25  // 10.25

Si bien es conciso y efectivo, esta no es una característica muy conocida de JavaScript, por lo que no se recomienda su uso, ya que puede hacer que su código no sea tan fácil de entender.

Multiplicar por 1

Este enfoque es posiblemente el más rápido:

let str="100";
let fltStr="100.21";
let nanStr="greetings";

str * 1;      // 100
fltStr * 1;   // 100.21
nanStr * 1;   // NaN
'2000' * 1;   // 2000
'102.15' * 1; // 102.15

Los dos enfoques anteriores funcionan simplemente debido al hecho de que JavaScript intenta asimilar los tipos de datos utilizados en una declaración como la suma o la multiplicación.

Usar objetos de cadena y número

Otra forma de transformar una cadena en un número o un número en una cadena es crear un nuevo objeto String o Number con el new palabra clave.

// Number to String
let numToStr = new String(2);   // String {'2'}

// String to Number
let strToNum = new Number('2'); // Number {2}

Esta práctica es, sin embargo, desanimado. Cuando se utilizan datos primitivos, los métodos de objeto no deben utilizarse para crearlos.
La creación de instancias de un tipo de datos primitivo con el contenedor de clase String o Number trae problemas de rendimiento y memoria.

Conclusión

Hay muchas formas válidas de manipular datos. Depende del programador decidir cuál prefiere, eligiendo el rendimiento sobre la legibilidad o un equilibrio entre los dos.

Para obtener más información, puede leer los siguientes recursos:

• parseInt
• parseFloat
• Math.floor
• Math.ceil