Wie überprüfe ich, ob eine Zahl float oder integer ist?

Wie finde ich heraus, dass eine Nummer floatoder ist integer?

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

Überprüfen Sie auf einen Rest, wenn Sie durch 1 teilen:

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

Wenn Sie nicht wissen, dass das Argument eine Zahl ist, benötigen Sie zwei Tests:

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

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

Update 2019 5 Jahre nach dem Schreiben dieser Antwort wurde eine Lösung in ECMA Script 2015 standardisiert. Diese Lösung wird in dieser Antwort behandelt .

Probieren Sie diese Funktionen aus, um zu testen, ob ein Wert ein primitiver Zahlenwert ist, der keinen Bruchteil enthält und innerhalb der Größengrenzen dessen liegt, was als exakte Ganzzahl dargestellt werden kann.

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

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

Warum nicht so etwas:

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

Es gibt eine Methode namens, Number.isInteger()die derzeit in allem außer IE implementiert ist. MDN bietet auch eine Polyfüllung für andere Browser:

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

In den meisten Anwendungsfällen ist es jedoch besser Number.isSafeInteger , wenn Sie auch prüfen, ob der Wert so hoch / niedrig ist, dass Dezimalstellen ohnehin verloren gegangen wären. MDN hat auch dafür ein Polyfil. (Sie benötigen auch die isIntegerPollyfill oben.)

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

Sie können einen einfachen regulären Ausdruck verwenden:

function isInt(value) {

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

    return er.test(value);
}

Oder Sie können die folgenden Funktionen entsprechend Ihren Anforderungen verwenden. Sie werden vom PHPJS-Projekt entwickelt .

is_int() => Überprüfen Sie, ob der Variablentyp eine Ganzzahl ist und ob sein Inhalt eine Ganzzahl ist

is_float() => Überprüfen Sie, ob der Variablentyp float ist und ob sein Inhalt float ist

ctype_digit() => Überprüfen Sie, ob der Variablentyp ein String ist und ob sein Inhalt nur Dezimalstellen enthält

Update 1

Jetzt werden auch negative Zahlen überprüft, danke für den Kommentar von @ChrisBartley !

Hier sind effiziente Funktionen, die prüfen, ob der Wert eine Zahl ist oder sicher in eine Zahl umgewandelt werden kann :

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

Und für ganze Zahlen (würde false zurückgeben, wenn der Wert ein Float ist):

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

Die Effizienz hierbei ist, dass parseInt (oder parseNumber) vermieden werden, wenn der Wert bereits eine Zahl ist. Beide Parsing-Funktionen immer konvertieren in eine Zeichenfolge und versuchen dann, diese Zeichenfolge zu analysieren. Dies wäre eine Verschwendung, wenn der Wert bereits eine Zahl ist.

Vielen Dank an die anderen Beiträge hier für weitere Ideen zur Optimierung!

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

funktioniert für alle Fälle.

Wie andere bereits erwähnt haben, haben Sie in JS nur Doppel. Wie definieren Sie eine Zahl als Ganzzahl? Überprüfen Sie einfach, ob die gerundete Zahl gleich ist:

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

Wie wäre es mit diesem?

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

Folgendes verwende ich für ganze Zahlen:

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

Kurz, schön :) Funktioniert die ganze Zeit. Dies ist, was David Flanagan vorschlägt, wenn ich mich nicht irre.

Es kommt wirklich darauf an, was Sie erreichen wollen. Wenn Sie stark typisierte Sprachen "emulieren" möchten, empfehle ich Ihnen, es nicht zu versuchen. Wie bereits erwähnt, haben alle Zahlen dieselbe Darstellung (denselben Typ).

Mit etwas wie Claudiu zur Verfügung gestellt:

isInteger( 1.0 ) -> wahr

Das sieht gut aus für den gesunden Menschenverstand, aber in so etwas wie C würde man bekommen false

