Como faço para converter uma string em um número inteiro em JavaScript?

A maneira mais simples seria usar a Numberfunção nativa :

var x = Number("1000")

Se isso não funcionar para você, existem os métodos parseInt , unary plus , parseFloat with floor e Math.round .

parseInt:

var x = parseInt("1000", 10); // you want to use radix 10
    // so you get a decimal number even with a leading 0 and an old browser ([IE8, Firefox 20, Chrome 22 and older][1])

unary mais se sua string já estiver na forma de um número inteiro:

var x = +"1000";

se sua string é ou pode ser uma flutuação e você deseja um número inteiro:

var x = Math.floor("1000.01"); //floor automatically converts string to number

ou, se você estiver usando o Math.floor várias vezes:

var floor = Math.floor;
var x = floor("1000.01");

Se você é do tipo que esquece de colocar o radical quando chama parseInt, pode usar o parseFloat e arredondá-lo como quiser. Aqui eu uso chão.

var floor = Math.floor;
var x = floor(parseFloat("1000.01"));

Curiosamente, Math.round (como Math.floor) fará uma conversão de string para número; portanto, se você quiser que o número seja arredondado (ou se você tiver um número inteiro na string), essa é uma ótima maneira, talvez o meu favorito:

var round = Math.round;
var x = round("1000"); //equivalent to round("1000",0)

Tente a função parseInt:

var number = parseInt("10");

Mas há um problema. Se você tentar converter "010" usando a função parseInt, ele detectará como número octal e retornará o número 8. Portanto, é necessário especificar um radical (de 2 a 36). Nesse caso, base 10.

parseInt(string, radix)

Exemplo:

var result = parseInt("010", 10) == 10; // Returns true

var result = parseInt("010") == 10; // Returns false

Observe que parseIntignora dados inválidos após analisar qualquer coisa válida.
Este guia será analisado como 51:

var result = parseInt('51e3daf6-b521-446a-9f5b-a1bb4d8bac36', 10) == 51; // Returns true

Existem duas maneiras principais de converter uma string em um número em javascript. Uma maneira é analisá-lo e a outra maneira é mudar seu tipo para um número. Todos os truques nas outras respostas (por exemplo, unary plus) envolvem coagir implicitamente o tipo da string a um número. Você também pode fazer o mesmo explicitamente com a função Number.

Análise

var parsed = parseInt("97", 10);

parseInt e parseFloat são as duas funções usadas para analisar seqüências de caracteres em números. A análise será interrompida silenciosamente se atingir um caractere que não reconheça, o que pode ser útil para analisar seqüências de caracteres como "92px", mas também é um pouco perigoso, pois não causará nenhum tipo de erro em entradas incorretas. retornará NaN a menos que a sequência comece com um número. O espaço em branco no início da string é ignorado. Aqui está um exemplo de como fazer algo diferente do que você deseja e sem dar indicação de que algo deu errado:

var widgetsSold = parseInt("97,800", 10); // widgetsSold is now 97

É uma boa prática sempre especificar a raiz como o segundo argumento. Em navegadores mais antigos, se a sequência iniciasse com um 0, seria interpretada como octal se o radical não fosse especificado, o que pegaria muita gente de surpresa. O comportamento do hexadecimal é acionado com o início da cadeia com 0x, se nenhuma raiz for especificada, por exemplo 0xff. O padrão realmente mudou com o ecmascript 5, de modo que os navegadores modernos não acionam mais octal quando há um 0 inicial, se nenhuma raiz foi especificada. parseInt entende radixes até a base 36; nesse caso, as letras maiúsculas e minúsculas são tratadas como equivalentes.

Alterando o tipo de uma seqüência de caracteres para um número

Todos os outros truques mencionados acima que não usam parseInt envolvem coagir implicitamente a string em um número. Eu prefiro fazer isso explicitamente,

var cast = Number("97");

Isso tem um comportamento diferente dos métodos de análise (embora ainda ignore o espaço em branco). É mais rigoroso: se ele não entende toda a string do que ela retorna NaN, então você não pode usá-la para strings como 97px. Como você deseja um número primitivo em vez de um objeto de invólucro de número, certifique-se de não colocar newna frente da função Número.

