Обеспечить ввод числовой (с плавающей запятой) с помощью Javascript, позволяющий знак минус? [Дубликат]

Если вы просто пытаетесь проверить, является ли строка целым числом (без десятичных знаков), регулярное выражение - это хороший способ. Другие методы, такие как isNaN, слишком сложны для чего-то настолько простого.

function isNumeric(value) {
    return /^-{0,1}\d+$/.test(value);
}

console.log(isNumeric('abcd'));         // false
console.log(isNumeric('123a'));         // false
console.log(isNumeric('1'));            // true
console.log(isNumeric('1234567890'));   // true
console.log(isNumeric('-23'));          // true
console.log(isNumeric(1234));           // true
console.log(isNumeric('123.4'));        // false
console.log(isNumeric(''));             // false
console.log(isNumeric(undefined));      // false
console.log(isNumeric(null));           // false

Чтобы использовать только целые числа positive , используйте это:

function isNumeric(value) {
    return /^\d+$/.test(value);
}

console.log(isNumeric('123'));          // true
console.log(isNumeric('-23'));          // false

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

Если аргумент (строка) не может быть преобразован в число, он возвращает NaN, поэтому вы можете определить, была ли приведенная строка допустимым числом или нет.

Примечания: Обратите внимание, что при передаче пустой строки или '\t\t' и '\n\t', когда Number возвращает 0; Передача true вернет 1, а false вернет 0.

    Number('34.00') // 34
    Number('-34') // -34
    Number('123e5') // 12300000
    Number('123e-5') // 0.00123
    Number('999999999999') // 999999999999
    Number('9999999999999999') // 10000000000000000 (integer accuracy up to 15 digit)
    Number('0xFF') // 255
    Number('Infinity') // Infinity  

    Number('34px') // NaN
    Number('xyz') // NaN
    Number('true') // NaN
    Number('false') // NaN

    // cavets
    Number('    ') // 0
    Number('\t\t') // 0
    Number('\n\t') // 0

Моя попытка немного запутать, возможно, не лучшее решение

function isInt(a){
    return a === ""+~~a
}


console.log(isInt('abcd'));         // false
console.log(isInt('123a'));         // false
console.log(isInt('1'));            // true
console.log(isInt('0'));            // true
console.log(isInt('-0'));           // false
console.log(isInt('01'));           // false
console.log(isInt('10'));           // true
console.log(isInt('-1234567890'));  // true
console.log(isInt(1234));           // true
console.log(isInt('123.4'));        // false
console.log(isInt(''));             // false

// other types then string returns false
console.log(isInt(5));              // false
console.log(isInt(undefined));      // false
console.log(isInt(null));           // false
console.log(isInt('0x1'));          // false
console.log(isInt(Infinity));       // false

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

if(str === String(Number(str))) {
  // it's a "perfectly formatted" number
}

Остерегайтесь! Это будет отклонять строки, такие как .1, 40.000, 080, 00.1. Это очень придирчиво - строка должна соответствовать «самой минимальной совершенной форме» номера для прохождения этого теста.

Он использует конструктор String и Number для перевода строки в число и назад, и, таким образом, проверяет, соответствует ли «идеальная минимальная форма» JavaScript (тот, который он преобразовал с помощью исходного конструктора Number) в исходную строку.

Я тестировал, и решение Майкла лучше. Проголосуйте за его ответ выше (найдите эту страницу для «Если вы действительно хотите убедиться, что строка», чтобы найти ее). В сущности, его ответ таков:

function isNumeric(num){
  num = "" + num; //coerce num to be a string
  return !isNaN(num) && !isNaN(parseFloat(num));
}

Он работает для каждого тестового примера, который я описал здесь: https://jsfiddle.net/wggehvp9/5/

Многие из других решений терпят неудачу для этих случаев: '', null, "", true и []. Теоретически вы можете использовать их с правильной обработкой ошибок, например:

return !isNaN(num);

или

return (+num === +num);

со специальной обработкой для / \ s /, null, "" , true, false, [] (и другие?)

parseInt (), но имейте в виду, что эта функция немного отличается в том смысле, что она, например, возвращает 100 для parseInt («100px»).

Старый вопрос, но в данных ответах несколько точек.

Научная нотация.

!isNaN('1e+30') is true, однако в большинстве случаев, когда люди

Большие плавающие числа могут вести себя странно

