Bir sayının kayar sayı veya tam sayı olup olmadığını nasıl kontrol edebilirim?

Nasıl bir sayı olduğunu bulmak için floatya integer?

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

1'e bölerken kalan olup olmadığını kontrol edin:

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

Argümanın bir sayı olduğunu bilmiyorsanız, iki teste ihtiyacınız vardır:

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

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

Bu cevabın yazılmasından 5 yıl sonra 2019 Güncellemesi , ECMA Script 2015'te bir çözüm standardize edildi. Bu çözüm bu cevapta ele alınmıştır .

Bir değerin kesirli kısmı olmayan ve tam bir tamsayı olarak gösterilebilecek boyut sınırları içinde olan bir sayı ilkel değeri olup olmadığını test etmek için bu işlevleri deneyin.

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

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

Neden böyle bir şey olmasın:

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

Number.isInteger()IE dışında her şeyde şu anda uygulanan denilen bir yöntem var . MDN ayrıca diğer tarayıcılar için bir çoklu dolgu sağlar:

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

Ancak, çoğu kullanım Number.isSafeInteger durumunda, değerin çok yüksek / düşük olup olmadığını kontrol etmek için daha iyi olursunuz . MDN yanı bunun için bir POLYFIL sahiptir. ( isIntegerYukarıdaki polly dolgusuna da ihtiyacınız var .)

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

Basit bir normal ifade kullanabilirsiniz:

function isInt(value) {

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

    return er.test(value);
}

Veya ihtiyaçlarınıza göre aşağıdaki işlevleri de kullanabilirsiniz. PHPJS Projesi tarafından geliştirilmiştir .

is_int() => Değişken türünün tam sayı olup olmadığını ve içeriğinin tam sayı olup olmadığını kontrol edin

is_float() => Değişken türünün kayan ve içeriğinin kayan olup olmadığını kontrol edin

ctype_digit() => Değişken türünün dize olup olmadığını ve içeriğinde yalnızca ondalık basamak olup olmadığını kontrol edin

Güncelleme 1

Şimdi @ChrisBartley yorum için teşekkürler, negatif sayıları da kontrol eder !

Değerin bir sayı olup olmadığını veya bir sayıya güvenle dönüştürülebildiğini kontrol eden verimli işlevler şunlardır :

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

Ve tamsayılar için (değer bir kayan nokta ise false değerini döndürür):

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

Buradaki verimlilik, değer zaten bir sayı olduğunda parseInt (veya parseNumber) değerinden kaçınılmasıdır. Her iki ayrıştırma işlevi her zaman önce dizeye dönüştürülür ve daha sonra bu değer ayrıştırılmaya çalışır; bu değer zaten bir sayı ise israf olur.

Optimizasyon için daha fazla fikir verdiğiniz için buradaki diğer gönderilere teşekkür ederiz!

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

tüm durumlar için çalışır.

Diğerlerinin de belirttiği gibi, sadece JS'de iki katına sahipsiniz. Peki bir sayıyı tamsayı olarak nasıl tanımlarsınız? Sadece yuvarlanmış sayının kendisine eşit olup olmadığını kontrol edin:

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

Buna ne dersin?

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

İşte tamsayılar için ne kullanıyorum:

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

Kısa, güzel :) Her zaman çalışır. David Flanagan'ın yanılmıyorsam önerdiği şey budur.

Gerçekten ne elde etmek istediğinize bağlıdır. Güçlü yazılan dilleri "taklit etmek" istiyorsanız denemenizi tavsiye ederim. Diğerlerinin belirttiği gibi, tüm sayılar aynı temsile sahiptir (aynı tip).

Claudiu gibi bir şey kullanmak şunları sağladı:

isInteger( 1.0 ) -> doğru

sağduyu için iyi görünüyor, ama C gibi bir şeyde false

Ondalık ondalık kısmı olan herhangi bir Float numarası (ör. 1.0, 12.00, 0.0) dolaylı olarak Tamsayıya çevrilir, bu nedenle Float olup olmadıklarını kontrol etmek mümkün değildir.

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

Gerçekten bu kadar karmaşık olmak zorunda değil. Bir tamsayının parseFloat () ve parseInt () eşdeğerlerinin sayısal değeri aynı olacaktır. Böylece şunları yapabilirsiniz:

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

Sonra

if (isInt(x)) // do work

Bu aynı zamanda dize kontrollerine de izin verir ve bu nedenle katı değildir. Güçlü bir tür çözüm istiyorsanız (aka, dizelerle çalışmaz):

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

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

Bunun işi yapmadığı bir durum olmadı.

BU, İKİ INT VE FLOAT İÇİN KONTROL İÇİN SON KOD

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

VEYA

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

Bu kadar basit:

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

Konsolda şunu deneyin:

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!

Bu birçok insanı karıştırıyor. Ne zaman bir şey .0 olduğunda, artık bir şamandıra değil. Bu bir tamsayı. Ya da sadece ona "sayısal bir şey" diyebilirsiniz, çünkü o zamanlar C'de olduğu gibi katı bir ayrım yoktur. İyi eski zamanlar.

Temel olarak, yapabileceğiniz tek şey, tamsayı kontrol etmek, 1.000'in bir tamsayı olduğunu kabul etmektir.

İlginç yan not

Büyük sayılar hakkında bir yorum vardı. Büyük sayılar bu yaklaşım için HİÇBİR problem anlamına gelir; parseInt numarayı işleyemediğinde (çok büyük olduğu için) gerçek değerden başka bir şey döndürür, böylece test YANLIŞ döndürür. Bu iyi bir şeydir çünkü bir şeyi bir "sayı" olarak görürseniz, normalde JS'nin onunla hesaplayabilmesini beklersiniz - bu nedenle evet, sayılar sınırlıdır ve parseInt bunu dikkate almak için bu şekilde dikkate alacaktır .

