Как проверить, является ли переменная целой в JavaScript, и бросать предупреждение, если это не так? Я пробовал это, но он не работает:
<html>
<head>
<script type="text/javascript">
var data = 22;
alert(NaN(data));
</script>
</head>
</html>
используйте оператор ===, как показано ниже
if (data === parseInt(data, 10))
alert("data is integer")
else
alert("data 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/
Здесь 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 позаботиться об этом.
Предполагая, что вы ничего не знаете о переменной, о которой идет речь, вы должны придерживаться такого подхода:
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
}
Вы можете проверить, имеет ли номер остаток:
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.
}
}
Number.isInteger() кажется, это путь.
MDN также предоставил следующие polyfill для браузеров, не поддерживающих Number.isInteger(), главным образом все версии IE.
Number.isInteger = Number.isInteger || function(value) {
return typeof value === "number" &&
isFinite(value) &&
Math.floor(value) === value;
};
Будьте осторожны при использовании
num% 1
пустая строка ('') или boolean (true или false) вернется как целое число. Возможно, вы не захотите это сделать
false % 1 // true
'' % 1 //true
Number.isInteger(22); //true
Number.isInteger(22.2); //false
Number.isInteger('22'); //false
встроенная функция в браузере. Dosnt поддерживает старые браузеры
Альтернативы:
Math.round(num)=== num
Однако, Math.round() также завершится с ошибкой для пустой строки и boolean
Вы можете использовать простое регулярное выражение:
function isInt(value) {
var er = /^-?[0-9]+$/;
return er.test(value);
}
Во-первых, NaN - это "номер" (да, я знаю, что это странно, просто рулон с ним), а не "функция".
Вам нужно проверить оба, если тип переменной - это число, а для проверки целого я использовал бы модуль.
alert(typeof data === 'number' && data%1 == 0);
Чтобы проверить, требуется ли целое число, подобное плакату:
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
Стандарт ECMA-262 6.0 (ES6) включает Number.isInteger.
Чтобы добавить поддержку старого браузера, я настоятельно рекомендую использовать сильное и поддерживаемое сообщества решение:
https://github.com/paulmillr/es6-shim
которая представляет собой чистую библиотеку ESF JS polyfills.
Обратите внимание, что этот lib требует es5-shim, просто следуйте README.md.
if(Number.isInteger(Number(data))){
//-----
}
Вы можете попробовать Number.isInteger(Number(value)), если value может быть целым числом в строковой форме, например, var value = "23", и вы хотите, чтобы это оценивалось до true. Избегайте использования Number.isInteger(parseInt(value)), потому что это не всегда возвращает правильное значение. например, если var value = "23abc" и вы используете реализацию parseInt, он все равно вернет true.
Но если вы хотите строго целые значения, то, вероятно, Number.isInteger(value) должен сделать трюк.
Простейшее и самое чистое решение для 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
Проверьте, равна ли переменная той же переменной, округленной до целого числа, например:
if(Math.round(data) != data) {
alert("Variable is not an integer!");
}
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(). Возможно, 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;
};
Вы можете использовать regexp для этого:
function isInteger(n) {
return (typeof n == 'number' && /^-?\d+$/.test(n+''));
}
Вы можете использовать эту функцию:
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
Из http://www.toptal.com/javascript/interview-questions:
function isInteger(x) { return (x^0) === x; }
Обнаружено, что это лучший способ сделать это.
Используйте оператор |:
(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;
};
Это позволит решить еще один сценарий (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;
}
Для положительных целых значений без разделителей:
return ( data !== '' && data === data.replace(/\D/, '') );
Тесты 1. если не пустые и 2. если значение равно результату замены нецифрового char в его значении.
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 (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 ложь
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>
Мне пришлось проверить, является ли переменная (строка или число) целым числом, и я использовал это условие:
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.
Lodash https://lodash.com/docs#isInteger (начиная с 4.0.0) есть функция, чтобы проверить, является ли переменная целой:
_.isInteger(3);
// → true
_.isInteger(Number.MIN_VALUE);
// → false
_.isInteger(Infinity);
// → false
_.isInteger('3');
// → false
После нескольких успехов и неудач я придумал это решение:
const isInt = (value) => {
return String(parseInt(value, 10)) === String(value)
}
Мне понравилась вышеприведенная идея проверить значение не NaN и использовать parseFloat, но когда я попробовал его в инфраструктуре React, он почему-то не работал.
Изменить: Я нашел более удобный способ, не используя строки:
var isInt = function (str) {
return str === '0' || !!~~str;
}
Я думаю, что это самый короткий ответ. Может быть, даже самый эффективный, но я мог бы быть исправлен.:)
Вы можете использовать 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 в противном случае.
Это работает для меня.. Попробуйте это...
$(document).on("input", ".numOnly", function(e) {
this.value = this.value.replace(/[^0-9\$]/g,'');
});
Вместо ввода вы можете использовать keypress, keyup, keydown и т.д.