Obviamente, a conversão para um número fornece um valor que pode ser um número flutuante em vez de um número inteiro; portanto, se você quiser um número inteiro, precisará modificá-lo. Existem algumas maneiras de fazer isso:

var rounded = Math.floor(Number("97.654"));  // other options are Math.ceil, Math.round
var fixed = Number("97.654").toFixed(0); // rounded rather than truncated
var bitwised = Number("97.654")|0;  // do not use for large numbers

Qualquer operador bit a bit (aqui eu fiz bit a bit ou, mas você também pode fazer uma dupla negação como em uma resposta anterior ou em um deslocamento de bits) converterá o valor em um número inteiro de 32 bits e a maioria deles converterá em um número inteiro assinado. Observe que isso não será o desejado para números inteiros grandes . Se o número inteiro não puder ser representado em 32 bits, ele será quebrado.

~~"3000000000.654" === -1294967296
// This is the same as
Number("3000000000.654")|0
"3000000000.654" >>> 0 === 3000000000 // unsigned right shift gives you an extra bit
"300000000000.654" >>> 0 === 3647256576 // but still fails with larger numbers

Para funcionar corretamente com números maiores, você deve usar os métodos de arredondamento

Math.floor("3000000000.654") === 3000000000
// This is the same as
Math.floor(Number("3000000000.654"))

Tenha em mente que todos esses métodos entender a notação exponencial, por isso 2e2é 200melhor que NaN. Além disso, o Number entende "Infinito", enquanto os métodos de análise não.

personalizadas

É improvável que um desses métodos faça exatamente o que você deseja. Por exemplo, geralmente eu desejaria um erro se a análise falhar e não preciso de suporte para Infinito, exponencial ou espaço em branco à esquerda. Dependendo do seu caso de uso, às vezes faz sentido escrever uma função de conversão personalizada.

Sempre verifique se a saída de Number ou um dos métodos de análise é o tipo de número que você espera. Você quase certamente desejará usar isNaNpara garantir que o número não seja NaN (geralmente a única maneira de descobrir que a análise falhou).

ParseInt () e + são diferentes

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

Embora seja uma pergunta antiga, mas talvez isso possa ser útil para alguém.

Eu uso essa maneira de converter string para número int

var str = "25";       // string
var number = str*1;   // number

Portanto, ao multiplicar por 1, o valor não muda, mas js retorna automaticamente um número.

Mas, como é mostrado abaixo, isso deve ser usado se você tiver certeza de que stré um número (ou pode ser representado como um número); caso contrário, ele retornará NaN - não um número.

você pode criar uma função simples de usar, por exemplo

function toNumber(str) {
   return str*1;
}

O mais rápido

var x = "1000"*1;

Teste

Aqui está uma pequena comparação de velocidade (apenas Mac OS) ... :)

Para chrome 'plus' e 'mul' são os mais rápidos (> 700.000,00 op / s), 'Math.floor' é o mais lento. Para o Firefox, 'plus' é o mais lento (!) 'Mul' é o mais rápido (> 900.000.000 op / s). No Safari, 'parseInt' é jejum, 'número' é mais lento (mas os resultados são bastante semelhantes,> 13.000.000 <31.000.000). Portanto, o Safari para converter strings para int é 10 vezes mais lento que outros navegadores. Então o vencedor é ' mul ' :)

Você pode executá-lo no seu navegador por este link https://jsperf.com/js-cast-str-to-number/1

Atualizar

Eu também testo var x = ~~"1000";- no Chrome e Safari é um pouco mais lento que var x = "1000"*1(<1%), no Firefox é um pouco mais rápido (<1%). Eu atualizo a imagem acima e testei

Tente parseInt.

var number = parseInt("10", 10); //number will have value of 10.

Eu postei a resposta errada aqui, desculpe. fixo.

Esta é uma pergunta antiga, mas eu amo esse truque:

~~"2.123"; //2
~~"5"; //5

