Come convertire una stringa in numero in TypeScript?

Data una rappresentazione in forma di stringa di un numero, come posso convertirlo per numberdigitare in TypeScript?

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

Esattamente come in JavaScript , è possibile utilizzare le parseInto parseFloatfunzioni, o semplicemente utilizzare l'unario +operatore:

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

Tutte le tecniche menzionate avranno una digitazione corretta e analizzeranno correttamente semplici stringhe intere decimali come "123", ma si comporteranno in modo diverso per vari altri casi, probabilmente previsti, (come "123.45") e angoli (come null).

Tabella presa da questa risposta

Il modo Typescript per farlo sarebbe:

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

come risposta qui: https://stackoverflow.com/a/23440948/2083492

Per i nostri colleghi utenti angolari:

All'interno di un modello , Number(x)e parseInt(x)getta un errore, e +xnon ha alcun effetto. Il casting valido sarà x*1o x/1.

Come mostrato da altre risposte qui, ci sono diversi modi per fare la conversione:

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

Vorrei citare ancora una cosa parseInt.

Durante l'utilizzo parseInt, ha senso passare sempre il parametro radix . Per la conversione decimale, cioè 10. Questo è il valore predefinito per il parametro, motivo per cui può essere omesso. Per binario, è un 2e 16per esadecimale. In realtà, qualsiasi radix tra e compreso 2 e 36 opere.

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

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

La parseIntfunzione, beh, analizza le stringhe per convertirle in numeri. In alcune implementazioni di JS, parseIntanalizza gli zeri iniziali come ottali:

Sebbene scoraggiato da ECMAScript 3 e proibito da ECMAScript 5, molte implementazioni interpretano una stringa numerica che inizia con uno 0 iniziale come ottale. Quanto segue può avere un risultato ottale o può avere un risultato decimale. Specifica sempre una radice per evitare questo comportamento inaffidabile.

- MDN

Il fatto che il codice diventi più chiaro è un piacevole effetto collaterale della specifica del parametro radix.

Poiché parseFloatanalizza solo espressioni numeriche in radix 10, qui non è necessario un parametro radix.

Maggiori informazioni su questo:

• Perché dobbiamo usare Radix? (Domanda SO)
• SO Risposta a "Qual è la differenza tra parseInt () e Number ()?"

Esponendo ciò che ha detto Ryan, TypeScript abbraccia gli idiomi JavaScript in generale.

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

Tutti gli interessanti dettagli approfonditi nella conversione del tipo JavaScript .

Puoi seguire uno dei seguenti modi.

var str = '54';

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

Conversione da stringa a numero:

In Typescript convertiamo una stringa in un numero nei seguenti modi:

• ParseInt(): Questa funzione accetta 2 argomenti, il primo è una stringa da analizzare. Il secondo è la radice (la base nei sistemi numerici matematici, ad esempio 10 per i decimali e 2 per i binari). Restituisce quindi il numero intero, se il primo carattere non può essere convertito in un numero, NaNverrà restituito.
• ParseFloat(): Prende come argomento il valore che vogliamo analizzare e restituisce un numero in virgola mobile. Se il valore non può essere convertito in un numero, NaNviene restituito.
• + operatore: l'operatore usato in modo appropriato può forzare un valore di stringa in un numero.

Esempi:

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

Quale usare?

1. Utilizzare ParseInt()quando si desidera convertire una stringa in un numero intero . Tuttavia, il tipo di dati è ancora mobile, poiché tutti i valori numerici sono valori in virgola mobile in TS . Utilizzare questo metodo anche quando è necessario specificare la radice del numero che si desidera analizzare.
2. Utilizzare ParseFloat()quando è necessario analizzare una stringa in un numero in virgola mobile .
3. È possibile utilizzare l' +operatore prima di una stringa per forzarla in un numero in virgola mobile . Il vantaggio è che la sintassi è molto breve.

Il modo più semplice è usare + strVal o Number (strVal)

Esempi:

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

Ci sono funzioni integrate come parseInt(), parseFloat()e Number()in Typescript, puoi usarle.

Chiamare la funzione con => convertstring ('10 .00 ')

parseFloat (string) => Può essere usato per convertire in float, in Fix (4) => in quanti decimali

parseInt (str) => Può essere usato per convertire in numeri interi

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

Strumento di conversione numerica online

Convertitore di numeri

Ci sono tre modi

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

Ci sono molti di voi che hanno problemi a convertire i tipi di dati che sono difficili da risolvere nelle situazioni di programmazione ionica, perché proprio questo linguaggio è nuovo, qui fornirò le istruzioni dettagliate per l'utente di sapere come convertire i tipi ionici in dati stringa tipo intero.

In linguaggi di programmazione come java, php, c, c ++, ... tutti possono spostare facilmente i dati, quindi in ionico possono anche creare per noi la conversione dei dati è anche un modo semplice, non da ultimo in altri linguaggi di programmazione.

this.mPosition = parseInt("");

se stai parlando solo di tipi, come hanno detto altre persone, parseInt () etc restituirà il tipo corretto. Inoltre, se per qualsiasi motivo il valore può essere sia un numero che una stringa e non si desidera chiamare parseInt (), anche il tipo di espressioni verrà castato nel tipo corretto:

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

Ecco una versione modificata della funzione StrToNumber. Come prima,

1. Consente di visualizzare un segno opzionale davanti o dietro il valore numerico.
2. Esegue un controllo per verificare che ci sia un solo segno in testa o in coda alla stringa.
3. Se si verifica un errore, viene restituito un valore predefinito "passato".

Questa risposta è una possibile soluzione che si adatta meglio alla domanda iniziale rispetto al mio post precedente.

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

dattiloscritto deve sapere che il nostro var asarà etereNumber || 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);
}

Puoi sempre utilizzare l'opzione Cast. Innanzitutto, è necessario convertire l'oggetto in un tipo "sconosciuto" e quindi trasmetterlo in un tipo di oggetto previsto.

let subID:number = 0;

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