Bunu dene:

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

Tarayıcımda (IE8) bu "a tamam; b başarısız" döndürür, bu da tam olarak b'deki büyük sayıdan kaynaklanır. Sınır değişebilir ama sanırım 20 basamak "herkes için yeterli olmalı", bir klasik alıntı için :)

Bu çözüm benim için çalıştı.

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

Tamsayılar için bunu kullanıyorum

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

Java betiğinde tüm sayılar internally 64 bit floating pointjava'da iki ile aynıdır. Javascript'te farklı türler yoktur, hepsi türe göre temsil edilir number. Bu yüzden instanceofkontrol yapamayacaksın . Ancak u bir kesirli sayı olup olmadığını öğrenmek için yukarıdaki çözümleri kullanabilirsiniz. Java script tasarımcıları tek bir tür ile hissettim onlar sayısız tür döküm hataları önleyebilirsiniz.

Bazı durumlarda Number nesneleri doğrudan mod operatörünü (%) kullanmanıza izin vermez, bu durumda karşı karşıyaysanız bu çözümü kullanabilirsiniz.

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

Burada bazı cevapları denerken bu çözümü yazdım. Bu, bir dize içindeki sayılarla da çalışır.

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

Bu, ilk önce bir dizeye dönüştürmek zorunda kalmanızı engelleyen% yanıtı kadar performans değil, ancak henüz kimsenin yayınlamadığını görmedim, bu yüzden iyi çalışması gereken başka bir seçenek var:

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

Meraklılar için, Benchmark.js'yi kullanarak bu yayında en çok oylanan cevapları (ve bugün yayınlanmış olanları) test ettim, işte sonuçlarım:

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

İşte kodum. Boş bir dize (aksi takdirde geçecek) olup olmadığını kontrol eder ve ardından sayısal formata dönüştürür. Şimdi, '1.1'in 1.1'e eşit olmasını isteyip istemediğinize bağlı olarak, bu aradığınız şey olabilir veya olmayabilir.

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;

};

Hem pozitif hem de negatif tamsayılar için doğru olacak bu küçük işlevi seviyorum:

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

1 veya "1", "1.0" haline geldiğinden çalışır, bu da isNaN (), false değerini döndürür (daha sonra reddettiğimiz ve döndüğümüz), ancak 1.0 veya "1.0", "1.0.0" olurken "string", "string" olur. 0 ", her ikisi de sayı değil, bu nedenle isNaN () yanlış döndürür (ve yine reddedilir).

Yalnızca pozitif tamsayılar istiyorsanız, bu varyant vardır:

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

veya negatif tamsayılar için:

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

isPositiveInt (), sıralı sayısal dizeyi test edilecek değerin önüne taşıyarak çalışır. Örneğin, isPositiveInt (1), isNaN () yönteminin "01" değerini verir ve bu da false değerini değerlendirir. Bu arada isPositiveInt (-1), isNaN () 'nin "0-1" değerini doğrulamasıyla sonuçlanır, bu da doğru olarak değerlendirilir. Geri dönüş değerini reddediyoruz ve bu bize ne istediğimizi veriyor. isNegativeInt () benzer şekilde çalışır, ancak isNaN () öğesinin dönüş değerini reddetmeden.

Düzenle:

Orijinal uygulamam da dizilerde ve boş dizelerde true değerini döndürür. Bu uygulamanın bu kusuru yoktur. Ayrıca val bir dize veya sayı değilse veya boş bir dize ise erken dönme avantajına sahiptir ve bu durumlarda daha hızlı hale getirir. İlk iki maddeyi değiştirerek daha da değiştirebilirsiniz.

typeof(val) != "number"

yalnızca değişmez sayıları eşleştirmek istiyorsanız (dizeleri değil)

Düzenle:

Henüz yorum gönderemiyorum, bu yüzden bunu yanıtıma ekliyorum. @Asok tarafından yayınlanan karşılaştırma çok bilgilendiricidir; bununla birlikte, en hızlı işlev, şamandıralar, diziler, booleans ve boş dizeler için TRUE döndürdüğü için gereksinimlere uymaz.

Listeye cevabımı ekleyerek, işlevlerin her birini test etmek için aşağıdaki test paketini oluşturdum (dizeleri ayrıştıran işlev 8 ve işlevsiz 9):

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

Ayrıca, 8 numaralı fonksiyonun karşılaştırmasını listeye ekliyorum. Biraz utanç verici oldukları için sonucu yayınlamayacağım (örneğin, bu işlev hızlı DEĞİLDİR) ...

(Kısaltılmış - Çıktı oldukça uzun olduğu için başarılı testleri kaldırdım) sonuçlar aşağıdaki gibidir:

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!

Her fonksiyonun nerede başarısız olduğunu görebilmeniz için hatalar bıraktım ve (string) '#' testleri, her fonksiyonun dizelerde tamsayı ve float değerlerini nasıl işlediğini görebilirsiniz, bazıları bu sayı ve bazı olarak ayrıştırılabilir olmayabilir.

Test edilen 10 fonksiyondan OP'nin gereksinimlerine gerçekten uyanlar [1,3,5,6,8,9]

Değişken doğrulama koşulu:

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

Tamsayı doğrulama koşulu:

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

Umarım bu yardımcı olabilir.

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

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

typeof a === 'number'Dizeleri hariç tutmak istiyorsanız ekleyebilirsiniz .