javascript - vantagens - regime de flutuação suja




Como posso verificar se um número é flutuante ou inteiro? (20)

É simples como:

if( n === parseInt(n) ) ...

Tente isso no console:

x=1;
x===parseInt(x); // true
x="1";
x===parseInt(x); // false
x=1.1;
x===parseInt(x); // false, obviously

// BUT!

x=1.0;
x===parseInt(x); // true, because 1.0 is NOT a float!

Isso confunde muita gente. Sempre que algo é 0, não é mais um float. É um inteiro. Ou você pode simplesmente chamá-lo de "uma coisa numérica", pois não há distinção estrita como na época em C. Bons velhos tempos.

Então, basicamente, tudo que você pode fazer é checar por inteiro aceitando o fato de que 1.000 é um inteiro.

Nota lateral interessante

Houve um comentário sobre números enormes. Números enormes significam nenhum problema para essa abordagem; sempre que parseInt for incapaz de manipular o número (pois é muito grande), ele retornará algo diferente do valor real para que o teste retorne FALSE. Isso é bom porque se você considera algo como um "número" que você normalmente espera que o JS possa calcular com ele - então sim, os números são limitados e o parseInt levará isso em consideração , para colocar desta forma.

Tente isto:

<script>

var a = 99999999999999999999;
var b = 999999999999999999999; // just one more 9 will kill the show!
var aIsInteger = (a===parseInt(a))?"a is ok":"a fails";
var bIsInteger = (b===parseInt(b))?"b is ok":"b fails";
alert(aIsInteger+"; "+bIsInteger);

</script>

No meu navegador (IE8) isso retorna "a é ok; b falha", que é exatamente por causa do grande número em b. O limite pode variar, mas acho que 20 dígitos "devem ser suficientes para qualquer um", para citar um clássico :)

Como descobrir que um número é float ou integer ?

1.25 --> float  
1 --> integer  
0 --> integer  
0.25 --> float

Aqui está meu código. Ele verifica para certificar-se de que não é uma seqüência vazia (que caso contrário passará) e, em seguida, converte para o formato numérico. Agora, dependendo se você quer que '1.1' seja igual a 1.1, isso pode ou não ser o que você está procurando.

var isFloat = function(n) {
    n = n.length > 0 ? Number(n) : false;
    return (n === parseFloat(n));
};
var isInteger = function(n) {
    n = n.length > 0 ? Number(n) : false;
    return (n === parseInt(n));
};

var isNumeric = function(n){

   if(isInteger(n) || isFloat(n)){
        return true;
   }
   return false;

};

Aqui estão funções eficientes que verificam se o valor é um número ou podem ser convertidas com segurança em um número:

function isNumber(value) {
    if ((undefined === value) || (null === value)) {
        return false;
    }
    if (typeof value == 'number') {
        return true;
    }
    return !isNaN(value - 0);
}

E para inteiros (retornaria false se o valor fosse float):

function isInteger(value) {
    if ((undefined === value) || (null === value)) {
        return false;
    }
    return value % 1 == 0;
}

A eficiência aqui é que parseInt (ou parseNumber) são evitados quando o valor já é um número. Ambas as funções de análise sempre convertem para string primeiro e depois tentam analisar essa string, o que seria um desperdício se o valor já for um número.

Obrigado aos outros posts aqui por fornecer mais ideias para otimização!


Como outros mencionaram, você só tem dobra em JS. Então, como você define um número como sendo um inteiro? Basta verificar se o número arredondado é igual a si mesmo:

function isInteger(f) {
    return typeof(f)==="number" && Math.round(f) == f;
}
function isFloat(f) { return typeof(f)==="number" && !isInteger(f); }

Essa solução funcionou para mim.

<html>
<body>
  <form method="post" action="#">
    <input type="text" id="number_id"/>
    <input type="submit" value="send"/>
  </form>
  <p id="message"></p>
  <script>
    var flt=document.getElementById("number_id").value;
    if(isNaN(flt)==false && Number.isInteger(flt)==false)
    {
     document.getElementById("message").innerHTML="the number_id is a float ";
    }
   else 
   {
     document.getElementById("message").innerHTML="the number_id is a Integer";
   }
  </script>
</body>
</html>

Eu escrevi função que aceita strings (se alguém precisar)

function isInt(x) {
    return !isNaN(x) && eval(x).toString().length == parseInt(eval(x)).toString().length
}

function isFloat(x) {
    return !isNaN(x) && !isInt(eval(x)) && x.toString().length > 0
}

exemplo ouptuts:

console.log(isFloat('0.2'))  // true
console.log(isFloat(0.2))    // true
console.log(isFloat('.2'))   // true
console.log(isFloat('-.2'))  // true
console.log(isFloat(-'.2'))  // true
console.log(isFloat(-.2))    // true
console.log(isFloat('u.2'))  // false
console.log(isFloat('2'))    // false
console.log(isFloat('0.2u')) // false

console.log(isInt('187'))  // true
console.log(isInt(187))    // true
console.log(isInt('1.2'))  // false
console.log(isInt('-2'))   // true
console.log(isInt(-'1'))   // true
console.log(isInt('10e1')) // true
console.log(isInt(10e1))   // true

