Respostas:
A maneira mais simples seria usar a Number
funçã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)
'4'>>0
e '4'>>>0
.
parseInt
e parseFloat
alegremente aceita cartas. Number
Retorna apenas NaN
consistentemente.
NaN
para cada valor que não seja exatamente um número inteiro. Portanto nenhum desses funcionar como Number('2.2')
coage a 2
e Number('')
coagir a 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 parseInt
ignora 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
parseInt('0asdf', 10)
produz 0
.
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 new
na 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
é 200
melhor 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 isNaN
para garantir que o número não seja NaN (geralmente a única maneira de descobrir que a análise falhou).
97,8,00
e similar ou não. Um truque simples é fazer um .replace(/[^0-9]/g, "")
que removerá todos os dígitos não da sua string e, depois, fará a conversão. Isto naturalmente irá ignorar todos os tipos de cordas loucas que você provavelmente deve erro em vez de apenas parse ...
.replace(/[^0-9.]/g, "")
, caso contrário "1.05" se tornará "105".
var fixed = Number("97.654").toFixed(0); // rounded rather than truncated
, estamos recebendo um string
(por causa do .toFixed
método) em vez de um number
(número inteiro). Se queremos que o número inteiro arredondado provavelmente é melhor usar apenasMath.round("97.654");
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;
}
var x = "1000"*1;
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
parseInt
não funcionaria corretamente para um flutuador. parseFloat
funciona corretamente neste caso.
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
SyntaxError
, você deve usar um ponto duplo, por exemplo: 2..toInt();
o primeiro ponto encerrará a representação de um Number
literal e o segundo ponto é o acessador da propriedade.
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 ...
+
?
parseInt
é. Uma implementação comum é const myNumber = +myNumberAsAString
semelhante a um padrão +=
ou =+
operador à primeira vista. Além disso, se usado incorretamente, pode levar a erros de concatenação. Essa solução é baseada no fato de que 0 é assumido como o lado esquerdo quando nenhum número é fornecido.
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 em int
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;
}
int2str
função será interrompida se um byte for 0, que pode ser um elemento legítimo dentro do valor, portanto o if
... break
deve ser removido para que você retorne um valor completo de 4 bytes.
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
parseInteger
, não parseNumber
. Eu acho que todas as soluções são uma solução alternativa, já que o JS não suporta números inteiros e flutuantes como tipos separados. Poderíamos retornar em null
vez de NaN
, se Not A Number for enganoso.
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`
var num1 = "12423"; typeof num1;
retorna string
.
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;
}
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>
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