Come posso verificare che un numero sia float o intero?

Come scoprire che un numero è floato integer?

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

cerca un resto quando dividi per 1:

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

Se non sai che l'argomento è un numero, hai bisogno di due test:

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

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

Aggiornamento 2019 5 anni dopo la stesura di questa risposta, una soluzione è stata standardizzata in ECMA Script 2015. Tale soluzione è trattata in questa risposta .

Prova queste funzioni per verificare se un valore è un valore primitivo numerico che non ha una parte frazionaria e rientra nei limiti di dimensione di ciò che può essere rappresentato come un intero esatto.

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

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

Perché non qualcosa del genere:

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

C'è un metodo chiamato Number.isInteger()che è attualmente implementato in tutto tranne IE. MDN fornisce anche un polyfill per altri browser:

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

Tuttavia, per la maggior parte dei casi di utilizzo, è meglio utilizzare, Number.isSafeInteger che controlla anche se il valore è così alto / basso che eventuali cifre decimali sarebbero andate perse comunque. MDN ha un polyfil anche per questo. (Hai anche bisogno del isIntegerpollyfill sopra.)

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;
};

Puoi usare una semplice espressione regolare:

function isInt(value) {

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

    return er.test(value);
}

Oppure puoi usare anche le seguenti funzioni, in base alle tue esigenze. Sono sviluppati dal progetto PHPJS .

is_int() => Controlla se il tipo di variabile è intero e se il suo contenuto è intero

is_float() => Controlla se il tipo di variabile è float e se il suo contenuto è float

ctype_digit() => Controlla se il tipo di variabile è stringa e se il suo contenuto ha solo cifre decimali

Aggiornamento 1

Ora controlla anche i numeri negativi, grazie per il commento di @ChrisBartley !

Ecco alcune funzioni efficienti che controllano se il valore è un numero o possono essere convertiti in modo sicuro in un numero:

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

E per i numeri interi (restituirebbe false se il valore è float):

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

L'efficienza qui è che parseInt (o parseNumber) vengono evitati quando il valore è già un numero. Entrambe le funzioni di analisi sempre convertite prima in stringa e quindi tentano di analizzare quella stringa, il che sarebbe uno spreco se il valore è già un numero.

Grazie agli altri post qui per aver fornito ulteriori idee per l'ottimizzazione!

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;
}

funziona per tutti i casi.

Come altri hanno già detto, hai solo doppie in JS. Quindi, come si definisce un numero intero? Basta controllare se il numero arrotondato è uguale a se stesso:

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

Che ne dici di questo?

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

Ecco cosa uso per i numeri interi:

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

Breve, carino :) Funziona sempre. Questo è ciò che David Flanagan suggerisce se non sbaglio.

Dipende davvero da cosa vuoi ottenere. Se vuoi "emulare" lingue fortemente tipizzate, allora ti suggerisco di non provarci. Come altri hanno già detto, tutti i numeri hanno la stessa rappresentazione (lo stesso tipo).

Utilizzando qualcosa come Claudiu fornito:

isInteger( 1.0 ) -> vero

che sembra buono per il senso comune, ma in qualcosa come C si otterrebbe false

Qualsiasi numero Float con una parte decimale zero (ad es. 1.0, 12.00, 0.0) viene implicitamente trasmesso a Integer, quindi non è possibile verificare se sono Float o meno.

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

Non deve essere così complicato. Il valore numerico degli equivalenti parseFloat () e parseInt () di un numero intero sarà lo stesso. Quindi puoi fare così:

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

Poi

if (isInt(x)) // do work

Ciò consentirà anche il controllo delle stringhe e quindi non è rigoroso. Se vuoi una soluzione di tipo forte (aka, non funzionerà con le stringhe):

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

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

Non ho avuto un caso in cui questo non ha funzionato.

QUESTO È IL CODICE FINALE PER CONTROLLARE SIA INT E GALLEGGIANTE

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

O

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');
}

È semplice come:

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

Prova questo in 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!

Questo confonde molte persone. Ogni volta che qualcosa è 0, non è più un float. È un numero intero. Oppure puoi semplicemente chiamarlo "una cosa numerica" ​​perché non esiste una distinzione rigorosa come allora in C. Bei vecchi tempi.

Quindi, fondamentalmente, tutto ciò che puoi fare è controllare il numero intero accettando il fatto che 1.000 è un numero intero.

Nota a margine interessante

C'è stato un commento su numeri enormi. Numeri enormi non significano NESSUN problema per questo approccio; ogni volta che parseInt non è in grado di gestire il numero (perché è troppo grande) restituirà qualcos'altro rispetto al valore effettivo, quindi il test restituirà FALSE. Questa è una buona cosa perché se consideri qualcosa come un "numero" normalmente ti aspetti che JS sia in grado di calcolare con esso - quindi sì, i numeri sono limitati e analizzeremo questo , per metterlo in questo modo.

