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

The isNaN() function determines whether a value is an illegal number (Not-a-Number).

This function returns true if the value equates to NaN. Otherwise it returns false.

This function is different from the Number specific Number.isNaN() method.

  The global isNaN() function, converts the tested value to a Number, then tests it.

Number.isNan() does not convert the values to a Number, and will not return true for any value that is not of the type Number...

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

И вы можете пойти по пути RegExp:

var num = "987238";

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

2 октября 2020 г .: обратите внимание, что многие простые подходы чреваты тонкими ошибками (например, пробелы, неявный частичный синтаксический анализ, основание, приведение массивов и т. д.), Которые многие из ответов здесь не принимают во внимание. Следующая реализация может сработать для вас, но обратите внимание, что она не обслуживает разделители чисел, кроме десятичной точки «.»:

function isNumeric(str) {
  if (typeof str != "string") return false // we only process strings!  
  return !isNaN(str) && // use type coercion to parse the _entirety_ of the string (`parseFloat` alone does not do this)...
         !isNaN(parseFloat(str)) // ...and ensure strings of whitespace fail
}

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

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

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

Для простого преобразования строки в число

Полезно для преобразования 12 пикселей в 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

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

Пока работает:

function checkNumber(value) {
    return value % 1 == 0;
}

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

Цитировать:

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

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

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

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

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

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

!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(check){ 
    check = check + "";
    var isNumber =   check.trim().length>0? !isNaN(check):false;
    return isNumber;
    }

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

    function isNumeric(value) {
        return /^-?\d+$/.test(value);
    }
    
    console.info(isNumeric('abcd'));         // false
    console.info(isNumeric('123a'));         // false
    console.info(isNumeric('1'));            // true
    console.info(isNumeric('1234567890'));   // true
    console.info(isNumeric('-23'));          // true
    console.info(isNumeric(1234));           // true
    console.info(isNumeric('123.4'));        // false
    console.info(isNumeric(''));             // false
    console.info(isNumeric(undefined));      // false
    console.info(isNumeric(null));           // false

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

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

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

В моем приложении мы разрешаем только символы a-z, A-Z и 0-9. Я нашел ответ выше, используя "нить% 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;
 };

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

Я так делаю:

function isString(value)
{
    return value.length !== undefined;
}
function isNumber(value)
{
    return value.NaN !== undefined;
}

Конечно, здесь будет отключена isString (), если вы передадите какой-либо другой объект, для которого определена длина.

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

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

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

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


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

// other types then string returns false
console.info(isInt(5));              // false
console.info(isInt(undefined));      // false
console.info(isInt(null));           // false
console.info(isInt('0x1'));          // false
console.info(isInt(Infinity));       // 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))
}

Если кто-нибудь когда-нибудь зайдет так далеко, я потратил некоторое время на взлом, пытаясь исправить момент.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

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

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

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

Почему реализация 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));
};

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

Вы можете использовать типы, такие как библиотека потока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

Мне нравится простота этого.

Number.isNaN(Number(value))

Вышеупомянутый обычный Javascript, но я использую его в сочетании с машинописным текстом Typeguard для интеллектуальной проверки типов. Это очень полезно для компилятора машинописного текста, чтобы дать вам правильный intellisense и исключить ошибки типа.

Машинописные шрифты

isNotNumber(value: string | number): value is string {
    return Number.isNaN(Number(this.smartImageWidth));
}
isNumber(value: string | number): value is number {
    return Number.isNaN(Number(this.smartImageWidth)) === false;
}

Допустим, у вас есть свойство width, которое является number | string. Возможно, вы захотите выполнить логику в зависимости от того, является ли это строкой.

var width: number|string;
width = "100vw";

if (isNotNumber(width)) 
{
    // the compiler knows that width here must be a string
    if (width.endsWith('vw')) 
    {
        // we have a 'width' such as 100vw
    } 
}
else 
{
    // the compiler is smart and knows width here must be number
    var doubleWidth = width * 2;    
}

Typeguard достаточно умен, чтобы ограничить тип width в операторе if ТОЛЬКО string. Это позволяет компилятору разрешить width.endsWith(...), чего он не разрешил бы, если бы тип был string | number.

