Как проверить, является ли число целым или с плавающей запятой?

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

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

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

Функция isFloat возвращает true, если n — это число с дробной частью, тогда как функция isInteger возвращает true, если n — это целое число. Оба метода проверяют, является ли n числом и при необходимости используют побитовые операции для определения, имеет ли число дробную часть.

Ваш код имеет смысл, но он не совсем корректен для проверки, является ли число целым. Функция parseInt будет преобразовывать строку в целое число, и если n было передано как строка, это может привести к результатам, которые не соответствуют вашим ожиданиям. Например, если передать n значение '2.5', то parseInt(n) вернет 2, и проверка parseInt(n) === n даст ложный результат.

Более надежный способ проверки целого числа может выглядеть так:

var isInt = function(n) {
    return Number.isInteger(n);
};

Эта функция использует метод Number.isInteger, который возвращает true, если переданное значение является целым числом. Это более строгое и правильное решение. Также, если вам необходимо поддерживать строки, содержащие целые числа, можно использовать Number.isInteger вместе с предварительным преобразованием:

var isInt = function(n) {
    const num = Number(n);
    return Number.isInteger(num);
};

Этот вариант будет корректно обрабатывать как числа, так и строковые представления целых чисел.

Ваш код правильно реализует функции для проверки, является ли число целым (integer) или дробным (float). Функция isInteger проверяет, является ли переданное значение числом, конечным и целым (сравнивает с его округленным значением вниз), что позволяет ей корректно определять целые числа. В свою очередь, функция isFloat использует остаток от деления на 1, чтобы определить, есть ли дробная часть.

Вот ваши тесты:

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

Результаты:

• isInteger(1.0) возвращает true, поскольку 1.0 является целым числом.
• isFloat(1.0) возвращает false, так как 1.0 не имеет дробной части.
• isFloat(1.2) возвращает true, поскольку 1.2 является дробным числом.
• isInteger(1.2) возвращает false, так как 1.2 не является целым числом.
• isFloat(1) возвращает false, поскольку 1 — это целое число.
• isInteger(1) возвращает true, так как 1 — это целое число.
• isFloat(2e+2) возвращает false, так как 200 — это целое число.
• isInteger(2e+2) возвращает true, так как 200 — это целое число.
• Входные значения '1', NaN, null и undefined возвращают false для обеих функций, как и ожидалось, поскольку они не являются числами.

Ваше решение прекрасно справляется с задачей, и тесты демонстрируют его корректность. Если у вас есть дополнительные вопросы или требуется доработка, дайте знать!

В 2022 году мы можем использовать методы объекта Number для проверки типов чисел.

Чтобы проверить, является ли значение конечным числом (целым или дробным), можно использовать:

Number.isFinite(val);

Для проверки, является ли значение целым числом, используйте:

Number.isInteger(val);

Если вам нужно проверить, является ли значение дробным числом (не целым), вы можете использовать следующее условие:

!Number.isInteger(val) && Number.isFinite(val);

Эти методы позволяют просто и эффективно проводить необходимые проверки типов чисел.

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

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

Для проверки целых чисел (функция вернет false, если значение - это дробное число):

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

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

Спасибо другим участникам за предоставленные идеи для оптимизации!