Как проверить, является ли строка действительным числом?

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

Вот пример функции, которая проверяет, является ли значение целым числом:

function isNumeric(value) {
    return /^-?\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(1234n));          // 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

Таким образом, с помощью регулярных выражений можно легко и эффективно проверить строку на наличие целого числа.

Принятый ответ на этот вопрос имеет несколько недостатков (как отметили некоторые другие пользователи). Вот один из самых простых и проверенных способов решения этой задачи в 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

// Принятый ответ не проходит эти тесты:
console.log(isNumeric(''));                   // false
console.log(isNumeric(null));                 // false
console.log(isNumeric([]));                   // false

Этот подход позволяет корректно проверять, является ли значение числовым, и учитывает различные случаи, которые могут быть упущены другими решениями.

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

var str = "987238";

if(str.match(/^-?\d+$/)){
  // валидное целое число (положительное или отрицательное)
  const num = parseInt(str, 10);
} else if(str.match(/^-?\d*\.\d+$/)){
  // валидное дробное число
  const num = parseFloat(str);
} else {
  // не валидное число
}

В этом коде сначала проверяется, соответствует ли строка формату целого числа с помощью регулярного выражения /^-?\d+$/, которое позволяет отрицательные и положительные целые числа. Если это условие не выполняется, проверяется, является ли строка дробным числом с помощью регулярного выражения /^-?\d*\.\d+$/. Если строка не соответствует ни одному из этих условий, она считается невалидной.

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

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

parseFloat("2016-12-31")  // вернёт 2016
parseFloat("1-1") // вернёт 1
parseFloat("1.2.3") // вернёт 1.2

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

Number("") // вернёт 0
Number(" ") // вернёт 0
Number(" \u00A0   \t\n\r") // вернёт 0

Проблема с написанием собственного регулярного выражения заключается в том, что если вы не создадите точное регулярное выражение для сопоставления дробного числа, как его понимает JavaScript, вы пропустите некоторые случаи или, наоборот, распознаете случаи, которые не должны быть признаны. Даже если вы сможете создать собственное регулярное выражение, зачем это делать? Существуют более простые встроенные способы.

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

function isNumber(str) {
  if (typeof str != "string") return false; // обрабатываем только строки!
  // также можно привести к строке: str = "" + str
  return !isNaN(str) && !isNaN(parseFloat(str));
}

Конечно, вот перевод на русский в стиле ответа на StackOverflow:

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

Однострочное решение для проверки целого числа (isInteger):

const isInteger = num => /^-?[0-9]+$/.test(num+'');

Однострочное решение для проверки числового значения (isNumeric): Принимает как целые числа, так и дробные.

const isNumeric = num => /^-?[0-9]+(?:\.[0-9]+)?$/.test(num+'');

Если у вас есть дополнительные вопросы или требуется объяснение, не стесняйтесь спрашивать!