O negativo bit a bit duplo cai qualquer coisa após o ponto decimal E o converte em um formato numérico. Foi-me dito que é um pouco mais rápido do que chamar funções e outros enfeites, mas não estou totalmente convencido.

EDIT: Outro método que acabei de ver aqui (uma pergunta sobre o operador javascript >>>, que é um deslocamento à direita com preenchimento zero), que mostra que mudar um número por 0 com esse operador converte o número em um uint32, o que é bom se você também quer sem sinal . Novamente, isso se converte em um número inteiro não assinado , o que pode levar a comportamentos estranhos se você usar um número assinado.

"-2.123" >>> 0; // 4294967294
"2.123" >>> 0; // 2
"-5" >>> 0; // 4294967291
"5" >>> 0; // 5

Cuidado se você usar parseInt para converter um float em notação científica! Por exemplo:

parseInt("5.6e-14") 

vai resultar em

5 

ao invés de

0

Para converter uma String em Inteiro, eu recomendo usar parseFloat e NOT parseInt. Aqui está o porquê:

Usando parseFloat:

parseFloat('2.34cms')  //Output: 2.34
parseFloat('12.5')     //Output: 12.5
parseFloat('012.3')    //Output: 12.3

Usando parseInt:

parseInt('2.34cms')  //Output: 2
parseInt('12.5')     //Output: 12
parseInt('012.3')    //Output: 12

Portanto, se você notou parseInt descarta os valores após as casas decimais, enquanto parseFloat permite trabalhar com números de ponto flutuante e, portanto, mais adequado se você deseja reter os valores após casas decimais. Use parseInt se e somente se tiver certeza de que deseja o valor inteiro.

Também como uma observação lateral: Mootools tem a função toInt () que é usada em qualquer string nativa (ou flutuante (ou inteiro)).

"2".toInt()   // 2
"2px".toInt() // 2
2.toInt()     // 2

Veja o exemplo abaixo. Isso ajudará a esclarecer sua dúvida

Example                  Result

parseInt("4")            4
parseInt("5aaa")         5
parseInt("4.33333")      4
parseInt("aaa");         NaN (means "Not a Number")

usando a função parseint Ele dará apenas o número inteiro presente e não a string

podemos usar em +(stringOfNumber)vez de usarparseInt(stringOfNumber)

Ex: +("21")retorna int de 21 como o parseInt("21").

podemos usar esse operador "+" unário também para analisar float ...

Tente str - 0converter stringpara number.

> str = '0'
> str - 0
  0
> str = '123'
> str - 0
  123
> str = '-12'
> str - 0
  -12
> str = 'asdf'
> str - 0
  NaN
> str = '12.34'
> str - 0
  12.34

Aqui estão dois links para comparar o desempenho de várias maneiras de converter string em int

https://jsperf.com/number-vs-parseint-vs-plus

http://phrogz.net/js/string_to_number.html

Existem várias maneiras no JavaScript de converter uma string em um valor numérico ... Tudo simples e prático, escolha a maneira que funciona para você:

var num = Number("999.5"); //999.5
var num = parseInt("999.5", 10); //999
var num = parseFloat("999.5"); //999.5
var num = +"999.5"; //999.5

Além disso, qualquer operação matemática os converte em número, por exemplo ...

var num = "999.5" / 1; //999.5
var num = "999.5" * 1; //999.5
var num = "999.5" - 1 + 1; //999.5
var num = "999.5" - 0; //999.5
var num = Math.floor("999.5"); //999
var num = ~~"999.5"; //999

Minha maneira preferida é usar +sign, que é a maneira elegante de converter uma string em número em JavaScript.

O Google me deu essa resposta como resultado, então ...

Na verdade, eu precisava "salvar" uma string como um número inteiro, para uma ligação entre C e JavaScript, então eu converti a string em um valor inteiro:

