Я сподіваюся, що в такому концептуальному просторі є щось таке, що і стара IsNumeric()
функція VB6 ?
isNaN("")
, isNaN(" ")
, isNaN(false)
і т.д. Він повертається false
для них, це означає , що вони є числами.
Я сподіваюся, що в такому концептуальному просторі є щось таке, що і стара IsNumeric()
функція VB6 ?
isNaN("")
, isNaN(" ")
, isNaN(false)
і т.д. Він повертається false
для них, це означає , що вони є числами.
Відповіді:
Це працює незалежно від того, вміст змінної - це рядок чи число.
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
isNaN
"Щоб перевірити, чи змінна не є числом". "не число" не те саме, що "IEEE-794 NaN", для чого isNaN
тести. Зокрема, це використання не вдається при тестуванні булевих та порожніх рядків. Див. Розробник.mozilla.org/ en-US/ docs/ Web/JavaScript/ Reference/… .
var n = 'a'; if (+n === +n) { // is number }
це на 3994% швидше, ніж isNaN в останній версії Chrome. Дивіться тест на працездатність тут: jsperf.com/isnan-vs-typeof/5
isNaN(1 + false + parseInt("1.do you trust your users?"))
І ви можете пройти шлях 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
/^-?\d+$/
правильно?
Якщо ви дійсно хочете , щоб переконатися зробити , що рядок містить тільки число, будь-яке число (ціле або з плаваючою точкою), а саме номер, ви не можете використовувати 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))
}
' 1'
, '2 '
і ' 3 '
все повертається правдою.
isNumber
функція, не мають справу з інтерфейсами користувача. Крім того, гарне введення числа не дозволить починати пробіли.
Прийнята відповідь на це запитання має досить багато недоліків (як підкреслила пара інших користувачів). Це один із найпростіших і перевірених способів наблизитись до нього у 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()
повертається false
для БУДЬ-ЯКОГО рядки , що містять тільки пробільні символи, в тому числі такі речі , як «\ u00A0».
Старе запитання, але в наведених відповідях бракує декількох моментів.
Наукові позначення.
!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
Number
Конструктор точно так же , як і +x
.
Number()
обробляє плаваючі числа, як Number.parseFloat()
ніNumber.parseInt()
Можливо, до цього питання стикаються один-два людей, яким потрібна набагато суворіша перевірка, ніж зазвичай (як я). У цьому випадку це може бути корисно:
if(str === String(Number(str))) {
// it's a "perfectly formatted" number
}
Остерігайся! Це буде відкидати рядки , як .1
, 40.000
, 080
, 00.1
. Це дуже вибагливо - рядок повинен відповідати " найменш досконалій формі " числа для проходження цього тесту.
Він використовує String
і Number
конструктор, щоб передати рядок до числа і знову, і тим самим перевіряє, чи відповідає "ідеальна мінімальна форма" двигуна JavaScript (та, яку він перетворив у початковий Number
конструктор).
(str === String(Math.round(Number(str))))
.
"Infinity"
, "-Infinity"
і "NaN"
пройдіть цей тест. Однак це можна виправити за допомогою додаткового Number.isFinite
тесту.
str === ("" + +str)
. В основному він перевіряє, чи є рядок результатом строфіфікації номера JS. Знаючи це, ми також можемо побачити проблему: тест проходить, 0.000001
але не дає змоги 0.0000001
, а саме тоді, коли він 1e-7
проходить. Те саме для дуже великих чисел.
parseInt (), але майте на увазі, що ця функція дещо відрізняється в тому сенсі, що вона, наприклад, повертає 100 для parseInt ("100px").
parseInt(09)
.
paraseInt(09, 10)
, 10
аргумент вам більше не потрібен . parseInt('09')
тепер дорівнює 9.
Цитата:
isNaN (num) // повертає true, якщо змінна НЕ містить дійсного числа
не зовсім вірно, якщо вам потрібно перевірити провідні / кінцеві пробіли - наприклад, коли потрібна певна кількість цифр, і вам потрібно отримати, скажімо, "1111", а не "111" або "111", можливо, для PIN-коду вхід.
Краще використовувати:
var num = /^\d+$/.test(num)
'-1'
, '0.1'
і '1e10'
всі повертають хибні. Крім того, значення, що перевищують позитивну нескінченність або менші за негативну нескінченність, повертають істинні, тоді як вони, ймовірно, повинні повертати помилкові.
Чому реалізація 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));
};
Я не перевіряв жодного з них дуже іншим способом, ніж тестування вручну кількох випадків використання, на які я буду вражати своє сучасне загроза, що все дуже стандартні речі. Це ситуація "стоячи на плечі гігантів".
Ну, я використовую цей, який я зробив ...
Це працює досі:
function checkNumber(value) {
if ( value % 1 == 0 )
return true;
else
return false;
}
Якщо ви помітили якусь проблему з цим, скажіть, будь ласка.
return !isNaN(parseInt(value, 10));
Якщо хто-небудь коли-небудь заходить так далеко, я витратив деякий час на злому, намагаючись виправити момент.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
Будь-які пропозиції вітаються. :]
isNumeric(' ')
і isNumeric('')
?
&& (val.replace(/\s/g,'') !== '') //Empty && (val.slice(-1) !== '.') //Decimal without Number
, щоб вирішити вищезгадане питання і таке, що я мав сам.
Використання простого 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 ...
}
Можливо, це перероблялося занадто багато разів, однак я сьогодні боровся з цим і хотів опублікувати свою відповідь, так як я не бачив жодної іншої відповіді, яка б це робила так просто або ретельно:
var isNumeric = function(num){
return (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num);
}
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
функцію та лише минуле в цих випадках використання та сканувати "справжнє" для всіх.
Або, щоб побачити значення, які кожен повертає:
Часто "дійсне число" означає номер 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');
}
Збережіть собі головний біль від спроби знайти «вбудоване» рішення.
Немає хорошої відповіді, і надзвичайно обґрунтована відповідь у цій темі невірна.
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
042
) та шістнадцяткове ( 0x45f
)
У моїй програмі ми дозволяємо лише 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)], я не можу говорити про це, але це саме те, що нам потрібно.
% 1
операцію на них), і інтерпретуватимете рядок як шістнадцятковий або плаваючий літерал.
Моє рішення:
// 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
Я використовую наступне:
const isNumber = s => !isNaN(+s)
1..1
, 1,1
, -32.1.12
і , що більш важливо не вдається undefined
і NaN
. Якщо ви пройшли undefined
або NaN
що, це поверне вам помилковий позитив, сказавши, що це число.