Jak przekonwertować ciąg na liczbę w TypeScript?

Biorąc pod uwagę ciąg znaków reprezentujący liczbę, w jaki sposób mogę przekonwertować go na numberczcionkę TypeScript?

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

Dokładnie jak w JavaScript , możesz użyć parseIntalbo parseFloatfunkcje, lub po prostu użyć jednoargumentowy +operator:

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

Wszystkie wymienione techniki będą miały poprawne pisanie i poprawnie parsują proste ciągi dziesiętne, takie jak "123", ale będą zachowywać się inaczej dla różnych innych, prawdopodobnie oczekiwanych, przypadków (jak "123.45") i narożników (jak null).

Tabela pochodzi z tej odpowiedzi

Typowym sposobem na zrobienie tego byłoby:

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

zgodnie z odpowiedzią tutaj: https://stackoverflow.com/a/23440948/2083492

Dla naszych innych użytkowników Angular:

Wewnątrz szablonu , Number(x)i parseInt(x)zgłasza błąd, i +xnie ma żadnego wpływu. Prawidłowy casting to x*1lub x/1.

Jak pokazują inne odpowiedzi tutaj, istnieje wiele sposobów konwersji:

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

Chciałbym jednak wspomnieć o jeszcze jednej sprawie parseInt.

Podczas używania parseIntsensowne jest zawsze przekazywanie parametru radix . To znaczy do konwersji dziesiętnej 10. Jest to domyślna wartość parametru, dlatego można ją pominąć. W przypadku plików binarnych jest to a, 2a 16w systemie szesnastkowym. Właściwie każda podstawa między 2 a 36 włącznie.

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

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

Ta parseIntfunkcja analizuje ciągi, aby przekonwertować je na liczby. W niektórych implementacjach JS parseIntanalizuje zera wiodące jako ósemkowe:

Mimo że ECMAScript 3 go zniechęca, a ECMAScript 5 zabrania, wiele implementacji interpretuje ciąg liczbowy rozpoczynający się od 0 na początku jako ósemkowy. Poniższe wyniki mogą być ósemkowe lub dziesiętne. Zawsze określaj podstawę, aby uniknąć tego niewiarygodnego zachowania.

- MDN

Fakt, że kod staje się wyraźniejszy, jest miłym efektem ubocznym określenia parametru radix.

Ponieważ parseFloatanalizuje tylko wyrażenia liczbowe w Radix 10, nie ma potrzeby tutaj parametru Radix.

Więcej na ten temat:

• Dlaczego musimy używać Radix? (SO Pytanie)
• SO Odpowiedź na „Jaka jest różnica między parseInt () a Number ()?”

Wyjaśniając to, co powiedział Ryan, TypeScript obejmuje ogólnie idiomy JavaScript.

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

Wszystkie interesujące szczegółowe informacje na temat konwersji typów JavaScript .

Możesz wykonać jeden z następujących sposobów.

var str = '54';

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

Konwersja ciągu na liczbę:

W Typescript konwertujemy ciąg na liczbę w następujący sposób:

• ParseInt(): Ta funkcja przyjmuje 2 argumenty, pierwszy to ciąg do analizy. Drugi to podstawa (podstawa w matematycznych systemach liczbowych, np. 10 dla dziesiętnych i 2 dla binarnych). Następnie zwraca liczbę całkowitą, jeśli pierwszy znak nie może zostać przekształcony w liczbę, NaNzostanie zwrócony.
• ParseFloat(): Bierze jako argument wartość, którą chcemy przeanalizować, i zwraca liczbę zmiennoprzecinkową. Jeśli wartości nie można przekonwertować na liczbę, NaNzwracana jest.
• + operator: Operator, gdy jest odpowiednio używany, może zmusić wartość ciągu do liczby.

Przykłady:

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

Którego użyć?

1. Użyj, ParseInt()gdy chcesz przekonwertować ciąg na liczbę całkowitą . Jednak typ danych jest wciąż zmiennoprzecinkowy, ponieważ wszystkie wartości liczbowe są wartościami zmiennoprzecinkowymi w TS . Skorzystaj również z tej metody, jeśli chcesz określić podstawę liczby, którą chcesz przeanalizować.
2. Użyj, ParseFloat()gdy potrzebujesz parsować ciąg znaków na liczbę zmiennoprzecinkową .
3. Możesz użyć +operatora przed ciągiem, aby przekonwertować go na liczbę zmiennoprzecinkową . Zaletą tego jest to, że składnia jest bardzo krótka.

Najłatwiejszym sposobem jest użycie + strVal lub Number (strVal)

Przykłady:

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

Są wbudowane funkcje, takie jak parseInt(), parseFloat()i Number()na maszynie, można użyć tych.

Wywołaj funkcję za pomocą => convertstring ('10 .00 ')

parseFloat (string) => Można go użyć do konwersji na zmiennoprzecinkowe, toFixed (4) => do liczby miejsc po przecinku

parseInt (str) => Można go użyć do konwersji na liczbę całkowitą

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

Narzędzie do konwersji numerów online

Konwerter liczb

Istnieją trzy sposoby

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

Wielu z was ma problem z konwersją typów danych, które są trudne do rozwiązania w programowaniu jonowym, ponieważ ten sam język jest nowy, tutaj szczegółowo opiszę instrukcje dla użytkownika, aby wiedzieć, jak przekonwertować typy danych jonowych na dane łańcuchowe wpisz liczbę całkowitą.

W językach programowania, takich jak java, php, c, c ++, ... wszystko może łatwo przenosić dane, a następnie w jońskim może również tworzyć dla nas konwersję danych, jest to również łatwy sposób, również w innych językach programowania.

this.mPosition = parseInt("");

jeśli mówimy tylko o typach, jak powiedzieli inni, parseInt () itp. zwróci poprawny typ. Ponadto, jeśli z jakiegokolwiek powodu wartością może być zarówno liczba, jak i ciąg znaków, a użytkownik nie chce wywoływać funkcji parseInt (), wyrażenia typeof również będą rzutowane na poprawny typ:

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

Oto zmodyfikowana wersja funkcji StrToNumber. Jak wcześniej,

1. Umożliwia wyświetlanie opcjonalnego znaku przed lub za wartością liczbową.
2. Dokonuje sprawdzenia, aby sprawdzić, czy na głowie lub ogonie sznurka znajduje się tylko jeden znak.
3. Jeśli wystąpi błąd, zwracana jest „domyślna” wartość domyślna.

Ta odpowiedź jest możliwym rozwiązaniem, które lepiej pasuje do pytania początkowego niż mój poprzedni 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);    
   }

maszynopis musi wiedzieć, że nasz var abędzie eteremNumber || 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);
}

Zawsze możesz użyć opcji rzutowania. Najpierw musisz przekonwertować obiekt na typ „nieznany”, a następnie rzutować go na oczekiwany typ obiektu.

let subID:number = 0;

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