Como verifico se um número é flutuante ou inteiro?

Como descobrir que um número é floatou integer?

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

verifique o restante ao dividir por 1:

function isInt(n) {
   return n % 1 === 0;
}

Se você não souber que o argumento é um número, precisará de dois testes:

function isInt(n){
    return Number(n) === n && n % 1 === 0;
}

function isFloat(n){
    return Number(n) === n && n % 1 !== 0;
}

Atualização 2019 5 anos após a redação desta resposta, uma solução foi padronizada no ECMA Script 2015. Essa solução é abordada nesta resposta .

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

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

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

Por que não algo assim:

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

Existe um método chamado Number.isInteger()que atualmente é implementado em tudo, menos no IE. O MDN também fornece um polyfill para outros navegadores:

Number.isInteger = Number.isInteger || function(value) {
  return typeof value === 'number' && 
    isFinite(value) && 
    Math.floor(value) === value;
};

No entanto, para a maioria dos casos de uso, é melhor usar o Number.isSafeInteger que também verifica se o valor é tão alto / baixo que qualquer casa decimal seria perdida de qualquer maneira. A MDN também possui um polilato. (Você também precisa do isIntegerpreenchimento de polly acima.)

if (!Number.MAX_SAFE_INTEGER) {
    Number.MAX_SAFE_INTEGER = 9007199254740991; // Math.pow(2, 53) - 1;
}
Number.isSafeInteger = Number.isSafeInteger || function (value) {
   return Number.isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER;
};

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 seu conteúdo é inteiro

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

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

Atualização 1

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

Aqui estão funções eficientes que verificam se o valor é um número ou pode ser convertido 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 números inteiros (retornaria false se o valor for um valor flutuante):

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

A eficiência aqui é que parseInt (ou parseNumber) é evitado quando o valor já é um número. As duas funções de análise sempre convertem primeiro em string e, em seguida, tentam analisar essa string, o que seria um desperdício se o valor já fosse um número.

Obrigado às outras postagens aqui por fornecer mais idéias para otimização!

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

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.

Como outros mencionados, você só tem duplas em JS. Então, como você define um número como um número 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); }

Que tal este?

isFloat(num) {
    return typeof num === "number" && !Number.isInteger(num);
}

Aqui está o que eu uso para números inteiros:

Math.ceil(parseFloat(val)) === val

Curto, legal :) Funciona o tempo todo. É o que David Flanagan sugere se não me engano.

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

Usando algo como Claudiu forneceu:

isInteger( 1.0 ) -> verdadeiro

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

Qualquer número flutuante com uma parte decimal zero (por exemplo, 1,0, 12,00, 0,0) é convertido implicitamente em Inteiro, portanto, não é possível verificar se eles são flutuantes ou não.

!!(24%1) // false
!!(24.2%1) // true

Realmente não precisa ser tão complicado. O valor numérico dos equivalentes parseFloat () e parseInt () de um número inteiro será o mesmo. Assim, você pode fazer o seguinte:

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 é rigoroso. Se quiser uma solução de tipo forte (ou seja, não funcionará com strings):

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

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

Não houve um caso em que isso não funcionou.

ESTE É O CÓDIGO FINAL PARA VERIFICAR INT E FLUTUAR

function isInt(n) { 
   if(typeof n == 'number' && Math.Round(n) % 1 == 0) {
       return true;
   } else {
       return false;
   }
} 

OU

function isInt(n) {   
   return typeof n == 'number' && Math.Round(n) % 1 == 0;   
}   

function isInteger(n) {
   return ((typeof n==='number')&&(n%1===0));
}

function isFloat(n) {
   return ((typeof n==='number')&&(n%1!==0));
}

function isNumber(n) {
   return (typeof n==='number');
}

É 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,0, não é mais um carro alegórico. É um número inteiro. Ou você pode simplesmente chamá-lo de "coisa numérica", pois não há distinção estrita como na época em C. Bons velhos tempos.

Então, basicamente, tudo o que você pode fazer é verificar se o número inteiro aceita o fato de que 1.000 é um número inteiro.

Nota lateral interessante

Houve um comentário sobre grandes números. Números enormes não significam problema para essa abordagem; sempre que parseInt for incapaz de manipular o número (por ser muito grande), ele retornará algo além do valor real; portanto, o teste retornará FALSE. Isso é bom porque se você considera algo um "número", 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 dessa maneira.

Tente o seguinte:

<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 está ok; b falha", o 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 :)

Esta 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>

Para números inteiros eu uso isso

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

No script java, todos os números são internally 64 bit floating pointiguais ao dobro do java. Não há tipos diferentes em javascript, todos são representados por tipo number. Portanto, você não poderá fazer uma instanceofverificação. No entanto, você pode usar as soluções acima fornecidas para descobrir se é um número fracionário. Os designers de scripts java sentiram com um único tipo que podem evitar inúmeros erros de conversão de tipos.

Algumas vezes, os objetos Number não permitem o uso direto do operador mod (%); se você estiver enfrentando esse caso, poderá usar esta solução.

