Я надеюсь, что есть что-то в том же концептуальном пространстве, что и старая IsNumeric()функция VB6 ?

Чтобы проверить, является ли переменная (включая строку) числом, проверьте, не является ли она числом:

Это работает независимо от того, является ли содержимое переменной строкой или числом.

isNaN(num)         // returns true if the variable does NOT contain a valid number

Примеры

isNaN(123)         // false
isNaN('123')       // false
isNaN('1e10000')   // false (This translates to Infinity, which is a number)
isNaN('foo')       // true
isNaN('10px')      // true

Конечно, вы можете отрицать это, если вам нужно. Например, чтобы реализовать IsNumericпример, который вы дали:

function isNumeric(num){
  return !isNaN(num)
}

Чтобы преобразовать строку, содержащую число, в число:

Работает только в том случае, если строка содержит только числовые символы, иначе она возвращает NaN.

+num               // returns the numeric value of the string, or NaN 
                   // if the string isn't purely numeric characters

Примеры

+'12'              // 12
+'12.'             // 12
+'12..'            // NaN
+'.12'             // 0.12
+'..12'            // NaN
+'foo'             // NaN
+'12px'            // NaN

Чтобы преобразовать строку свободно в число

Полезно для преобразования 12px в 12, например:

parseInt(num)      // extracts a numeric value from the 
                   // start of the string, or NaN.

Примеры

parseInt('12')     // 12
parseInt('aaa')    // NaN
parseInt('12px')   // 12
parseInt('foo2')   // NaN      These last two may be different
parseInt('12a5')   // 12       from what you expected to see. 

Поплавки

Имейте в виду , что, в отличие от +num, parseInt(как следует из названия) преобразует поплавок в целое число, отрубая все после десятичной точки (если вы хотите использовать parseInt() из - за этого поведения, вы , вероятно , лучше использовать другой метод вместо ) :

+'12.345'          // 12.345
parseInt(12.345)   // 12
parseInt('12.345') // 12

Пустые строки

Пустые строки могут быть немного нелогичными. +numпреобразует пустые строки или строки с пробелами в ноль и isNaN()предполагает то же самое:

+''                // 0
+'   '             // 0
isNaN('')          // false
isNaN('   ')       // false

Но parseInt()не согласен

parseInt('')       // NaN
parseInt('   ')    // NaN

И вы могли бы пойти RegExp-путь:

var num = "987238";

if(num.match(/^-{0,1}\d+$/)){
  //valid integer (positive or negative)
}else if(num.match(/^\d+\.\d+$/)){
  //valid float
}else{
  //not valid number
}

Если вы просто пытаетесь проверить, является ли строка целым числом (без десятичных разрядов), регулярное выражение является хорошим способом. Другие методы, такие как 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

Чтобы разрешить только положительные целые числа, используйте это:

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

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

Если вы действительно хотите , чтобы убедиться сделать , что строка содержит только число, любое число (целое или с плавающей точкой), а именно номер, вы не можете использовать 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()возвращает число, когда это не должно, и наоборот. Поэтому, чтобы узнать, является ли строка действительно точной и только числом, вызовите обе функции и посмотрите, возвращают ли они обе true:

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

Принятый ответ на этот вопрос имеет довольно много недостатков (как было подчеркнуто несколькими другими пользователями). Это один из самых простых и проверенных способов подойти к нему в javascript:

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

Ниже приведены несколько хороших тестовых случаев:

console.log(isNumeric(12345678912345678912)); // true
console.log(isNumeric('2 '));                 // true
console.log(isNumeric('-32.2 '));             // true
console.log(isNumeric(-32.2));                // true
console.log(isNumeric(undefined));            // false

// the accepted answer fails at these tests:
console.log(isNumeric(''));                   // false
console.log(isNumeric(null));                 // false
console.log(isNumeric([]));                   // false

Попробуйте функцию isNan :

Функция isNaN () определяет, является ли значение недопустимым числом (Not-a-Number).