Вы можете называть typeguard как хотите: isNotNumber, isNumber, isString, isNotString, но я думаю, что isString неоднозначен и труднее читать.

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

В статье предполагается, что переменная - это string или 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
}

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

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

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

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

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

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

Нет хорошего ответа, и ответ, получивший огромное количество голосов в этой ветке, неверен.

npm install is-number

In JavaScript, it's not always as straightforward as it should be to reliably check if a value is a number. It's common for devs to use +, -, or Number() to cast a string value to a number (for example, when values are returned from user input, regex matches, parsers, etc). But there are many non-intuitive edge cases that yield unexpected results:

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

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

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

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

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

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

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

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

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

При защите от пустых струн и null

// Base cases that are handled properly
Number.isNaN(Number('1')); // => false
Number.isNaN(Number('-1')); // => false
Number.isNaN(Number('1.1')); // => false
Number.isNaN(Number('-1.1')); // => false
Number.isNaN(Number('asdf')); // => true
Number.isNaN(Number(undefined)); // => true

// Special notation cases that are handled properly
Number.isNaN(Number('1e1')); // => false
Number.isNaN(Number('1e-1')); // => false
Number.isNaN(Number('-1e1')); // => false
Number.isNaN(Number('-1e-1')); // => false
Number.isNaN(Number('0b1')); // => false
Number.isNaN(Number('0o1')); // => false
Number.isNaN(Number('0xa')); // => false

// Edge cases that will FAIL if not guarded against
Number.isNaN(Number('')); // => false
Number.isNaN(Number(' ')); // => false
Number.isNaN(Number(null)); // => false

// Edge cases that are debatable
Number.isNaN(Number('-0b1')); // => true
Number.isNaN(Number('-0o1')); // => true
Number.isNaN(Number('-0xa')); // => true
Number.isNaN(Number('Infinity')); // => false 
Number.isNaN(Number('INFINITY')); // => true  
Number.isNaN(Number('-Infinity')); // => false 
Number.isNaN(Number('-INFINITY')); // => true  

Когда НЕ защищает от пустых строк и null

Используя parseInt:

// Base cases that are handled properly
Number.isNaN(parseInt('1')); // => false
Number.isNaN(parseInt('-1')); // => false
Number.isNaN(parseInt('1.1')); // => false
Number.isNaN(parseInt('-1.1')); // => false
Number.isNaN(parseInt('asdf')); // => true
Number.isNaN(parseInt(undefined)); // => true
Number.isNaN(parseInt('')); // => true
Number.isNaN(parseInt(' ')); // => true
Number.isNaN(parseInt(null)); // => true

// Special notation cases that are handled properly
Number.isNaN(parseInt('1e1')); // => false
Number.isNaN(parseInt('1e-1')); // => false
Number.isNaN(parseInt('-1e1')); // => false
Number.isNaN(parseInt('-1e-1')); // => false
Number.isNaN(parseInt('0b1')); // => false
Number.isNaN(parseInt('0o1')); // => false
Number.isNaN(parseInt('0xa')); // => false

// Edge cases that are debatable
Number.isNaN(parseInt('-0b1')); // => false
Number.isNaN(parseInt('-0o1')); // => false
Number.isNaN(parseInt('-0xa')); // => false
Number.isNaN(parseInt('Infinity')); // => true 
Number.isNaN(parseInt('INFINITY')); // => true  
Number.isNaN(parseInt('-Infinity')); // => true 
Number.isNaN(parseInt('-INFINITY')); // => true 

Используя parseFloat:

// Base cases that are handled properly
Number.isNaN(parseFloat('1')); // => false
Number.isNaN(parseFloat('-1')); // => false
Number.isNaN(parseFloat('1.1')); // => false
Number.isNaN(parseFloat('-1.1')); // => false
Number.isNaN(parseFloat('asdf')); // => true
Number.isNaN(parseFloat(undefined)); // => true
Number.isNaN(parseFloat('')); // => true
Number.isNaN(parseFloat(' ')); // => true
Number.isNaN(parseFloat(null)); // => true

