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:

     

    Etiquetas:

    Deja una respuesta

    Tu direcci贸n de correo electr贸nico no ser谩 publicada. Los campos obligatorios est谩n marcados con *