Comment convertir une chaîne en nombre en TypeScript?

Étant donné une représentation sous forme de chaîne d'un nombre, comment puis-je le convertir pour numbertaper en TypeScript?

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

Exactement comme en JavaScript , vous pouvez utiliser les parseIntou parseFloatfonctions, ou utilisez simplement le unaire +opérateur:

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

Toutes les techniques mentionnées auront un typage correct et analyseront correctement les chaînes entières décimales simples comme "123", mais se comporteront différemment pour divers autres cas, éventuellement attendus (comme "123.45") et cas de coin (comme null).

Tableau tiré de cette réponse

Pour ce faire, la méthode typographique serait la suivante:

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

comme répondu ici: https://stackoverflow.com/a/23440948/2083492

Pour nos collègues utilisateurs angulaires:

Au sein d' un modèle , Number(x)et parseInt(x)jette une erreur, et +xn'a pas d' effet. Le casting valide sera x*1ou x/1.

Comme le montrent d'autres réponses ici, il existe plusieurs façons d'effectuer la conversion:

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

Je voudrais mentionner encore une chose parseInt .

Lors de l'utilisation parseInt, il est logique de toujours passer le paramètre radix . Pour la conversion décimale, c'est 10. Il s'agit de la valeur par défaut du paramètre, c'est pourquoi il peut être omis. Pour binaire, c'est un 2et 16pour hexadécimal. En fait, tout radix compris entre 2 et 36 inclus.

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

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

La parseIntfonction, eh bien, analyse les chaînes pour les convertir en nombres. Dans certaines implémentations JS, parseIntanalyse les zéros non significatifs comme octaux:

Bien que découragées par ECMAScript 3 et interdites par ECMAScript 5, de nombreuses implémentations interprètent une chaîne numérique commençant par un 0 en tête comme octale. Ce qui suit peut avoir un résultat octal, ou il peut avoir un résultat décimal.Spécifiez toujours un radix pour éviter ce comportement peu fiable.

- MDN

Le fait que le code devienne plus clair est un effet secondaire agréable de la spécification du paramètre radix.

Depuis parseFloat que seules les expressions numériques sont analysées dans Radix 10, il n'est pas nécessaire d'avoir un paramètre Radix ici.

Plus à ce sujet:

• Pourquoi avons-nous besoin d'utiliser Radix? (Question SO)
• SO Répondre à "Quelle est la différence entre parseInt () et Number ()?"

Expliquant ce que Ryan a dit, TypeScript embrasse les idiomes JavaScript en général.

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()

Tous les détails intéressants et approfondis de la conversion de type JavaScript .

Vous pouvez suivre l'une des méthodes suivantes.

var str = '54';

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

Conversion de chaîne en nombre:

Dans Typescript, nous convertissons une chaîne en nombre de la manière suivante:

• ParseInt(): Cette fonction prend 2 arguments, le premier est une chaîne à analyser. Le second est le radix (la base dans les systèmes numériques mathématiques, par exemple 10 pour décimal et 2 pour binaire). Il retourne ensuite le nombre entier, si le premier caractère ne peut pas être converti en nombre, NaNil sera retourné.
• ParseFloat(): Prend comme argument la valeur que nous voulons analyser et retourne un nombre à virgule flottante. Si la valeur ne peut pas être convertie en nombre, NaNest renvoyée.
• + opérateur: L'opérateur, lorsqu'il est utilisé de manière appropriée, peut contraindre une valeur de chaîne en un nombre.

Exemples:

/*    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);

Lequel utiliser?

1. À utiliser ParseInt()lorsque vous souhaitez convertir une chaîne en entier . Cependant, le type de données est toujours un flottant, car toutes les valeurs numériques sont des valeurs à virgule flottante dans TS . Utilisez également cette méthode lorsque vous devez spécifier la base du nombre que vous souhaitez analyser.
2. À utiliser ParseFloat()lorsque vous devez analyser une chaîne en un nombre à virgule flottante .
3. Vous pouvez utiliser l' +opérateur avant une chaîne pour le contraindre en un nombre à virgule flottante . L'avantage est que la syntaxe est très courte.

Le moyen le plus simple consiste à utiliser + strVal ou Number (strVal)

Exemples:

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

Il existe des fonctions intégrées comme parseInt(), parseFloat()et Number()dans Typescript, vous pouvez les utiliser.

Appelez la fonction avec => convertstring ('10 .00 ')

parseFloat (string) => Il peut être utilisé pour convertir en float, toFixed (4) => en combien de décimales

parseInt (str) => Il peut être utilisé pour convertir en entier

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

Outil de conversion de numéro en ligne

Convertisseur de nombre

Il y a trois façons

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

Vous êtes nombreux à avoir un problème pour convertir les types de données difficiles à résoudre dans les situations de programmation ionique, car ce langage est nouveau, je vais détailler ici les instructions pour que l'utilisateur sache comment convertir les types ioniques en données de chaîne type entier.

Dans les langages de programmation tels que java, php, c, c ++, ... tous peuvent déplacer des données facilement, puis dans ionic peut également créer pour nous la conversion de données est également un moyen facile, notamment dans d'autres langages de programmation.

this.mPosition = parseInt("");

si vous ne parlez que de types, comme d'autres l'ont dit, parseInt () etc retournera le type correct. De plus, si, pour une raison quelconque, la valeur peut être à la fois un nombre ou une chaîne et que vous ne voulez pas appeler parseInt (), les expressions typeof seront également converties au type correct:

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

Voici une version modifiée de la fonction StrToNumber. Comme avant,

1. Il permet à un signe facultatif d'apparaître devant ou derrière la valeur numérique.
2. Il effectue une vérification pour vérifier qu'il n'y a qu'un seul signe en tête ou en queue de la chaîne.
3. Si une erreur se produit, une valeur par défaut "passée" est renvoyée.

Cette réponse est une solution possible mieux adaptée à la question initiale que mon précédent post.

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

dactylographié doit savoir que notre var ava être étherNumber || 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);
}

Vous pouvez toujours utiliser l'option de diffusion. Tout d'abord, vous devez convertir votre objet en type "inconnu", puis le convertir en un type d'objet attendu.

let subID:number = 0;

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