JavaScript convertir cadena a 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, convertir una cadena en un número.

Convertir cadena en número

Al igual que con los métodos anteriores, 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 una cadena como primer argumento y una base a la que se convertirá esa cadena. Este método siempre devuelve un 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 punto flotante. Devuelve el entero más cercano redondeado hacia abajo.
  • Math.ceil() se puede utilizar para redondear un número entero o de coma flotante.
  • Unary OperatorAl agregar un +signo 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 un prefijo, el radix es 10 (decimal).
  • 0 - Si el prefijo es 0, entonces el radix es 8 (octal). Sin embargo, esta característica está en desuso.
  • 0x - Si el prefijo es 0x, entonces el radix 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 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 se devuelve el entero más próximo redondeado hacia arriba .
El método puede aceptar cadenas, lo que también hace que sea 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 usted está necesitando para analizar los flotadores entonces ambos Math.floorMath.ceilprobablemente no son buenas opciones ya que siempre van a convertir 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 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
Aunque 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:
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 a que JavaScript intenta asimilar los tipos de datos utilizados en una declaración como la suma o la multiplicación.

Usando cadenas y objetos numéricos

Otra forma de transformar un String en número o un número en String es crear un nuevo objeto String o Number con la newpalabra 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, desalentada . Cuando se usan datos primitivos, los métodos de objeto no deben usarse para crearlos. 
La creación de una instancia de un tipo de datos primitivo con la envoltura de clase String o Number trae consigo problemas de rendimiento y memoria.

Conclusión

Hay muchas formas válidas de manipular los datos. Depende del programador decidir cuál prefiere, eligiendo el rendimiento sobre la legibilidad o un equilibrio entre los dos.
Para más información, puedes leer los siguientes recursos:

Acerca de: Programator

Somos Instinto Programador

0 comentarios:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

Con tecnología de Blogger.