/*
    Examples:
        int2str( str2int("test") ) == "test" // true
        int2str( str2int("t€st") ) // "t¬st", because "€".charCodeAt(0) is 8364, will be AND'ed with 0xff
    Limitations:
        max 4 chars, so it fits into an integer
*/
function str2int(the_str) {
    var ret = 0;
    var len = the_str.length;
    if (len >= 1) ret += (the_str.charCodeAt(0) & 0xff) <<  0;
    if (len >= 2) ret += (the_str.charCodeAt(1) & 0xff) <<  8;
    if (len >= 3) ret += (the_str.charCodeAt(2) & 0xff) << 16;
    if (len >= 4) ret += (the_str.charCodeAt(3) & 0xff) << 24;
    return ret;
}
function int2str(the_int) {
    var tmp = [
        (the_int & 0x000000ff) >>  0,
        (the_int & 0x0000ff00) >>  8,
        (the_int & 0x00ff0000) >> 16,
        (the_int & 0xff000000) >> 24
    ];
    var ret = "";
    for (var i=0; i<4; i++) {
        if (tmp[i] == 0)
            break;
        ret += String.fromCharCode(tmp[i]);
    }
    return ret;
}

Na minha opinião, nenhuma resposta cobre todos os casos extremos, pois a análise de um flutuador deve resultar em um erro.

function parseInteger(value) {
    if(value === '') return NaN;
    const number = Number(value);
    return Number.isInteger(number) ? number : NaN;
}

parseInteger("4")            // 4
parseInteger("5aaa")         // NaN
parseInteger("4.33333")      // NaN
parseInteger("aaa");         // NaN

Aqui está a solução mais fácil

let myNumber = "123" | 0;

Solução mais fácil

let myNumber = +"123";

Todos os acima estão corretos. Antes, certifique-se de que este é um número em uma string fazendo "typeot x === 'number'"; caso contrário, ele retornará NaN

 var num = "fsdfsdf242342";
 typeof num => 'string';

 var num1 = "12423";
 typeof num1 => 'number';
 +num1 = > 12423`

Outra opção é dobrar o valor XOR consigo mesmo:

var i = 12.34;
console.log('i = ' + i);
console.log('i ⊕ i ⊕ i = ' + (i ^ i ^ i));

Isso produzirá:

i = 12.34
i ⊕ i ⊕ i = 12

Eu adicionei apenas um mais (+) antes da string e essa foi a solução!

+"052254" //52254

Espero que ajude ;)

Somando a multiplicação de dígitos com seu respectivo poder de dez:

ou seja: 123 = 100 + 20 + 3 = 1 * 100 + 2 + 10 + 3 * 1 = 1 * (10 ^ 2) + 2 * (10 ^ 1) + 3 * (10 ^ 0)

function atoi(array) {

// use exp as (length - i), other option would be to reverse the array.
// multiply a[i] * 10^(exp) and sum

let sum = 0;

for (let i = 0; i < array.length; i++) {
    let exp = array.length-(i+1);
    let value = array[i] * Math.pow(10,exp);
    sum+=value;
}

return sum;

}

Eu uso isso

String.prototype.toInt = function (returnval) { 
    var i = parseInt(this);
    return isNaN(i) ? returnval !== undefined ? returnval : - 1  :      i; 
}

Dessa forma, eu sempre recebo um retorno.

A maneira mais segura de garantir que você obtenha um número inteiro válido:

let integer = (parseInt(value, 10) || 0);

Exemplos:

// Example 1 - Invalid value:
let value = null;
let integer = (parseInt(value, 10) || 0);
// => integer = 0

// Example 2 - Valid value:
let value = "1230.42";
let integer = (parseInt(value, 10) || 0);
// => integer = 1230

// Example 3 - Invalid value:
let value = () => { return 412 };
let integer = (parseInt(value, 10) || 0);
// => integer = 0

function parseIntSmarter(str) {
    // ParseInt is bad because it returns 22 for "22thisendsintext"
    // Number() is returns NaN if it ends in non-numbers, but it returns 0 for empty or whitespace strings.
    return isNaN(Number(str)) ? NaN : parseInt(str, 10);
}

você pode usar plus, por exemplo =>

var personAge = '24'; var personAge1 = (+ personAge)

então você pode ver o tipo de pessoaA idade é o número