¿Cómo verifico que un número sea flotante o entero?

¿Cómo encontrar que un número es floato integer?

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

verifique el resto al dividir entre 1:

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

Si no sabe que el argumento es un número, necesita dos pruebas:

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

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

Actualización 2019 5 años después de que se escribió esta respuesta, se estandarizó una solución en ECMA Script 2015. Esa solución se cubre en esta respuesta .

Pruebe estas funciones para comprobar si un valor es un valor primitivo numérico que no tiene una parte fraccional y está dentro de los límites de tamaño de lo que se puede representar como un entero exacto.

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

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

¿Por qué no algo como esto?

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

Hay un método llamado Number.isInteger()que actualmente se implementa en todo menos en IE. MDN también proporciona un polyfill para otros navegadores:

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

Sin embargo, para la mayoría de los casos de uso, es mejor usar el Number.isSafeInteger que también comprueba si el valor es tan alto / bajo que cualquier lugar decimal se habría perdido de todos modos. MDN también tiene un polyfil para esto. (También necesita el isIntegerpollyfill de arriba).

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

Puede usar una expresión regular simple:

function isInt(value) {

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

    return er.test(value);
}

O también puede usar las siguientes funciones, según sus necesidades. Son desarrollados por el Proyecto PHPJS .

is_int() => Verifique si el tipo de variable es entero y si su contenido es entero

is_float() => Verifique si el tipo de variable es flotante y si su contenido es flotante

ctype_digit() => Verifique si el tipo de variable es una cadena y si su contenido solo tiene dígitos decimales

Actualización 1

Ahora también verifica los números negativos, ¡gracias por el comentario de @ChrisBartley !

Aquí hay funciones eficientes que verifican si el valor es un número o se puede convertir de manera segura a un número:

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

Y para enteros (devolvería falso si el valor es flotante):

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

La eficiencia aquí es que parseInt (o parseNumber) se evitan cuando el valor ya es un número. Ambas funciones de análisis siempre se convierten en cadenas primero y luego intentan analizar esa cadena, lo que sería un desperdicio si el valor ya es un número.

¡Gracias a las otras publicaciones aquí por proporcionar más ideas para la optimización!

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 los casos.

Como otros mencionaron, solo tienes dobles en JS. Entonces, ¿cómo define un número como un número entero? Simplemente verifique si el número redondeado es igual a sí mismo:

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

Esto es lo que uso para los enteros:

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

Corto, agradable :) Funciona todo el tiempo. Esto es lo que sugiere David Flanagan si no me equivoco.

Realmente depende de lo que quieras lograr. Si desea "emular" idiomas fuertemente tipados, le sugiero que no lo intente. Como otros mencionaron, todos los números tienen la misma representación (el mismo tipo).

Usando algo como lo que Claudiu proporcionó:

isInteger( 1.0 ) -> verdadero

que se ve bien para el sentido común, pero en algo como C obtendrías false

Cualquier número Float con una parte decimal cero (p. Ej. 1.0, 12.00, 0.0) se convierte implícitamente en Integer, por lo que no es posible verificar si son Float o no.

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

Realmente no tiene que ser tan complicado. El valor numérico de los equivalentes parseFloat () y parseInt () de un entero será el mismo. Así puedes hacer así:

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

Entonces

if (isInt(x)) // do work

Esto también permitirá verificaciones de cadenas y, por lo tanto, no es estricto. Si desea una solución de tipo fuerte (es decir, no funcionará con cadenas):

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

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

No he tenido un caso donde esto no hizo el trabajo.

ESTE ES EL CÓDIGO FINAL PARA VERIFICAR TANTO INT Y FLOTADOR

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

Es simple como:

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

Prueba esto en la consola:

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!

Esto confunde a mucha gente. Cada vez que algo es .0, ya no es un flotador. Es un entero. O simplemente puede llamarlo "una cosa numérica", ya que no existe una distinción estricta como en aquel entonces en C. Los viejos tiempos.

Básicamente, todo lo que puede hacer es verificar el número entero aceptando el hecho de que 1,000 es un número entero.

Nota al margen interesante

Hubo un comentario sobre grandes números. Los números enormes no significan ningún problema para este enfoque; cada vez que parseInt no pueda manejar el número (porque es demasiado grande) devolverá algo más que el valor real, por lo que la prueba devolverá FALSE. Esto es algo bueno porque si considera que algo es un "número", normalmente espera que JS pueda calcular con él, así que sí, los números son limitados y parseInt lo tendrá en cuenta , para decirlo de esta manera.

