¿Cómo convertir una cadena a número en TypeScript?

Dada una representación de cadena de un número, ¿cómo puedo convertirlo para numberescribir en TypeScript?

var numberString: string = "1234";
var numberValue: number = /* what should I do with `numberString`? */;

Exactamente igual que en JavaScript , puede utilizar las parseInto parseFloatfunciones, o simplemente utilizar el unario +operador:

var x = "32";
var y: number = +x;

Todas las técnicas mencionadas tendrán un tipeo correcto y analizarán correctamente cadenas enteras decimales simples como "123", pero se comportarán de manera diferente para varios otros casos (como esperados "123.45") y casos de esquina (como null).

Tabla tomada de esta respuesta

La forma mecanografiada de hacer esto sería:

Number('1234') // 1234
Number('9BX9') // NaN

como se responde aquí: https://stackoverflow.com/a/23440948/2083492

Para nuestros compañeros usuarios de Angular:

Dentro de una plantilla , Number(x)y parseInt(x)arroja un error, y +xno tiene ningún efecto. El lanzamiento válido será x*1o x/1.

Como se muestra en otras respuestas aquí, hay varias formas de hacer la conversión:

Number('123');
+'123';
parseInt('123');
parseFloat('123.45')

Sin parseIntembargo, me gustaría mencionar una cosa más .

Cuando se usa parseInt, tiene sentido pasar siempre el parámetro radix . Para la conversión decimal, eso es 10. Este es el valor predeterminado para el parámetro, por lo que puede omitirse. Para binario, es un 2y 16para hexadecimal. En realidad, cualquier mezcla entre 2 y 36 obras incluidas.

parseInt('123')         // 123 (don't do this)
parseInt('123', 10)     // 123 (much better)

parseInt('1101', 2)     // 13
parseInt('0xfae3', 16)  // 64227

La parseIntfunción, bueno, analiza cadenas para convertirlas en números. En algunas implementaciones de JS, parseIntanaliza los ceros iniciales como octales:

Aunque desalentado por ECMAScript 3 y prohibido por ECMAScript 5, muchas implementaciones interpretan una cadena numérica que comienza con un 0 inicial como octal. Lo siguiente puede tener un resultado octal, o puede tener un resultado decimal. Siempre especifique una raíz para evitar este comportamiento poco confiable.

- MDN

El hecho de que el código se aclare es un buen efecto secundario de especificar el parámetro radix.

Como parseFloatsolo analiza las expresiones numéricas en la raíz 10, no hay necesidad de un parámetro de raíz aquí.

Más sobre esto:

• ¿Por qué necesitamos usar radix? (Pregunta SO)
• SO Responde a "¿Cuál es la diferencia entre parseInt () y Number ()?"

Explicando lo que dijo Ryan, TypeScript adopta los modismos de JavaScript en general.

var n = +"1"; // the unary + converts to number
var b = !!"2"; // the !! converts truthy to true, and falsy to false
var s = ""+3; // the ""+ converts to string via toString()

Todos los detalles en profundidad interesantes en JavaScript Type Conversion .

Puede seguir cualquiera de las siguientes formas.

var str = '54';

var num = +str; //easy way by using + operator
var num = parseInt(str); //by using the parseInt operation 

Conversión de cadena a número:

En Typecript, convertimos una cadena en un número de las siguientes maneras:

• ParseInt(): Esta función toma 2 argumentos, el primero es una cadena para analizar. El segundo es la raíz (la base en sistemas de numeración matemática, por ejemplo, 10 para decimal y 2 para binario). Luego devuelve el número entero, si el primer carácter no se puede convertir en un número, NaNse devolverá.
• ParseFloat(): Toma como argumento el valor que queremos analizar y devuelve un número de coma flotante. Si el valor no se puede convertir a un número, NaNse devuelve.
• + operador: El operador, cuando se usa adecuadamente, puede obligar a un valor de cadena a un número.

Ejemplos:

/*    parseInt   */

// note that a whole number is returned, so it will round the number
console.log(parseInt('51.023124'));

// parseInt will 'cut off' any part of the string which is not a number
console.log(parseInt('5adfe1234'));

// When the string starts with non number NaN is returned
console.log(parseInt('z123'));

console.log('--------');

/*    parseFloat   */

// parses the string into a number and keeping the precision of the number
console.log(typeof parseFloat('1.12321423'));

// parseFloat will 'cut off' any part of the string which is not a number
console.log(parseFloat('5.5abc'));

console.log('--------');

/*   + operator   */

let myString = '12345'

console.log(typeof +myString);

let myOtherString = '10ab'

// + operator will not cut off any 'non number' string part and will return NaN
console.log(+myOtherString);

¿Cuál usar?

1. Úselo ParseInt()cuando desee que una cadena se convierta en un entero . Sin embargo, el tipo de datos sigue siendo flotante, ya que todos los valores numéricos son valores de coma flotante en TS . También use este método cuando necesite especificar la raíz del número que desea analizar.
2. Úselo ParseFloat()cuando necesite analizar una cadena en un número de coma flotante .
3. Puede usar el +operador antes de una cadena para forzarlo a un número de coma flotante . La ventaja de esto es que la sintaxis es muy corta.

La forma más fácil es usar + strVal o Number (strVal)

Ejemplos:

let strVal1 = "123.5"
let strVal2 = "One"
let val1a = +strVal1
let val1b = Number(strVal1)
let val1c = parseFloat(strVal1)
let val1d = parseInt(strVal1)
let val1e = +strVal1 - parseInt(strVal1)
let val2a = +strVal2

