Как проверить, что число является float или integer?

как найти число float или integer?

1.25 --> float  
1 --> integer  
0 --> integer  
0.25 --> float
621
javascript numbers types

30 ответов

проверьте остаток при делении на 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;
}
1085

попробуйте эти функции, чтобы проверить, является ли значение примитивным числом, которое не имеет дробной части и находится в пределах размера того, что может быть представлено как точное целое число.

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

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

почему не что-то вроде этого:

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

существует метод под названием Number.isInteger() который в настоящее время реализован только в последнем Firefox и по-прежнему является частью предложения EcmaScript 6. Однако MDN предоставляет polyfill для других браузеров, который соответствует указанному в ECMA harmony:

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

вы можете использовать простое регулярное выражение:

function isInt(value) {

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

    return er.test(value);
}

или вы можете использовать следующие функции, в соответствии с вашими потребностями. Они разработаны проект PHPJS.

is_int() => проверьте, является ли тип переменной integer и если его содержимое integer

is_float() => проверьте, является ли тип переменной float и если его содержимое float

ctype_digit() => проверьте, является ли тип переменной string и если его содержимое имеет только десятичные цифры

обновление 1

теперь он также проверяет отрицательные числа, спасибо за @ChrisBartley комментарий!

33

вот эффективные функции, которые проверяют, является ли значение числом или может быть безопасно преобразован в номер:

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

и для целых чисел (вернет false, если значение float):

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

эффективность здесь заключается в том, что parseInt (или parseNumber) избегаются, когда значение уже является числом. Обе функции синтаксического анализа всегда сначала преобразовать в строку, а затем попытаться проанализировать эту строку, что было бы пустой тратой, если значение уже есть число.

спасибо другим сообщениям здесь за предоставление дальнейших идей для оптимизации!

17
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
11
function isInt(n) 
{
    return n != "" && !isNaN(n) && Math.round(n) == n;
}
function isFloat(n){
    return n != "" && !isNaN(n) && Math.round(n) != n;
}

работает для всех случаев.

9

Как уже упоминалось, у вас есть только двойники в JS. Итак, как вы определяете число, являющееся целым числом? Просто проверьте, равно ли округленное число самому себе:

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

вот что я использую для целых чисел:

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

Short, nice :) работает все время. Если я не ошибаюсь, Дэвид Фланаган предлагает именно это.

6

любое число Float с нулевой десятичной частью (например, 1.0, 12.00, 0.0) неявно приведено к целому числу, поэтому невозможно проверить, являются ли они Float или нет.

5
!!(24%1) // false
!!(24.2%1) // true
4
var isInt = function (n) { return n === (n | 0); };

не было случая, когда это не выполняло работу.

4

Это действительно зависит от того, чего вы хотите достичь. Если вы хотите "эмулировать" строго типизированные языки, я предлагаю вам не пытаться. Как уже упоминалось, все числа имеют одно и то же представление (один и тот же тип).

использовать что-то вроде Клаудиу указано:

isInteger( 1.0 ) -> true

что выглядит хорошо для здравого смысла, но в чем-то вроде C вы получите false

3

все просто:

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, это больше не поплавок. Это целое число. Или вы можете просто назвать это "числовой вещью", потому что нет строгого различия, как тогда в C. старые добрые времена.

таким образом, в основном, все, что вы можете сделать, это проверить integer, принимая тот факт, что 1.000 является целым числом.

интересные стороны Примечание

был комментарий об огромных числах. Огромные числа не означают никаких проблем для этого подхода; всякий раз, когда parseInt не может обработать число (поскольку оно слишком велико), он вернет что-то другое, чем фактическое значение, поэтому тест вернет FALSE. Это хорошо, потому что если вы считаете что - то "числом", вы обычно ожидаете, что JS сможет вычислить с ним-так что да, числа ограничены, и 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>

в моем браузере (IE8) это возвращает "a в порядке; B терпит неудачу", что именно из-за огромного числа в b. Предел может варьироваться, но я думаю, что 20 цифр "должно быть достаточно для любого", чтобы процитировать классическое:)

3