Наблюдать (используя Node.js):

> var s = Array(16 + 1).join('9')
undefined
> s.length
16
> s
'9999999999999999'
> !isNaN(s)
true
> Number(s)
10000000000000000
> String(Number(s)) === s
false
>

С другой стороны:

> var s = Array(16 + 1).join('1')
undefined
> String(Number(s)) === s
true
> var s = Array(15 + 1).join('9')
undefined
> String(Number(s)) === s
true
>

Итак, если вы ожидаете String(Number(s)) === s, тогда лучше ограничьте свои строки до 15 цифр максимум (после опущения ведущих нулей).

Infinity

> typeof Infinity
'number'
> !isNaN('Infinity')
true
> isFinite('Infinity')
false
>

Учитывая все это, проверяя, что данная строка является числом, удовлетворяющим всем следующим:

• не научная нотация
• предсказуемое преобразование в Number и обратно в String
• конечный

не является такой простой задачей. Вот простая версия:

  function isNonScientificNumberString(o) {
    if (!o || typeof o !== 'string') {
      // Should not be given anything but strings.
      return false;
    }
    return o.length <= 15 && o.indexOf('e+') < 0 && o.indexOf('E+') < 0 && !isNaN(o) && isFinite(o);
  }

Однако даже этот далеко не полный. Ведущие нули здесь не обрабатываются, но они проводят проверку длины.

Если вы действительно хотите убедиться, что строка содержит только число, любое число (целая или плавающая точка) и точно число, вы не можете использовать parseInt() / parseFloat(), Number() или !isNaN() сами по себе. Обратите внимание, что !isNaN() на самом деле возвращает true, когда Number() вернет число, а false, когда он вернет NaN, поэтому я исключу его из остальной части обсуждения.

] Проблема с parseFloat() в том, что она вернет число, если строка содержит любое число, даже если строка не содержит только и точно число:

parseFloat("2016-12-31")  // returns 2016
parseFloat("1-1") // return 1
parseFloat("1.2.3") // returns 1.2

Проблема с Number() заключается в том, что она вернет число в случаях, когда переданное значение не является числом вообще!

Number("") // returns 0
Number(" ") // returns 0
Number(" \u00A0   \t\n\r") // returns 0

Проблема с переводом ваших собственное регулярное выражение заключается в том, что если вы не создадите точное регулярное выражение для сопоставления числа с плавающей запятой, как признает Javascript, вы будете пропускать случаи или распознавать случаи, когда вам не следует. И даже если вы можете перевернуть свое собственное регулярное выражение, почему? Есть еще более простые способы сделать это.

Однако оказывается, что Number() (и isNaN()) делает правильную вещь для каждого случая, когда parseFloat() возвращает число, когда оно должно 't, и наоборот. Итак, чтобы узнать, действительно ли строка точно и только число, вызовите обе функции и посмотрите, верят ли они оба :

function isNumber(str) {
  if (typeof str != "string") return false // we only process strings!
  // could also coerce to string: str = ""+str
  return !isNaN(str) && !isNaN(parseFloat(str))
}

PFB - рабочее решение:

 function(check){ 
    check = check + "";
    var isNumber =   check.trim().length>0? !isNaN(check):false;
    return isNumber;
    }

Ну, я использую этот, который я сделал ...

Он работает до сих пор:

function checkNumber(value) {
    if ( value % 1 == 0 )
    return true;
    else
    return false;
}

Если вы заметили какие-либо проблемы с этим, скажите мне, пожалуйста.

В моем приложении мы разрешаем только a-z A-Z и 0-9 символов. Я нашел ответ выше, используя « string % 1 === 0», если строка не начиналась с 0xnn (например, 0x10), а затем она возвращала бы ее как числовую, когда мы этого не хотели. Следующая простая ловушка в моей числовой проверке, похоже, делает трюк в наших конкретных случаях.

function isStringNumeric(str_input){   
    //concat a temporary 1 during the modulus to keep a beginning hex switch combination from messing us up   
    //very simple and as long as special characters (non a-z A-Z 0-9) are trapped it is fine   
    return '1'.concat(str_input) % 1 === 0;}

Внимание: это может быть связано с давней ошибкой в ​​Javascript и Actionscript [Number ("1" + the_string)% 1 === 0)], я не могу говорить за это, но это именно то, что нам нужно.