Prueba esto:

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

En mi navegador (IE8) esto devuelve "a está bien; b falla", que es exactamente debido al gran número en b. El límite puede variar, pero supongo que 20 dígitos "deberían ser suficientes para cualquiera", por citar un clásico :)

Esta solución funcionó para mí.

<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 enteros uso esto

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

En el script java todos los números son internally 64 bit floating pointiguales al doble en java. No hay tipos diferentes en javascript, todos están representados por tipo number. Por lo tanto, no podrá hacer un instanceofcheque. Sin embargo, puede usar las soluciones anteriores para averiguar si es un número fraccionario. Los diseñadores de Java Script sintieron con un solo tipo que pueden evitar numerosos errores de conversión de tipos.

Algunas veces, los objetos numéricos no le permiten usar directamente el operador mod (%), si se enfrenta a ese caso, puede usar esta solución.

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

Intentando algunas de las respuestas aquí, terminé escribiendo esta solución. Esto funciona también con números dentro de una cadena.

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

Tal vez esto no sea tan eficaz como el% de respuesta, lo que evita que primero tenga que convertir a una cadena, pero todavía no he visto a nadie publicarlo, así que aquí hay otra opción que debería funcionar bien:

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

Para aquellos curiosos, usando Benchmark.js probé las respuestas más votadas (y la publicada hoy) en esta publicación, aquí están mis 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

Aquí está mi código. Comprueba para asegurarse de que no es una cadena vacía (que de lo contrario pasará) y luego la convierte a formato numérico. Ahora, dependiendo de si desea que '1.1' sea igual a 1.1, esto puede o no ser lo que está buscando.

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;

};

Me gusta esta pequeña función, que devolverá verdadero para los enteros positivos y negativos:

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

Esto funciona porque 1 o "1" se convierte en "1.0", que esNaN () devuelve falso en (que luego negamos y devolvemos), pero 1.0 o "1.0" se convierte en "1.0.0", mientras que "cadena" se convierte en "cadena". 0 ", ninguno de los cuales son números, por lo que isNaN () devuelve falso (y, de nuevo, se niega).

Si solo quieres enteros positivos, existe esta variante:

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

o, para enteros negativos:

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

isPositiveInt () funciona moviendo la cadena numérica concatenada por delante del valor a probar. Por ejemplo, isPositiveInt (1) da como resultado que isNaN () evalúe "01", que evalúa falso. Mientras tanto, isPositiveInt (-1) da como resultado que isNaN () evalúe "0-1", que evalúa verdadero. Negamos el valor de retorno y eso nos da lo que queremos. isNegativeInt () funciona de manera similar, pero sin negar el valor de retorno de isNaN ().

Editar:

Mi implementación original también devolvería verdadero en matrices y cadenas vacías. Esta implementación no tiene ese defecto. También tiene el beneficio de regresar temprano si val no es una cadena o número, o si es una cadena vacía, lo que lo hace más rápido en estos casos. Puede modificarlo aún más reemplazando las dos primeras cláusulas con

typeof(val) != "number"

si solo desea hacer coincidir números literales (y no cadenas)

Editar:

Todavía no puedo publicar comentarios, así que estoy agregando esto a mi respuesta. El punto de referencia publicado por @Asok es muy informativo; sin embargo, la función más rápida no cumple con los requisitos, ya que también devuelve VERDADERO para flotantes, matrices, booleanos y cadenas vacías.

Creé el siguiente conjunto de pruebas para probar cada una de las funciones, agregando mi respuesta a la lista también (función 8, que analiza las cadenas, y la función 9, que no):

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

También reescribí el punto de referencia con la función # 8 agregada a la lista. No publicaré el resultado, ya que son un poco vergonzosos (por ejemplo, esa función NO es rápida) ...

Los resultados (abreviado: eliminé las pruebas exitosas, ya que el resultado es bastante largo) son los siguientes:

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!

He dejado en fallas para que pueda ver dónde falla cada función, y el '#' prueba (cadena) para que pueda ver cómo cada función maneja los valores enteros y flotantes en las cadenas, ya que algunos pueden querer analizarlos como números y otros podría no.

De las 10 funciones probadas, las que realmente cumplen con los requisitos de OP son [1,3,5,6,8,9]

Condición para validación flotante:

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

Condición para la validación de enteros:

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

Espero que esto pueda 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
}

Puede agregar typeof a === 'number'si desea excluir cadenas.