Hoe een tekenreeks converteren naar nummer in typescript?

Gegeven een reeksvertegenwoordiging van een getal, hoe kan ik het converteren naar numbertypes in typescript?

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

1, Autoriteit 100%

precies zoals In Javascript kunt u de parseIntof parseFloatfuncties, of gebruik gewoon de unige +Operator:

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

Alle genoemde technieken zullen correct typen en zullen de eenvoudige decimale integer-snaren als "123"correct parseren, maar zullen zich anders gedragen voor verschillende andere, eventueel verwacht, gevallen (zoals "123.45") en hoekcases (zoals null).

Tafel genomen van dit antwoord

2, Autoriteit 71%

De typescript manier om dit te doen zou zijn:

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

zoals hier beantwoord: https://stackoverflow.com/a/23440948/2083492

Antwoord 3, autoriteit 7%

Voor onze mede-Angular-gebruikers:

Binnen een sjabloongeven Number(x)en parseInt(x)een fout en +xheeft geen effect. Geldige casting is x*1of x/1.

Antwoord 4, autoriteit 6%

Zoals uit andere antwoorden hier blijkt, zijn er meerdere manieren om de conversie uit te voeren:

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

Ik wil echter nog één ding noemen op parseInt.

Als je parseIntgebruikt, is het logisch om altijd de radix-parameter door te geven. Voor decimale conversie is dat 10. Dit is de standaardwaarde voor de parameter, daarom kan deze kanworden weggelaten. Voor binair is het een 2en 16voor hexadecimaal. Eigenlijk werkt elke radix tussen en inclusief 2 en 36.

parseInt('123')         // 123 (don't do this)
parseInt('123', 10)     // 123 (much better)
parseInt('1101', 2)     // 13
parseInt('0xfae3', 16)  // 64227

In sommige JS-implementaties, parseIntparseert voorloopnullen als octaal:

Hoewel afgeraden door ECMAScript 3 en verboden door ECMAScript 5, interpreteren veel implementaties een numerieke tekenreeks die begint met een leidende 0 als octaal. Het volgende kan een octaal resultaat hebben, of het kan een decimaal resultaat hebben. Geef altijd een radix op om dit onbetrouwbare gedrag te voorkomen.

– MDN

Het feit dat de code duidelijker wordt, is een leuke bijwerking van het opgeven van de radixparameter.

Sinds parseFloatPARSES PARSES NUMERIEKE EXPRESSIES IN RADIX 10, het is hier niet nodig voor een radixparameter.

Meer hierover:

• Waarom moeten we Radix gebruiken? (Zo vraag)
• dus antwoord op “Wat is het verschil tussen parseint () en nummer ()?”

5, Autoriteit 3%

Uitgesproken op wat Ryan zei, inscript het JavaScript-idioma in het algemeen.

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

Alle interessante diepgaande details op Javascript Type Conversion .

6, Autoriteit 2%

U kunt een van de volgende manieren volgen.

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

7

String To Number Conversion:

In typescript converteren wij een tekenreeks naar een getal op de volgende manieren:

• parseInt(): Deze functie heeft 2 argumenten nodig, de eerste is een string om te ontleden. De tweede is de radix (de basis in wiskundige numerieke systemen, bijvoorbeeld 10 voor decimaal en 2 voor binair). Het retourneert vervolgens het gehele getal, als het eerste teken niet kan worden omgezet in een getal, wordt NaNgeretourneerd.
• parseFloat(): Neemt als argument de waarde die we willen ontleden, en retourneert een getal met drijvende komma. Als de waarde niet kan worden geconverteerd naar een getal, wordt NaNgeretourneerd.
• +operator: de operator kan, indien correct gebruikt, een tekenreekswaarde in een getal dwingen.

Voorbeelden:

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

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

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

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

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

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

this.mPosition = parseInt("");

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

var numberString: string = "1234";
const numberValue = numberString as number;

const numberString = "12"
const number = ~~numberString