Alle Float-Zahlen mit einem Dezimalteil von Null (z. B. 1.0, 12.00, 0.0) werden implizit in Integer umgewandelt, sodass nicht überprüft werden kann, ob sie Float sind oder nicht.

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

Es muss wirklich nicht so kompliziert sein. Der numerische Wert der Entsprechungen parseFloat () und parseInt () einer Ganzzahl ist identisch. So können Sie Folgendes tun:

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

Dann

if (isInt(x)) // do work

Dies ermöglicht auch Zeichenfolgenprüfungen und ist daher nicht streng. Wenn Sie eine starke Lösung wünschen (auch bekannt als, funktioniert nicht mit Zeichenfolgen):

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

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

Ich hatte noch keinen Fall, in dem dies nicht funktioniert hat.

Dies ist der endgültige Code für die Überprüfung von INT und FLOAT

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

ODER

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 ist so einfach wie:

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

Versuchen Sie dies in der Konsole:

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!

Das verwirrt viele Leute. Immer wenn etwas .0 ist, ist es kein Float mehr. Es ist eine ganze Zahl. Oder man kann es einfach "eine numerische Sache" nennen, denn es gibt keine strenge Unterscheidung wie damals in C. Gute alte Zeiten.

Alles, was Sie tun können, ist, nach einer Ganzzahl zu suchen und die Tatsache zu akzeptieren, dass 1.000 eine Ganzzahl ist.

Interessante Randnotiz

Es gab einen Kommentar über große Zahlen. Riesige Zahlen bedeuten für diesen Ansatz KEIN Problem. Wenn parseInt die Zahl nicht verarbeiten kann (weil sie zu groß ist), wird etwas anderes als der tatsächliche Wert zurückgegeben, sodass der Test FALSE zurückgibt. Dies ist eine gute Sache, denn wenn Sie etwas als "Zahl" betrachten, erwarten Sie normalerweise, dass JS damit rechnen kann - also ja, die Zahlen sind begrenzt und parseInt wird dies berücksichtigen , um es so auszudrücken .

Versuche dies:

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

In meinem Browser (IE8) gibt dies "a ist in Ordnung; b schlägt fehl" zurück, was genau auf die große Zahl in b zurückzuführen ist. Das Limit kann variieren, aber ich denke, 20 Ziffern "sollten für jeden reichen", um einen Klassiker zu zitieren :)

Diese Lösung hat bei mir funktioniert.

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

Für ganze Zahlen verwende ich dies

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

In Java-Skripten sind alle Zahlen internally 64 bit floating pointidentisch mit Double in Java. Es gibt keine unterschiedlichen Typen in Javascript, alle werden nach Typ dargestellt number. Daher können Sie keinen instanceofScheck machen. Sie können jedoch die oben angegebenen Lösungen verwenden, um herauszufinden, ob es sich um eine Bruchzahl handelt. Designer von Java-Skripten, die mit einem einzigen Typ gefühlt haben, können zahlreiche Typumwandlungsfehler vermeiden.

Manchmal können Sie mit Number-Objekten den Mod-Operator (%) nicht direkt verwenden. Wenn Sie mit diesem Fall konfrontiert sind, können Sie diese Lösung verwenden.

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

Als ich einige der Antworten hier versuchte, schrieb ich diese Lösung. Dies funktioniert auch mit Zahlen innerhalb einer Zeichenfolge.

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

Dies ist möglicherweise nicht so performant wie die% -Antwort, wodurch verhindert wird, dass Sie zuerst in einen String konvertieren müssen, aber ich habe noch niemanden gesehen, der ihn veröffentlicht hat. Hier ist eine weitere Option, die gut funktionieren sollte:

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

Für diejenigen, die neugierig sind und Benchmark.js verwenden, habe ich die am besten bewerteten Antworten (und die heute veröffentlichten) auf diesen Beitrag getestet. Hier sind meine Ergebnisse:

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

