Eski VB6 IsNumeric()işleviyle aynı kavramsal alanda bir şey olmasını umuyorum ?

Bir değişkenin (dize dahil) sayı olup olmadığını kontrol etmek için sayı olmadığını kontrol edin:

Bu, değişken içeriğin bir dize veya sayı olmasına bakılmaksızın çalışır.

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

Örnekler

isNaN(123)         // false
isNaN('123')       // false
isNaN('1e10000')   // false (This translates to Infinity, which is a number)
isNaN('foo')       // true
isNaN('10px')      // true

Tabii ki, gerekirse bunu reddedebilirsiniz. Örneğin, IsNumericverdiğiniz örneği uygulamak için :

function isNumeric(num){
  return !isNaN(num)
}

Sayı içeren bir dizeyi sayıya dönüştürmek için:

Yalnızca dize yalnızca sayısal karakterler içeriyorsa çalışır , aksi takdirde döndürür NaN.

+num               // returns the numeric value of the string, or NaN 
                   // if the string isn't purely numeric characters

Örnekler

+'12'              // 12
+'12.'             // 12
+'12..'            // NaN
+'.12'             // 0.12
+'..12'            // NaN
+'foo'             // NaN
+'12px'            // NaN

Bir dizeyi gevşek bir şekilde sayıya dönüştürmek için

'12 piksel' değerini 12'ye dönüştürmek için kullanışlıdır, örneğin:

parseInt(num)      // extracts a numeric value from the 
                   // start of the string, or NaN.

Örnekler

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. 

Şamandıralar

Unutmayın, aksine +num,parseInt (adından da anlaşılacağı gibi), ondalık noktayı izleyen her şeyi keserek bir şamandırayı tamsayıya dönüştürür parseInt() ( bu davranış nedeniyle kullanmak istiyorsanız , bunun yerine muhtemelen başka bir yöntem kullanmaktan daha iyi olursunuz ). :

+'12.345'          // 12.345
parseInt(12.345)   // 12
parseInt('12.345') // 12

Boş dizeler

Boş dizeler biraz sezgisel olabilir. +numboş dizeleri veya boşluklu dizeleri sıfıra dönüştürür isNaN()ve aynı şeyi varsayar:

+''                // 0
+'   '             // 0
isNaN('')          // false
isNaN('   ')       // false

Ancak parseInt()aynı fikirde değil:

parseInt('')       // NaN
parseInt('   ')    // NaN

Ve RegExp yoluna gidebilirsiniz:

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
}

Bir dizenin tam sayı olup olmadığını kontrol etmeye çalışıyorsanız (ondalık basamak yok), normal ifade gitmek için iyi bir yoldur. Diğer yöntemler gibi isNaNçok basit bir şey için çok karmaşıktır.

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

Yalnızca pozitif tamsayılara izin vermek için şunu kullanın:

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

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

Eğer gerçekten bir dize sadece bir numara, herhangi bir sayıda (tamsayı veya kayan nokta) ve tam bir sayı içerdiğinden emin olmak için, sen olamaz kullanmak parseInt()/ parseFloat(), Number()veya !isNaN()kendileri tarafından. Not !isNaN()aslında geri dönüyor truezaman Number()bir numara dönecekti ve falsebunun ne zaman geri döneceğiniNaN , bu yüzden tartışma geri kalanından hariç tutar.

Sorun parseFloat(), dize yalnızca ve tam olarak bir sayı içermese bile dize herhangi bir sayı içeriyorsa bir sayı döndürmesidir :

parseFloat("2016-12-31")  // returns 2016
parseFloat("1-1") // return 1
parseFloat("1.2.3") // returns 1.2

Sorun Number(), geçirilen değerin hiç bir sayı olmadığı durumlarda bir sayı döndürmesi!

Number("") // returns 0
Number(" ") // returns 0
Number(" \u00A0   \t\n\r") // returns 0