Prova questo:

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

Nel mio browser (IE8) questo restituisce "a is ok; b fail" che è esattamente a causa dell'enorme numero in b. Il limite può variare ma immagino che 20 cifre "dovrebbero essere sufficienti per chiunque", per citare un classico :)

Questa soluzione ha funzionato per me.

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

Per i numeri interi uso questo

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

Nello script java tutti i numeri sono internally 64 bit floating pointuguali al doppio in java. Non ci sono tipi diversi in JavaScript, tutti sono rappresentati dal tipo number. Quindi non sarai in grado di fare un instanceofcontrollo. Tuttavia puoi utilizzare le soluzioni sopra riportate per scoprire se si tratta di un numero frazionario. i progettisti di script Java hanno sentito con un solo tipo che possono evitare numerosi errori di cast di tipo.

Alcune volte gli oggetti numerici non ti consentono di utilizzare direttamente l'operatore mod (%), se ti trovi di fronte a quel caso puoi usare questa soluzione.

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

Cercando alcune delle risposte qui ho finito per scrivere questa soluzione. Funziona anche con numeri all'interno di una stringa.

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);

Questo forse non è performante come la risposta%, che ti impedisce di convertirti prima in una stringa, ma non ho ancora visto nessuno pubblicarlo, quindi ecco un'altra opzione che dovrebbe funzionare bene:

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

Per i curiosi, usando Benchmark.js ho testato le risposte più votate (e quella pubblicata oggi) su questo post, ecco i miei risultati:

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

Ecco il mio codice Verifica che non sia una stringa vuota (che altrimenti passerà) e quindi la converte in formato numerico. Ora, a seconda che tu voglia che "1.1" sia uguale a 1.1, questo potrebbe essere o meno quello che stai cercando.

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;

};

Mi piace questa piccola funzione, che tornerà vera sia per gli interi positivi che per quelli negativi:

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

Questo funziona perché 1 o "1" diventa "1.0", che isNaN () restituisce false su (che quindi neghiamo e restituiamo), ma 1.0 o "1.0" diventa "1.0.0", mentre "stringa" diventa "stringa. 0 ", nessuno dei quali sono numeri, quindi isNaN () restituisce false (e, di nuovo, viene negato).

Se vuoi solo numeri interi positivi, c'è questa variante:

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

oppure, per numeri interi negativi:

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

isPositiveInt () funziona spostando la stringa numerica concatenata davanti al valore da testare. Ad esempio, isPositiveInt (1) risulta in isNaN () che valuta "01", che valuta false. Nel frattempo, isPositiveInt (-1) risulta in isNaN () che valuta "0-1", che valuta vero. Neghiamo il valore di ritorno e questo ci dà ciò che vogliamo. isNegativeInt () funziona in modo simile, ma senza negare il valore restituito di isNaN ().

Modificare:

La mia implementazione originale ritornerebbe vera anche su array e stringhe vuote. Questa implementazione non ha questo difetto. Ha anche il vantaggio di tornare presto se val non è una stringa o un numero o se è una stringa vuota, rendendola più veloce in questi casi. Puoi modificarlo ulteriormente sostituendo le prime due clausole con

typeof(val) != "number"

se vuoi solo abbinare numeri letterali (e non stringhe)

Modificare:

Non posso ancora pubblicare commenti, quindi lo sto aggiungendo alla mia risposta. Il benchmark pubblicato da @Asok è molto informativo; tuttavia, la funzione più veloce non soddisfa i requisiti, poiché restituisce anche VERO per float, array, booleani e stringhe vuote.

Ho creato la seguente suite di test per testare ciascuna delle funzioni, aggiungendo anche la mia risposta all'elenco (funzione 8, che analizza le stringhe e funzione 9, che non lo fa):

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!");
}

Ho anche eseguito nuovamente il benchmark con la funzione # 8 aggiunta all'elenco. Non pubblicherò il risultato, in quanto sono un po 'imbarazzanti (ad es. Quella funzione NON è veloce) ...

I risultati (abbreviati - ho rimosso i test riusciti, poiché l'output è piuttosto lungo) sono i seguenti:

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!

Ho lasciato degli errori in modo da poter vedere dove fallisce ogni funzione, e il test (#) 'stringa' in modo da poter vedere come ogni funzione gestisce valori interi e float nelle stringhe, poiché alcuni potrebbero volerli analizzati come numeri e alcuni non può.

Delle 10 funzioni testate, quelle che soddisfano effettivamente i requisiti di OP sono [1,3,5,6,8,9]

Condizione per la convalida mobile:

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

Condizione per la convalida di numeri interi:

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

Spero che questo possa essere utile.

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

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

È possibile aggiungere typeof a === 'number'se si desidera escludere le stringhe.