Вопрос по javascript – Проверьте, что строка является положительным целым числом

173

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

isNaN(str) возвращает true для всех видов нецелых значений иparseInt(str) возвращает целые числа для строк с плавающей запятой, например "2.5". И я не хочу использовать какой-либо плагин jQuery.

Вы разрешаете & quot; + 2 & quot ;? Как насчет "0.1e1"? Как насчет "1,0000"? Phrogz
Вопрос неясен до крайности. Вы не можете проверить, что "строка является целым числом", потому что такой вещи нет - ни один объект не может быть строкой и числом одновременно. Вы, вероятно, имели в виду «как проверить, является ли строка допустимым представлением целого числа», но чтобы ответить на это, нам нужно знать, какой язык или «культура» Вы говорите о. Например,٢‎٣٤ или жеMCMXIX оба являются допустимыми целочисленными представлениями, но я не думаю, что вы ищете код, который бы мог их проанализировать. Не могли бы вы указать, какие числовые форматы вы собираетесь поддерживать, поскольку люди, похоже, смущены этим. georg
isNaN() Функция ведет себя так, как она делает, потому что концепцияNot a Number имеет очень конкретное значение в спецификации IEEE 794 с плавающей запятой. Он не намеревается дать ответ на простой разговорный вопрос: «Это значение не число?» Pointy
Я думаю, что "неопределенно до крайности" само по себе немного экстремально; но в любом случае ... Контекстом является проверка поля ввода количества в корзине покупок, используемой в англоязычной стране, поэтому только западные цифры. По "положительному" Я имел в виду больше нуля. Приму ли я следующее: & quot; + 2 & quot; да, "0,1e1" нет, "1000" конечно почему нет. Однако, если вы можете предоставить ответ, который можно скорректировать, чтобы включить / исключить эти различные специализированные сценарии, я обещаю дать вам дополнительные взлеты (и я уверен, что другие тоже). Mick Byrne

Ваш Ответ

12   ответов
1

(~~a == a) гдеa это строка

Error: User Rate Limit Exceeded~~"-1" == "-1"Error: User Rate Limit ExceededtrueError: User Rate Limit Exceeded
Error: User Rate Limit Exceeded
2

Моя функция проверяет, является ли число + ve и может иметь также десятичное значение.

       function validateNumeric(numValue){
            var value = parseFloat(numValue);
            if (!numValue.toString().match(/^[-]?\d*\.?\d*$/)) 
                    return false;
            else if (numValue < 0) {
                return false;
            }
            return true;        
        }
2

Просто, основываясь на ответе VisioN выше, если вы используете плагин проверки jQuery, вы можете использовать это:

$(document).ready(function() {
    $.validator.addMethod('integer', function(value, element, param) {
        return (value >>> 0 === parseFloat(value) && value > 0);
    }, 'Please enter a non zero integer value!');
}

Затем вы можете использовать в своем обычном наборе правил или динамически добавить его таким образом:

$("#positiveIntegerField").rules("add", {required:true, integer:true});
1

просто

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

console.log(isInteger(1));

Вы также можете расширить Number и назначить ему функцию через прототип.

2
return ((parseInt(str, 10).toString() == str) && str.indexOf('-') === -1);

не будет работать, если вы дадите строку, подобную «0001»; хоть

0

Просто используйте это

let num = 1.2;
let res;
res = Number.isInteger(num);
console.log(res);

Вы получите результат в true или false.

Если оно будет целочисленным, оно вернет true, иначе вернет false.

Error: User Rate Limit Exceeded
0

Если вы используете формы HTML5, вы можете использовать атрибутmin="0" для элемента формы<input type="number" />, Это поддерживается всеми основными браузерами. Он не включает Javascript для таких простых задач, но интегрирован в новый стандарт HTML. Это задокументировано наhttps://www.w3schools.com/tags/att_input_min.asp

3

Это почти повторяющийся вопрос для этого:

Проверка десятичных чисел в JavaScript - IsNumeric ()

Это ответ:

function isNumber(n) {
  return !isNaN(parseFloat(n)) && isFinite(n);
}

Итак, положительное целое число будет:

function isPositiveInteger(n) {
  var floatN = parseFloat(n);
  return !isNaN(floatN) && isFinite(n) && floatN > 0
      && floatN % 1 == 0;
}
Error: User Rate Limit Exceeded
Error: User Rate Limit Exceeded Mick Byrne
69

Solution 1

Если мырассматривать целое число JavaScript должно быть значением максимума4294967295 (Т.е.Math.pow(2,32)-1), тогда следующее короткое решение будет отлично работать:

function isPositiveInteger(n) {
    return n >>> 0 === parseFloat(n);
}

DESCRIPTION:

  1. Zero-fill right shift operator does three important things:
    • truncates decimal part
      • 123.45 >>> 0 === 123
    • does the shift for negative numbers
      • -1 >>> 0 === 4294967295
    • "works" in range of MAX_INT
      • 1e10 >>> 0 === 1410065408
      • 1e7 >>> 0 === 10000000
  2. parseFloat does correct parsing of string numbers (setting NaN for non numeric strings)

TESTS:

"0"                     : true
"23"                    : true
"-10"                   : false
"10.30"                 : false
"-40.1"                 : false
"string"                : false
"1234567890"            : true
"129000098131766699.1"  : false
"-1e7"                  : false
"1e7"                   : true
"1e10"                  : false
"1edf"                  : false
" "                     : false
""                      : false

DEMO: http://jsfiddle.net/5UCy4/37/


Solution 2

Другой способ подходит для всех числовых значений, которые действительны доNumber.MAX_VALUEпримерно до1.7976931348623157e+308:

function isPositiveInteger(n) {
    return 0 === n % (!isNaN(parseFloat(n)) && 0 <= ~~n);
}

DESCRIPTION:

  1. !isNaN(parseFloat(n)) is used to filter pure string values, e.g. "", " ", "string";
  2. 0 <= ~~n filters negative and large non-integer values, e.g. "-40.1", "129000098131766699";
  3. (!isNaN(parseFloat(n)) && 0 <= ~~n) returns true if value is both numeric and positive;
  4. 0 === n % (...) checks if value is non-float -- here (...) (see 3) is evaluated as 0 in case of false, and as 1 in case of true.

TESTS:

"0"                     : true
"23"                    : true
"-10"                   : false
"10.30"                 : false
"-40.1"                 : false
"string"                : false
"1234567890"            : true
"129000098131766699.1"  : false
"-1e10"                 : false
"1e10"                  : true
"1edf"                  : false
" "                     : false
""                      : false

DEMO: http://jsfiddle.net/5UCy4/14/


The previous version:

function isPositiveInteger(n) {
    return n == "0" || ((n | 0) > 0 && n % 1 == 0);
}

DEMO: http://jsfiddle.net/5UCy4/2/

Error: User Rate Limit Exceeded(!isNaN(parseFloat(n)) && n % 1 === 0 && 0 <= ~~n)
Error: User Rate Limit Exceeded~~valError: User Rate Limit Exceeded
Error: User Rate Limit Exceededval|0Error: User Rate Limit Exceeded
Error: User Rate Limit Exceeded
Error: User Rate Limit Exceededjsfiddle.net/5UCy4/1
7

Современное решение, которое работает в узле и поперекболее 90% всех браузеров (кроме IE и Opera Mini) использоватьNumber.isInteger с последующей простой положительной проверкой.

Number.isInteger(x) && x > 0

Это былозавершено в ECMAScript 2015.

function isPositiveInteger(x) {
    return Number.isInteger(x) && x > 0
}

Полифил это:

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

Если вам нужно поддержать ввод, который может быть вstring или жеnumber форма, то вы можетеиспользовать эту функцию, я написал большой набор тестов против после того, как все существующие ответы (1/2/2018) потерпели неудачу на некоторой форме ввода.

function isPositiveInteger(v) {
  var i;
  return v && (i = parseInt(v)) && i > 0 && (i === v || ''+i === v);
}
262

Два ответа для вас:

  • Based on parsing

  • Regular expression

Следует отметить, что в обоих случаях я интерпретировал "положительное целое число" включать0, даже если0 не является положительным. Я включаю заметки, если вы хотите запретить0.

Based on Parsing

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

function isNormalInteger(str) {
    var n = Math.floor(Number(str));
    return n !== Infinity && String(n) === str && n >= 0;
}

Живой стенд:

function isNormalInteger(str) {
    var n = Math.floor(Number(str));
    return String(n) === str && n >= 0;
}
function gid(id) {
  return document.getElementById(id);
}
function test(str, expect) {
  console.log(str + ": " + (isNormalInteger(str) ? "Yes" : "No"));
}
gid("btn").addEventListener(
  "click",
  function() {
    test(gid("text").value);
  },
  false
);
test("1");
test("1.23");
test("1234567890123");
test("1234567890123.1");
<label>
  String:
  <input id="text" type="text" value="">
<label>
<input id="btn" type="button" value="Check">

Если вы хотите запретить0поменяй>= 0 в> 0.

Как это работает:

  1. Number(str): Convert str to a number; the number may well have a fractional portion, or may be NaN.

  2. Math.floor: Truncate the number (chops off any fractional portion).

  3. String(...): Converts the result back into a normal decimal string. For really big numbers, this will go to scientific notation, which may break this approach. (I don't quite know where the split is, the details are in the spec, but for whole numbers I believe it's at the point you've exceeded 21 digits [by which time the number has become very imprecise, as IEEE-754 double-precision numbers only have roughtly 15 digits of precision..)

  4. ... === str: Compares that to the original string.

  5. n >= 0: Check that it's positive.

Обратите внимание, что это не удается для ввода"+1"любой ввод в научную запись, который не превращается в ту же научную запись вString(...) stage, и для любого значения, которое тип JavaScript использует (двоичная с плавающей запятой IEEE-754 с двойной точностью), не может точно представить, какие разборы ближе к другому значению, чем заданное значение (которое включает в себя множество целых чисел свыше 9 007 199 254 740 992; пример,1234567890123456789 не удастся). Первое легко исправить, последние два не так уж и много.

Regular Expression

Другой подход заключается в проверке символов строки с помощью регулярного выражения, если ваша цель состоит в том, чтобы просто разрешить (скажем) необязательный+ с последующим либо0 или строка в обычном десятичном формате:

function isNormalInteger(str) {
    return /^\+?(0|[1-9]\d*)$/.test(str);
}

Живой стенд:

function isNormalInteger(str) {
    return /^\+?(0|[1-9]\d*)$/.test(str);
}
function gid(id) {
  return document.getElementById(id);
}
function test(str, expect) {
  console.log(str + ": " + (isNormalInteger(str) ? "Yes" : "No"));
}
gid("btn").addEventListener(
  "click",
  function() {
    test(gid("text").value);
  },
  false
);
test("1");
test("1.23");
test("1234567890123");
test("1234567890123.1");
<label>
  String:
  <input id="text" type="text" value="">
<label>
<input id="btn" type="button" value="Check">

Как это работает:

  1. ^: Match start of string

  2. \+?: Allow a single, optional + (remove this if you don't want to)

  3. (?:...|...): Allow one of these two options (without creating a capture group):

    1. (0|...): Allow 0 on its own...

    2. (...|[1-9]\d*): ...or a number starting with something other than 0 and followed by any number of decimal digits.

  4. $: Match end of string.

Если вы хотите запретить0 (поскольку оно не является положительным), регулярное выражение становится просто/^\+?[1-9]\d*$/ (например, мы можем потерять чередование, которое нам нужно, чтобы0).

Если вы хотите разрешить ведущие нули (0123, 00524), просто замените чередование(?:0|[1-9]\d*) с\d+

function isNormalInteger(str) {
    return /^\+?\d+$/.test(str);
}

Обратите внимание на то, когда вы конвертируете это в число: на современных движках, вероятно, было бы хорошо использовать+str или жеNumber(str) чтобы сделать это, но старые могут расширить их нестандартным (но ранее разрешенным) способом, который говорит, что ведущий ноль означаетoctal (основание 8), например "010"; = & GT; 8. После подтверждения номера вы можете безопасно использоватьparseInt(str, 10) чтобы гарантировать, что он анализируется как десятичный (основание 10).parseInt будет игнорировать мусор в конце строки, но мы убедились, что с регулярным выражением ничего не будет.

Error: User Rate Limit Exceeded Mick Byrne
Error: User Rate Limit Exceededa post by James PadolseyError: User Rate Limit Exceeded
Error: User Rate Limit Exceeded
Error: User Rate Limit Exceeded
Error: User Rate Limit ExceededNumber(' ')Error: User Rate Limit ExceededNumber('')Error: User Rate Limit Exceeded0Error: User Rate Limit ExceededNaNError: User Rate Limit Exceeded
17

Похоже, регулярное выражение это путь:

var isInt = /^\+?\d+$/.test('the string');
@Chango: & quot; 1.0 & quot; не является целым числом. Это число с плавающей запятой, где дробная часть равна 0. Это большая разница. :-)
@Chango: Извините, но обязательноdownvoting за то, что он не обрабатывал научную нотацию, когда ОП ничего не сказал по этому поводу, немного резок? И что вы имеете в виду, что он "не работает"? с "-1" или "1,0"? Те, которые специально предназначены для провала, в соответствии с ОП.
Это очень неточное решение.
Закрыть, если & quot; 1.0 " или ".1e1" разрешены.
Ну, 1290000192379182379123782900192981231 - это целое число, но оно не может быть точно представлено в собственных числах JavaScript, поэтому с помощью регулярного выражения по-прежнему необходимо выполнять числовое преобразование и проверять его работоспособность.

Похожие вопросы