javascript - मैं कैसे जांचूं कि एक संख्या फ्लोट या पूर्णांक है?




types numbers (20)

1 से विभाजित करते समय शेष की जांच करें:

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

यदि आप नहीं जानते कि तर्क एक संख्या है तो आपको दो परीक्षणों की आवश्यकता है:

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

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

यह कैसे पता चलता है कि कोई संख्या float या integer ?

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

आप एक साधारण नियमित अभिव्यक्ति का उपयोग कर सकते हैं:

function isInt(value) {

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

    return er.test(value);
}

या आप अपनी आवश्यकताओं के अनुसार, नीचे दिए गए कार्यों का भी उपयोग कर सकते हैं। वे PHPJS परियोजना द्वारा विकसित किए जाते हैं।

is_int() => जांचें कि चर प्रकार पूर्णांक है और यदि इसकी सामग्री पूर्णांक है

is_float() => जांचें कि परिवर्तनीय प्रकार फ़्लोट है और यदि इसकी सामग्री फ़्लोट है

is_float() => जांचें कि परिवर्तनीय प्रकार स्ट्रिंग है और यदि इसकी सामग्री में केवल दशमलव अंक हैं

अद्यतन 1

अब यह ऋणात्मक संख्या भी जांचता है, @ChrisBartley टिप्पणी के लिए धन्यवाद!


ऐसा कुछ क्यों नहीं है:

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

जावा स्क्रिप्ट में सभी संख्याएं internally 64 bit floating point , जो जावा में दोगुनी है। जावास्क्रिप्ट में कोई भिन्न प्रकार नहीं हैं, सभी प्रकार number द्वारा दर्शाए जाते हैं। इसलिए आप एक instanceof जांच करने में सक्षम नहीं होंगे। हालांकि आप यह पता लगाने के लिए दिए गए उपरोक्त समाधानों का उपयोग कर सकते हैं कि यह एक आंशिक संख्या है या नहीं। जावा स्क्रिप्ट के डिजाइनरों को एक ही प्रकार के साथ महसूस किया गया है, वे कई प्रकार की कास्ट त्रुटियों से बच सकते हैं।


पूर्णांक के लिए मैं इसका उपयोग करता हूं

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

मुझे यह छोटा फ़ंक्शन पसंद है, जो सकारात्मक और नकारात्मक पूर्णांक दोनों के लिए सच होगा:

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

यह काम करता है क्योंकि 1 या "1" "1.0" बन जाता है, जो एनएएनएन () पर झूठा रिटर्न देता है (जिसे हम तब अस्वीकार करते हैं और लौटते हैं), लेकिन 1.0 या "1.0" "1.0.0" बन जाता है, जबकि "स्ट्रिंग" स्ट्रिंग हो जाता है। 0 ", जिनमें से कोई भी संख्या नहीं है, इसलिए एनएएन () झूठी वापसी करता है (और, फिर से, अस्वीकार हो जाता है)।

यदि आप केवल सकारात्मक पूर्णांक चाहते हैं, तो यह संस्करण है:

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

या, नकारात्मक पूर्णांक के लिए:

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

isPositiveInt () परीक्षण के मूल्य से पहले समेकित संख्यात्मक स्ट्रिंग को स्थानांतरित करके काम करता है। उदाहरण के लिए, isPositiveInt (1) परिणाम isNaN () का मूल्यांकन "01" का मूल्यांकन करता है, जो झूठे मूल्यांकन करता है। इस बीच, isPositiveInt (-1) परिणाम isNaN () का मूल्यांकन "0-1" का मूल्यांकन करता है, जो सत्य का मूल्यांकन करता है। हम वापसी मूल्य को अस्वीकार करते हैं और यह हमें वह देता है जो हम चाहते हैं। isNegativeInt () समान रूप से काम करता है, लेकिन isNaN () के वापसी मूल्य को अस्वीकार किए बिना।

संपादित करें:

मेरा मूल कार्यान्वयन भी सरणी और खाली तारों पर सच होगा। इस कार्यान्वयन में दोष नहीं है। अगर वैल स्ट्रिंग या नंबर नहीं है, या यदि यह खाली स्ट्रिंग है, तो इन मामलों में इसे तेज़ी से बनाते हुए इसे वापस लौटने का लाभ भी मिलता है। आप पहले दो खंडों को प्रतिस्थापित करके इसे और संशोधित कर सकते हैं