Kendi regex'inizi yuvarlamadaki sorun, bir kayan nokta numarasını Javascript tarafından tanıdığı gibi eşleştirmek için tam regex oluşturmazsanız, vakaları özleyeceğiniz veya yapmamanız gereken vakaları tanıyacağınızdır. Kendi regex'inizi yuvarlayabilseniz bile, neden? Bunu yapmanın daha basit yerleşik yolları vardır.

Bununla birlikte, ortaya çıkmadığında bir sayı döndüren her durum için Number()(ve isNaN()) doğru olanı yapar parseFloat()ve tersi de geçerlidir. Bir dizenin gerçekten ve sadece bir sayı olup olmadığını öğrenmek için, her iki işlevi de çağırın ve her ikisinin de doğru olup olmadığını görün :

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

Bu soru için kabul edilen cevabın birkaç kusuru var (diğer birkaç kullanıcı tarafından vurgulandığı gibi). Bu, javascript'te ona ulaşmanın en kolay ve kanıtlanmış yollarından biridir:

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

Aşağıda bazı iyi test durumları verilmiştir:

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

İsNan işlevini deneyin :

İsNaN () işlevi, bir değerin geçersiz bir sayı olup olmadığını belirler (Sayı Değil).

Değer NaN'ye eşitse bu işlev true değerini döndürür. Aksi takdirde yanlış döndürür.

Bu işlev, Numaraya özgü Number.isNaN () işlevinden farklıdır yönteminden .

  Global isNaN () işlevi, test edilen değeri bir Number'a dönüştürür, sonra test eder.

Number.isNan (), değerleri bir Number'a dönüştürmez ve Number türünde olmayan herhangi bir değer için true değerini döndürmez ...

Eski soru, ancak verilen cevaplarda birkaç nokta eksik.

Bilimsel gösterim.

!isNaN('1e+30')olduğu trueinsanlar numaralar için sorduğunuzda ancak vakaların çoğunda, onlar gibi şeyler eşleştirmek istemiyoruz 1e+30.

Büyük kayan sayılar tuhaf davranabilir

Gözlemleyin (Node.js kullanarak):

> var s = Array(16 + 1).join('9')
undefined
> s.length
16
> s
'9999999999999999'
> !isNaN(s)
true
> Number(s)
10000000000000000
> String(Number(s)) === s
false
>

Diğer yandan:

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

Yani, biri beklerse String(Number(s)) === s , dizelerinizi en fazla 15 basamakla daha iyi sınırlayın (baştaki sıfırları atladıktan sonra).

Sonsuzluk

> typeof Infinity
'number'
> !isNaN('Infinity')
true
> isFinite('Infinity')
false
>

Tüm bunlar göz önüne alındığında, verilen dizenin aşağıdakilerin tümünü karşılayan bir sayı olup olmadığını kontrol edin:

• bilimsel olmayan gösterim
• öngörülebilir dönüş Numberve dönüşString
• sınırlı

o kadar kolay bir iş değil. İşte basit bir sürüm:

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

Ancak, bu bile tam olmaktan uzaktır. Baştaki sıfırlar burada ele alınmaz, ancak uzunluk testini vidalar.

Test ettim ve Michael'ın çözümü en iyisi. Yukarıdaki cevabına oy verin (bulmak için "Gerçekten bir dize olduğundan emin olmak istiyorsanız" için bu sayfayı arayın). Özünde, cevabı şudur:

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

Burada belgelediğim her test vakası için çalışır: https://jsfiddle.net/wggehvp9/5/

Diğer çözümlerin çoğu şu uç durumlarda başarısız olur: '', null, "", true ve []. Teorik olarak, bunları uygun hata işlemeyle kullanabilirsiniz, örneğin:

return !isNaN(num);

veya

return (+num === +num);

/ \ s /, null, "", true, false, [] (ve diğerleri?)

Oluşturucusuna bir bağımsız değişken iletirken Number sonucunu kullanabilirsiniz .

Bağımsız değişken (dize) bir sayıya dönüştürülemezse, NaN değerini döndürür, böylece sağlanan dizenin geçerli bir sayı olup olmadığını belirleyebilirsiniz.

