(Вбудований) спосіб у JavaScript, щоб перевірити, чи є рядок дійсним номером


1189

Я сподіваюся, що в такому концептуальному просторі є щось таке, що і стара IsNumeric()функція VB6 ?


3
Дивіться це пов'язане питання , яке я задав деякий час тому.
Майкл Харен

38
Якщо ви перейшли до цього питання, спробуйте пропустити всі відповіді RegEx. Це просто НЕ спосіб зробити це.
Джоель Куехорн

14
Якщо хтось не хоче зробити саме це: Щоб перевірити, чи є в заданому рядку формат дійсного потоку цифр. Чому тоді слід помилятися?
SasQ

17
Обрана відповідь невірна !!! Дивіться свої коментарі, але в основному це не вдається, наприклад , з isNaN(""), isNaN(" "), isNaN(false)і т.д. Він повертається falseдля них, це означає , що вони є числами.
Андрій

1
тож обрана відповідь є невірною, а також регулярне вирівнювання не є так. Який з них тоді правильний?
Вір нам

Відповіді:


2322

Щоб перевірити, чи є змінною (включаючи рядок) число, перевірте, чи не є вона числом:

Це працює незалежно від того, вміст змінної - це рядок чи число.

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

133
Дуже важливою зауваженням про parseInt є те, що він дозволить вам вказати радіус для перетворення рядка в int. Це велика готча, тому що вона намагається відгадати радіус для вас, якщо ви не поставите її. Так, наприклад: parseInt ("17") приводить до 17 (десятковий, 10), але parseInt ("08") приводить до 0 (восьмеричний, 8). Отже, якщо ви не маєте наміру іншого, найбезпечніше використовувати parseInt (число, 10), вказавши явно 10 як радіус.
Адам Реней

36
Зауважте, що! IsNaN (undefined) повертає значення false.
Девід Гелсінг

111
Це просто неправильно - як це отримало стільки результатів? Ви не можете використовувати isNaN"Щоб перевірити, чи змінна не є числом". "не число" не те саме, що "IEEE-794 NaN", для чого isNaNтести. Зокрема, це використання не вдається при тестуванні булевих та порожніх рядків. Див. Розробник.mozilla.org/ en-US/ docs/ Web/JavaScript/ Reference/… .
EML

46
Найшвидший спосіб перевірити, чи є щось число, - це перевірка "рівності самому": var n = 'a'; if (+n === +n) { // is number }це на 3994% швидше, ніж isNaN в останній версії Chrome. Дивіться тест на працездатність тут: jsperf.com/isnan-vs-typeof/5
Кевін Юрковський

22
** Попередження ** Ця відповідь неправильна. Використовуйте на свій страх і ризик. Приклад:isNaN(1 + false + parseInt("1.do you trust your users?"))
keithpjolley

55

І ви можете пройти шлях 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
}

40
У цьому випадку RegExp == погано
Джоель Коухорн

10
Це не вдається в шістнадцяткових числах (наприклад, 0x12), плаває без провідного нуля (.42, наприклад) та від’ємних чисел.
Орі

17
@JoelCoehoorn Care детально пояснює, чому тут RegExp == погано? Здається, це для мене дійсний випадок використання.
computrius

6
Існує більше способів, ніж, як здається, побудувати число (шістнадцяткові числа в іншому коментарі - лише один приклад), і є багато чисел, які можуть не вважатись дійсними (переповнення типу, занадто точне тощо). Крім того, регулярний вираз є і повільнішим, і складнішим, ніж просто використання вбудованих механізмів
Joel Coehoorn

1
також повинен відповідати науковій нотації ... 1e10 тощо
Джозеф Мердріньяк

51

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

11
console.log (isNumeric ('- 1'));
yongnan

5
console.log (isNumeric ('2e2'));
Гаель Барбін

11
Можливо, просто перейменуйте "isNumeric" на "hasOnlyDigits". у багатьох випадках саме такий чек ви шукаєте.
gus3001

1
Це те, що я шукав, еквівалент php ctype_digit
Miguel Pynto

/^-?\d+$/правильно?
Сукіма

36

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

2
Це повертає справжнє значення, коли в рядку є пробіли чи пробіли. ' 1', '2 'і ' 3 'все повертається правдою.
Rudey

Додаючи щось подібне до заяви-звороту, це вирішить: &&! / ^ \ S + | \ s + $ / g.test (str)
Ultroman Tacoman