Existe um método chamado Number.isInteger() que atualmente é implementado apenas no Firefox mais recente e ainda faz parte da proposta do EcmaScript 6. No entanto, o MDN fornece um polyfill para os outros navegadores, que corresponde ao especificado na harmonia do ECMA:

if (!Number.isInteger) {
  Number.isInteger = function isInteger (nVal) {
    return typeof nVal === "number" && isFinite(nVal) && nVal > -9007199254740992 && nVal < 9007199254740992 && Math.floor(nVal) === nVal;
  };
}

Isso realmente depende do que você deseja alcançar. Se você quiser "emular" idiomas fortemente tipados, sugiro que não tente. Como outros mencionaram, todos os números têm a mesma representação (o mesmo tipo).

Usando algo como Claudiu fornecido:

isInteger( 1.0 ) -> verdadeiro

que parece bom para o senso comum, mas em algo como C você teria false


Não precisa ser tão complicado. O valor numérico dos equivalentes parseFloat () e parseInt () de um inteiro será o mesmo. Assim você pode fazer assim:

function isInt(value){ 
    return (parseFloat(value) == parseInt(value)) && !isNaN(value);
}

Então

if (isInt(x)) // do work

Isso também permitirá verificações de string e, portanto, não é estrito. Se quiser uma solução de tipo forte (não funciona com strings):

function is_int(value){ return !isNaN(parseInt(value * 1) }

No script java, todos os números são internally 64 bit floating point , o mesmo que o dobro em java. Não existem tipos diferentes no javascript, todos são representados pelo number tipo. Portanto, você não poderá fazer um teste de verificação. No entanto, você pode usar as soluções acima fornecidas para descobrir se é um número fracionário. Os designers do script java sentiram com um único tipo que podem evitar vários erros de conversão de tipo.


Para inteiros eu uso isso

function integer_or_null(value) {
    if ((undefined === value) || (null === value)) {
        return null;
    }
    if(value % 1 != 0) {
        return null;
    }
    return value;
}

Por que não algo assim:

var isInt = function(n) { return parseInt(n) === n };

Tente estas funções para testar se um valor é um valor primitivo de número que não tem parte fracionária e está dentro dos limites de tamanho do que pode ser representado como um inteiro exato.

function isFloat(n) {
    return n === +n && n !== (n|0);
}

function isInteger(n) {
    return n === +n && n === (n|0);
}

Você pode usar uma expressão regular simples:

function isInt(value) {

    var er = /^-?[0-9]+$/;

    return er.test(value);
}

Ou você também pode usar as funções abaixo, de acordo com suas necessidades. Eles são desenvolvidos pelo Projeto PHPJS .

is_int() => Verifique se o tipo de variável é inteiro e se o seu conteúdo é inteiro

is_float() => Verifique se o tipo de variável é float e se o seu conteúdo é float

is_float() => Verifique se o tipo de variável é string e se seu conteúdo tem apenas dígitos decimais

Atualização 1

Agora também verifica números negativos, obrigado pelo comentário @ChrisBartley !


YourJS oferece as seguintes duas funções que trabalham para todos os números, incluindo o retorno falsepara -Infinitye Infinity:

function isFloat(x) {
  return typeOf(x, 'Number') && !!(x % 1);
}

function isInt(x) {
  return typeOf(x, 'Number') && x % 1 == 0;
}

Devido ao fato de que typeOf()é uma função interna do YourJS, se você quiser usar essas definições, você pode baixar a versão para apenas estas funções aqui: http://yourjs.com/snippets/build/34


Condição para validação flutuante:

if (lnk.value == +lnk.value && lnk.value != (lnk.value | 0)) 

Condtion para Validação Integer:

if (lnk.value == +lnk.value && lnk.value == (lnk.value | 0)) 

Espero que isso possa ser útil.


function int(a) {
  return a - a === 0 && a.toString(32).indexOf('.') === -1
}

function float(a) {
  return a - a === 0 && a.toString(32).indexOf('.') !== -1
}

Você pode adicionar typeof a === 'number'se quiser excluir strings.


function isInt(n) 
{
    return n != "" && !isNaN(n) && Math.round(n) == n;
}
function isFloat(n){
    return n != "" && !isNaN(n) && Math.round(n) != n;
}

funciona para todos os casos.


function isInteger(x) { return typeof x === "number" && isFinite(x) && Math.floor(x) === x; }
function isFloat(x) { return !!(x % 1); }

// give it a spin

isInteger(1.0);        // true
isFloat(1.0);          // false
isFloat(1.2);          // true
isInteger(1.2);        // false
isFloat(1);            // false
isInteger(1);          // true    
isFloat(2e+2);         // false
isInteger(2e+2);       // true
isFloat('1');          // false
isInteger('1');        // false
isFloat(NaN);          // false
isInteger(NaN);        // false
isFloat(null);         // false
isInteger(null);       // false
isFloat(undefined);    // false
isInteger(undefined);  // false

var isInt = function (n) { return n === (n | 0); };

Não tive um caso em que isso não funcionasse.







numbers