typeof(val) != "number"

यदि आप केवल शाब्दिक संख्याओं से मेल खाना चाहते हैं (और तार नहीं)

संपादित करें:

मैं अभी तक टिप्पणियां पोस्ट नहीं कर सकता, इसलिए मैं इसे अपने उत्तर में जोड़ रहा हूं। @ एस्क द्वारा पोस्ट किया गया बेंचमार्क बहुत जानकारीपूर्ण है; हालांकि, सबसे तेज़ कार्य आवश्यकताओं को पूरा नहीं करता है, क्योंकि यह फ्लोट्स, सरणी, बूलियन और खाली तारों के लिए भी सत्य लौटाता है।

मैंने प्रत्येक फ़ंक्शन का परीक्षण करने के लिए निम्न परीक्षण सूट बनाया है, सूची में मेरा जवाब जोड़ना है, साथ ही (फ़ंक्शन 8, जो स्ट्रिंग पार्स और फ़ंक्शन 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!");
}

मैं सूची में जोड़ा गया फ़ंक्शन # 8 के साथ बेंचमार्क भी दोहराता हूं। मैं परिणाम पोस्ट नहीं करूंगा, क्योंकि वे थोड़ा शर्मनाक हैं (उदाहरण के लिए कि फ़ंक्शन तेज़ नहीं है) ...

(संक्षिप्त - मैंने सफल परीक्षण हटा दिए, क्योंकि आउटपुट काफी लंबा है) परिणाम इस प्रकार हैं:

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!

I've left in failures so you can see where each function is failing, and the (string) '#' tests so you can see how each function handles integer and float values in strings, as some may want these parsed as numbers and some may not.

Out of the 10 functions tested, the ones that actually fit OP's requirements are [1,3,5,6,8,9]


मैंने फ़ंक्शन लिखा जो तारों को स्वीकार करता है (अगर किसी को आवश्यकता होगी)

function isInt(x) {
    return !isNaN(x) && eval(x).toString().length == parseInt(eval(x)).toString().length
}

function isFloat(x) {
    return !isNaN(x) && !isInt(eval(x)) && x.toString().length > 0
}

उदाहरण ouptuts:

console.log(isFloat('0.2'))  // true
console.log(isFloat(0.2))    // true
console.log(isFloat('.2'))   // true
console.log(isFloat('-.2'))  // true
console.log(isFloat(-'.2'))  // true
console.log(isFloat(-.2))    // true
console.log(isFloat('u.2'))  // false
console.log(isFloat('2'))    // false
console.log(isFloat('0.2u')) // false

console.log(isInt('187'))  // true
console.log(isInt(187))    // true
console.log(isInt('1.2'))  // false
console.log(isInt('-2'))   // true
console.log(isInt(-'1'))   // true
console.log(isInt('10e1')) // true
console.log(isInt(10e1))   // true

यह इतना आसान है:

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

इसे कंसोल में आज़माएं:

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!

यह बहुत से लोगों को भ्रमित करता है। जब भी कुछ है .0, यह अब एक फ्लोट नहीं है। यह एक पूर्णांक है। या आप इसे "एक संख्यात्मक चीज़" कह सकते हैं क्योंकि सी में अच्छे समय के साथ कोई सख्त भेद नहीं है।

तो मूल रूप से, आप जो भी कर सकते हैं वह इस तथ्य को स्वीकार करने वाले पूर्णांक की जांच है कि 1.000 एक पूर्णांक है।

दिलचस्प पक्ष नोट

बड़ी संख्या के बारे में एक टिप्पणी थी। बड़ी संख्या का मतलब इस दृष्टिकोण के लिए कोई समस्या नहीं है; जब भी parseInt संख्या को संभालने में असमर्थ है (इसके लिए बहुत बड़ा है) यह वास्तविक मूल्य से कुछ और लौटाएगा ताकि परीक्षा गलत हो जाएगी। यह एक अच्छी बात है क्योंकि यदि आप कुछ "संख्या" पर विचार करते हैं तो आप आम तौर पर जेएस को इसके साथ गणना करने में सक्षम होने की उम्मीद करते हैं - इसलिए हाँ, संख्याएं सीमित हैं और पार्स इसे इस तरह से रखने के लिए इसे ध्यान में रखेगी।

इसे इस्तेमाल करे:

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

