Como converter uma string em um inteiro em JavaScript?

Tente a função parseInt:

var number = parseInt("10");

parseInt(string, radix)

Exemplo:

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

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

Existem duas maneiras principais de converter uma string para 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 implicitamente coagir o tipo da cadeia a um número. Você também pode fazer a mesma coisa explicitamente com a função Número.

Processamento

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

ParseInt e parseFloat são as duas funções usadas para processar cadeias de caracteres em números. Analise vai parar silenciosamente se ele atinge um personagem que não reconhece, o que pode ser útil para analisar strings como "92px", mas também é um pouco perigoso, uma vez que ele não vai lhe dar qualquer tipo de erro na entrada ruim, em vez disso você vai voltar NaN a menos que a string começa com um número. O espaço em branco no início do texto é ignorado. Aqui está um exemplo dele fazendo algo diferente do que você quer, e não dando nenhuma indicação de que algo correu mal:

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

Mudar o tipo de um texto para um número

var cast = Number("97");

Isto tem um comportamento diferente dos métodos parse (embora ainda ignore espaços em branco). É mais rigoroso: se ele não entende toda a cadeia de caracteres do que devolve NaN, por isso não pode usá-lo para cadeias de caracteres como 97px. Uma vez que você quer um número primitivo em vez de um objeto de invólucro de Números, certifique-se de que você não coloca new na frente da função Número.

Obviamente, a conversão para um número dá-lhe um valor que pode ser um flutuador em vez de um inteiro, por isso, se quiser um inteiro, terá de o modificar. Há 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 bitwise (aqui eu fiz um bitwise ou, mas você também pode fazer o dobro a negação como em uma resposta anterior ou um bitshift) irá converter o valor para um inteiro de 32bit, e a maioria deles irá converter para um inteiro assinado. Note que este não vai querer que você queira para inteiros grandes . Se o inteiro não puder ser representado em 32bits, ele irá se envolver.

~~"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 trabalhar correctamente com números maiores, 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 estes métodos compreendem a notação exponencial, por isso 2e2 é 200 bastante do que a NaN. Além disso, o número compreende "infinito", enquanto os métodos de análise não.

Personalizado

Verifique sempre se a saída do número ou de um dos métodos de processamento é o tipo de número que você espera. Você quase certamente vai querer usar isNaN para se certificar de que o número não é NaN (normalmente a única maneira que você descobre que o parse falhou).

ParseInt () e + são diferentes

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

Uso esta forma de converter o texto para int número

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

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

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

Pode criar uma função simples de usar, por exemplo

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

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

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

O Double bitwise negative cai de qualquer coisa após o ponto decimal e converte-o para um formato de número. Disseram-me que é um pouco mais rápido do que chamar funções e outras coisas, mas não estou totalmente convencido.

Editar: outro método que acabei de veraqui (uma pergunta sobre o javascript > > > > operador, que é um turno à direita de preenchimento zero) que mostra que mudar um número por 0 com este operador converte o número para um uint32 o que é bom se também o quiser sem sinal. Mais uma vez, isto converte-se a um inteiro sem sinal, o que pode levar a comportamentos estranhos se usar um número assinado.

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

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

parseInt("5.6e-14") 

Resultará em

5 

Em vez de

0

Aqui há pouca comparação de Velocidade (apenas Mac Os)... :)

Pelo cromo 'mais' e ' mul 'são mais rápidos,' Math.floor' é mais lento (>700,000,00 op/s). Para o Firefox 'plus' é mais lento (!) 'mul' é o mais rápido (>900.000.000 op/s). Em Safari 'parseInt' é fastes, 'número' é mais lento (mas os resultados são bastante semelhantes, >13,000,000 ' :)

Podes passá-lo na tua navegador por esta ligação https://jsperf.com/casttonumber

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

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

Por favor, Veja em baixo example.It vai ajudar a limpar a sua dúvida

Example                  Result

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

Ao usar a função parseint só irá dar op de inteiro presente e não o texto

Para converter uma cadeia em Inteiro, eu recomendo usar parseFloat e NÃO parseInt. Eis o porquê:

Usar o parseFloat:

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

Usar o parseInt:

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

Por isso, se tiver notado que o parseInt descarta os valores após as casas decimais, enquanto o parseFloat lhe permite trabalhar com números de vírgula flutuante e, portanto, mais adequado se quiser manter os valores após as casas decimais. Usar o parseInt se e apenas se tiver a certeza que deseja o inteiro valor.

Podemos usar +(stringOfNumber) em vez de usar parseInt(stringOfNumber)

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

Podemos usar este operador unário " + " para analisar também o flutuador...

Tente str - 0 Converter string para 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 para int

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

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

Existem muitas maneiras em JavaScript para converter uma string para um valor de número... Tudo simples e prático, escolha a maneira que um trabalha 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

Também qualquer operaçãoMatemática converte-os 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

A minha maneira preferida é usar + sinal, que é a maneira elegante de converter uma cadeia de caracteres para número em JavaScript.

Eu realmente precisava "salvar" uma cadeia como um inteiro, para uma ligação entre C e JavaScript, então eu converto a cadeia 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 como processar um carro flutuante 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

Todos OS acima estão correctos. Por favor, certifique-se antes que este é um número em uma string, fazendo "typeot x === 'número'" outro sábio ele retornará nan

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

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

Outra opção é duplicar XOR o valor por si mesmo:

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

Isto irá resultar:

i = 12.34
i ⊕ i ⊕ i = 12

Eu uso este

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