Wie konvertiere ich eine Zeichenfolge in TypeScript in eine Zahl?

Wie kann ich bei einer Zeichenfolgendarstellung einer Zahl diese numberin TypeScript konvertieren ?

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

Genau wie in JavaScript , können Sie die verwenden parseIntoder parseFloatFunktionen, oder einfach die einstelligen verwenden +Betreiber:

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

Alle genannten Techniken haben eine korrekte Typisierung und analysieren einfache dezimale Ganzzahlzeichenfolgen wie korrekt "123", verhalten sich jedoch für verschiedene andere, möglicherweise erwartete Fälle (wie "123.45") und Eckfälle (wie null) unterschiedlich.

Tabelle aus dieser Antwort entnommen

Der Typescript-Weg, dies zu tun, wäre:

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

wie hier beantwortet: https://stackoverflow.com/a/23440948/2083492

Für unsere Angular-Mitbenutzer:

Innerhalb einer Vorlage , Number(x)und parseInt(x)wirft einen Fehler, und +xhat keine Auswirkungen. Gültiges Casting ist x*1oder x/1.

Wie andere Antworten hier zeigen, gibt es mehrere Möglichkeiten, die Konvertierung durchzuführen:

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

Ich möchte jedoch noch etwas erwähnen parseInt.

Bei der Verwendung parseIntist es sinnvoll, immer den Radix-Parameter zu übergeben . Für die Dezimalumrechnung also 10. Dies ist der Standardwert für den Parameter, weshalb es kann weggelassen werden. Für Binär ist es ein 2und 16für Hexadezimal. Tatsächlich funktioniert jeder Radix zwischen und einschließlich 2 und 36.

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

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

Die parseIntFunktion analysiert Zeichenfolgen, um sie in Zahlen umzuwandeln. In einigen JS-Implementierungen werden parseIntführende Nullen als Oktal analysiert:

Obwohl von ECMAScript 3 abgeraten und von ECMAScript 5 verboten, interpretieren viele Implementierungen eine numerische Zeichenfolge, die mit einer führenden 0 beginnt, als Oktal. Das Folgende kann ein oktales Ergebnis oder ein dezimales Ergebnis haben. Geben Sie immer einen Radix an, um dieses unzuverlässige Verhalten zu vermeiden.

- MDN

Die Tatsache, dass der Code klarer wird, ist ein netter Nebeneffekt bei der Angabe des Radix-Parameters.

Da parseFloatin Radix 10 nur numerische Ausdrücke analysiert werden, ist hier kein Radix-Parameter erforderlich.

Mehr dazu:

• Warum müssen wir Radix verwenden? (SO Frage)
• SO Antwort auf "Was ist der Unterschied zwischen parseInt () und Number ()?"

TypeScript erläutert, was Ryan gesagt hat, und verwendet im Allgemeinen die JavaScript-Redewendungen.

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 interessanten Details bei der JavaScript-Typkonvertierung .

Sie können eine der folgenden Möglichkeiten wählen.

var str = '54';

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

Umwandlung von Zeichenfolgen in Zahlen:

In Typescript konvertieren wir eine Zeichenfolge auf folgende Weise in eine Zahl:

• ParseInt(): Diese Funktion benötigt 2 Argumente, das erste ist eine zu analysierende Zeichenfolge. Der zweite ist der Radix (die Basis in mathematischen Zahlensystemen, z. B. 10 für Dezimal und 2 für Binär). Es wird dann die Ganzzahl zurückgegeben, wenn das erste Zeichen nicht in eine Zahl umgewandelt werden kann, NaNwird zurückgegeben.
• ParseFloat(): Nimmt als Argument den Wert, den wir analysieren möchten, und gibt eine Gleitkommazahl zurück. Wenn der Wert nicht in eine Zahl konvertiert werden kann, NaNwird zurückgegeben.
• + Operator: Der Operator kann bei entsprechender Verwendung einen Zeichenfolgenwert in eine Zahl zwingen.

Beispiele:

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

Welche verwenden?

1. Verwenden ParseInt()Sie diese Option, wenn eine Zeichenfolge in eine Ganzzahl konvertiert werden soll . Der Datentyp ist jedoch immer noch ein Gleitkommawert , da alle Zahlenwerte Gleitkommawerte in TS sind . Verwenden Sie diese Methode auch, wenn Sie den Radix der Zahl angeben müssen, die Sie analysieren möchten.
2. Verwenden ParseFloat()Sie diese Option, wenn Sie eine Zeichenfolge in eine Gleitkommazahl analysieren müssen .
3. Sie können den +Operator vor einer Zeichenfolge verwenden, um sie in eine Gleitkommazahl zu zwingen . Dies hat den Vorteil, dass die Syntax sehr kurz ist.

Am einfachsten ist es, + strVal oder Number (strVal) zu verwenden.

Beispiele:

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

Es gibt eingebaute Funktionen wie parseInt(), parseFloat()und Number()in Maschinenschrift, können Sie diese verwenden.

Rufen Sie die Funktion mit => convertstring ('10 .00 ') auf.

parseFloat (string) => Es kann verwendet werden, um in float, toFixed (4) => in wie viele Dezimalstellen umzuwandeln

parseInt (str) => Kann zur Konvertierung in eine Ganzzahl verwendet werden

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

Online-Tool zur Nummernkonvertierung

Nummernwandler

Es gibt drei Möglichkeiten

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

Viele von Ihnen haben ein Problem mit der Konvertierung von Datentypen, die in Situationen der ionischen Programmierung schwer zu lösen sind, da genau diese Sprache neu ist. Hier werde ich dem Benutzer detaillierte Anweisungen geben, wie er Datenionentypen in Zeichenfolgendaten konvertieren kann Geben Sie eine Ganzzahl ein.

In Programmiersprachen wie Java, PHP, C, C ++, ... können alle Daten leicht verschieben, dann kann in ionic auch für uns die Datenkonvertierung eine einfache Möglichkeit sein, nicht zuletzt in anderen Programmiersprachen.

this.mPosition = parseInt("");

Wenn Sie nur über Typen sprechen, wie andere Leute sagten, gibt parseInt () usw. den richtigen Typ zurück. Wenn der Wert aus irgendeinem Grund sowohl eine Zahl als auch eine Zeichenfolge sein kann und Sie parseInt () nicht aufrufen möchten, wird der Typ der Ausdrücke ebenfalls in den richtigen Typ umgewandelt:

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

Hier ist eine modifizierte Version der StrToNumber-Funktion. Wie vorher,

1. Es ermöglicht ein optionales Zeichen vor oder hinter dem numerischen Wert.
2. Es wird überprüft, ob am Kopf oder am Ende der Zeichenfolge nur ein Zeichen vorhanden ist.
3. Wenn ein Fehler auftritt, wird ein "übergebener" Standardwert zurückgegeben.

Diese Antwort ist eine mögliche Lösung, die besser für die ursprüngliche Frage geeignet ist als mein vorheriger Beitrag.

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

Typoskript muss wissen, dass unser var aÄther sein wirdNumber || 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);
}

Sie können jederzeit die Cast-Option verwenden. Zuerst müssen Sie Ihr Objekt in den Typ "unbekannt" konvertieren und dann in einen erwarteten Objekttyp umwandeln.

let subID:number = 0;

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