मेरे ब्राउज़र (आईई 8) में यह "ठीक है; बी विफल रहता है" जो कि बी में बड़ी संख्या के कारण है। सीमा भिन्न हो सकती है लेकिन मुझे लगता है कि शास्त्रीय उद्धरण के लिए 20 अंक "किसी के लिए पर्याप्त होना चाहिए"


यह वास्तव में इतना जटिल नहीं है। एक पूर्णांक के parseFloat () और parseInt () समकक्षों का सांख्यिक मान समान होगा। इस प्रकार आप ऐसा कर सकते हैं:

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

फिर

if (isInt(x)) // do work

यह स्ट्रिंग चेक के लिए भी अनुमति देगा और इस प्रकार सख्त नहीं है। यदि एक मजबूत प्रकार का समाधान चाहते हैं (उर्फ, तारों के साथ काम नहीं करेगा):

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

यह वास्तव में उस पर निर्भर करता है जिसे आप प्राप्त करना चाहते हैं। यदि आप दृढ़ता से टाइप की गई भाषाओं को "अनुकरण" करना चाहते हैं तो मेरा सुझाव है कि आप कोशिश नहीं कर रहे हैं। जैसा कि अन्य लोगों ने उल्लेख किया है कि सभी संख्याओं का एक ही प्रतिनिधित्व (एक ही प्रकार) है।

क्लाउडियो जैसे कुछ का उपयोग करना:

isInteger( 1.0 ) -> सच है

जो सामान्य ज्ञान के लिए ठीक दिखता है, लेकिन सी जैसे कुछ में आपको false लगेगा


यहां कुशल कार्य हैं जो जांचते हैं कि मान एक संख्या है या सुरक्षित रूप से किसी संख्या में परिवर्तित किया जा सकता है:

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

और पूर्णांक के लिए (यदि मूल्य एक फ्लोट है तो झूठी वापसी होगी):

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

यहां दक्षता यह है कि जब मूल्य पहले से ही एक संख्या है तो parseInt (या parseNumber) से बचा जाता है। दोनों पार्सिंग फ़ंक्शंस हमेशा पहले स्ट्रिंग में कनवर्ट करते हैं और फिर उस स्ट्रिंग को पार्स करने का प्रयास करते हैं, जो कि कचरा होगा यदि मान पहले से ही एक संख्या है।

अनुकूलन के लिए और विचार प्रदान करने के लिए यहां अन्य पदों के लिए धन्यवाद!


यहां मैं पूर्णांक के लिए उपयोग करता हूं:

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

छोटा, अच्छा :) हर समय काम करता है। डेविड फ़्लानागन ने सुझाव दिया है कि क्या मुझे गलत नहीं लगता है।


YourJS provides the following two functions which work for all numbers including returning false for -Infinity and Infinity :

function isFloat(x) {
  return typeOf(x, 'Number') && !!(x % 1);
}

function isInt(x) {
  return typeOf(x, 'Number') && x % 1 == 0;
}

Due to the fact that typeOf() is a YourJS internal function, if you wanted to use these definitions you can download the version for just these functions here: http://yourjs.com/snippets/build/34


Number.isInteger() नामक एक विधि है जिसे वर्तमान में केवल नवीनतम फ़ायरफ़ॉक्स में लागू किया गया है और अभी भी एक्मास्क्रिप्ट 6 प्रस्ताव का हिस्सा है। हालांकि MDN अन्य ब्राउज़रों के लिए एक पॉलीफिल प्रदान करता है, जो ईसीएमए सद्भाव में निर्दिष्ट एक से मेल खाता है:

if (!Number.isInteger) {
  Number.isInteger = function isInteger (nVal) {
    return typeof nVal === "number" && isFinite(nVal) && nVal > -9007199254740992 && nVal < 9007199254740992 && Math.floor(nVal) === nVal;
  };
}

Some times Number objects don't allow you to use direct the mod operator (%), if you are facing that case you can use this solution.

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

उन उत्सुक लोगों के लिए, Benchmark.js का उपयोग करके मैंने इस पोस्ट पर सबसे अधिक वोट वाले उत्तरों (और आज पोस्ट किया गया) का परीक्षण किया, यहां मेरे परिणाम दिए गए हैं:

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

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

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

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

You can add typeof a === 'number' if you want to exclude strings.


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

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




numbers