ЭТО ОКОНЧАТЕЛЬНЫЙ КОД ДЛЯ ПРОВЕРКИ КАК INT, ТАК И FLOAT

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

или 

function isInt(n) {   
   return typeof n == 'number' && Math.Round(n) % 1 == 0;   
}
2
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');
}
2

Я написал функцию, которая принимает строки (если кому-то понадобится)

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
}

пример выхода выходит:

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
2

для целых чисел я использую этот

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

Это действительно не так сложно. Числовое значение эквивалентов 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) }
1

в Java script все числа являются internally 64 bit floating point, то же, что и double в java. В javascript нет разных типов, все они представлены типом number. Следовательно, вы не сможете сделать instanceof проверка. Однако u может использовать приведенные выше решения, чтобы узнать, является ли это дробным числом. дизайнеры Java script чувствовали с одним типом, они могут избежать многочисленных ошибок приведения типа.

1

это, возможно, не так эффективно, как % answer, что мешает вам сначала преобразовать в строку, но я еще не видел, чтобы кто-то опубликовал ее, поэтому вот еще один вариант, который должен работать нормально:

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

для любопытных, используя 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
1

вот мой код. Он проверяет, что это не пустая строка (которая в противном случае пройдет), а затем преобразует ее в числовой формат. Теперь, в зависимости от того, хотите ли вы, чтобы " 1.1 " был равен 1.1, это может быть или не быть тем, что вы ищете. 

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;

};
1

мне нравится эта маленькая функция, которая вернет true как для положительных, так и для отрицательных целых чисел:

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

это работает, потому что 1 или " 1 "становится" 1.0", который isNaN() возвращает false on (который мы затем отрицаем и возвращаем), но 1.0 или" 1.0 "становится" 1.0.0", а" string "становится" string.0", ни одно из которых не является числами, поэтому isNaN () возвращает false (и, опять же, отрицается).

если вы хотите только положительные целые числа, есть такой вариант:

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", которая вычисляет false. Между тем, isPositiveInt(-1) приводит к оценке isNaN () "0-1", которая оценивает true. Мы отрицаем возвращаемое значение, и это дает нам то, что мы хотим. isNegativeInt () работает аналогично, но без отрицания возвращаемого значения isNaN().

Edit:

моя исходная реализация также вернет true для массивов и пустых строк. Эта реализация не имеют этого дефекта. Он также имеет преимущество раннего возвращения, если val не является строкой или числом, или если это пустая строка, что делает его быстрее в этих случаях. Вы можете дополнительно изменить его, заменив первые два предложения, с

typeof(val) != "number"

если вы хотите только соответствовать буквальным числам (а не строки)

Edit:

Я пока не могу публиковать комментарии, поэтому добавляю это в свой ответ. Бенчмарк, опубликованный @Asok, очень информативен; однако самая быстрая функция не соответствует требованиям, так как она также возвращает TRUE для поплавков, массивов, логических значений и пустых строк.

Я создал следующий набор тестов для тестирования каждой из функций, добавив свой ответ в список (функция 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!

Я оставил в сбоях, чтобы вы могли видеть, где каждая функция терпит неудачу, и тесты (string)'#', чтобы вы могли видеть, как каждая функция обрабатывает целочисленные и плавающие значения в строки, так как некоторые могут хотеть, чтобы они анализировались как числа, а некоторые-нет.

из 10 протестированных функций те, которые фактически соответствуют требованиям OP, являются [1,3,5,6,8,9]

1

Condtion для плавающей проверки:

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

Condtion для целочисленной проверки:

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

надеюсь, это может быть полезно.

1
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' Если вы хотите исключить строки.

1

YourJS предоставляет следующие две функции, которые работают для всех чисел, включая возврат false на -Infinity и Infinity:

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

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

из-за того, что typeOf() является внутренней функцией YourJS, если вы хотите использовать эти определения, вы можете скачать версию только для этих функций здесь:http://yourjs.com/snippets/build/34

1

несколько раз объекты Number не позволяют использовать прямой оператор mod ( % ), если вы столкнулись с этим случаем, вы можете использовать это решение.

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

Это решение работает для меня.

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