Эта функция возвращает true, если значение равно NaN. В противном случае возвращается false.

Эта функция отличается от метода Number.isNaN () для конкретного номера .

  Глобальная функция isNaN () преобразует проверенное значение в число, а затем проверяет его.

Number.isNan () не преобразует значения в Number и не возвращает true для любого значения, которое не относится к типу Number ...

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

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

!isNaN('1e+30')это true, однако , в большинстве случаев , когда люди просят числа, они не хотят , чтобы соответствовать вещам , как 1e+30.

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

Обратите внимание (используя 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 цифрами (после пропуска ведущих нулей).

бесконечность

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

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

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

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, [] (и других?)

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

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

Примечания: Обратите внимание, при пропуске пустой строки или, '\t\t'а '\n\t'как число вернет 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

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

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

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

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

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

Quote:

isNaN (num) // возвращает true, если переменная НЕ содержит действительное число

не совсем верно, если вам нужно проверить начальные / конечные пробелы - например, когда требуется определенное количество цифр, и вам нужно получить, скажем, «1111», а не «111» или «111» для, возможно, PIN-кода вход.

Лучше использовать:

var num = /^\d+$/.test(num)

Почему реализация jQuery недостаточно хороша?

function isNumeric(a) {
    var b = a && a.toString();
    return !$.isArray(a) && b - parseFloat(b) + 1 >= 0;
};

Майкл предложил что-то вроде этого (хотя я украл измененную версию "user1691651 - John" здесь):

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

Ниже приведено решение, которое, скорее всего, имеет плохую производительность, но хорошие результаты. Это придумка, сделанная из реализации jQuery 1.12.4 и ответа Майкла, с дополнительной проверкой для пробелов в начале / конце (потому что версия Майкла возвращает true для чисел с пробелами в начале / конце):

function isNumeric(a) {
    var str = a + "";
    var b = a && a.toString();
    return !$.isArray(a) && b - parseFloat(b) + 1 >= 0 &&
           !/^\s+|\s+$/g.test(str) &&
           !isNaN(str) && !isNaN(parseFloat(str));
};

Последняя версия имеет две новые переменные. Один из них можно обойти, выполнив:

function isNumeric(a) {
    if ($.isArray(a)) return false;
    var b = a && a.toString();
    a = a + "";
    return b - parseFloat(b) + 1 >= 0 &&
            !/^\s+|\s+$/g.test(a) &&
            !isNaN(a) && !isNaN(parseFloat(a));
};

Я не очень-то тестировал эти средства, кроме как вручную протестировать те несколько сценариев использования, которые мне удастся использовать в моем нынешнем затруднительном положении, и все это очень стандартные вещи. Это ситуация «стоять на плечах гигантов».

Это недопустимо для TypeScript как:

declare function isNaN(number: number): boolean;

Для TypeScript вы можете использовать:

/^\d+$/.test(key)

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

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

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

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

Если кто-нибудь когда-нибудь зайдет так далеко, я потратил некоторое время на то, чтобы попытаться исправить patch.js ( https://github.com/moment/moment ). Вот что я у него забрал:

function isNumeric(val) {
    var _val = +val;
    return (val !== val + 1) //infinity check
        && (_val === +val) //Cute coercion check
        && (typeof val !== 'object') //Array/object check
}

Обрабатывает следующие случаи:

Правда! :

isNumeric("1"))
isNumeric(1e10))
isNumeric(1E10))
isNumeric(+"6e4"))
isNumeric("1.2222"))
isNumeric("-1.2222"))
isNumeric("-1.222200000000000000"))
isNumeric("1.222200000000000000"))
isNumeric(1))
isNumeric(0))
isNumeric(-0))
isNumeric(1010010293029))
isNumeric(1.100393830000))
isNumeric(Math.LN2))
isNumeric(Math.PI))
isNumeric(5e10))

Ложь! :