if(object instanceof Number ){
   if( ((Number) object).doubleValue() % 1 == 0 ){
      //your object is an integer
   }
   else{
      //your object is a double
   }
}

Tentando algumas das respostas aqui, acabei escrevendo esta solução. Isso funciona também com números dentro de uma string.

function isInt(number) {
    if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
    return !(number - parseInt(number));
}

function isFloat(number) {
    if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
    return number - parseInt(number) ? true : false;
}

    var tests = {
        'integer' : 1,
        'float' : 1.1,
        'integerInString' : '5',
        'floatInString' : '5.5',
        'negativeInt' : -345,
        'negativeFloat' : -34.98,
        'negativeIntString' : '-45',
        'negativeFloatString' : '-23.09',
        'notValidFalse' : false,
        'notValidTrue' : true,
        'notValidString' : '45lorem',
        'notValidStringFloat' : '4.5lorem',
        'notValidNan' : NaN,
        'notValidObj' : {},
        'notValidArr' : [1,2],
    };

    function isInt(number) {
        if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
        return !(number - parseInt(number));
    }
    
    function isFloat(number) {
        if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
        return number - parseInt(number) ? true : false;
    }

    function testFunctions(obj) {
        var keys = Object.keys(obj);
        var values = Object.values(obj);

        values.forEach(function(element, index){
            console.log(`Is ${keys[index]} (${element}) var an integer? ${isInt(element)}`);
            console.log(`Is ${keys[index]} (${element}) var a float? ${isFloat(element)}`);
        });
    }

    testFunctions(tests);

Talvez isso não seja tão eficiente quanto a resposta%, o que impede que você precise converter para uma string primeiro, mas ainda não vi ninguém postá-la, então aqui está outra opção que deve funcionar bem:

function isInteger(num) {
    return num.toString().indexOf('.') === -1;
}

Para os curiosos, usando o Benchmark.js, testei as respostas mais votadas (e as postadas hoje) nesta publicação, eis os meus resultados:

var n = -10.4375892034758293405790;
var suite = new Benchmark.Suite;
suite
    // kennebec
    .add('0', function() {
        return n % 1 == 0;
    })
    // kennebec
    .add('1', function() {
        return typeof n === 'number' && n % 1 == 0;
    })
    // kennebec
    .add('2', function() {
        return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
    })

    // Axle
    .add('3', function() {
        return n.toString().indexOf('.') === -1;
    })

    // Dagg Nabbit
    .add('4', function() {
        return n === +n && n === (n|0);
    })

    // warfares
    .add('5', function() {
        return parseInt(n) === n;
    })

    // Marcio Simao
    .add('6', function() {
        return /^-?[0-9]+$/.test(n.toString());
    })

    // Tal Liron
    .add('7', function() {
        if ((undefined === n) || (null === n)) {
            return false;
        }
        if (typeof n == 'number') {
            return true;
        }
        return !isNaN(n - 0);
    });

// Define logs and Run
suite.on('cycle', function(event) {
    console.log(String(event.target));
}).on('complete', function() {
    console.log('Fastest is ' + this.filter('fastest').pluck('name'));
}).run({ 'async': true });

0 x 12,832,357 ops/sec ±0.65% (90 runs sampled)
1 x 12,916,439 ops/sec ±0.62% (95 runs sampled)
2 x 2,776,583 ops/sec ±0.93% (92 runs sampled)
3 x 10,345,379 ops/sec ±0.49% (97 runs sampled)
4 x 53,766,106 ops/sec ±0.66% (93 runs sampled)
5 x 26,514,109 ops/sec ±2.72% (93 runs sampled)
6 x 10,146,270 ops/sec ±2.54% (90 runs sampled)
7 x 60,353,419 ops/sec ±0.35% (97 runs sampled)

Fastest is 7 Tal Liron

Aqui está o meu código. Ele verifica se não é uma sequência vazia (que de outra forma passará) e depois a converte para o formato numérico. Agora, dependendo de você querer 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;

};

Eu gosto dessa pequena função, que retornará true para números inteiros positivos e negativos:

function isInt(val) {
    return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN(val+".0");
}

Isso funciona porque 1 ou "1" se torna "1.0", que éNaN () retorna falso em (que então negamos e retornamos), mas 1.0 ou "1.0" se torna "1.0.0", enquanto "string" se torna "string". 0 ", nenhum dos quais são números, então isNaN () retorna falso (e, novamente, é negado).

Se você deseja apenas números inteiros positivos, existe esta variante:

function isPositiveInt(val) {
    return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN("0"+val);
}

ou, para números inteiros negativos:

function isNegativeInt(val) {
    return `["string","number"].indexOf(typeof(val)) > -1` && val !== '' && isNaN("0"+val);
}

isPositiveInt () funciona movendo a seqüência numérica concatenada à frente do valor a ser testado. Por exemplo, isPositiveInt (1) resulta em isNaN () avaliando "01", que avalia falso. Enquanto isso, isPositiveInt (-1) resulta em isNaN () avaliando "0-1", que avalia true. Negamos o valor de retorno e isso nos dá o que queremos. isNegativeInt () funciona de maneira semelhante, mas sem negar o valor de retorno de isNaN ().

