जावास्क्रिप्ट में दशमलव संख्या की गणना करें - IsNumeric ()


2376

जावास्क्रिप्ट में दशमलव संख्या को मान्य करने का सबसे साफ, सबसे प्रभावी तरीका क्या है?

के लिए बोनस अंक:

  1. स्पष्टता। समाधान साफ ​​और सरल होना चाहिए।
  2. क्रॉस-प्लेटफॉर्म।

परीक्षण के मामलों:

01. IsNumeric('-1')      => true
02. IsNumeric('-1.5')    => true
03. IsNumeric('0')       => true
04. IsNumeric('0.42')    => true
05. IsNumeric('.42')     => true
06. IsNumeric('99,999')  => false
07. IsNumeric('0x89f')   => false
08. IsNumeric('#abcdef') => false
09. IsNumeric('1.2.3')   => false
10. IsNumeric('')        => false
11. IsNumeric('blah')    => false

256
बस एक नोट 99,999 फ्रांस में एक वैध संख्या है, इसका यूके / यूएस प्रारूप में 99.999 के समान है, इसलिए यदि आप एक स्ट्रिंग में पढ़ रहे हैं तो इनपुट फॉर्म कहो तो 99,999 सच हो सकता है।
रीसलेस

5
इसके अलावा बाहर की जाँच इस पोस्ट और महान टिप्पणियाँ
powtac

79
दशमलव कॉमा पूरे यूरोप और रूस में मानक है (ब्रिटेन को छोड़कर)
कलमरियस

90
jQuery 1.7 ने jQuery.isNumericउपयोगिता समारोह पेश किया है: api.jquery.com/jQuery.isNumeric
एट्स गोरल

24
jQuery.isNumericओपी के सातवें परीक्षण मामले ( IsNumeric('0x89f') => *false*) में विफल रहेगा । मुझे यकीन नहीं है कि मैं इस परीक्षण मामले से सहमत हूं, हालांकि।
टिम लेहनर

जवाबों:


2898

@ जोएल का जवाब बहुत करीब है, लेकिन यह निम्नलिखित मामलों में विफल होगा:

// Whitespace strings:
IsNumeric(' ')    == true;
IsNumeric('\t\t') == true;
IsNumeric('\n\r') == true;

// Number literals:
IsNumeric(-1)  == false;
IsNumeric(0)   == false;
IsNumeric(1.1) == false;
IsNumeric(8e5) == false;

कुछ समय पहले मुझे एक IsNumericफ़ंक्शन लागू करना था , यह पता लगाने के लिए कि क्या एक चर में संख्यात्मक मान शामिल है, भले ही इसके प्रकार की परवाह किए बिना , यह Stringएक संख्यात्मक मान हो सकता है (मुझे घातीय संकेतन, आदि पर भी विचार करना होगा), एक Numberवस्तु, वस्तुतः उस समारोह में कुछ भी पारित किया जा सकता है, मैं किसी भी प्रकार की धारणा नहीं बना सकता था, प्रकार की जबरदस्ती का ख्याल रखना (जैसे। +true == 1;लेकिन trueविचार नहीं किया जाना चाहिए "numeric")।

मुझे लगता है कि कई फ़ंक्शन कार्यान्वयन के लिए किए गए +30 यूनिट परीक्षणों के इस सेट को साझा करने के लायक है , और वह भी साझा करें जो मेरे सभी परीक्षणों को पास करता है:

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

PS को कोई रूपांतरण नहीं होने के कारण PSNNN और isFinite का भ्रामक व्यवहार है। ES6 में, Number.isNaN और Number.isFinite इन मुद्दों को ठीक करेगा। इनका उपयोग करते समय ध्यान रखें।


अपडेट : यहां बताया गया है कि jQuery अब कैसे करता है (2.2-स्थिर) :

isNumeric: function(obj) {
    var realStringObj = obj && obj.toString();
    return !jQuery.isArray(obj) && (realStringObj - parseFloat(realStringObj) + 1) >= 0;
}

अपडेट : कोणीय 4.3 :

export function isNumeric(value: any): boolean {
    return !isNaN(value - parseFloat(value));
}

26
यह उन अन्य स्थानों के साथ विफल होता है जहां हम दशमलव का उपयोग करते हैं, लेकिन 'n = n.replace (/, /, ""; ") जोड़ें;' इसे ठीक करने के लिए वापसी से पहले।
ज़ोल्टन लेंग्येल

5
@ रोब, वह व्यवहार जानबूझकर किया 2e308 > Number.MAX_VALUEगया है 2e308 == Infinity। यदि आप एक ऐसा फ़ंक्शन चाहते हैं जो trueसकारात्मक और नकारात्मक अनंत मानों के लिए भी रिटर्न करता है, तो परीक्षण सूट में फ़ंक्शन नंबर 2 की जांच करें । चीयर्स।
सीएमएस

39
वैसे, इकाई परीक्षणों का उपयोग अब jQuery परियोजना
CMS

7
jQuery अब इस कार्यान्वयन का उपयोग कर रहे हैं ।
रिचर्ड टॉवर्स

4
यहाँ समाधान सिर्फ JQuery का उपयोग करने के लिए है। उनके पास अब इसका और भी बेहतर क्रियान्वयन है: github.com/jquery/jquery/blob/master/src/core.js#L230
रॉबर्ट मासैओली

337

Arrrgh! नियमित अभिव्यक्ति के उत्तर न सुनें। RegEx इसके लिए icky है, और मैं केवल प्रदर्शन की बात नहीं कर रहा हूं। अपनी नियमित अभिव्यक्ति के साथ गलतियों को सुलझाना असंभव, सूक्ष्म बनाना आसान है।

यदि आप उपयोग नहीं कर सकते हैं isNaN(), तो यह बहुत बेहतर काम करना चाहिए:

function IsNumeric(input)
{
    return (input - 0) == input && (''+input).trim().length > 0;
}

यहां देखिए यह कैसे काम करता है:

(input - 0)अभिव्यक्ति आपका इनपुट मान पर प्रकार बलात्कार करने के लिए जावास्क्रिप्ट बलों; इसे पहले घटाव संचालन के लिए एक संख्या के रूप में व्याख्या किया जाना चाहिए। यदि वह संख्या में रूपांतरण विफल हो जाता है, तो अभिव्यक्ति में परिणाम होगा NaN। यह संख्यात्मक परिणाम तब आपके द्वारा पास किए गए मूल मूल्य की तुलना में है। चूंकि बाएं हाथ की तरफ अब संख्यात्मक है, इसलिए टाइप कॉर्शन का फिर से उपयोग किया जाता है। अब जबकि दोनों ओर के इनपुट को एक ही मूल मान से एक ही प्रकार के लिए ज़ब्त किया गया था, तो आपको लगता है कि उन्हें हमेशा (हमेशा सच) होना चाहिए। हालाँकि, एक विशेष नियम है जो कहता NaNहै कि कभी भी समान नहीं है NaN, और इसलिए ऐसा मान जिसे किसी संख्या में परिवर्तित नहीं किया जा सकता है (और केवल मान जिन्हें संख्याओं में परिवर्तित नहीं किया जा सकता है) का परिणाम गलत होगा।

लंबाई पर जांच एक विशेष मामले के लिए है जिसमें खाली तार शामिल हैं। यह भी ध्यान दें कि यह आपके 0x89f परीक्षण पर गिरता है, लेकिन ऐसा इसलिए है क्योंकि कई वातावरणों में यह संख्या शाब्दिक परिभाषित करने का एक अच्छा तरीका है। यदि आप उस विशिष्ट परिदृश्य को पकड़ना चाहते हैं तो आप एक अतिरिक्त जाँच जोड़ सकते हैं। इससे भी बेहतर, अगर यह आपके उपयोग न करने का कारण है isNaN()तो बस अपने स्वयं के फ़ंक्शन को चारों ओर लपेटें isNaN()जो अतिरिक्त जांच भी कर सकते हैं।

सारांश में, यदि आप जानना चाहते हैं कि क्या मूल्य को किसी संख्या में परिवर्तित किया जा सकता है, तो वास्तव में इसे एक संख्या में बदलने का प्रयास करें।


मैं वापस गया और इस बात के लिए कुछ शोध किया कि व्हाट्सएप स्ट्रिंग में अपेक्षित आउटपुट क्यों नहीं था, और मुझे लगता है कि मैं इसे अभी प्राप्त करता हूं: खाली स्ट्रिंग के 0बजाय इसके लिए मजबूर किया जाता है NaN। बस लंबाई की जाँच से पहले स्ट्रिंग ट्रिमिंग इस मामले को संभाल लेंगे।

नए कोड के खिलाफ यूनिट परीक्षण चल रहा है और यह केवल अनन्तता और बूलियन शाब्दिक पर विफल रहता है, और एक ही समय में एक समस्या यह होनी चाहिए कि क्या आप कोड उत्पन्न कर रहे हैं (वास्तव में, जो एक शाब्दिक में टाइप करेगा और जांच करेगा कि क्या यह संख्यात्मक है? आपको पता होना चाहिए ), और यह उत्पन्न करने के लिए कुछ अजीब कोड होगा।

लेकिन, फिर से, इसका उपयोग करने का एकमात्र कारण यह है कि यदि किसी कारण से आपको isNN () से बचना है।


28
यह व्हॉट्सएप स्ट्रिंग्स पर विफल रहता है, उदाहरण IsNumeric(' ')के लिए IsNumeric('\n\t'), आदि सभी रिटर्नtrue
क्रिसेंट फ्रेश

29
यह Numberशाब्दिक रूप से IsNumeric(5) == false;मेरे द्वारा पोस्ट किए गए यूनिट परीक्षणों के सेट की जांच करने में भी विफल रहेगा , यह फ़ंक्शन 16परीक्षण सूट पर संख्या है । stackoverflow.com/questions/18082/…
CMS

20
मैं विश्वास नहीं कर सकता कि कोई भी नियमित अभिव्यक्ति का उपयोग नहीं करने के बारे में चेतावनी देने के बाद एक नियमित अभिव्यक्ति (प्रतिस्थापित) का उपयोग करता है ... दी गई, एक व्हाट्सएप की जगह एक नंबर पार्स की तुलना में सरल है, लेकिन यह निश्चित रूप से "icky" है।
पैट्रिक एम

1
@ ऑरोल यह एक बड़ी समस्या है ... उस तारीख के बाद कोई सुरक्षा सुधार जारी नहीं होने के कारण, एक्सपी से दूर रहना प्राथमिकता होनी चाहिए।
जोएल कोएहॉर्न

1
यदि आप IE8 या उससे कम का उपयोग कर रहे हैं, तो @Oriol XP या नहीं, आप भयावह रूप से पुराने सॉफ़्टवेयर का उपयोग कर रहे हैं। दी गई XP IE9 + नहीं चला सकती है इसलिए Chrome या FF का उपयोग करें। IE8 का उपयोग करके अतीत में रहने वाले लोग कई वेब डेवलपर्स के अस्तित्व का प्रतिबंध हैं। अगर मैं समय वापस ले सकता हूं तो मैंने यह सुनिश्चित कर लिया है कि आईई 8 में पूरी तरह से अच्छा कोड भी चलता है ... मेरे लिए एफएफ और क्रोम में काम करने वाले कोड लेने और आईई 8 में चलने के लिए पैचिंग करना उतना ही व्यावहारिक है जितना कि विंडोज 8 निष्पादन योग्य और यह सुनिश्चित करना कि यह विंडोज़ 3.1 में समान हो।
chiliNUT

70

इस तरह से काम करने लगता है:

function IsNumeric(input){
    var RE = /^-{0,1}\d*\.{0,1}\d+$/;
    return (RE.test(input));
}

एक पंक्ति में:

const IsNumeric = (num) => /^-{0,1}\d*\.{0,1}\d+$/.test(num);

और इसका परीक्षण करने के लिए:

const IsNumeric = (num) => /^-{0,1}\d*\.{0,1}\d+$/.test(num);
    
    function TestIsNumeric(){
        var results = ''
        results += (IsNumeric('-1')?"Pass":"Fail") + ": IsNumeric('-1') => true\n";
        results += (IsNumeric('-1.5')?"Pass":"Fail") + ": IsNumeric('-1.5') => true\n";
        results += (IsNumeric('0')?"Pass":"Fail") + ": IsNumeric('0') => true\n";
        results += (IsNumeric('0.42')?"Pass":"Fail") + ": IsNumeric('0.42') => true\n";
        results += (IsNumeric('.42')?"Pass":"Fail") + ": IsNumeric('.42') => true\n";
        results += (!IsNumeric('99,999')?"Pass":"Fail") + ": IsNumeric('99,999') => false\n";
        results += (!IsNumeric('0x89f')?"Pass":"Fail") + ": IsNumeric('0x89f') => false\n";
        results += (!IsNumeric('#abcdef')?"Pass":"Fail") + ": IsNumeric('#abcdef') => false\n";
        results += (!IsNumeric('1.2.3')?"Pass":"Fail") + ": IsNumeric('1.2.3') => false\n";
        results += (!IsNumeric('')?"Pass":"Fail") + ": IsNumeric('') => false\n";
        results += (!IsNumeric('blah')?"Pass":"Fail") + ": IsNumeric('blah') => false\n";
        
        return results;
    }