isNumeric(NaN))
isNumeric(Infinity))
isNumeric(-Infinity))
isNumeric())
isNumeric(undefined))
isNumeric('[1,2,3]'))
isNumeric({a:1,b:2}))
isNumeric(null))
isNumeric([1]))
isNumeric(new Date()))

По иронии судьбы, тот, с которым я борюсь больше всего:

isNumeric(new Number(1)) => false

Любые предложения приветствуются. :]

Используя простой JavaScript:

Number.isNaN(Number('1')); // false
Number.isNaN(Number('asdf')); // true

Используя Lodash:

_.isNaN(_.toNumber('1')); // false
_.isNaN(_.toNumber('asdf')); // true

function isNumberCandidate(s) {
  const str = (''+ s).trim();
  if (str.length === 0) return false;
  return !isNaN(+str);
}

console.log(isNumberCandidate('1'));       // true
console.log(isNumberCandidate('a'));       // false
console.log(isNumberCandidate('000'));     // true
console.log(isNumberCandidate('1a'));      // false 
console.log(isNumberCandidate('1e'));      // false
console.log(isNumberCandidate('1e-1'));    // true
console.log(isNumberCandidate('123.3'));   // true
console.log(isNumberCandidate(''));        // false
console.log(isNumberCandidate(' '));       // false
console.log(isNumberCandidate(1));         // true
console.log(isNumberCandidate(0));         // true
console.log(isNumberCandidate(NaN));       // false
console.log(isNumberCandidate(undefined)); // false
console.log(isNumberCandidate(null));      // false
console.log(isNumberCandidate(-1));        // true
console.log(isNumberCandidate('-1'));      // true
console.log(isNumberCandidate('-1.2'));    // true
console.log(isNumberCandidate(0.0000001)); // true
console.log(isNumberCandidate('0.0000001')); // true
console.log(isNumberCandidate(Infinity));    // true
console.log(isNumberCandidate(-Infinity));    // true

console.log(isNumberCandidate('Infinity'));  // true

if (isNumberCandidate(s)) {
  // use +s as a number
  +s ...
}

2019: включая примеры ES3, ES6 и TypeScript

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

ES3

var isNumeric = function(num){
    return (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num);  
}

ES6

const isNumeric = (num) => (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num);

Машинопись

const isNumeric = (num: any) => (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num as number);

Это кажется довольно простым и охватывает все основы, которые я видел на многих других постах и ​​придумал сам:

// Positive Cases
console.log(0, isNumeric(0) === true);
console.log(1, isNumeric(1) === true);
console.log(1234567890, isNumeric(1234567890) === true);
console.log('1234567890', isNumeric('1234567890') === true);
console.log('0', isNumeric('0') === true);
console.log('1', isNumeric('1') === true);
console.log('1.1', isNumeric('1.1') === true);
console.log('-1', isNumeric('-1') === true);
console.log('-1.2354', isNumeric('-1.2354') === true);
console.log('-1234567890', isNumeric('-1234567890') === true);
console.log(-1, isNumeric(-1) === true);
console.log(-32.1, isNumeric(-32.1) === true);
console.log('0x1', isNumeric('0x1') === true);  // Valid number in hex
// Negative Cases
console.log(true, isNumeric(true) === false);
console.log(false, isNumeric(false) === false);
console.log('1..1', isNumeric('1..1') === false);
console.log('1,1', isNumeric('1,1') === false);
console.log('-32.1.12', isNumeric('-32.1.12') === false);
console.log('[blank]', isNumeric('') === false);
console.log('[spaces]', isNumeric('   ') === false);
console.log('null', isNumeric(null) === false);
console.log('undefined', isNumeric(undefined) === false);
console.log([], isNumeric([]) === false);
console.log('NaN', isNumeric(NaN) === false);

Вы также можете попробовать свою собственную isNumericфункцию и просто пройти мимо этих вариантов использования и отсканировать «true» для всех из них.

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

2019: практическая и строгая проверка числовой достоверности

Часто «действительное число» означает число Javascript, исключая NaN и Infinity, то есть «конечное число».

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

