Jak sprawdzić, czy liczba jest liczbą zmiennoprzecinkową lub liczbą całkowitą?

Jak okaże się, że liczba ta jest floatalbo integer?

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

zaznacz resztę, dzieląc przez 1:

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

Jeśli nie wiesz, że argument jest liczbą, potrzebujesz dwóch testów:

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

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

Aktualizacja 2019 5 lat po napisaniu tej odpowiedzi rozwiązanie zostało ustandaryzowane w skrypcie ECMA 2015. Rozwiązanie to jest ujęte w tej odpowiedzi .

Wypróbuj te funkcje, aby sprawdzić, czy wartość jest pierwotną wartością liczbową, która nie ma części ułamkowej i mieści się w granicach wielkości, które można przedstawić jako dokładną liczbę całkowitą.

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

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

Dlaczego nie coś takiego:

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

Istnieje metoda o nazwie, Number.isInteger()która jest obecnie implementowana we wszystkim oprócz IE. MDN zapewnia również wypełnianie wielu innych przeglądarek:

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

Jednak w przypadku większości przypadków użycia lepiej jest użyć tego, Number.isSafeInteger który również sprawdza, czy wartość jest tak wysoka / niska, że ​​i tak zostaną utracone miejsca dziesiętne. MDN ma do tego również polyfil. (Potrzebujesz również isIntegerwypełnienia powyżej).

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

Możesz użyć prostego wyrażenia regularnego:

function isInt(value) {

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

    return er.test(value);
}

Możesz też skorzystać z poniższych funkcji, w zależności od potrzeb. Są opracowywane przez projekt PHPJS .

is_int() => Sprawdź, czy typ zmiennej jest liczbą całkowitą i czy jej zawartość jest liczbą całkowitą

is_float() => Sprawdź, czy typ zmiennej jest zmiennoprzecinkowy i czy jego zawartość jest zmiennoprzecinkowa

ctype_digit() => Sprawdź, czy typ zmiennej jest łańcuchem i czy jego zawartość ma tylko cyfry dziesiętne

Aktualizacja 1

Teraz sprawdza również liczby ujemne, dziękuję za komentarz @ChrisBartley !

Oto wydajne funkcje, które sprawdzają, czy wartość jest liczbą lub czy można ją bezpiecznie przekonwertować na liczbę:

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

A dla liczb całkowitych (zwróciłoby wartość false, jeśli wartość jest liczbą zmiennoprzecinkową):

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

Wydajność polega na tym, że parseInt (lub parseNumber) jest unikany, gdy wartość jest już liczbą. Obie funkcje parsowania zawsze konwertują najpierw na ciąg, a następnie próbują parsować ten ciąg, co byłoby marnotrawstwem, jeśli wartość jest już liczbą.

Dziękujemy innym postom tutaj za dostarczenie dalszych pomysłów na optymalizację!

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

działa we wszystkich przypadkach.

Jak wspomnieli inni, masz tylko podwójne w JS. Jak więc zdefiniować liczbę będącą liczbą całkowitą? Po prostu sprawdź, czy zaokrąglona liczba jest sobie równa:

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

Co powiesz na ten?

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

Oto, czego używam do liczb całkowitych:

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

Krótko, miło :) Działa cały czas. Tak sugeruje David Flanagan, jeśli się nie mylę.

To naprawdę zależy od tego, co chcesz osiągnąć. Jeśli chcesz „emulować” silnie napisane języki, sugeruję, abyś nie próbował. Jak wspomniano inni, wszystkie liczby mają tę samą reprezentację (ten sam typ).

Używanie czegoś takiego jak Claudiu zapewniło:

isInteger( 1.0 ) -> prawda

co wygląda dobrze dla zdrowego rozsądku, ale w czymś takim jak C byś dostał false

Każda liczba zmiennoprzecinkowa z zerową częścią dziesiętną (np. 1,0, 12,00, 0,0) jest domyślnie rzutowana na liczbę całkowitą, więc nie można sprawdzić, czy są zmiennoprzecinkowe, czy nie.

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

To naprawdę nie musi być takie skomplikowane. Wartość liczbowa odpowiedników parseFloat () i parseInt () liczb całkowitych będzie taka sama. W ten sposób możesz zrobić tak:

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

Następnie

if (isInt(x)) // do work

Umożliwi to również sprawdzanie ciągów, a zatem nie jest ścisłe. Jeśli chcesz rozwiązania typu silnego (aka, nie będzie działać z ciągami znaków):

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

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

Nie miałem przypadku, w którym to nie zadziałało.

TO JEST OSTATECZNY KOD KONTROLI ZARÓWNO WEWNĘTRZNEJ I PŁYWAKOWEJ

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

LUB

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

To proste jak:

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

Wypróbuj to w konsoli:

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!

To dezorientuje wielu ludzi. Ilekroć coś ma wartość .0, nie jest to już liczba zmiennoprzecinkowa. To jest liczba całkowita. Możesz też nazwać to „rzeczą liczbową”, ponieważ nie ma tak ścisłego rozróżnienia, jak wtedy w C. Dobre, stare czasy.

Zasadniczo wszystko, co możesz zrobić, to sprawdzić liczbę całkowitą, akceptując fakt, że 1.000 jest liczbą całkowitą.

Ciekawa uwaga dodatkowa

Był komentarz na temat wielkich liczb. Ogromne liczby oznaczają ŻADNY problem dla tego podejścia; ilekroć parseInt nie jest w stanie obsłużyć liczby (ponieważ jest zbyt duża), zwróci coś innego niż wartość rzeczywista, więc test zwróci FAŁSZ. Jest to dobra rzecz, ponieważ jeśli uważasz coś za „liczbę”, zwykle spodziewasz się, że JS będzie w stanie to obliczyć - więc tak, liczby są ograniczone i parsuje To weźmie to pod uwagę , mówiąc inaczej.