Notlar: Boş dize veya geçen Not '\t\t've '\n\t'Numarası 0 dönecektir olarak; True değerini geçmek 1, false değerini 0 döndürür.

    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

Belki her zamankinden daha sıkı bir kontrol gerektiren bu soruya rastlayan bir ya da iki kişi var (benim yaptığım gibi). Bu durumda, bu yararlı olabilir:

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

Dikkat! Bu gibi dizeleri reddeder .1, 40.000, 080, 00.1. Çok seçici - dize , bu testin geçebilmesi için sayının " en az mükemmel formuyla " eşleşmelidir .

Dizeyi bir sayıya geri döndürmek için Stringve Numberyapıcısını kullanır ve böylece JavaScript motorunun "mükemmel minimal formunun" (ilk Numberoluşturucu ile dönüştürüldüğü form ) orijinal dizeyle eşleşip eşleşmediğini kontrol eder.

parseInt (), ancak bu işlevin örneğin parseInt ("100px") için 100 döndürdüğü anlamında biraz farklı olduğunu unutmayın.

Alıntı:

isNaN (num) // değişken geçerli bir sayı İÇERMEZSE doğru değerini döndürür

önde gelen / sondaki boşlukları kontrol etmeniz gerekirse tamamen doğru değildir - örneğin belirli bir rakam basamağı gerektiğinde ve örneğin bir PIN için '111' veya '111' değil, '1111' almanız gerekir. giriş.

Kullanımı daha iyi:

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

JQuery'nin uygulanması neden yeterince iyi değil?

function isNumeric(a) {
    var b = a && a.toString();
    return !$.isArray(a) && b - parseFloat(b) + 1 >= 0;
};

Michael böyle bir şey önerdi ("user1691651 - John" un değiştirilmiş halini burada çalmış olmama rağmen):

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

Aşağıdakiler, büyük olasılıkla kötü performansa sahip, ancak sağlam sonuçlara sahip bir çözümdür. Bu, jQuery 1.12.4 uygulamasından ve Michael'ın cevabından, önde gelen / sondaki boşluklar için ekstra bir kontrolle yapılan bir mekanizmadır (çünkü Michael'ın sürümü önde gelen / sondaki boşluklara sahip sayısallar için doğru döner):

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

Ancak ikinci versiyonun iki yeni değişkeni vardır. Kişi bunlardan birini yapabilir:

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

Bunların hiçbirini çok fazla test etmedim. Bu, "devlerin omuzlarında durmak" durumudur.

TypeScript için şu şekilde geçerli değildir:

declare function isNaN(number: number): boolean;

TypeScript için şunları kullanabilirsiniz:

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

Yaptığım bunu kullanıyorum ...

Şimdiye kadar çalışıyor:

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

Bununla ilgili herhangi bir sorun tespit ederseniz, lütfen bana bildirin.

Herkes bu kadar aşağı olsun, moment.js yama ( https://github.com/moment/moment ) bu çalışırken kesmek için biraz zaman geçirdim . İşte ondan aldığım bir şey:

function isNumeric(val) {
    var _val = +val;
    return (val !== val + 1) //infinity check
        && (_val === +val) //Cute coercion check
        && (typeof val !== 'object') //Array/object check
}

Aşağıdaki durumları ele alır:

Doğru! :

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))

Yanlış! :

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()))

İronik olarak, en çok mücadele ettiğim kişi:

isNumeric(new Number(1)) => false

Herhangi bir öneri hoş geldiniz. :]

Düz JavaScript kullanma:

Number.isNaN(Number('1')); // false
Number.isNaN(Number('asdf')); // true

Lodash kullanma:

_.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 ve TypeScript Örnekleri Dahil

Belki bu çok fazla kez yeniden düzenlendi, ancak bugün de bununla mücadele ettim ve cevabımı göndermek istedim, çünkü basit veya iyice yapan başka bir cevap görmedim:

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

