Как проверить, является ли переменная целым числом в JavaScript?

function isInteger(argument) { return argument == ~~argument; }

Использование:

isInteger(1);     // true<br>
isInteger(0.1);   // false<br>
isInteger("1");   // true<br>
isInteger("0.1"); // false<br>

или:

function isInteger(argument) { return argument == argument + 0 && argument == ~~argument; }

Использование:

isInteger(1);     // true<br>
isInteger(0.1);   // false<br>
isInteger("1");   // false<br>
isInteger("0.1"); // false<br>

Вы также можете попробовать это так

var data = 22;
if (Number.isInteger(data)) {
    console.log("integer");
 }else{
     console.log("not an integer");
 }

или

if (data === parseInt(data, 10)){
    console.log("integer");
}else{
    console.log("not an integer");
}

В ES6 добавлено 2 новых метода для объекта Number.

В нем метод Number.isInteger () возвращает true, если аргумент является целым числом.

Пример использования:

Number.isInteger(10);        // returns true
Number.isInteger(10.5);      // returns false

Хорошо, получил минус, причина не описала мой пример, так что больше примеров:):

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

var isInteger = /^[0-9]\d*$/;

isInteger.test(123); //true
isInteger.test('123'); // true
isInteger.test('sdf'); //false
isInteger.test('123sdf'); //false

// If u want to avoid string value:
typeof testVal !== 'string' && isInteger.test(testValue);

var x = 1.5;
if(!isNaN(x)){
 console.log('Number');
 if(x % 1 == 0){
   console.log('Integer');
 }
}else {
 console.log('not a number');
}

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

function isInteger(value) {
    return (value == parseInt(value));
}

Она вернет true, даже если значение является строкой, содержащей целочисленное значение.
Итак, результаты будут:

alert(isInteger(1)); // true
alert(isInteger(1.2)); // false
alert(isInteger("1")); // true
alert(isInteger("1.2")); // false
alert(isInteger("abc")); // false

Это решит еще один сценарий ( 121. ), точка в конце

function isInt(value) {
        var ind = value.indexOf(".");
        if (ind > -1) { return false; }

        if (isNaN(value)) {
            return false;
        }

        var x = parseFloat(value);
        return (x | 0) === x;

    }

Из http://www.toptal.com/javascript/interview-questions :

function isInteger(x) { return (x^0) === x; } 

Нашли, что это лучший способ сделать это.

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

function isInteger(n) {
    return (typeof n == 'number' && /^-?\d+$/.test(n+''));
}

Lodash https://lodash.com/docs#isInteger (начиная с 4.0.0) имеет функцию для проверки, является ли переменная целым числом:

_.isInteger(3);
// → true

_.isInteger(Number.MIN_VALUE);
// → false

_.isInteger(Infinity);
// → false

_.isInteger('3');
// → false

Кроме того, Number.isInteger(). Может быть, Number.isSafeInteger() - это еще один вариант здесь с использованием спецификации ES6.

Чтобы заполнить Number.isSafeInteger(..) в браузерах до ES6:

Number.isSafeInteger = Number.isSafeInteger || function(num) {
    return typeof num === "number" && 
           isFinite(num) && 
           Math.floor(num) === num &&
           Math.abs( num ) <= Number.MAX_SAFE_INTEGER;
};

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

function isInt(value) {
    var er = /^-?[0-9]+$/;
    return er.test(value);
}

Вы можете попробовать Number.isInteger(Number(value)), если value может быть целым числом в строковой форме, например, var value = "23", и вы хотите, чтобы это значение оценивалось как true. Старайтесь не пытаться Number.isInteger(parseInt(value)), потому что это не всегда возвращает правильное значение. например, если var value = "23abc" и вы используете реализацию parseInt, она все равно вернет true.

Но если вы хотите строго целочисленные значения, то, вероятно, Number.isInteger(value) должны сделать свое дело.

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

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

http://jsfiddle.net/e267369d/1/

Некоторые другие ответы имеют аналогичное решение (опираться на parseFloat в сочетании с isNaN), но мой должен быть более прямым и самообъяснимым.

Редактировать: я обнаружил, что мой метод не работает для строк, содержащих запятую (например, «1,2»), и я также понял, что в моем конкретном случае я хочу, чтобы функция не работала, если строка не является допустимым целым числом (должен потерпеть неудачу на любом float, даже 1.0). Итак, вот моя функция Mk II:

function isInt(a){
    return !isNaN(a) && parseInt(a) == parseFloat(a) && (typeof a != 'string' || (a.indexOf('.') == -1 && a.indexOf(',') == -1));
}

http://jsfiddle.net/e267369d/3/

Конечно, если вам действительно нужна функция чтобы принимать целочисленные числа с плавающей точкой (1.0 штук), вы всегда можете удалить условие точки a.indexOf('.') == -1.

if(Number.isInteger(Number(data))){
    //-----
}

Для положительных целых значений без разделителей:

return ( data !== '' && data === data.replace(/\D/, '') );

Проверяет 1. если не пусто, и 2. если значение равно результату замены нецифрового символа в его значении.

Вы можете проверить, есть ли у числа остаток:

var data = 22;

if(data % 1 === 0){
   // yes it's an integer.
}

Обратите внимание: если ваш ввод также может быть текстовым, и вы хотите проверить, во-первых, это не так, тогда вы можете сначала проверить тип:

var data = 22;

if(typeof data === 'number'){
     // yes it is numeric

    if(data % 1 === 0){
       // yes it's an integer.
    }
}

Чтобы проверить, нужно ли целое число, например, плакат:

if (+data===parseInt(data)) {return true} else {return false}

уведомление + перед данными (преобразует строку в число) и === для точного.

Вот примеры:

data=10
+data===parseInt(data)
true

data="10"
+data===parseInt(data)
true

data="10.2"
+data===parseInt(data)
false

Почему никто не упомянул Number.isInteger()?

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger

Прекрасно работает для меня и решает проблему с NaN, начинающимся с числа.

Будьте осторожны при использовании

num% 1

пустая строка ('') или логическое значение (true или false) вернется как целое число. Возможно, вы не захотите делать это

false % 1 // true
'' % 1 //true

Number.isInteger (data)

Number.isInteger(22); //true
Number.isInteger(22.2); //false
Number.isInteger('22'); //false

встроенной функции в браузере. Dosnt поддерживает старые браузеры

Альтернативы:

Math.round(num)=== num

Однако Math.round () также не будет работать для пустой строки и логического значения

Используйте оператор |:

(5.3 | 0) === 5.3 // => false
(5.0 | 0) === 5.0 // => true

Итак, тестовая функция может выглядеть так:

var isInteger = function (value) {
  if (typeof value !== 'number') {
    return false;
  }

  if ((value | 0) !== value) {
    return false;
  }

  return true;
};

Проверьте, равна ли переменная той же самой переменной, округленной до целого числа, например:

if(Math.round(data) != data) {
    alert("Variable is not an integer!");
}

Это зависит от того, хотите ли вы также приводить строки в качестве потенциальных целых чисел?

Это будет делать:

function isInt(value) {
  return !isNaN(value) && 
         parseInt(Number(value)) == value && 
         !isNaN(parseInt(value, 10));
}

С побитовыми операциями

Простой анализ и проверьте

function isInt(value) {
  var x = parseFloat(value);
  return !isNaN(value) && (x | 0) === x;
}

Короткое замыкание и сохранение операции разбора:

function isInt(value) {
  if (isNaN(value)) {
    return false;
  }
  var x = parseFloat(value);
  return (x | 0) === x;
}

Или, возможно, оба в одном кадре:

function isInt(value) {
  return !isNaN(value) && (function(x) { return (x | 0) === x; })(parseFloat(value))
}

Тесты:

isInt(42)        // true
isInt("42")      // true
isInt(4e2)       // true
isInt("4e2")     // true
isInt(" 1 ")     // true
isInt("")        // false
isInt("  ")      // false
isInt(42.1)      // false
isInt("1a")      // false
isInt("4e2a")    // false
isInt(null)      // false
isInt(undefined) // false
isInt(NaN)       // false

Вот скрипка: http://jsfiddle.net/opfyrqwp/28/

Производительность

Тестирование показывает, что решение с коротким замыканием имеет лучшая производительность (ops / sec).

// Short-circuiting, and saving a parse operation
function isInt(value) {
  var x;
  if (isNaN(value)) {
    return false;
  }
  x = parseFloat(value);
  return (x | 0) === x;
}

Вот эталонный тест: http://jsben.ch/#/htLVw