// Special notation cases that are handled properly
Number.isNaN(parseFloat('1e1')); // => false
Number.isNaN(parseFloat('1e-1')); // => false
Number.isNaN(parseFloat('-1e1')); // => false
Number.isNaN(parseFloat('-1e-1')); // => false
Number.isNaN(parseFloat('0b1')); // => false
Number.isNaN(parseFloat('0o1')); // => false
Number.isNaN(parseFloat('0xa')); // => false

// Edge cases that are debatable
Number.isNaN(parseFloat('-0b1')); // => false
Number.isNaN(parseFloat('-0o1')); // => false
Number.isNaN(parseFloat('-0xa')); // => false
Number.isNaN(parseFloat('Infinity')); // => false 
Number.isNaN(parseFloat('INFINITY')); // => true  
Number.isNaN(parseFloat('-Infinity')); // => false 
Number.isNaN(parseFloat('-INFINITY')); // => true

Заметки:

• В соответствии с ответом на исходный вопрос рассматриваются только строковые, пустые и неинициализированные значения. Дополнительные граничные случаи существуют, если рассматриваются массивы и объекты.
• Символы в двоичной, восьмеричной, шестнадцатеричной и экспоненциальной нотации не чувствительны к регистру (то есть: «0xFF», «0XFF», «0xfF» и т. д. Дадут одинаковый результат в тестовых примерах, показанных выше).
• В отличие от Infinity (с учетом регистра), в некоторых случаях константы из объектов Number и Math, переданные в виде тестовых примеров в строковом формате любому из вышеперечисленных методов, будут определены как не числа.
• См. здесь для объяснения того, как аргументы преобразуются в Number и почему существуют крайние случаи для null и пустых строк.

Это недействительно для TypeScript, так как:

declare function isNaN(number: number): boolean;

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

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

Вот высокопроизводительная (2,5 * 10 ^ 7 итераций / с @ 3,8 ГГц Haswell) версия реализации isNumber. Он работает для всех тестов, которые я смог найти (включая символы):

var isNumber = (function () {
  var isIntegerTest = /^\d+$/;
  var isDigitArray = [!0, !0, !0, !0, !0, !0, !0, !0, !0, !0];
  function hasLeading0s (s) {
    return !(typeof s !== 'string' ||
    s.length < 2 ||
    s[0] !== '0' ||
    !isDigitArray[s[1]] ||
    isIntegerTest.test(s));
  }
  var isWhiteSpaceTest = /\s/;
  return function isNumber (s) {
    var t = typeof s;
    var n;
    if (t === 'number') {
      return (s <= 0) || (s > 0);
    } else if (t === 'string') {
      n = +s;
      return !((!(n <= 0) && !(n > 0)) || n === '0' || hasLeading0s(s) || !(n !== 0 || !(s === '' || isWhiteSpaceTest.test(s))));
    } else if (t === 'object') {
      return !(!(s instanceof Number) || ((n = +s), !(n <= 0) && !(n > 0)));
    }
    return false;
  };
})();

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.info(0, isNumeric(0) === true);
console.info(1, isNumeric(1) === true);
console.info(1234567890, isNumeric(1234567890) === true);
console.info('1234567890', isNumeric('1234567890') === true);
console.info('0', isNumeric('0') === true);
console.info('1', isNumeric('1') === true);
console.info('1.1', isNumeric('1.1') === true);
console.info('-1', isNumeric('-1') === true);
console.info('-1.2354', isNumeric('-1.2354') === true);
console.info('-1234567890', isNumeric('-1234567890') === true);
console.info(-1, isNumeric(-1) === true);
console.info(-32.1, isNumeric(-32.1) === true);
console.info('0x1', isNumeric('0x1') === true);  // Valid number in hex
// Negative Cases
console.info(true, isNumeric(true) === false);
console.info(false, isNumeric(false) === false);
console.info('1..1', isNumeric('1..1') === false);
console.info('1,1', isNumeric('1,1') === false);
console.info('-32.1.12', isNumeric('-32.1.12') === false);
console.info('[blank]', isNumeric('') === false);
console.info('[spaces]', isNumeric('   ') === false);
console.info('null', isNumeric(null) === false);
console.info('undefined', isNumeric(undefined) === false);
console.info([], isNumeric([]) === false);
console.info('NaN', isNumeric(NaN) === false);

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

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

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

