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

Как проверить, является ли переменная целой в JavaScript, и бросать предупреждение, если это не так? Я пробовал это, но он не работает:

<html>
    <head>
        <script type="text/javascript">
            var data = 22;
            alert(NaN(data));
        </script>
    </head>
</html>

Ответы

Ответ 1

используйте оператор ===, как показано ниже

if (data === parseInt(data, 10))
    alert("data is integer")
else
    alert("data is not an integer")

Ответ 2

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

Это сделает:

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/

Здесь yolpo: http://www.yolpo.com/embed.html?gist=a3c46f837ea7bbb708ae&autoplay=2

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

Тестирование показывает, что решение с коротким замыканием имеет лучшую производительность (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);
}

Конечно, я предлагаю позволить minifier позаботиться об этом.

Ответ 3

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

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
}

Ответ 4

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

var data = 22;

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

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

var data = 22;

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

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

Ответ 5

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

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

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

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

Ответ 6

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

num% 1

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

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

Number.isInteger(данные)

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

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

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

Math.round(num)=== num

Однако, Math.round() также завершится с ошибкой для пустой строки и boolean

Ответ 7

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

function isInt(value) {

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

    return er.test(value);
}

Ответ 8

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

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

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

Ответ 9

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

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

Ответ 10

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

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

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

которая представляет собой чистую библиотеку ESF JS polyfills.

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

Ответ 11

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

Ответ 12

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

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

Ответ 13

Простейшее и самое чистое решение для 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

Ответ 14

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

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

Ответ 15

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 и ^ не будут работать хорошо.

Ответ 16

Кроме того, Number.isInteger(). Возможно, Number.isSafeInteger() - это еще один вариант здесь, используя указанный ES6.

В polyfill Number.isSafeInteger(..) в браузерах pre-ES6:

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

Ответ 17

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

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

Ответ 18

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

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

Ответ 19

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

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

Обнаружено, что это лучший способ сделать это.

Ответ 20

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

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

Ответ 21

Это позволит решить еще один сценарий (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;

    }

Ответ 22

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

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

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

Ответ 23

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

Ответ 24

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

String (1000000000000000000000) '1e + 21'

parseInt (1000000000000000000000, 10) 1

parseInt (1000000000000000000000, 10) === 1000000000000000000000 ложь

Ответ 25

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>

Ответ 26

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

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

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

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

Изменить: я обнаружил, что мой метод не работает для строк, содержащих запятую (например, "1,2" ), и я также понял, что в моем конкретном случае я хочу, чтобы функция завершилась неудачей, если строка не является допустимым целым числом (должно завершиться неудачно на любом поплавке, даже 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/

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

Ответ 27

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

_.isInteger(3);
// → true

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

_.isInteger(Infinity);
// → false

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

Ответ 28

После нескольких успехов и неудач я придумал это решение:

const isInt = (value) => {
  return String(parseInt(value, 10)) === String(value)
}

Мне понравилась вышеприведенная идея проверить значение не NaN и использовать parseFloat, но когда я попробовал его в инфраструктуре React, он почему-то не работал.

Изменить: Я нашел более удобный способ, не используя строки:

var isInt = function (str) {
  return str === '0' || !!~~str;
}

Я думаю, что это самый короткий ответ. Может быть, даже самый эффективный, но я мог бы быть исправлен.:)

Ответ 29

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

function isInt(data){
  if(typeof(data)=='number'){
    var patt=/^[0-9e+]+$/;
    data=data+"";
    data=data.match(patt);
    if(data==null){return false;}
     else {return true;}}
  else{return false;} 
}

Он вернет false, если данные не являются целыми числами, true в противном случае.

Ответ 30

Это работает для меня.. Попробуйте это...

$(document).on("input", ".numOnly", function(e) {
    this.value = this.value.replace(/[^0-9\$]/g,'');
});

Вместо ввода вы можете использовать keypress, keyup, keydown и т.д.