/**
 * Returns true if 'candidate' is a finite number or a string referring (not just 'including') a finite number
 * To keep in mind:
 *   Number(true) = 1
 *   Number('') = 0
 *   Number("   10  ") = 10
 *   !isNaN(true) = true
 *   parseFloat('10 a') = 10
 *
 * @param {?} candidate
 * @return {boolean}
 */
function isReferringFiniteNumber(candidate) {
  if (typeof (candidate) === 'number') return Number.isFinite(candidate);
  if (typeof (candidate) === 'string') {
    return (candidate.trim() !== '') && Number.isFinite(Number(candidate));
  }
  return false;
}

и используйте это так:

if (isReferringFiniteNumber(theirValue)) {
  myCheckedValue = Number(theirValue);
} else {
  console.warn('The provided value doesn\'t refer to a finite number');
}

ПФБ рабочий раствор:

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

Избавьте себя от головной боли, пытаясь найти «встроенное» решение.

Там нет хорошего ответа, и крайне недооцененный ответ в этой теме является неправильным.

npm install is-number

В JavaScript это не всегда так просто, как следует проверять, является ли значение числом. Обычно разработчики используют +, - или Number () для приведения строкового значения к числу (например, когда значения возвращаются из пользовательского ввода, совпадений регулярных выражений, анализаторов и т. Д.). Но есть много неинтуитивных крайних случаев, которые дают неожиданные результаты:

console.log(+[]); //=> 0
console.log(+''); //=> 0
console.log(+'   '); //=> 0
console.log(typeof NaN); //=> 'number'

Недавно я написал статью о том, как убедиться, что переменная является действительным числом: https://github.com/jehugaleahsa/artifacts/blob/master/2018/typescript_num_hack.md В статье объясняется, как обеспечить с плавающей запятой или целое число, если это важно ( +xпротив ~~x).

В статье предполагается, что переменная a stringили a numberдля начала и trimдоступна / заполнена. Нетрудно расширить его и на другие типы. Вот мясо этого:

// Check for a valid float
if (x == null
    || ("" + x).trim() === ""
    || isNaN(+x)) {
    return false;  // not a float
}

// Check for a valid integer
if (x == null
    || ("" + x).trim() === ""
    || ~~x !== +x) {
    return false;  // not an integer
}

Моя попытка немного сбить с толку, Pherhaps не лучшее решение

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));           // false
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

В моем приложении мы допускаем только символы AZ и 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)], я не могу за это говорить, но это именно то, что нам нужно.

Мое решение:

// returns true for positive ints; 
// no scientific notation, hexadecimals or floating point dots

var isPositiveInt = function(str) { 
   var result = true, chr;
   for (var i = 0, n = str.length; i < n; i++) {
       chr = str.charAt(i);
       if ((chr < "0" || chr > "9") && chr != ",") { //not digit or thousands separator
         result = false;
         break;
       };
       if (i == 0 && (chr == "0" || chr == ",")) {  //should not start with 0 or ,
         result = false;
         break;
       };
   };
   return result;
 };

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

Вы можете использовать типы, как в потоке librar y, для статической проверки времени компиляции. Конечно, не очень полезно для пользовательского ввода.

// @flow

function acceptsNumber(value: number) {
  // ...
}

acceptsNumber(42);       // Works!
acceptsNumber(3.14);     // Works!
acceptsNumber(NaN);      // Works!
acceptsNumber(Infinity); // Works!
acceptsNumber("foo");    // Error!

Вот одна строка, чтобы проверить, sNumявляется ли допустимое числовое значение; он был протестирован для широкого спектра материалов:

!isNaN(+s.replace(/\s|\$/g, ''));  // returns True if numeric value

Просто используйте isNaN(), это преобразует строку в число, и если получит правильное число , вернет false...

isNaN("Alireza"); //return true
isNaN("123"); //return false

Я использую следующее:

const isNumber = s => !isNaN(+s)