Spróbuj tego:

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

W mojej przeglądarce (IE8) zwraca to „a jest w porządku; b kończy się niepowodzeniem”, co jest właśnie spowodowane dużą liczbą w b. Limit może się różnić, ale wydaje mi się, że 20 cyfr „powinno wystarczyć każdemu”, żeby zacytować klasykę :)

To rozwiązanie działało dla mnie.

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

W przypadku liczb całkowitych używam tego

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

W skrypcie Java wszystkie liczby są takie internally 64 bit floating pointsame, jak podwójne w Javie. W javascript nie ma różnych typów, wszystkie są reprezentowane według typu number. Dlatego nie będziesz w stanie wykonać instanceofczeku. Możesz jednak użyć powyższych rozwiązań, aby dowiedzieć się, czy jest to liczba ułamkowa. projektanci skryptu Java uważali, że jednym typem mogą uniknąć licznych błędów rzutowania.

Czasami obiekty Number nie pozwalają na bezpośrednie użycie operatora mod (%), jeśli masz do czynienia z tą sprawą, możesz użyć tego rozwiązania.

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

Próbując tutaj niektórych odpowiedzi, ostatecznie napisałem to rozwiązanie. Działa to również z liczbami w ciągu.

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

To może nie jest tak wydajne jak% answer, co uniemożliwia najpierw konwersję na ciąg, ale jeszcze nie widziałem, żeby ktoś go opublikował, więc oto inna opcja, która powinna działać dobrze:

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

Dla tych ciekawych, używając Benchmark.js przetestowałem najczęściej głosowane odpowiedzi (i jedną opublikowaną dzisiaj) na ten post, oto moje wyniki:

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

Oto mój kod. Sprawdza, czy nie jest to pusty ciąg (który w przeciwnym razie przejdzie), a następnie konwertuje go do formatu numerycznego. Teraz, w zależności od tego, czy chcesz, aby „1.1” było równe 1.1, może to być to, czego szukasz.

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;

};

Podoba mi się ta mała funkcja, która zwróci prawdę zarówno dla liczb całkowitych dodatnich, jak i ujemnych:

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

Działa to, ponieważ 1 lub „1” zamienia się na „1.0”, czyli isNaN () zwraca false na (które następnie negujemy i zwracamy), ale 1.0 lub „1.0” staje się „1.0.0”, podczas gdy „string” staje się „string”. 0 ”, z których żadna nie jest liczbą, więc isNaN () zwraca false (i ponownie zostaje zanegowany).

Jeśli chcesz tylko dodatnich liczb całkowitych, jest ten wariant:

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

lub, dla ujemnych liczb całkowitych:

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

isPositiveInt () działa poprzez przesunięcie skonkatenowanego ciągu liczbowego przed testowaną wartość. Na przykład isPositiveInt (1) powoduje, że isNaN () ocenia „01”, co oznacza fałsz. Tymczasem, isPositiveInt (-1) powoduje, że isNaN () ocenia „0-1”, co ocenia true. Negujemy wartość zwrotu, a to daje nam to, czego chcemy. isNegativeInt () działa podobnie, ale bez zanegowania zwracanej wartości isNaN ().

Edytować:

Moja oryginalna implementacja zwróciłaby również wartość true dla tablic i pustych ciągów. Ta implementacja nie ma tej wady. Ma również tę zaletę, że zwraca wcześniej, jeśli val nie jest łańcuchem ani liczbą, lub jeśli jest pustym łańcuchem, co przyspiesza w takich przypadkach. Możesz dalej go modyfikować, zastępując dwie pierwsze klauzule

typeof(val) != "number"

jeśli chcesz dopasować tylko liczby literalne (a nie ciągi znaków)

Edytować:

Nie mogę jeszcze dodawać komentarzy, więc dodaję to do mojej odpowiedzi. Benchmark opublikowany przez @Asok jest bardzo pouczający; jednak najszybsza funkcja nie spełnia wymagań, ponieważ zwraca PRAWDA również dla liczb zmiennoprzecinkowych, tablic, boolanów i pustych ciągów.

Utworzyłem następujący zestaw testów, aby przetestować każdą z funkcji, dodając również moją odpowiedź do listy (funkcja 8, która analizuje ciągi, i funkcja 9, która nie):

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

Przekartczyłem również test porównawczy z funkcją nr 8 dodaną do listy. Nie opublikuję wyniku, ponieważ są nieco zawstydzające (np. Ta funkcja NIE jest szybka) ...

Wyniki (skrócone - usunąłem udane testy, ponieważ dane wyjściowe są dość długie) są następujące:

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!

Zostawiłem awarie, abyś mógł zobaczyć, gdzie zawodzi każda funkcja, oraz testy (ciąg) „#”, abyś mógł zobaczyć, jak każda funkcja obsługuje wartości całkowite i zmiennoprzecinkowe w ciągach, ponieważ niektóre mogą chcieć je parsować jako liczby, a niektóre może nie.

Spośród 10 przetestowanych funkcji te, które faktycznie spełniają wymagania OP, to [1,3,5,6,8,9]

Warunki swobodnej weryfikacji:

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

Warunki sprawdzania poprawności liczb całkowitych:

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

Mam nadzieję, że to może być pomocne.

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

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

Możesz dodać, typeof a === 'number'jeśli chcesz wykluczyć ciągi.