console.log(TestIsNumeric());
.as-console-wrapper { max-height: 100% !important; top: 0; }

मैंने उस regex को http://www.codetoad.com/javascript/isnumeric.asp से उधार लिया था । स्पष्टीकरण:

/^ match beginning of string
-{0,1} optional negative sign
\d* optional digits
\.{0,1} optional decimal point
\d+ at least one digit
$/ match end of string

1
// ALSO SHOULD BE को आपके परीक्षण परिणामों में जोड़ा गया + = (!! Isumumeric ('-'); परिणाम + = (!! IsNumeric ('01 ')? "Pass": "Fail") + ": IsNumeric ('01') => false \ n"; परिणाम + = (!! IsNumeric ('- 01'); "पास": "विफल") + ": IsNumeric ('- 01') => false \ n"; परिणाम + = (!! IsNumeric ('000'); "पास": "विफल") + ": IsNumeric ('000') => false \ n";
Dan

यह क्या करता है? / ^ - {0,1} \ d * \ _। {0,1} \ d + $ /
कॉल- me

क्या "{0,1}" को "?" से बदला जा सकता है, इसलिए आपका regexp कुछ इस तरह दिखाई देगा:
बादल

अच्छा और सरल।
ब्रेकर

53

याहू! UI इसका उपयोग करता है:

isNumber: function(o) {
    return typeof o === 'number' && isFinite(o);
}

25
यह संख्या की सामग्री के विपरीत चर प्रकार की अधिक जाँच कर रहा है। इसके साथ बनाए गए नंबरों पर भी यह फेल हो जाएगा new Number(1)
एलेक्स

4
जैसा कि एलेक्स कहते हैं, यह वास्तव में सामने वाले प्रश्न का उत्तर नहीं देता है क्योंकि यह विफल हो जाएगा यदि ओ = "1001"।
केस

50
function IsNumeric(num) {
     return (num >=0 || num < 0);
}

यह 0x23 प्रकार की संख्या के लिए भी काम करता है।


29
IsNumeric(''), IsNumeric(' '), IsNumeric(true), IsNumeric(false), IsNumeric(null)लौटने trueके बजाय false
ओरियल

49

स्वीकृत उत्तर आपके परीक्षण में विफल रहा # 7 और मुझे लगता है कि ऐसा इसलिए है क्योंकि आपने अपना विचार बदल दिया है। तो यह स्वीकृत उत्तर की प्रतिक्रिया है, जिसके साथ मेरे पास मुद्दे थे।

कुछ परियोजनाओं के दौरान मुझे कुछ डेटा को मान्य करने और जितना संभव हो उतना निश्चित होना चाहिए कि यह एक जावास्क्रिप्ट संख्यात्मक मान है जिसे गणितीय कार्यों में उपयोग किया जा सकता है।

jQuery, और कुछ अन्य जावास्क्रिप्ट पुस्तकालयों में पहले से ही ऐसा फ़ंक्शन शामिल है, जिसे आमतौर पर कहा जाता है isNumericस्टैकओवरफ्लो पर एक पोस्ट भी है जिसे उत्तर के रूप में व्यापक रूप से स्वीकार किया गया है, वही सामान्य दिनचर्या जो उपर्युक्त पुस्तकालयों का उपयोग कर रही है।

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

सबसे पहले, ऊपर दिया गया कोड सही होगा यदि तर्क 1 लंबाई का सरणी था, और वह एकल तत्व एक प्रकार का था जिसे उपरोक्त तर्क द्वारा संख्यात्मक माना जाता है। मेरी राय में, यदि यह एक सरणी है तो इसका संख्यात्मक नहीं है।

इस समस्या को कम करने के लिए, मैंने तर्क से छूट सरणियों के लिए एक चेक जोड़ा

function isNumber(n) {
  return Object.prototype.toString.call(n) !== '[object Array]' &&!isNaN(parseFloat(n)) && isFinite(n);
}

बेशक, आप इसके बजाय Array.isArrayjquery $.isArrayया प्रोटोटाइप का भी उपयोग कर सकते हैंObject.isArrayObject.prototype.toString.call(n) !== '[object Array]'

मेरा दूसरा मुद्दा यह था कि नकारात्मक हेक्साडेसिमल पूर्णांक शाब्दिक तार ("-0xA" -> -10) को संख्यात्मक के रूप में नहीं गिना जा रहा था। हालांकि, सकारात्मक हेक्साडेसिमल पूर्णांक शाब्दिक तार ("0xA" -> 10) को संख्यात्मक के रूप में माना जाता था। मुझे वैध सांख्यिक होने की आवश्यकता थी।

मैंने तब इसे ध्यान में रखते हुए तर्क को संशोधित किया।

function isNumber(n) {
  return Object.prototype.toString.call(n) !== '[object Array]' &&!isNaN(parseFloat(n)) && isFinite(n.toString().replace(/^-/, ''));
}

यदि आप प्रत्येक बार फ़ंक्शन को कॉल करने के लिए रेगेक्स के निर्माण के बारे में चिंतित हैं, तो आप इसे एक क्लोजर में फिर से लिख सकते हैं, इस पर कुछ

var isNumber = (function () {
  var rx = /^-/;

  return function (n) {
      return Object.prototype.toString.call(n) !== '[object Array]' &&!isNaN(parseFloat(n)) && isFinite(n.toString().replace(rx, ''));
  };
}());

फिर मैंने CMS +30 परीक्षण मामलों को लिया और jsfiddle पर परीक्षण को क्लोन करके मेरे अतिरिक्त परीक्षण मामलों और मेरे ऊपर वर्णित समाधान को जोड़ा।

यह व्यापक रूप से स्वीकृत / उपयोग किए गए उत्तर की जगह नहीं ले सकता है, लेकिन यदि यह आपके isNumeric फ़ंक्शन से परिणाम के रूप में उम्मीद कर रहा है तो अधिक है, तो उम्मीद है कि यह कुछ मदद करेगा।

