Як я можу перевірити, чи число є плаваючим чи цілим?

Як знайти, що число є floatабо integer?

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

перевірити на залишок при діленні на 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;
}

Оновлення 2019 року через 5 років після написання цієї відповіді рішення було стандартизоване у сценарії ECMA 2015. Це рішення охоплене у цій відповіді .

Спробуйте скористатися цими функціями, щоб перевірити, чи є значення примітивним числом, яке не має дробової частини і чи не в межах граничних розмірів того, що може бути представлено у вигляді точного цілого числа.

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

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

Чому б не щось подібне:

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

Існує метод, Number.isInteger()який називається, який зараз реалізується у всьому, крім IE. MDN також забезпечує полісистему для інших браузерів:

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

Однак для більшості випадків використання вам краще використовувати те, Number.isSafeInteger що також перевіряє, чи є значення настільки високим / низьким, що будь-які десяткові знаки в будь-якому разі були б втрачені. MDN також має поліфіл для цього. (Також вам потрібен isIntegerполіліф вище.)

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

Ви можете використовувати простий регулярний вираз:

function isInt(value) {

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

    return er.test(value);
}

Або ви також можете використовувати наведені нижче функції, відповідно до ваших потреб. Вони розроблені Проектом PHPJS .

is_int() => Перевірте, чи змінний тип є цілим числом, чи вміст його цілим

is_float() => Перевірте, чи є змінний тип float і чи є його вміст float

ctype_digit() => Перевірте, чи тип змінної є рядковим і чи вміст має лише десяткових цифр

Оновлення 1

Тепер він перевіряє і негативні цифри, дякую за коментар @ChrisBartley !

Ось ефективні функції, які перевіряють, чи є значення числом, чи їх можна безпечно перетворити на число:

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

А для цілих чисел (поверне помилковим, якщо значенням є float):

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

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

Дякуємо іншим публікаціям тут за надані подальші ідеї для оптимізації!

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

працює для всіх випадків.

Як згадували інші, у вас є лише дубль у JS. Отже, як визначити число, яке є цілим числом? Просто перевірте, чи округлене число дорівнює самому собі:

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

Як щодо цього?

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

Ось що я використовую для цілих чисел:

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

Коротко, приємно :) Працює весь час. Ось що пропонує Девід Фланаган, якщо я не помиляюся.

Це дійсно залежить від того, чого ви хочете досягти. Якщо ви хочете "імітувати" сильно набрані мови, то я пропоную вам не намагатися. Як згадували інші, всі номери мають однакове представлення (одного типу).

Використовуючи щось на кшталт Клавдіу, передбачено:

isInteger( 1.0 ) -> правда

що виглядає чудово для здорового глузду, але в чомусь подібному C ви отримаєте false

Будь-яке число Float з нульовою десятковою частиною (наприклад, 1,0, 12,00, 0,0) неявно передається цілому, тому неможливо перевірити, чи вони плаваючі чи ні.

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

Це дійсно не повинно бути таким складним. Чисельне значення еквівалентів 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) }

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

У мене не було випадку, коли це не зробило б роботу.

ЦЕ КІНЦЕВИЙ КОД ЗА ПЕРЕВІРТАННЯ ВІД І ПЛАТУ

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

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

Це просто так:

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. Добрі старі часи.

В основному, все, що ви можете зробити, це перевірити на ціле число, прийнявши той факт, що 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 цифр "комусь вистачить", цитую класика :)

Це рішення спрацювало на мене.

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

Для цілих чисел я використовую це

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

У сценарії Java всі числа є такими internally 64 bit floating pointж, як у подвійному у Java. У javascript немає різних типів, всі представлені типом number. Отже, ви не зможете зробити instanceofперевірку. Однак ви можете використовувати наведені вище рішення, щоб дізнатись, чи є це дробовим числом. Дизайнери сценарію java відчували себе одним типом, вони можуть уникнути численних помилок у ролях типу.

Інколи об'єкти Number не дозволяють використовувати прямий оператор мод (%), якщо ви стикаєтеся з цим випадком, ви можете використовувати це рішення.

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

Спробувавши деякі відповіді тут, я закінчив написання цього рішення. Це також працює з числами в рядку.

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

Це, можливо, не настільки ефективно, як відповідь%, що заважає вам спочатку перетворитись на рядок, але я ще не бачив, щоб хтось розмістив її, тому ось ще один варіант, який повинен працювати добре:

function isInteger(num) {
    return num.toString().indexOf('.') === -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, це може бути, а може і не бути тим, що ви шукаєте.

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;

};

Мені подобається ця маленька функція, яка поверне істину як для позитивних, так і для негативних цілих чисел:

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

Це працює, тому що 1 або "1" стає "1,0", що isNaN () повертає помилкове значення (яке ми потім заперечуємо і повертаємо), але 1,0 або "1,0" стає "1,0,0", а "рядок" стає "рядком". 0 ", жодне з яких не є числами, тому isNaN () повертає помилкові (і, знову ж таки, заперечується).

Якщо ви хочете лише додатні цілі числа, є такий варіант:

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 ().

Редагувати:

Моя оригінальна реалізація також поверне справжнє для масивів та порожніх рядків. Цей недолік не має цього дефекту. Це також має перевагу повернення достроково, якщо val не є рядком або числом, або якщо це порожній рядок, що робить його швидшим у цих випадках. Ви можете додатково змінити його, замінивши перші два пункти на

typeof(val) != "number"

якщо ви хочете відповідати лише буквальним числам (а не рядкам)

Редагувати:

Я поки не можу публікувати коментарі, тому я додаю це до своєї відповіді. Тест, розміщений @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 перевірених функцій ті, які фактично відповідають вимогам ОП, [1,3,5,6,8,9]

Умова для плаваючої перевірки:

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

Умова для перевірки цілого числа:

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

Сподіваюся, це може бути корисним.

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'якщо хочете виключити рядки.