2
@RuudLenders - більшості людей буде байдуже, чи є пробіли, які замикаються, щоб зробити рядок дійсним числом, оскільки його легко випадково помістити в зайві пробіли у великій кількості інтерфейсів.
Ян

3
Це вірно в тому випадку, якщо рядок числа надходить із введення користувача. Але я подумав, що все одно слід згадати пробіли, тому що я думаю, що більшість людей, яким потрібна isNumberфункція, не мають справу з інтерфейсами користувача. Крім того, гарне введення числа не дозволить починати пробіли.
Rudey

36

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

22

Спробуйте функцію isNan :

Функція isNaN () визначає, чи є значення незаконним числом (Not-a-Number).

Ця функція повертає true, якщо значення дорівнює NaN. В іншому випадку він повертає помилкове.

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

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

Number.isNan () не перетворює значення в число і не поверне істинне для будь-якого значення, яке не належить до типу Number ...


2
Переконайтеся, що ви додали чек на порожній рядок. isNaN ('') повертає помилкове значення, але ви, мабуть, хочете, щоб він повернув істину в цьому випадку.
Майкл Харен

3
isFinite - це краща перевірка - вона має справу з кутовим випадком нескінченності
JonnyRaa

3
@MichaelHaren Не досить добре! isNaN()повертається falseдля БУДЬ-ЯКОГО рядки , що містять тільки пробільні символи, в тому числі такі речі , як «\ u00A0».
Майкл

1
УВАГА: Не працює для значень: null, "" (порожній рядок) та false.
Дженні О'Рейлі

Я усвідомлюю, що ця відповідь була надана 11 років тому і за кілька хвилин до прийнятої, але подобається це чи ні, прийнята відповідь має НАДАГО більше розмов навколо неї, тому ця відповідь насправді нічого не додає до відповіді на питання. Я б радив видалити його, щоб не відволікати нових читачів. Я також думаю, що ви отримаєте значок «Дисциплінований», якщо це зробите.
Дан Даскалеску

14

Старе запитання, але в наведених відповідях бракує декількох моментів.

Наукові позначення.

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

Однак навіть цей далеко не завершений. Тут не обробляються провідні нулі, але вони роблять випробування на довжину.


1
"Однак у більшості випадків, коли люди запитують номери, вони не хочуть відповідати таким речам, як 1e + 30" Чому б ви це сказали? Якщо хтось хоче знати, чи містить рядок число, мені здається, він хотів би знати, чи містить він число, а 1e + 30 - це число. Звичайно, якби я тестував рядок на числове значення в JavaScript, я б хотів, щоб це відповідало.
Ден Джонс

9

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

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, [] (та інші?)


1
Це все ще повертає істину з проміжними / провідними пробілами. Додаючи щось подібне до заяви-звороту, це вирішить: &&! / ^ \ S + | \ s + $ / g.test (str)
Ultroman Tacoman

2
Отже, "123" має бути помилковим, а не числом, а "1234" - числом? Мені подобається, як воно є, так що "123" є числом, але це може бути на розсуд розробника, якщо провідні чи кінцеві пробіли повинні змінити значення.
JohnP2

8

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

Якщо аргумент (рядок) не може бути перетворений у число, він повертає 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

NumberКонструктор точно так же , як і +x.
GregRos

В якості бічної примітки майте на увазі, що ES6 також Number()обробляє плаваючі числа, як Number.parseFloat()ніNumber.parseInt()
zurfyx

7

Можливо, до цього питання стикаються один-два людей, яким потрібна набагато суворіша перевірка, ніж зазвичай (як я). У цьому випадку це може бути корисно:

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

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

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


2
Дякую @JoeRocc. Я потребував в цьому теж, але тільки для цілих чисел, так що я додав: (str === String(Math.round(Number(str)))).
keithpjolley

Будьте в курсі цього "Infinity", "-Infinity"і "NaN"пройдіть цей тест. Однак це можна виправити за допомогою додаткового Number.isFiniteтесту.
GregRos

Це точно так само, як str === ("" + +str). В основному він перевіряє, чи є рядок результатом строфіфікації номера JS. Знаючи це, ми також можемо побачити проблему: тест проходить, 0.000001але не дає змоги 0.0000001, а саме тоді, коли він 1e-7проходить. Те саме для дуже великих чисел.
GregRos

5

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


І 11 за parseInt(09).
djechlin

10
тому що вам потрібно скористатисяparaseInt(09, 10)
Гавін

1
Як і для ECMAScript 5 , який має широку підтримку браузера (IE≥9), , 10аргумент вам більше не потрібен . parseInt('09')тепер дорівнює 9.
Rory O'Kane

