JavaScript Convertir cadena en número

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 con el otro...

Introducción

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

Convertir cadena en número {#convertir 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(), Operador unario / Multiplicar por 1.

  • .parseInt() toma una cadena como primer argumento y una base a la que se convertirá esa cadena. Este método siempre devuelve un número entero.
  • .parseFloat() toma una cadena como argumento y devuelve el número de coma flotante equivalente.
  • Math.floor() se usa para redondear un número entero o de coma flotante. Devuelve el entero más cercano redondeado hacia abajo.
  • Math.ceil() se puede usar para redondear un número entero o de punto flotante.
  • Operador unario Al agregar un signo + antes de una Cadena, se convertirá en un número si sigue el formato correcto.
  • Multiplicar por 1
    If a String is multiplied by the primitive number 1, the string will become a number.

.parseInt()

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

  • Sin prefijo - Si no hay prefijo, la raíz es 10 (decimal).
  • 0 - Si el prefijo es 0, entonces la base es 8 (octal). Sin embargo, esta característica 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:

1
2
3
4
5
6
7
8
9
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()

1
2
3
4
5
6
7
let str = '100';
let fltStr = '100.21';
let nanStr = 'bye';

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

Matemáticas.piso()

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.

1
2
3
4
5
6
7
let str = '100';
let fltStr = '99.89';
let nanStr = 'bye';

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

Matemáticas.ceil()

Muy similar al método anterior, aunque esta vez devuelve el entero más cercano redondeado hacia arriba.

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

1
2
3
4
5
6
7
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, entonces 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 existe una solución alternativa que tiene un mejor rendimiento pero carece de legibilidad.

1
2
3
4
5
6
7
8
9
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.

Multiplicando por 1

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

1
2
3
4
5
6
7
8
9
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 por el 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 Cadena o Número con la palabra clave nuevo.

1
2
3
4
5
// Number to String
let numToStr = new String(2);   // String {'2'}

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

Sin embargo, esta práctica está desaconsejada. Al usar datos primitivos, los métodos de objeto no deben usarse 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: