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

876

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`? */;
Paul0515
fuente
2
@o_nix engaña al compilador, no cambia el tipo de console.log(typeof <number><any>"1", typeof Number("1"))letra : imprimirá string number.
k0pernikus

Respuestas:

1384

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 de conversión Tabla tomada de esta respuesta

Ryan Cavanaugh
fuente
237
pequeña pista: parseInt (nulo) devuelve NaN pero + nulo devuelve 0
Robin J
17
No es tan expresivo como la respuesta mejor calificada de Philip aquí que hace esto a la manera de TypeScript.
Patrick
10
No hay forma de TypeScript porque TypeScript es solo JavaScript.
thedayturns
47
@thedayturns no hay forma de programación ya que la programación es solo electricidad
jiroch
1
@Patrick no está seguro de por qué lo estás llamando así "TypeScript", ya que también es simplemente Javascript ...
Sandy Gifford
1092

La forma mecanografiada de hacer esto sería:

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

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

Philip
fuente
44
Nota: puede verificar NaN usando la isNaNfunción.
Heinrich Ulbricht
2
Tenga en cuenta que esto no funcionará: let value: number = valueAsString;
yonexbat
1
Creo que el nuevo Número ("1234"). ValueOf () es realmente lo que todos estamos buscando-
chrismarx
23
@Devid, podría simplificarlo let a = Number('x') || 0;, Number('x')volvería NaN, que es "falsey". Por alo tanto, se le asignaría 0.Mucho más limpio y posiblemente (un poco) más rápido que usar la declaración ternaria y analizar dos veces.
Geoff James
44
@ Paul0515 ¿puede actualizar esto para que sea la respuesta correcta
Chris Lang
94

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.

phil294
fuente
¡eso es maravilloso! como dijiste en HTML + x no se convierte en número en absoluto
sa_
3
Eso es porque Numberno está en el alcance de la evaluación. Puedes escribir class MyComponent { Number = Number; }para usarlo.
Aluan Haddad
58

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:

Fabian Lauer
fuente
y uno más: ~~ '123' (usando ToInt32 interno)
aMarCruz
@aMarCruz es cierto, pero debatiría si esto es semánticamente útil
Fabian Lauer
52

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 .

usuario2040786
fuente
22

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 
Labib Hussain
fuente
13

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.
Willem van der Veen
fuente
7

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
Ben Dev
fuente
2

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

Dios poderoso Loki
fuente
2

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
}
Kanish Mathew
fuente
2

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

usuario2569050
fuente
1

Hay tres maneras

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

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("");
Tienanhvn
fuente
0

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
  }
}
cancerbero
fuente
0

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);    
   }

James W Simms
fuente
0

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);
}
Ernesto
fuente
-1

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();
Gaj Julije
fuente
TypeScript solo tiene sugerencias de tipo, sin conversión de tipo. Engaña al compilador para que piense que es un número, en tiempo de ejecución seguirá siendo una cadena a menos que lo analice.
k0pernikus
console.log(typeof <number><unknown>"1", typeof Number("1"))imprimirá string number.
k0pernikus