Editar:

Minha implementação original também retornaria true em matrizes e seqüências de caracteres vazias. Esta implementação não possui esse defeito. Ele também tem o benefício de retornar mais cedo se val não for uma sequência ou número ou se for uma sequência vazia, tornando-o mais rápido nesses casos. Você pode modificá-lo ainda mais, substituindo as duas primeiras cláusulas por

typeof(val) != "number"

se você quiser apenas combinar números literais (e não cadeias)

Editar:

Ainda não posso postar comentários, então estou adicionando isso à minha resposta. A referência postada por @Asok é muito informativa; no entanto, a função mais rápida não se encaixa nos requisitos, pois também retorna TRUE para flutuadores, matrizes, booleanos e cadeias vazias.

Criei o seguinte conjunto de testes para testar cada uma das funções, adicionando também minha resposta à lista (função 8, que analisa seqüências de caracteres, e função 9, que não):

funcs = [
    function(n) {
        return n % 1 == 0;
    },
    function(n) {
        return typeof n === 'number' && n % 1 == 0;
    },
    function(n) {
        return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
    },
    function(n) {
        return n.toString().indexOf('.') === -1;
    },
    function(n) {
        return n === +n && n === (n|0);
    },
    function(n) {
        return parseInt(n) === n;
    },
    function(n) {
        return /^-?[0-9]+$/.test(n.toString());
    },
    function(n) {
        if ((undefined === n) || (null === n)) {
            return false;
        }
        if (typeof n == 'number') {
            return true;
        }
        return !isNaN(n - 0);
    },
    function(n) {
        return ["string","number"].indexOf(typeof(n)) > -1 && n !== '' && !isNaN(n+".0");
    }
];
vals = [
    [1,true],
    [-1,true],
    [1.1,false],
    [-1.1,false],
    [[],false],
    [{},false],
    [true,false],
    [false,false],
    [null,false],
    ["",false],
    ["a",false],
    ["1",null],
    ["-1",null],
    ["1.1",null],
    ["-1.1",null]
];

for (var i in funcs) {
    var pass = true;
    console.log("Testing function "+i);
    for (var ii in vals) {
        var n = vals[ii][0];
        var ns;
        if (n === null) {
            ns = n+"";
        } else {
            switch (typeof(n)) {
                case "string":
                    ns = "'" + n + "'";
                    break;
                case "object":
                    ns = Object.prototype.toString.call(n);
                    break;
                default:
                    ns = n;
            }
            ns = "("+typeof(n)+") "+ns;
        }

        var x = vals[ii][1];
        var xs;
        if (x === null) {
            xs = "(ANY)";
        } else {
            switch (typeof(x)) {
                case "string":
                    xs = "'" + n + "'";
                    break;
                case "object":
                    xs = Object.prototype.toString.call(x);
                    break;
                default:
                    xs = x;
            }
            xs = "("+typeof(x)+") "+xs;
        }

        var rms;
        try {
            var r = funcs[i](n);
            var rs;
            if (r === null) {
                rs = r+"";
            } else {
                switch (typeof(r)) {
                    case "string":
                        rs = "'" + r + "'";
                        break;
                    case "object":
                        rs = Object.prototype.toString.call(r);
                        break;
                    default:
                        rs = r;
                }
                rs = "("+typeof(r)+") "+rs;
            }

            var m;
            var ms;
            if (x === null) {
                m = true;
                ms = "N/A";
            } else if (typeof(x) == 'object') {
                m = (xs === rs);
                ms = m;
            } else {
                m = (x === r);
                ms = m;
            }
            if (!m) {
                pass = false;
            }
            rms = "Result: "+rs+", Match: "+ms;
        } catch (e) {
            rms = "Test skipped; function threw exception!"
        }

        console.log("    Value: "+ns+", Expect: "+xs+", "+rms);
    }
    console.log(pass ? "PASS!" : "FAIL!");
}

Também refiz a referência com a função # 8 adicionada à lista. Não publicarei o resultado, pois eles são um pouco embaraçosos (por exemplo, essa função NÃO é rápida) ...

Os resultados (resumidos - removi testes bem-sucedidos, pois a saída é bastante longa) são os seguintes:

Testing function 0
Value: (object) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) false, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: null, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
FAIL!

Testing function 1
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 2
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 3
Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (object) false, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: null, Expect: (boolean) false, Test skipped; function threw exception!
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) 'a', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
FAIL!

Testing function 4
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 5
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 6
Value: null, Expect: (boolean) false, Test skipped; function threw exception!
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 7
Value: (number) 1.1, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (number) -1.1, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) true, Match: N/A
FAIL!

Testing function 8
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 9
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Eu deixei falhas para que você possa ver onde cada função está falhando, e o (string) '#' testa para que você possa ver como cada função lida com valores inteiros e flutuantes em strings, pois alguns podem querer que eles sejam analisados ​​como números e alguns não deve.

Das 10 funções testadas, as que realmente atendem aos requisitos do OP são [1,3,5,6,8,9]

Condição para validação flutuante:

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

Condição para validação de número inteiro:

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 desejar excluir cadeias de caracteres.