Это основано на некоторых предыдущих ответах и ​​комментариях. Следующее охватывает все крайние случаи и также довольно кратко:

const isNumRegEx = /^-?(\d*\.)?\d+$/;

function isNumeric(n, allowScientificNotation = false) {
    return allowScientificNotation ? 
                !Number.isNaN(parseFloat(n)) && Number.isFinite(n) :
                isNumRegEx.test(n);
}

Это, кажется, улавливает, казалось бы, бесконечное количество крайних случаев:

function isNumber(x, noStr) {
    /*

        - Returns true if x is either a finite number type or a string containing only a number
        - If empty string supplied, fall back to explicit false
        - Pass true for noStr to return false when typeof x is "string", off by default

        isNumber(); // false
        isNumber([]); // false
        isNumber([1]); // false
        isNumber([1,2]); // false
        isNumber(''); // false
        isNumber(null); // false
        isNumber({}); // false
        isNumber(true); // false
        isNumber('true'); // false
        isNumber('false'); // false
        isNumber('123asdf'); // false
        isNumber('123.asdf'); // false
        isNumber(undefined); // false
        isNumber(Number.POSITIVE_INFINITY); // false
        isNumber(Number.NEGATIVE_INFINITY); // false
        isNumber('Infinity'); // false
        isNumber('-Infinity'); // false
        isNumber(Number.NaN); // false
        isNumber(new Date('December 17, 1995 03:24:00')); // false
        isNumber(0); // true
        isNumber('0'); // true
        isNumber(123); // true
        isNumber(123.456); // true
        isNumber(-123.456); // true
        isNumber(-.123456); // true
        isNumber('123'); // true
        isNumber('123.456'); // true
        isNumber('.123'); // true
        isNumber(.123); // true
        isNumber(Number.MAX_SAFE_INTEGER); // true
        isNumber(Number.MAX_VALUE); // true
        isNumber(Number.MIN_VALUE); // true
        isNumber(new Number(123)); // true
    */

    return (
        (typeof x === 'number' || x instanceof Number || (!noStr && x && typeof x === 'string' && !isNaN(x))) &&
        isFinite(x)
    ) || false;
};

Я использовал эту функцию как инструмент проверки формы, и я не хотел, чтобы пользователи могли писать экспоненциальную функцию, поэтому я придумал эту функцию:

<script>

    function isNumber(value, acceptScientificNotation) {

        if (true !== acceptScientificNotation){
            return /^-{0,1}\d+(\.\d+)?$/.test(value);
        }

        if (true === Array.isArray(value)) {
            return false;
        }
        return !isNaN(parseInt(value, 10));
    }


    console.info(isNumber(""));              // false
    console.info(isNumber(false));           // false
    console.info(isNumber(true));            // false
    console.info(isNumber("0"));             // true
    console.info(isNumber("0.1"));           // true
    console.info(isNumber("12"));            // true
    console.info(isNumber("-12"));           // true
    console.info(isNumber(-45));             // true
    console.info(isNumber({jo: "pi"}));      // false
    console.info(isNumber([]));              // false
    console.info(isNumber([78, 79]));        // false
    console.info(isNumber(NaN));             // false
    console.info(isNumber(Infinity));        // false
    console.info(isNumber(undefined));       // false
    console.info(isNumber("0,1"));           // false



    console.info(isNumber("1e-1"));          // false
    console.info(isNumber("1e-1", true));    // true
</script>

Итак, это будет зависеть от тестовых случаев, которые вы хотите обработать.

function isNumeric(number) {
  return !isNaN(parseFloat(number)) && !isNaN(+number);
}

Я искал обычные типы чисел в javascript. 0, 1 , -1, 1.1 , -1.1 , 1E1 , -1E1 , 1e1 , -1e1, 0.1e10, -0.1.e10 , 0xAF1 , 0o172, Math.PI, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY

А также они представлены в виде строк:
'0', '1', '-1', '1.1', '-1.1', '1E1', '-1E1', '1e1', '-1e1', '0.1e10', '-0.1.e10', '0xAF1', '0o172'

Я действительно хотел исключить и не отмечать их как числовые '', ' ', [], {}, null, undefined, NaN

На сегодняшний день все остальные ответы, похоже, не прошли один из этих тестовых примеров.