daktilo ile yazılmış yazı

const isNumeric = (num: any) => (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num as number);

Bu oldukça basit görünüyor ve diğer birçok yazıda gördüğüm ve kendimi düşündüğüm tüm üsleri kapsıyor:

// 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);

Kendiniz de deneyebilirsiniz isNumeric kullanımınızı ve bu kullanım durumlarında geçmiş olabilir ve hepsi için "doğru" tarayabilirsiniz.

Veya, her birinin döndürdüğü değerleri görmek için:

2019: Pratik ve sıkı sayısal geçerlilik kontrolü

Genellikle, 'geçerli sayı' NaN ve Infinity hariç bir Javascript numarası, yani 'sonlu sayı' anlamına gelir.

Bir değerin sayısal geçerliliğini kontrol etmek için (örneğin harici bir kaynaktan) ESlint Airbnb tarzında tanımlayabilirsiniz:

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

ve şu şekilde kullanın:

if (isReferringFiniteNumber(theirValue)) {
  myCheckedValue = Number(theirValue);
} else {
  console.warn('The provided value doesn\'t refer to a finite number');
}

PFB çalışma çözümü:

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

Kendinize "yerleşik" bir çözüm bulmaya çalışmanın baş ağrısını kurtarın.

İyi bir cevap yok ve bu konudaki büyük ölçüde onaylanmış cevap yanlış.

npm install is-number

JavaScript'te, bir değerin sayı olup olmadığını güvenilir bir şekilde kontrol etmek her zaman o kadar basit değildir. Bir geliştiricinin +, - veya Number () kullanarak bir dize değerini bir sayıya dönüştürmesi yaygındır (örneğin, değerler kullanıcı girişinden, normal ifade eşleşmelerinden, ayrıştırıcılardan vb. Döndürüldüğünde). Ancak beklenmedik sonuçlar veren birçok sezgisel olmayan kenar durumu vardır:

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

Geçenlerde bir değişken sağlamak için yolları hakkında bir makale geçerli bir sayıdır yazdı: https://github.com/jehugaleahsa/artifacts/blob/master/2018/typescript_num_hack.md makalede aşağıdakilerin nasıl, kayan nokta veya tamsayı sağlamak için bu yıllardan eğer önemli ( +xvs ~~x).

Makale, değişkenin başlangıç ​​için a stringveya a numberolduğunu ve trimkullanılabilir / çoklu doldurulmuş olduğunu varsayar . Diğer türleri de kapsayacak şekilde genişletmek zor olmaz. İşte eti:

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

Biraz kafa karıştırıcı olma girişimi, Belki de en iyi çözüm değil

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

Benim uygulamada biz sadece az AZ ve 0-9 karakter izin veriyoruz. Ben dize 0xnn (0x10 gibi) ile başlayan sürece " dize % 1 === 0" kullanarak yukarıdaki cevap bulundu ve sonra biz istemediğinde bunu sayısal olarak dönecekti. Sayısal kontrolümdeki aşağıdaki basit tuzak, özel durumlarımızda hile yapıyor gibi görünüyor.

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

Uyarı : Bu Javascript ve Actionscript [Number ("1" + the_string)% 1 === 0)] uzun süredir devam eden bir hata kullanıyor olabilir, bunun için konuşamam, ama tam olarak ihtiyacımız olan şey bu.

Çözümüm:

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

Döngünün içine, belirli gereksinimlerinize uyacak ek koşullar ekleyebilirsiniz.

Statik, derleme zamanı kontrolünü elde etmek için , akış librartı gibi, türlerden yararlanabilirsiniz. Tabii ki kullanıcı girişi için çok yararlı değil.

// @flow

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

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

sNumGeçerli bir sayısal değer olup olmadığını kontrol etmek için bir astar ; çok çeşitli girişler için test edilmiştir:

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

Sadece kullanmak isNaN()bu dize dönüştürür, sayı ve geçerli alırsanız sayısını döndürür false...

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

Aşağıdakileri kullanıyorum:

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