EDIT: जैसा कि बर्गी ने बताया , अन्य संभावित वस्तुएं हैं जिन्हें संख्यात्मक माना जा सकता है और यह ब्लैकलिस्ट की तुलना में श्वेतसूची में बेहतर होगा। इसे ध्यान में रखते हुए मैं मानदंड जोड़ूंगा।

मैं चाहता हूं कि मेरा समसामयिक फ़ंक्शन केवल संख्याओं या स्ट्रिंग्स पर विचार करे

इसे ध्यान में रखते हुए, इसका उपयोग करना बेहतर होगा

function isNumber(n) {
  return (Object.prototype.toString.call(n) === '[object Number]' || Object.prototype.toString.call(n) === '[object String]') &&!isNaN(parseFloat(n)) && isFinite(n.toString().replace(/^-/, ''));
}

समाधान का परीक्षण करें

var testHelper = function() {

  var testSuite = function() {
    test("Integer Literals", function() {
      ok(isNumber("-10"), "Negative integer string");
      ok(isNumber("0"), "Zero string");
      ok(isNumber("5"), "Positive integer string");
      ok(isNumber(-16), "Negative integer number");
      ok(isNumber(0), "Zero integer number");
      ok(isNumber(32), "Positive integer number");
      ok(isNumber("040"), "Octal integer literal string");
      ok(isNumber(0144), "Octal integer literal");
      ok(isNumber("-040"), "Negative Octal integer literal string");
      ok(isNumber(-0144), "Negative Octal integer literal");
      ok(isNumber("0xFF"), "Hexadecimal integer literal string");
      ok(isNumber(0xFFF), "Hexadecimal integer literal");
      ok(isNumber("-0xFF"), "Negative Hexadecimal integer literal string");
      ok(isNumber(-0xFFF), "Negative Hexadecimal integer literal");
    });

    test("Foating-Point Literals", function() {
      ok(isNumber("-1.6"), "Negative floating point string");
      ok(isNumber("4.536"), "Positive floating point string");
      ok(isNumber(-2.6), "Negative floating point number");
      ok(isNumber(3.1415), "Positive floating point number");
      ok(isNumber(8e5), "Exponential notation");
      ok(isNumber("123e-2"), "Exponential notation string");
    });

    test("Non-Numeric values", function() {
      equals(isNumber(""), false, "Empty string");
      equals(isNumber("        "), false, "Whitespace characters string");
      equals(isNumber("\t\t"), false, "Tab characters string");
      equals(isNumber("abcdefghijklm1234567890"), false, "Alphanumeric character string");
      equals(isNumber("xabcdefx"), false, "Non-numeric character string");
      equals(isNumber(true), false, "Boolean true literal");
      equals(isNumber(false), false, "Boolean false literal");
      equals(isNumber("bcfed5.2"), false, "Number with preceding non-numeric characters");
      equals(isNumber("7.2acdgs"), false, "Number with trailling non-numeric characters");
      equals(isNumber(undefined), false, "Undefined value");
      equals(isNumber(null), false, "Null value");
      equals(isNumber(NaN), false, "NaN value");
      equals(isNumber(Infinity), false, "Infinity primitive");
      equals(isNumber(Number.POSITIVE_INFINITY), false, "Positive Infinity");
      equals(isNumber(Number.NEGATIVE_INFINITY), false, "Negative Infinity");
      equals(isNumber(new Date(2009, 1, 1)), false, "Date object");
      equals(isNumber(new Object()), false, "Empty object");
      equals(isNumber(function() {}), false, "Instance of a function");
      equals(isNumber([]), false, "Empty Array");
      equals(isNumber(["-10"]), false, "Array Negative integer string");
      equals(isNumber(["0"]), false, "Array Zero string");
      equals(isNumber(["5"]), false, "Array Positive integer string");
      equals(isNumber([-16]), false, "Array Negative integer number");
      equals(isNumber([0]), false, "Array Zero integer number");
      equals(isNumber([32]), false, "Array Positive integer number");
      equals(isNumber(["040"]), false, "Array Octal integer literal string");
      equals(isNumber([0144]), false, "Array Octal integer literal");
      equals(isNumber(["-040"]), false, "Array Negative Octal integer literal string");
      equals(isNumber([-0144]), false, "Array Negative Octal integer literal");
      equals(isNumber(["0xFF"]), false, "Array Hexadecimal integer literal string");
      equals(isNumber([0xFFF]), false, "Array Hexadecimal integer literal");
      equals(isNumber(["-0xFF"]), false, "Array Negative Hexadecimal integer literal string");
      equals(isNumber([-0xFFF]), false, "Array Negative Hexadecimal integer literal");
      equals(isNumber([1, 2]), false, "Array with more than 1 Positive interger number");
      equals(isNumber([-1, -2]), false, "Array with more than 1 Negative interger number");
    });
  }

  var functionsToTest = [

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

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

    function(n) {
      return !isNaN((n));
    },

    function(n) {
      return !isNaN(parseFloat(n));
    },

    function(n) {
      return typeof(n) != "boolean" && !isNaN(n);
    },

    function(n) {
      return parseFloat(n) === Number(n);
    },

    function(n) {
      return parseInt(n) === Number(n);
    },

    function(n) {
      return !isNaN(Number(String(n)));
    },

    function(n) {
      return !isNaN(+('' + n));
    },

    function(n) {
      return (+n) == n;
    },

    function(n) {
      return n && /^-?\d+(\.\d+)?$/.test(n + '');
    },

    function(n) {
      return isFinite(Number(String(n)));
    },

    function(n) {
      return isFinite(String(n));
    },

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

    function(n) {
      return parseFloat(n) == n;
    },

    function(n) {
      return (n - 0) == n && n.length > 0;
    },

    function(n) {
      return typeof n === 'number' && isFinite(n);
    },

    function(n) {
      return !Array.isArray(n) && !isNaN(parseFloat(n)) && isFinite(n.toString().replace(/^-/, ''));
    }

  ];


  // Examines the functionsToTest array, extracts the return statement of each function
  // and fills the toTest select element.
  var fillToTestSelect = function() {
    for (var i = 0; i < functionsToTest.length; i++) {
      var f = functionsToTest[i].toString();
      var option = /[\s\S]*return ([\s\S]*);/.exec(f)[1];
      $("#toTest").append('<option value="' + i + '">' + (i + 1) + '. ' + option + '</option>');
    }
  }

  var performTest = function(functionNumber) {
    reset(); // Reset previous test
    $("#tests").html(""); //Clean test results
    isNumber = functionsToTest[functionNumber]; // Override the isNumber global function with the one to test
    testSuite(); // Run the test

    // Get test results
    var totalFail = 0;
    var totalPass = 0;
    $("b.fail").each(function() {
      totalFail += Number($(this).html());
    });
    $("b.pass").each(function() {
      totalPass += Number($(this).html());
    });
    $("#testresult").html(totalFail + " of " + (totalFail + totalPass) + " test failed.");

    $("#banner").attr("class", "").addClass(totalFail > 0 ? "fail" : "pass");
  }

  return {
    performTest: performTest,
    fillToTestSelect: fillToTestSelect,
    testSuite: testSuite
  };
}();


$(document).ready(function() {
  testHelper.fillToTestSelect();
  testHelper.performTest(0);

  $("#toTest").change(function() {
    testHelper.performTest($(this).children(":selected").val());
  });
});
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js" type="text/javascript"></script>
<script src="https://rawgit.com/Xotic750/testrunner-old/master/testrunner.js" type="text/javascript"></script>
<link href="https://rawgit.com/Xotic750/testrunner-old/master/testrunner.css" rel="stylesheet" type="text/css">
<h1>isNumber Test Cases</h1>

<h2 id="banner" class="pass"></h2>

<h2 id="userAgent">Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.95 Safari/537.11</h2>

<div id="currentFunction"></div>

<div id="selectFunction">
  <label for="toTest" style="font-weight:bold; font-size:Large;">Select function to test:</label>
  <select id="toTest" name="toTest">
  </select>
</div>

<div id="testCode"></div>

<ol id="tests">
  <li class="pass">
    <strong>Integer Literals <b style="color:black;">(0, 10, 10)</b></strong>

    <ol style="display: none;">
      <li class="pass">Negative integer string</li>

      <li class="pass">Zero string</li>

      <li class="pass">Positive integer string</li>

      <li class="pass">Negative integer number</li>

      <li class="pass">Zero integer number</li>

      <li class="pass">Positive integer number</li>

      <li class="pass">Octal integer literal string</li>

      <li class="pass">Octal integer literal</li>

      <li class="pass">Hexadecimal integer literal string</li>

      <li class="pass">Hexadecimal integer literal</li>
    </ol>
  </li>

  <li class="pass">
    <strong>Foating-Point Literals <b style="color:black;">(0, 6, 6)</b></strong>

    <ol style="display: none;">
      <li class="pass">Negative floating point string</li>

      <li class="pass">Positive floating point string</li>

      <li class="pass">Negative floating point number</li>

      <li class="pass">Positive floating point number</li>

      <li class="pass">Exponential notation</li>

      <li class="pass">Exponential notation string</li>
    </ol>
  </li>

  <li class="pass">
    <strong>Non-Numeric values <b style="color:black;">(0, 18, 18)</b></strong>

    <ol style="display: none;">
      <li class="pass">Empty string: false</li>

      <li class="pass">Whitespace characters string: false</li>

      <li class="pass">Tab characters string: false</li>

      <li class="pass">Alphanumeric character string: false</li>

      <li class="pass">Non-numeric character string: false</li>

      <li class="pass">Boolean true literal: false</li>

      <li class="pass">Boolean false literal: false</li>

      <li class="pass">Number with preceding non-numeric characters: false</li>

      <li class="pass">Number with trailling non-numeric characters: false</li>

      <li class="pass">Undefined value: false</li>

      <li class="pass">Null value: false</li>

      <li class="pass">NaN value: false</li>

      <li class="pass">Infinity primitive: false</li>

      <li class="pass">Positive Infinity: false</li>

      <li class="pass">Negative Infinity: false</li>

      <li class="pass">Date object: false</li>

      <li class="pass">Empty object: false</li>

      <li class="pass">Instance of a function: false</li>
    </ol>
  </li>
</ol>

<div id="main">
  This page contains tests for a set of isNumber functions. To see them, take a look at the source.
</div>

<div>
  <p class="result">Tests completed in 0 milliseconds.
    <br>0 tests of 0 failed.</p>
</div>


2
यह मेरे विचार में सबसे अधिक परिरक्षित कार्य है; आखरी वाला। स्वीकृत उत्तर कवर शायद सभी मामलों में 99.99% है, लेकिन यह एक छोटे ओवरहेड के साथ मामलों का शायद 100% है)।
शमूएल

आप "99,999" के फ़ॉइटिंग-पॉइंट शाब्दिक के बारे में भूल गए। यह सभी यूरोप से बाहर ब्रिटेन में एक मान्य संख्या है
एंड्री होर्डा

यह भूल नहीं था, यह कुछ ऐसा नहीं था जिसे मैंने जावास्क्रिप्ट संख्याओं के अर्थ में एक संख्यात्मक माना, ओपी ने यह भी कहाIsNumeric('99,999') => false
Xotic750

34

हाँ, बिल्ट-इन isNaN(object)किसी भी रेगेक्स पार्सिंग की तुलना में बहुत तेज़ होगा, क्योंकि यह मक्खी पर व्याख्या के बजाय अंतर्निहित और संकलित है।

हालांकि परिणाम कुछ अलग हैं जो आप खोज रहे हैं ( इसे आज़माएं ):

                                              // IS NUMERIC
document.write(!isNaN('-1') + "<br />");      // true
document.write(!isNaN('-1.5') + "<br />");    // true
document.write(!isNaN('0') + "<br />");       // true
document.write(!isNaN('0.42') + "<br />");    // true
document.write(!isNaN('.42') + "<br />");     // true
document.write(!isNaN('99,999') + "<br />");  // false
document.write(!isNaN('0x89f') + "<br />");   // true
document.write(!isNaN('#abcdef') + "<br />"); // false
document.write(!isNaN('1.2.3') + "<br />");   // false
document.write(!isNaN('') + "<br />");        // true
document.write(!isNaN('blah') + "<br />");    // false

18

फ़ंक्शन का उपयोग करें isNaN। मेरा मानना ​​है कि यदि आप !isNaN(yourstringhere)इसके लिए परीक्षण करते हैं तो इनमें से किसी भी स्थिति के लिए ठीक काम करता है।


नोट:! IsNaN (null) == सच चूंकि नंबर (null) == 0
जोनाथन लोनोस्की

if (((x == null || isNaN (x))) अलर्ट ("Numeric "); // लेकिन यह समाधान 0x40 को स्वीकार करता है इसलिए यह अभी भी वही नहीं है जो ऑप चाहता था।
कुछ

ध्यान दें कि NNN ("इन्फिनिटी") === गलत है, जो संभवत: वह भी नहीं है जो आप चाहते हैं (लेकिन वास्तविक जीवन में भी नहीं होगा)।
एरिक हेसेलिंक

16

JQuery 1.7 के बाद से, आप उपयोग कर सकते हैं jQuery.isNumeric():

$.isNumeric('-1');      // true
$.isNumeric('-1.5');    // true
$.isNumeric('0');       // true
$.isNumeric('0.42');    // true
$.isNumeric('.42');     // true
$.isNumeric('0x89f');   // true (valid hexa number)
$.isNumeric('99,999');  // false
$.isNumeric('#abcdef'); // false
$.isNumeric('1.2.3');   // false
$.isNumeric('');        // false
$.isNumeric('blah');    // false

बस ध्यान दें कि आपने जो कहा उसके विपरीत, 0x89fएक वैध संख्या है (हेक्सा)


ओपी वैध दशमलव संख्या चाहता है , इसलिए jQuery isNumeric सूट नहीं करता है। यह बहुत बड़ी संख्या के लिए भी विफल रहता है।
21

13

यह RegExp के बिना किया जा सकता है

function IsNumeric(data){
    return parseFloat(data)==data;
}

5
यदि हम == का उपयोग कर रहे हैं, तो यह स्ट्रिंग्स के रूप में प्रस्तुत संख्याओं के लिए भी सही होगा। तो "42" को "==" के मामले में मान्य संख्या के रूप में गिना जाएगा और === के मामले में अमान्य माना जाएगा
जलीय

यह "-0", "-.0", ".0" और "0." पर सही है
Janus Troelsen

8

मुझे पता है कि मूल प्रश्न में jQuery का उल्लेख नहीं था, लेकिन यदि आप jQuery का उपयोग करते हैं, तो आप कर सकते हैं:

$.isNumeric(val)

सरल।

https://api.jquery.com/jQuery.isNumeric/ (jQuery 1.7 के अनुसार)


8
return (input - 0) == input && input.length > 0;

मेरे लिए काम नहीं किया। जब मैंने एक चेतावनी दी और परीक्षण किया, input.lengthथा undefined। मुझे लगता है कि पूर्णांक लंबाई की जांच करने के लिए कोई संपत्ति नहीं है। तो मैंने जो किया था

var temp = '' + input;
return (input - 0) == input && temp.length > 0;

यह ठीक काम किया।


7

अगर मैं गलत नहीं हूँ, तो यह स्थिरांक ( Infinity, NaN) और साइन ऑपरेटरों को छोड़कर किसी भी मान्य जावास्क्रिप्ट संख्या मान से मेल खाना चाहिए +/ -(क्योंकि वे वास्तव में संख्या का हिस्सा नहीं हैं जहाँ तक मेरा संबंध है, वे अलग-अलग ऑपरेटर हैं):

मुझे एक टोकन के लिए इसकी आवश्यकता थी, जहां मूल्यांकन के लिए जावास्क्रिप्ट को नंबर भेजना एक विकल्प नहीं था ... यह निश्चित रूप से सबसे कम संभव नियमित अभिव्यक्ति नहीं है, लेकिन मेरा मानना ​​है कि यह जावास्क्रिप्ट के संख्या सिंटैक्स के सभी बारीक बारीकियों को पकड़ता है।

/^(?:(?:(?:[1-9]\d*|\d)\.\d*|(?:[1-9]\d*|\d)?\.\d+|(?:[1-9]\d*|\d)) 
(?:[e]\d+)?|0[0-7]+|0x[0-9a-f]+)$/i

मान्य संख्या में शामिल होंगे:

 - 0
 - 00
 - 01
 - 10
 - 0e1
 - 0e01
 - .0
 - 0.
 - .0e1
 - 0.e1
 - 0.e00
 - 0xf
 - 0Xf

अमान्य नंबर होंगे

 - 00e1
 - 01e1
 - 00.0
 - 00x0
 - .
 - .e0

7

केवल @ सीएमएस के उत्तर के साथ मुझे जो समस्या थी , वह है NaNइनफिनिटी एंड इनफिनिटी, जो कई स्थितियों के लिए उपयोगी संख्या है। NaNसांख्यिक मूल्यों के लिए जाँच करने का एक तरीका है जो स्वयं के बराबर नहीं है NaN != NaN,! तो वास्तव में 3 परीक्षण हैं जिनसे आप निपटना चाहेंगे ...

function isNumber(n) {
  n = parseFloat(n);
  return !isNaN(n) || n != n;
}
function isFiniteNumber(n) {
  n = parseFloat(n);
  return !isNaN(n) && isFinite(n);
}    
function isComparableNumber(n) {
  n = parseFloat(n);
  return (n >=0 || n < 0);
}

isFiniteNumber('NaN')
false
isFiniteNumber('OxFF')
true
isNumber('NaN')
true
isNumber(1/0-1/0)
true
isComparableNumber('NaN')
false
isComparableNumber('Infinity')
true

MyComparableNumber एक और सुरुचिपूर्ण उत्तर के बहुत करीब है , लेकिन हेक्स और संख्याओं के अन्य स्ट्रिंग प्रतिनिधित्व को संभालता है।



6

मैं निम्नलिखित जोड़ना चाहूंगा:

1. IsNumeric('0x89f') => true
2. IsNumeric('075') => true

पॉजिटिव हेक्स नंबर से शुरू होता है 0xऔर नेगेटिव हेक्स नंबर से शुरू होता है -0x। पॉजिटिव ऑक्टो नंबर से शुरू होता है 0और नेगेटिव ऑक्टो नंबर से शुरू होता है -0। यह वह चीज लेता है जो पहले से ही ध्यान में रखी गई है, लेकिन इसमें हेक्स और ऑक्टल नंबर, नकारात्मक वैज्ञानिक, इन्फिनिटी शामिल हैं और दशमलव वैज्ञानिक को हटा दिया गया है ( 4e3.2यह मान्य नहीं है)।

function IsNumeric(input){
  var RE = /^-?(0|INF|(0[1-7][0-7]*)|(0x[0-9a-fA-F]+)|((0|[1-9][0-9]*|(?=[\.,]))([\.,][0-9]+)?([eE]-?\d+)?))$/;
  return (RE.test(input));
}

6

मुझे लगता है कि parseFloat फ़ंक्शन यहां सभी काम कर सकता है। नीचे दिए गए फ़ंक्शन में इस पृष्ठ पर सभी परीक्षण शामिल हैं isNumeric(Infinity) == true:

function isNumeric(n) {

    return parseFloat(n) == n;
}

हां, मैं इस नतीजे पर पहुंचा हूं। मुझे यह भी काफी पसंद है कि इस पद्धति का उपयोग करके सरणियों का इलाज किया जाता है; एक मान वाला एक सरणी उस मान के रूप में मायने रखता है, लेकिन बाकी सब विफल रहता है: IsNumeric([3]) == true; IsNumeric([]) == false; IsNumeric([3, 4]) == false; लेकिन मुझे लगता है कि स्वाद की बात है!
मार्क बिर्बेक

4

जोड़ने के लिए परीक्षणों की एक जोड़ी:

IsNumeric('01.05') => false
IsNumeric('1.') => false
IsNumeric('.') => false

मैं इसके साथ आया:

function IsNumeric(input) {
    return /^-?(0|[1-9]\d*|(?=\.))(\.\d+)?$/.test(input);
}

समाधान कवर:

  • शुरुआत में एक वैकल्पिक नकारात्मक संकेत
  • एक एकल शून्य, या एक या एक से अधिक अंक 0 से शुरू नहीं हो रहे हैं, या कुछ भी नहीं है जब तक एक अवधि के बाद
  • एक अवधि जो 1 या अधिक संख्याओं के बाद होती है

4

एक पूर्णांक मान द्वारा सत्यापित किया जा सकता है:

function isNumeric(value) {
    var bool = isNaN(+value));
    bool = bool || (value.indexOf('.') != -1);
    bool = bool || (value.indexOf(",") != -1);
    return !bool;
};

यह रास्ता आसान और तेज है! सभी परीक्षणों की जाँच कर रहे हैं!


4

यहाँ एक lil सा बेहतर संस्करण है (शायद वहाँ सबसे तेज़ तरीका है) जो मैं सटीक jQuery के संस्करण के बजाय उपयोग करता हूं, मुझे वास्तव में पता नहीं है कि वे इस का उपयोग क्यों नहीं करते हैं:

function isNumeric(val) {
    return !isNaN(+val) && isFinite(val);
}

JQuery के संस्करण का नकारात्मक पहलू है कि यदि आप numerics प्रमुख और पत्र अनुगामी तरह से एक स्ट्रिंग पारित है सांख्यिक अंश बाहर निकालने और 123 वापस आ जाएगी, लेकिन, दूसरे गार्ड यह वैसे भी असफल हो जायेगी। यूनीरी ऑपरेटर के साथ यह पहले ही पहरे पर मर जाएगा क्योंकि + इस तरह के संकर के लिए NaN फेंकता है :) थोड़ा सा प्रदर्शन अभी तक मुझे लगता है कि एक ठोस अर्थ लाभ है।"123abc"parseFloat | parseIntisFinite+


2
Unary '+' से सावधान रहें valueOf () को ऑब्जेक्ट पर - इस jsfiddle को देखें । इसके अलावा यह प्रमुख व्हाट्सएप के लिए भी विफल रहता है, जैसा कि अग्रणी उत्तर देता है।
इयरकैम

3

मेरा समाधान,

function isNumeric(input) {
    var number = /^\-{0,1}(?:[0-9]+){0,1}(?:\.[0-9]+){0,1}$/i;
    var regex = RegExp(number);
    return regex.test(input) && input.length>0;
}

यह हर स्थिति में काम करता प्रतीत होता है, लेकिन मैं गलत हो सकता हूं।


यही कारण है कि regex कम भ्रामक होगा यदि आप बेकार में वर्ण, उपयोग से बच नहीं किया जाएगा ?के लिए {0,1}और \dके लिए [0-9]। इसके अलावा +और फिर इसे लपेटकर (?:){0,1}, आप उपयोग कर सकते हैं *और (गैर) कैप्चरिंग समूहों को भूल सकते हैं।
एलेक्स

3

मैं सरल समाधान का उपयोग कर रहा हूं:

function isNumber(num) {
    return parseFloat(num).toString() == num
}

5
यह अंत में शानदार 0 के साथ कुछ भी विफल हो जाएगा। उदाहरण: "10.0"
Janus Troelsen

3

यह काम करना चाहिए। यहां प्रदान किए गए कुछ फ़ंक्शन त्रुटिपूर्ण हैं, यहां भी किसी अन्य फ़ंक्शन की तुलना में तेज़ होना चाहिए।

        function isNumeric(n)
        {
            var n2 = n;
            n = parseFloat(n);
            return (n!='NaN' && n2==n);
        }

व्याख्या की:

स्वयं की एक प्रति बनाएँ, फिर संख्या को फ्लोट में रूपांतरित करता है, फिर मूल संख्या के साथ स्वयं की तुलना करता है, यदि यह अभी भी एक संख्या है, (चाहे पूर्णांक या फ्लोट), और मूल संख्या से मेल खाती है, अर्थात, यह वास्तव में एक संख्या है।

यह न्यूमेरिक स्ट्रिंग्स के साथ-साथ सादे नंबरों के साथ काम करता है। हेक्साडेसिमल संख्याओं के साथ काम नहीं करता है।

चेतावनी: अपने जोखिम पर उपयोग करें, कोई गारंटी नहीं।


4
अपने जोखिम पर उपयोग करें, कोई गारंटी नहीं है कि मैं उस कोड का उपयोग नहीं करूंगा जिसके बारे में लेखक आश्वस्त नहीं है;)
एलेक्स

1
@ एलेक्स, कम से कम चीजों के बारे में आपकी अपनी राय है। हर समय सिर्फ आलोचना मत करो।
स्टीवर्ट Mbofana

3

falseखाली स्ट्रिंग्स के लिए कोई भी उत्तर वापस नहीं आता, उसके लिए एक फिक्स ...

function is_numeric(n)
{
 return (n != '' && !isNaN(parseFloat(n)) && isFinite(n));
}

3

यह जाँचने के लिए कि एक चर में एक वैध संख्या है और न केवल एक स्ट्रिंग जो एक संख्या की तरह दिखती है, Number.isFinite(value)का उपयोग किया जा सकता है।

यह ES2015 के बाद से भाषा का हिस्सा है

उदाहरण:

Number.isFinite(Infinity)   // false
Number.isFinite(NaN)        // false
Number.isFinite(-Infinity)  // false

Number.isFinite(0)          // true
Number.isFinite(2e64)       // true

Number.isFinite('0')        // false
Number.isFinite(null)       // false

1
मुझे लगता है कि बहुत से लोग इस सवाल का संदर्भ उपयोगकर्ता इनपुट को पार्स करने के लिए करेंगे, जो आमतौर पर एक स्ट्रिंग होगा । यह उत्तर उन मामलों में विफल रहता है, जैसा कि आप उदाहरणों में सही ढंग से सूचीबद्ध करते हैं, जैसेNumber.isFinite('0') -> false
माइकल हरेन

आप पूरी तरह से सही हैं। मैंने यह स्पष्ट करने की कोशिश की।
20:12 पर adius

3
function inNumeric(n){
   return Number(n).toString() === n;
}

यदि n संख्यात्मक है Number(n), तो संख्यात्मक मान toString()वापस आएगा और इसे वापस स्ट्रिंग में बदल देगा। लेकिन अगर n संख्यात्मक नहीं है Number(n)वापस आ जाएगी NaNतो यह मूल से मेल नहीं खाएगीn


हालांकि यह कोड स्निपेट प्रश्न को हल कर सकता है, जिसमें स्पष्टीकरण सहित वास्तव में आपकी पोस्ट की गुणवत्ता में सुधार करने में मदद करता है। याद रखें कि आप भविष्य में पाठकों के लिए प्रश्न का उत्तर दे रहे हैं, और उन लोगों को आपके कोड सुझाव के कारणों का पता नहीं चल सकता है। कृपया व्याख्यात्मक टिप्पणियों के साथ अपने कोड को भीड़ने की कोशिश न करें, क्योंकि इससे कोड और स्पष्टीकरण दोनों की पठनीयता कम हो जाती है!
गुडबाय StackExchange

2

मुझे लगता है कि यह कई बार उत्तर दिया गया है, लेकिन निम्नलिखित एक सभ्य उम्मीदवार है जो कुछ परिदृश्यों में उपयोगी हो सकता है।

यह ध्यान दिया जाना चाहिए कि यह मानता है कि '.42' एक संख्या नहीं है, और '4.' कोई संख्या नहीं है, इसलिए इसे ध्यान में रखा जाना चाहिए।

function isDecimal(x) {
  return '' + x === '' + +x;
}

function isInteger(x) {
  return '' + x === '' + parseInt(x);
}

isDecimalनिम्न परीक्षण गुजरता है:

function testIsNumber(f) {
  return f('-1') && f('-1.5') && f('0') && f('0.42')
    && !f('.42') && !f('99,999') && !f('0x89f')
    && !f('#abcdef') && !f('1.2.3') && !f('') && !f('blah');
}

यहां विचार यह है कि प्रत्येक संख्या या पूर्णांक में एक "कैनोनिकल" स्ट्रिंग प्रतिनिधित्व है, और प्रत्येक गैर-कैनोनिकल प्रतिनिधित्व को अस्वीकार कर दिया जाना चाहिए। इसलिए हम एक नंबर और बैक पर जाते हैं, और देखते हैं कि परिणाम मूल स्ट्रिंग है या नहीं।

क्या ये फ़ंक्शन आपके लिए उपयोगी हैं, उपयोग के मामले पर निर्भर करता है। एक विशेषता यह है कि अलग-अलग तार अलग-अलग संख्याओं का प्रतिनिधित्व करते हैं (यदि दोनों isNumber()परीक्षण पास करते हैं )।

यह ऑब्जेक्ट प्रॉपर्टी नामों के रूप में संख्याओं के लिए प्रासंगिक है।

var obj = {};
obj['4'] = 'canonical 4';
obj['04'] = 'alias of 4';
obj[4];  // prints 'canonical 4' to the console.

2

नॉकआउटJs पुस्तकालय सत्यापन कार्यों का निर्माण

इसे विस्तारित करके क्षेत्र को मान्य किया जाता है

1) संख्या

self.number = ko.observable(numberValue).extend ({संख्या: सत्य}) ;

परीक्षण का मामला

numberValue = '0.0'    --> true
numberValue = '0'      --> true
numberValue = '25'     --> true
numberValue = '-1'     --> true
numberValue = '-3.5'   --> true
numberValue = '11.112' --> true
numberValue = '0x89f'  --> false
numberValue = ''       --> false
numberValue = 'sfsd'   --> false
numberValue = 'dg##$'  --> false

2) अंक

self.number = ko.observable(numberValue).extend ({अंक: सत्य}) ;

परीक्षण का मामला

numberValue = '0'      --> true
numberValue = '25'     --> true
numberValue = '0.0'    --> false
numberValue = '-1'     --> false
numberValue = '-3.5'   --> false
numberValue = '11.112' --> false
numberValue = '0x89f'  --> false
numberValue = ''       --> false
numberValue = 'sfsd'   --> false
numberValue = 'dg##$'  --> false

3) न्यूनतम और अधिकतम

self.number = ko.observable(numberValue).extend ({मिनट: 5})। विस्तार ({अधिकतम: 10}) ;

यह फ़ील्ड केवल 5 और 10 के बीच मान स्वीकार करती है

परीक्षण का मामला

numberValue = '5'    --> true
numberValue = '6'    --> true
numberValue = '6.5'  --> true
numberValue = '9'    --> true
numberValue = '11'   --> false
numberValue = '0'    --> false
numberValue = ''    --> false

2

यदि आपको दशमलव के एक विशेष सेट को मान्य करने की आवश्यकता है तो आप इस सरल जावास्क्रिप्ट का उपयोग कर सकते हैं:

http://codesheet.org/codesheet/x1kI7hAD

<input type="text" name="date" value="" pattern="[0-9]){1,2}(\.){1}([0-9]){2}" maxlength="6" placeholder="od npr.: 16.06" onchange="date(this);" />

जावास्क्रिप्ट:

function date(inputField) {        
  var isValid = /^([0-9]){1,2}(\.){1}([0-9]){2}$/.test(inputField.value);   
  if (isValid) {
    inputField.style.backgroundColor = '#bfa';
  } else {
    inputField.style.backgroundColor = '#fba';
  }
  return isValid;
}

2

isNumeric=(el)=>{return Boolean(parseFloat(el)) && isFinite(el)}

कुछ भी बहुत अलग नहीं है लेकिन हम बूलियन कंस्ट्रक्टर का उपयोग कर सकते हैं

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.