Я сподіваюся, що в такому концептуальному просторі є щось таке, що і стара 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()повертає число, коли воно не повинно, і навпаки. Тож, щоб дізнатись, чи справді рядок є саме таким і лише числом, зателефонуйте обом функціям і подивіться, чи вони обидва повертають істину:

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. В іншому випадку він повертає помилкове.

Ця функція відрізняється від конкретного числа.isNaN () методу .

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

Number.isNan () не перетворює значення в число і не поверне істинне для будь-якого значення, яке не належить до типу 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, [] (та інші?)

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

Якщо аргумент (рядок) не може бути перетворений у число, він повертає NaN, тому ви можете визначити, чи надана рядок була дійсною чи ні.

Примітки: Примітка при передачі порожнього рядка або '\t\t'і '\n\t'як число поверне 0; При передачі істини повернеться 1, а помилкове - 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. Це дуже вибагливо - рядок повинен відповідати " найменш досконалій формі " числа для проходження цього тесту.

Він використовує Stringі Numberконструктор, щоб передати рядок до числа і знову, і тим самим перевіряє, чи відповідає "ідеальна мінімальна форма" двигуна JavaScript (та, яку він перетворив у початковий Numberконструктор).

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

Цитата:

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

Майкл запропонував щось подібне (хоча я вкрав змінену версію користувача "16166565 - Джон "):

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

Далі йде рішення з найбільш ймовірно поганими показниками, але надійними результатами. Це вигадка, зроблена з реалізації jQuery 1.12.4 та відповіді Майкла, з додатковою перевіркою провідних / кінцевих пробілів (тому що версія Майкла повертає істинні для числових значень із провідними / трейлінгами):

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

Якщо ви помітили якусь проблему з цим, скажіть, будь ласка.

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

Використання Лодаша:

_.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функцію та лише минуле в цих випадках використання та сканувати "справжнє" для всіх.

Або, щоб побачити значення, які кожен повертає:

2019: Практична і чітка чисельна перевірка дійсності

Часто "дійсне число" означає номер Javascript, виключаючи NaN та нескінченність, тобто "кінцеве число".

Щоб перевірити числову достовірність значення (наприклад, із зовнішнього джерела), ви можете визначити у стилі 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');
}

PFB робоче рішення:

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

Збережіть собі головний біль від спроби знайти «вбудоване» рішення.

Немає хорошої відповіді, і надзвичайно обґрунтована відповідь у цій темі невірна.

npm install is-number

У JavaScript це не завжди так просто, як це слід надійно перевірити, чи є значення числом. Devs звичайно використовувати +, - або 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 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;
 };

Ви можете додати додаткові умови всередині циклу, щоб відповідати вашим конкретним потребам.

Ви можете використовувати типи, як, наприклад, у бібліотеці потоків 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)