console.log("val1a->", val1a) // 123.5
console.log("val1b->", val1b) // 123.5
console.log("val1c->", val1c) // 123.5
console.log("val1d->", val1d) // 123
console.log("val1e->", val1e) // 0.5
console.log("val2a->", val2a) // NaN

Hay funciones incorporadas como parseInt(), parseFloat()y Number()en Typecript, puede usarlas.

Llame a la función con => convertstring ('10 .00 ')

parseFloat (string) => Se puede usar para convertir a float, toFixed (4) => a cuántos decimales

parseInt (str) => Se puede usar para convertir a entero

convertstring(string){
    let number_parsed: any = parseFloat(string).toFixed(4)
    return number_parsed
}

var myNumber: number = 1200;
//convert to hexadecimal value
console.log(myNumber.toString(16)); //will return  4b0
//Other way of converting to hexadecimal
console.log(Math.abs(myNumber).toString(16)); //will return  4b0
//convert to decimal value
console.log(parseFloat(myNumber.toString()).toFixed(2)); //will return  1200.00

Herramienta de conversión de números en línea

Convertidor de números

Hay tres maneras

 let a = + '12'; 
 let b = parseInt('12' , 10); // 10 means decimal number
 let c = Number('12');

Hay muchos de ustedes que tienen problemas para convertir tipos de datos que son difíciles de resolver en las situaciones de programación iónica, porque este mismo lenguaje es nuevo, aquí detallaré instrucciones para que el usuario sepa cómo convertir tipos de datos iónicos en datos de cadena tipo entero.

En lenguajes de programación como java, php, c, c ++, ... todos pueden mover datos fácilmente, luego en iónico también pueden crearnos la conversión de datos también es una manera fácil, no menos importante en otros lenguajes de programación.

this.mPosition = parseInt("");

si está hablando solo de tipos, como dijeron otras personas, parseInt (), etc. devolverá el tipo correcto. Además, si por algún motivo el valor puede ser tanto un número como una cadena y no desea llamar a parseInt (), las expresiones typeof también se convertirán al tipo correcto:

function f(value:number|string){
  if(typeof value==='number'){
   // value : number
  }else {
   // value : string
  }
}

Aquí hay una versión modificada de la función StrToNumber. Como antes,

1. Permite que aparezca un signo opcional delante o detrás del valor numérico.
2. Realiza una verificación para verificar que solo haya un signo en la cabeza o la cola de la cadena.
3. Si se produce un error, se devuelve un valor predeterminado "pasado".

Esta respuesta es una posible solución que se adapta mejor a la pregunta inicial que mi publicación anterior.

   static StrToNumber(val: string, defaultVal:number = 0): number
   {        
      let result:number = defaultVal;      
      if(val == null) 
         return result;            
      if(val.length == 0) 
         return result;      
      val = val.trim();
      if(val.length == 0) 
         return(result);
      let sign:number = 1;     
      //
      // . obtain sign from string, and place result in "sign" local variable. The Sign naturally defaults to positive
      //     1 for positive, -1 for negative.
      // . remove sign character from val. 
      //      Note, before the function returns, the result is multiplied by the sign local variable to reflect the sign.
      // . error check for multiple sign characters
      // . error check to make sure sign character is at the head or tail of the string
      //              
      {  
         let positiveSignIndex = val.indexOf('+');
         let negativeSignIndex = val.indexOf('-');
         let nTailIndex = val.length-1;
         //
         // make sure both negative and positive signs are not in the string
         //
         if( (positiveSignIndex != -1) && (negativeSignIndex != -1) ) 
             return result;
         //
         // handle postive sign
         //
         if (positiveSignIndex != -1)
         {
            //
            // make sure there is only one sign character
            //
            if( (positiveSignIndex != val.lastIndexOf('+')) )
             return result;     
             //
             // make sure the sign is at the head or tail
             //
             if( (positiveSignIndex > 0) && (positiveSignIndex < nTailIndex )  )
                 return result;
             //
             // remove sign from string
             //
             val = val.replace("+","").trim();                 
         }    
         //
         // handle negative sign
         //
         if (negativeSignIndex != -1)
         {
            //
            // make sure there is only one sign character
            //
            if( (negativeSignIndex != val.lastIndexOf('-')) )
             return result;     
             //
             // make sure the sign is at the head or tail
             //
             if( (negativeSignIndex > 0) && (negativeSignIndex < nTailIndex )  )
                 return result;
             //
             // remove sign from string
             //
             val = val.replace("-","").trim();  
             sign = -1;                 
         }               
         //
         // make sure text length is greater than 0
         //       
         if(val.length == 0) 
            return result;                             
      }   
      //
      // convert string to a number
      //
      var r = +(<any>val);
      if( (r != null) && (!isNaN(r)) )
      {          
         result = r*sign;         
      }
      return(result);    
   }

mecanografiado necesita saber que nuestro var ava a ser éterNumber || String

export type StringOrNumber = number | string;

export function toString (v: StringOrNumber) {
 return `${v}`;
}


export function toNumber (v: StringOrNumber) {
 return Number(v);
}

export function toggle (v: StringOrNumber) {
 return typeof v === "number" ? `${v}` : Number(v);
}

Siempre puedes usar la opción de enviar. Primero, debe convertir su objeto a tipo "desconocido" y luego convertirlo en un tipo de objeto esperado.

let subID:number = 0;

subID = <number><unknown> await obj_s1aSite.submissionTableFirstID.getText();