Если вам интересна более короткая, тупая форма короткого замыкания:

function isInt(value) {
  var x;
  return isNaN(value) ? !1 : (x = parseFloat(value), (0 | x) === x);
}

Конечно, я бы предложил, чтобы минификатор позаботился об этом.

Предполагая, что вы ничего не знаете о рассматриваемой переменной, вы должны использовать такой подход:

if(typeof data === 'number') {
    var remainder = (data % 1);
    if(remainder === 0) {
        // yes, it is an integer
    }
    else if(isNaN(remainder)) {
        // no, data is either: NaN, Infinity, or -Infinity
    }
    else {
        // no, it is a float (still a number though)
    }
}
else {
    // no way, it is not even a number
}

Проще говоря:

if(typeof data==='number' && (data%1)===0) {
    // data is an integer
}

Стандарт ECMA-262 6.0 (ES6) включает функцию Number.isInteger .

Чтобы добавить поддержку старого браузера, я настоятельно рекомендую использовать надежное и поддерживаемое сообществом решение:

https://github.com/paulmillr/es6-shim

, которая является чистой ES6 JS polyfills library .

Обратите внимание, что для этой библиотеки требуется es5-shim, просто следуйте README.md.

Самое простое и чистое решение до ECMAScript-6 (которое также достаточно надежно, чтобы возвращать false, даже если в функцию передается не числовое значение, такое как строка или ноль):

function isInteger(x) { return (x^0) === x; } 

Следующее решение также будет работать, хотя и не так элегантно, как приведенное выше:

function isInteger(x) { return Math.round(x) === x; }

Обратите внимание , что Math.ceil () или Math.floor () могут использоваться одинаково хорошо (вместо Math.round ()) в приведенной выше реализации.

Или в качестве альтернативы:

function isInteger(x) { return (typeof x === 'number') && (x % 1 === 0); }

Одним из довольно распространенных неправильных решений является следующее:

function isInteger(x) { return parseInt(x, 10) === x; }

Хотя этот основанный на parseInt подход будет хорошо работать для многих значений x, один раз x становится довольно большим, он не сможет работать должным образом. Проблема в том, что parseInt () приводит свой первый параметр к строке перед разбором цифр. Следовательно, как только число станет достаточно большим, его строковое представление будет представлено в экспоненциальной форме (например, 1e + 21). Соответственно, parseInt () затем попытается проанализировать 1e + 21, но прекратит синтаксический анализ, когда достигнет символа e, и поэтому вернет значение 1. Наблюдение:

> String(1000000000000000000000)
'1e+21'

> parseInt(1000000000000000000000, 10)
1

> parseInt(1000000000000000000000, 10) === 1000000000000000000000
false

Во-первых, NaN - это «число» (да, я знаю, что это странно, просто катитесь с ним), а не «функция».

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

alert(typeof data === 'number' && data%1 == 0);

Number.isInteger() - лучший способ, если ваш браузер поддерживает его, если нет, я думаю, что есть много способов пойти:

function isInt1(value){
  return (value^0) === value
}

или:

function isInt2(value){
  return (typeof value === 'number') && (value % 1 === 0); 
}

или :

function isInt3(value){
  return parseInt(value, 10) === value; 
}

или:

function isInt4(value){
  return Math.round(value) === value; 
}

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

var value = 1
isInt1(value)   // return true
isInt2(value)   // return true
isInt3(value)   // return true
isInt4(value)   // return true

var value = 1.1
isInt1(value)   // return false
isInt2(value)   // return false
isInt3(value)   // return false
isInt4(value)   // return false

var value = 1000000000000000000
isInt1(value)   // return false
isInt2(value)   // return true
isInt3(value)   // return false
isInt4(value)   // return true

var value = undefined
isInt1(value)   // return false
isInt2(value)   // return false
isInt3(value)   // return false
isInt4(value)   // return false

var value = '1' //number as string
isInt1(value)   // return false
isInt2(value)   // return false
isInt3(value)   // return false
isInt4(value)   // return false

Итак, все эти методы работают, но когда число очень большой, parseInt и оператор ^ не будут работать хорошо.

Number.isInteger(), кажется, путь.

MDN также предоставил следующий polyfill для браузеров, не поддерживающих Number.isInteger(), в основном все версии IE.

Ссылка на страницу MDN

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