Como converter uma seqüência de caracteres em número no TypeScript?

Dada uma representação de seqüência de caracteres de um número, como posso convertê-lo para numberdigitar TypeScript?

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

Exatamente como em JavaScript , você pode usar os parseIntou parseFloatfunções, ou simplesmente usar o unário +operador:

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

Todas as técnicas mencionadas terão digitação correta e analisarão corretamente cadeias inteiras decimais simples "123", como , mas se comportarão de maneira diferente para vários outros casos (possivelmente "123.45") e casos de canto (como null) possíveis .

Tabela retirada desta resposta

A maneira Typcript para fazer isso seria:

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

conforme respondido aqui: https://stackoverflow.com/a/23440948/2083492

Para nossos colegas usuários angulares:

Dentro de um template , Number(x)e parseInt(x)gera um erro, e +xnão tem efeito. A transmissão válida será x*1ou x/1.

Como mostrado por outras respostas aqui, existem várias maneiras de fazer a conversão:

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

Eu gostaria de mencionar mais uma coisa parseInt.

Ao usar parseInt, faz sentido sempre passar o parâmetro radix . Para conversão decimal, é isso 10. Este é o valor padrão para o parâmetro, e é por isso que ele pode ser omitido. Para binário, é um 2e 16para hexadecimal. Na verdade, qualquer mistura entre 2 e 36, inclusive.

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

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

A parseIntfunção, assim, analisa cadeias de caracteres para convertê-las em números. Em algumas implementações de JS, parseIntanalisa zeros à esquerda como octal:

Embora desencorajada pelo ECMAScript 3 e proibida pelo ECMAScript 5, muitas implementações interpretam uma sequência numérica começando com um 0 inicial como octal. O seguinte pode ter um resultado octal ou um resultado decimal.Sempre especifique uma raiz para evitar esse comportamento não confiável.

- MDN

O fato de o código ficar mais claro é um bom efeito colateral da especificação do parâmetro radix.

Como parseFloatapenas analisa expressões numéricas no radix 10, não há necessidade de um parâmetro radix aqui.

Mais sobre isso:

• Por que precisamos usar o radix? (Pergunta SO)
• Resposta do SO a "Qual é a diferença entre parseInt () e Number ()?"

Explicando o que Ryan disse, o TypeScript abrange os idiomas JavaScript em geral.

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

Todos os detalhes detalhados interessantes em JavaScript Type Conversion .

Você pode seguir uma das seguintes maneiras.

var str = '54';

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

Conversão de string para número:

No TypeScript, convertemos uma string em um número das seguintes maneiras:

• ParseInt(): Esta função recebe 2 argumentos, o primeiro é uma string para analisar. O segundo é a raiz (a base nos sistemas de números matemáticos, por exemplo, 10 para decimal e 2 para binário). Em seguida, ele retorna o número inteiro, se o primeiro caractere não puder ser convertido em um número,NaN será retornado.
• ParseFloat(): Aceita como argumento o valor que queremos analisar e retorna um número de ponto flutuante. Se o valor não puder ser convertido em um número, NaNserá retornado.
• + operador: o operador, quando usado adequadamente, pode coagir um valor de sequência em um número.

Exemplos:

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

Qual usar?

1. Use ParseInt()quando desejar que uma sequência seja convertida em um número inteiro . No entanto, o tipo de dados ainda é flutuante, pois todos os valores numéricos são valores de ponto flutuante no TS . Também use esse método quando precisar especificar a raiz do número que deseja analisar.
2. Use ParseFloat()quando você precisar analisar uma sequência em um número de ponto flutuante .
3. Você pode usar o +operador antes de uma sequência para coagi-la a um número de ponto flutuante . A vantagem disso é que a sintaxe é muito curta.

A maneira mais fácil é usar + strVal ou Number (strVal)

Exemplos:

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

Existem funções embutidas como parseInt(), parseFloat()e Number()no Typescript, você pode usá-las.

Chame a função com => converttstring ('10 .00 ')

parseFloat (string) => Pode ser usado para converter em float, toFixed (4) => em quantos decimais

parseInt (str) => Pode ser usado para converter em número inteiro

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

Ferramenta de conversão de números online

Number Converter

Existem três maneiras

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

Muitos de vocês estão tendo problemas para converter tipos de dados difíceis de resolver nas situações de programação iônica, porque essa linguagem é nova, aqui vou detalhar instruções para o usuário saber como converter tipos iônicos em dados de cadeia de caracteres digite inteiro.

Em linguagens de programação como java, php, c, c ++, ... tudo pode mover dados facilmente, então no ionic também pode criar para nós a conversão de dados também é uma maneira fácil, inclusive em outras linguagens de programação.

this.mPosition = parseInt("");

se você está falando apenas de tipos, como outras pessoas disseram, parseInt () etc retornará o tipo correto. Além disso, se por algum motivo o valor puder ser um número ou uma sequência e você não quiser chamar parseInt (), as expressões typeof também serão convertidas no tipo correto:

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

Aqui está uma versão modificada da função StrToNumber. Como antes,

1. Permite que um sinal opcional apareça na frente ou atrás do valor numérico.
2. Ele executa uma verificação para verificar se há apenas um sinal na cabeça ou no final da corda.
3. Se ocorrer um erro, um valor padrão "passado" será retornado.

Essa resposta é uma solução possível mais adequada à pergunta inicial do que no post anterior.

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

datilografado precisa saber que o nosso var aéter seráNumber || 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);
}

Você sempre pode usar a opção de transmissão. Primeiro, você deve converter seu objeto para o tipo "desconhecido" e depois convertê-lo em um tipo de objeto esperado.

let subID:number = 0;

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