Hier ist mein Code. Es wird überprüft, ob es sich um eine leere Zeichenfolge handelt (die sonst übergeben wird), und anschließend in ein numerisches Format konvertiert. Abhängig davon, ob '1.1' gleich 1.1 sein soll, ist dies möglicherweise das, wonach Sie suchen, oder auch nicht.

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;

};

Ich mag diese kleine Funktion, die sowohl für positive als auch für negative ganze Zahlen wahr ist:

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

Dies funktioniert, weil 1 oder "1" zu "1.0" wird, was ist, dass NaN () false zurückgibt (was wir dann negieren und zurückgeben), aber 1.0 oder "1.0" zu "1.0.0" wird, während "string" zu "string" wird. 0 ", von denen keine Zahlen sind, daher gibt isNaN () false zurück (und wird erneut negiert).

Wenn Sie nur positive ganze Zahlen möchten, gibt es diese Variante:

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

oder für negative ganze Zahlen:

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

isPositiveInt () verschiebt die verkettete numerische Zeichenfolge vor den zu testenden Wert. Zum Beispiel führt isPositiveInt (1) dazu, dass isNaN () "01" auswertet, was false auswertet. Währenddessen führt isPositiveInt (-1) dazu, dass isNaN () "0-1" auswertet, was true ergibt. Wir negieren den Rückgabewert und das gibt uns, was wir wollen. isNegativeInt () funktioniert ähnlich, ohne jedoch den Rückgabewert von isNaN () zu negieren.

Bearbeiten:

Meine ursprüngliche Implementierung würde auch für Arrays und leere Zeichenfolgen true zurückgeben. Diese Implementierung hat diesen Fehler nicht. Es hat auch den Vorteil, dass es frühzeitig zurückgegeben wird, wenn val keine Zeichenfolge oder Zahl ist oder wenn es eine leere Zeichenfolge ist, was es in diesen Fällen schneller macht. Sie können es weiter ändern, indem Sie die ersten beiden Klauseln durch ersetzen

typeof(val) != "number"

wenn Sie nur Literalzahlen (und keine Zeichenfolgen) abgleichen möchten)

Bearbeiten:

Ich kann noch keine Kommentare posten, daher füge ich dies meiner Antwort hinzu. Der von @Asok veröffentlichte Benchmark ist sehr informativ. Die schnellste Funktion entspricht jedoch nicht den Anforderungen, da sie auch TRUE für Floats, Arrays, Boolesche Werte und leere Zeichenfolgen zurückgibt.

Ich habe die folgende Testsuite erstellt, um jede der Funktionen zu testen, und meine Antwort ebenfalls zur Liste hinzugefügt (Funktion 8, die Zeichenfolgen analysiert, und Funktion 9, die dies nicht tut):

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

Ich habe auch den Benchmark mit der Funktion # 8 wiederholt, die der Liste hinzugefügt wurde. Ich werde das Ergebnis nicht veröffentlichen, da sie etwas peinlich sind (z. B. ist diese Funktion NICHT schnell) ...

Die (gekürzt - ich habe erfolgreiche Tests entfernt, da die Ausgabe ziemlich lang ist) Ergebnisse sind wie folgt:

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!

Ich habe Fehler hinterlassen, damit Sie sehen können, wo jede Funktion ausfällt, und die (Zeichenfolge) '#' testet, damit Sie sehen können, wie jede Funktion Ganzzahl- und Gleitkommawerte in Zeichenfolgen behandelt, da einige diese möglicherweise als Zahlen und andere analysieren möchten nicht dürfen.

Von den 10 getesteten Funktionen sind diejenigen, die tatsächlich den Anforderungen von OP entsprechen, [1,3,5,6,8,9]

Bedingung für die Floating-Validierung:

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

Bedingung für die Ganzzahlvalidierung:

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

Hoffe das könnte hilfreich sein.

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

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

Sie können hinzufügen, typeof a === 'number'wenn Sie Zeichenfolgen ausschließen möchten.