4

Цитата:

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

не зовсім вірно, якщо вам потрібно перевірити провідні / кінцеві пробіли - наприклад, коли потрібна певна кількість цифр, і вам потрібно отримати, скажімо, "1111", а не "111" або "111", можливо, для PIN-коду вхід.

Краще використовувати:

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

Значення '-1', '0.1'і '1e10'всі повертають хибні. Крім того, значення, що перевищують позитивну нескінченність або менші за негативну нескінченність, повертають істинні, тоді як вони, ймовірно, повинні повертати помилкові.
Rudey

4

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

Я не перевіряв жодного з них дуже іншим способом, ніж тестування вручну кількох випадків використання, на які я буду вражати своє сучасне загроза, що все дуже стандартні речі. Це ситуація "стоячи на плечі гігантів".


4

Він не дійсний для TypeScript як:

declare function isNaN(number: number): boolean;

Для TypeScript ви можете використовувати:

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


3

Ну, я використовую цей, який я зробив ...

Це працює досі:

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

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


12
Це дає неправильний результат для порожнього рядка, порожнього масиву, false та null.
Орі

2
Чи не повинно це бути потрійним рівним?
тости_флякс

1
У моїй програмі ми дозволяємо лише az AZ та 0-9 символів. Я виявив, що вище працювало, якщо рядок не починався з 0xnn, і тоді він поверне її як числовий, коли не повинен був.
rwheadon

6
ви можете просто зробити "повернути значення% 1 === 0"
Брайан Шермерхорн

Просто зробітьreturn !isNaN(parseInt(value, 10));
DarkNeuron

3

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

Будь-які пропозиції вітаються. :]


2
Що про isNumeric(' ')і isNumeric('')?
Алекс Кори

Я хотів би додати && (val.replace(/\s/g,'') !== '') //Empty && (val.slice(-1) !== '.') //Decimal without Number, щоб вирішити вищезгадане питання і таке, що я мав сам.
frankenapps


3
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 ...
}

Дякую, чудова відповідь!
М.Абулсуд

3

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

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

Результати кожного тесту на <code> isNumeric () </code>


3

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

2

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

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

2

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

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

npm install is-number

У JavaScript це не завжди так просто, як це слід надійно перевірити, чи є значення числом. Devs звичайно використовувати +, - або Number () для передачі значення рядка до числа (наприклад, коли значення повертаються з введення користувача, збігів регулярних виразів, парсерів тощо). Але є багато неінтуїтивних крайових випадків, які дають несподівані результати:

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

1

Нещодавно я написав статтю про способи забезпечення змінної є дійсним числом: 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
}

1

Моя спроба трохи заплутати, 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

Це не дуже погано, два поганих - це не працює для жодної недесяткової нотації, наприклад (1) наукове позначення та (2) позначення без основи-10, наприклад восьмеричне ( 042) та шістнадцяткове ( 0x45f)
Домі

Це не дає відповіді на питання пошуку числового значення, воно шукає лише int.
Джеремі

0

У моїй програмі ми дозволяємо лише 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)], я не можу говорити про це, але це саме те, що нам потрібно.


Чому це буде помилка в JavaScript?
Бергі

Я просто не бачу тієї самої поведінки з аналогічним рішенням в perl або C, і оскільки я не розробник мови програмування для JavaScript або сценарію дій, я не знаю, чи є поведінка, яку я переживаю, справді навмисно чи ні.
rwheadon

Ну, javascript трохи неохайний щодо неявного типу кастингу, але, як тільки ви дізнаєтесь, що можете легко зрозуміти, як це працює. Ви кидаєте рядки до чисел (викликаючи чисельну % 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;
 };

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


0

Ви можете використовувати типи, як, наприклад, у бібліотеці потоків y, щоб отримати статичну та складати перевірку часу. Звичайно, не дуже корисно для введення користувача.

// @flow

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

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

0

Ось один вкладиш, щоб перевірити, чи sNumє дійсним числовим значенням; він був протестований на широкий спектр вхідних даних:

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

0

Просто використовуйте isNaN(), це перетворить рядок у число і, якщо отримаєте дійсне число , повернеться false...

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

0

Я використовую наступне:

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

Працює досить добре це багато випадків, але зазнає невдачі справи , як 1..1, 1,1, -32.1.12і , що більш важливо не вдається undefinedі NaN. Якщо ви пройшли undefinedабо NaNщо, це поверне вам помилковий позитив, сказавши, що це число.
Джеремі
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.