Te puede interesar:Un tutorial de SQLite con Node.js
Introducción
Contenido
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.
Te puede interesar:Sirviendo archivos estáticos con node y Express.js.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 primitivo1
, la cadena se convertirá en un número.
.parseInt ()
La base se puede definir agregando prefijos a los números que queremos analizar:
Te puede interesar:Eliminar asignación de JavaScript- 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:
Te puede interesar:Promesas en Node.js.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.
Te puede interesar:Construyendo una API REST con Node y Expresslet 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.
Te puede interesar:Desplegando una aplicación Node.js en un Droplet de DigitalOcean con DockerEl método puede aceptar cadenas, lo que también lo convierte en una forma de convertir una cadena en un número:
Te puede interesar:Usar fetch para enviar solicitudes HTTP en JavaScriptlet 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.
Te puede interesar:Usando Sequelize ORM con Node.js y Expresslet 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: