Converter uma string em um número inteiro?
https://stackoverflow.com/questions/1133770
-
16-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Como converto uma string em um número inteiro em JavaScript?
Solução
A maneira mais simples seria usar o nativo Number função:
var x = Number("1000")
Se isso não funcionar para você, então há o parseint, unário mais, Parsefloat com piso, e Math.Round métodos.
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 Plus se sua string já estiver na forma de um número inteiro:
var x = +"1000";
Se sua string for ou pode ser um flutuador e você deseja um número inteiro:
var x = Math.floor("1000.01"); //floor automatically converts string to number
Ou, se você vai usar o Math.Floor várias vezes:
var floor = Math.floor;
var x = floor("1000.01");
Se você é do tipo que esquece de colocar o Radix quando chama o Parseint, pode usar o Parsefloat e contorná -lo como quiser. Aqui eu uso o piso.
var floor = Math.floor;
var x = floor(parseFloat("1000.01"));
É interessante
var round = Math.round;
var x = round("1000"); //equivalent to round("1000",0)
Outras dicas
Experimente 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, você precisará especificar um Radix (de 2 para 36). Neste caso, base 10.
parseInt(string, radix)
Exemplo:
var result = parseInt("010", 10) == 10; // Returns true
var result = parseInt("010") == 10; // Returns false
Observe que parseInt Ignora dados ruins depois de analisar qualquer coisa válida.
Este GUID irá analisar 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 de outra maneira é alterar seu tipo para um número. Todos os truques nas outras respostas (por exemplo, unários) envolvem implicitamente coagir o tipo de string a um número. Você também pode fazer a mesma coisa explicitamente com a função numérica.
Análise
var parsed = parseInt("97", 10);
Parseint e Parsefloat são as duas funções usadas para analisar strings em números. A análise irá parar silenciosamente se atingir um personagem que não reconhece, o que pode ser útil para analisar cordas como "92px", mas também é um pouco perigoso, pois não lhe dará nenhum tipo de erro na entrada ruim, em vez disso, você 'Return Nan, a menos que a string comece com um número. O espaço em branco no início da string é ignorado. Aqui está um exemplo disso fazendo algo diferente do que você deseja e não dando nenhuma indicação de que algo deu errado:
var widgetsSold = parseInt("97,800", 10); // widgetsSold is now 97
É uma boa prática sempre especificar o Radix como o segundo argumento. Nos navegadores mais antigos, se a string começasse com 0, ela seria interpretada como octal se o Radix não fosse especificado, o que pegou muitas pessoas de surpresa. O comportamento para hexadecimal é desencadeado com o início da string com 0x se nenhum Radix for especificado, por exemplo 0xff. O padrão realmente mudou com o ECMAScript 5; portanto, os navegadores modernos não desencadeiam mais octal quando houver um líder 0 se nenhum Radix foi especificado. Parseint entende as radixes até a base 36, caso em que as letras superiores e minúsculas são tratadas como equivalentes.
Alterando o tipo de string para um número
Todos os outros truques mencionados acima que não usam o Parseint envolvem implicitamente coagir a string em um número. Eu prefiro fazer isso explicitamente,
var cast = Number("97");
Isso tem um comportamento diferente dos métodos parse (embora ainda ignore o espaço em branco). É mais rigoroso: se não entende toda a corda do que retorna NaN, então você não pode usá -lo para cordas como 97px. Como você deseja um número primitivo em vez de um objeto numérico, verifique se você não coloca new na frente da função numérica.
Obviamente, a conversão para um número fornece um valor que pode ser um flutuador e não 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 bitwise (aqui eu fiz um pouco ou, mas você também pode fazer uma dupla negação como em uma resposta anterior ou um desvio de bits) converterá o valor em um número inteiro de 32 bits, e a maioria deles se converterá a um número inteiro assinado. Observe que isso não vai querer que você queira para inteiros grandes. Se o número inteiro não puder ser representado em 32bits, ele será envolvido.
~~"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 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"))
Lembre -se de que todos esses métodos entendem a notação exponencial, então 2e2 é 200 em vez de nan. Além disso, o número entende "infinito", enquanto os métodos de Parse não.
Personalizado
É improvável que qualquer um desses métodos faça exatamente o que você deseja. Por exemplo, geralmente eu gostaria de um erro lançado se a análise falhar, e não preciso de suporte para o infinito, exponenciais ou espaço em branco. Dependendo da sua USECASE, às vezes faz sentido escrever uma função de conversão personalizada.
Sempre verifique se a saída do número ou um dos métodos Parse é o tipo de número que você espera. Você quase certamente vai querer usar isNaN Para 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 uma pergunta antiga, mas talvez isso possa ser útil para alguém.
Eu uso essa maneira de converter string para int número
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 o 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 função simples de usar, por exemplo
function toNumber(str) {
return str*1;
}
Experimente o Parseint.
var number = parseInt("10", 10); //number will have value of 10.
O mais rápido
var x = "1000"*1;
Teste
Aqui está pouca comparação de velocidade (somente Mac OS) ... :)
Para o Chrome 'Plus' e 'Mul' são mais rápidos (> 700.000,00 op/s), 'Math.floor' é mais lento. Para o Firefox 'plus' é mais lento (!) 'Mul' é mais rápido (> 900.000.000 de op/s). No safari 'parseint' é jejues, o 'número' é mais lento (mas os resultados são bastante semelhantes,> 13.000.000 <31.000.000). Portanto, o safari para a corda fundida para int é mais de 10x mais lento que outros navegadores. Então o vencedor é 'mul' :)
Você pode executá -lo no seu navegador por este linkhttps://jsperf.com/js-cast-tr-to-number/1
Atualizar
Eu também testo var x = ~~"1000"; - no Chrome e Safari é um pouco mais lento do que var x = "1000"*1 (<1%), no Firefox é um pouco mais rápido (<1%). Eu atualizo a imagem e teste acima
Eu postei a resposta errada aqui, desculpe. fixo.
Esta é uma pergunta antiga, mas eu amo esse truque:
~~"2.123"; //2
~~"5"; //5
O duplo negativo bit -bit -in qualquer coisa após o ponto decimal e o converte em um formato numérico. Disseram -me que é um pouco mais rápido do que chamar funções e outros enfeites, mas não estou totalmente convencido.
Editar: Outro método que acabei de ver aqui (Uma pergunta sobre o operador JavaScript >>>, que é uma mudança 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 você também quiser não assinado. Novamente, isso se converte para um 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 o Parseint para converter um flutuador na notação científica! Por exemplo:
parseInt("5.6e-14")
vai resultar em
5
ao invés de
0
Também como uma nota lateral: Mootools tem a função toint () que é usada em qualquer string nativa (ou flutuação (ou número inteiro)).
"2".toInt() // 2
"2px".toInt() // 2
2.toInt() // 2
Para converter uma string em número inteiro, eu recomendo usar parsefloat e NÃO 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 o Parseint descarta os valores após os decimais, enquanto o Parsefloat permite que você trabalhe com números de ponto flutuante e, portanto, mais adequado se você quiser reter os valores após decimais. Use o Parseint se e somente se tiver certeza de que deseja o valor inteiro.
Por favor, veja o exemplo abaixo. Isso ajudará a limpar 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, ele só dará o op de inteiro presente e não a string
podemos usar +(stringOfNumber) ao invés de usar parseInt(stringOfNumber)
Ex: +("21") retorna int de 21 como o parseInt("21").
Podemos usar este operador unário "+" para analisar também ...
Tentar 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
Existem muitas maneiras de JavaScript para converter uma string em um valor numérico ... tudo simples e útil, escolha a maneira como alguém 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
Também qualquer Matemática a operação 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
Meu caminho preferido está usando + sinal, que é a maneira elegante de converter uma string em número em JavaScript.
Na minha opinião, nenhuma resposta abrange todos os casos de borda, pois analisar 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
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 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;
}
Todos os acima estão corretos. Certifique -se de que antes disso é um número em uma string fazendo "typeot x === 'número'" Outros sábios, ele retornará NAN
var num = "fsdfsdf242342";
typeof num => 'string';
var num1 = "12423";
typeof num1 => 'number';
+num1 = > 12423`
Outra opção é dobrar o xorar o valor consigo mesmo:
var i = 12.34;
console.log('i = ' + i);
console.log('i ⊕ i ⊕ i = ' + (i ^ i ^ i));
Isso será lançado:
i = 12.34
i ⊕ i ⊕ i = 12
function doSth(){
var a = document.getElementById('input').value;
document.getElementById('number').innerHTML = toNumber(a) + 1;
}
function toNumber(str){
return +str;
}<input id="input" type="text">
<input onclick="doSth()" type="submit">
<span id="number"></span>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 int de volta.
Eu só adicionei um mais (+) antes da string e essa foi a solução!
+"052254" //52254
Espero que ajude ;)
Resumindo a multiplicação de dígitos com seu respectivo poder de dez:
isto é: 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;
}
Aqui está a solução mais fácil
let myNumber = "123" | 0;
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);
}
