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


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

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

  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

2156


मूल


बस एक नोट 99,999 फ्रांस में एक मान्य संख्या है, यह यूके / हमारे प्रारूप में 99.9 99 के समान है, इसलिए यदि आप एक इनपुट फॉर्म कहने से स्ट्रिंग में पढ़ रहे हैं तो 99,999 सच हो सकते हैं। - Re0sless
यह भी देखें इस पोस्ट और महान टिप्पणियां। - powtac
डेसिमल कॉमा पूरे यूरोप और रूस में मानक है (यूके को छोड़कर) - Calmarius
jQuery 1.7 ने पेश किया है jQuery.isNumeric उपयोगिता समारोह: api.jquery.com/jQuery.isNumeric - Ates Goral
jQuery.isNumeric ओपी के सातवें टेस्ट केस में असफल रहेगा (IsNumeric('0x89f') => *false*)। मुझे यकीन नहीं है कि मैं इस परीक्षण मामले से सहमत हूं, हालांकि। - Tim Lehner


जवाब:


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

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

अनुलेख  isNaN और isFinite संख्या में मजबूर रूपांतरण के कारण भ्रमित व्यवहार करें। ईएस 6 में, 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));
}

2760



यह जवाब सही है। stackoverflow.com/questions/18082/... जोएल का जवाब गलत है। एक गलत जवाब सही से अधिक वोट कैसे एकत्र कर सकता है? - Arvin
यह अन्य लोकेशंस के साथ विफल रहता है जहां हम दशमलव अल्पविराम का उपयोग करते हैं, लेकिन 'n = n.replace (/, /, "।") जोड़ें;' इसे ठीक करने के लिए वापसी से पहले। - Zoltan Lengyel
@RobG, वह व्यवहार जानबूझकर है, 2e308 > Number.MAX_VALUE जबसे 2e308 == Infinity। यदि आप एक समारोह चाहते हैं जो लौटाता है true सकारात्मक और नकारात्मक अनंत मूल्यों के लिए भी, फ़ंक्शन की जांच करें संख्या 2 में परीक्षण सूट। चीयर्स। - CMS
वैसे, इकाई परीक्षण अब उपयोग किया जा रहा है jQuery परियोजना - CMS
jQuery अब भी हैं का उपयोग करते हुए यह कार्यान्वयन - RichardTowers


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। लंबाई जांच से पहले स्ट्रिंग को ट्रिम करना इस मामले को संभालेगा।

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

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


315



यदि आपको 0x89f विशेष केस के लिए केवल खाते की आवश्यकता है तो बेहतर है, isNaN () के आस-पास एक IsNumeric () फ़ंक्शन को लपेटता है जो तब आपकी विशेष जांच केवल तभी करता है जब NNN () गलत हो। - Joel Coehoorn
यह व्हाइटस्पेस तारों पर विफल रहता है, उदाहरण के लिए IsNumeric(' '), IsNumeric('\n\t'), आदि सभी वापसी true - Crescent Fresh
यह भी असफल हो जाएगा Number शाब्दिक IsNumeric(5) == false; मैंने पोस्ट किए गए यूनिट परीक्षणों के सेट की जांच करें, यह फ़ंक्शन नंबर है 16 परीक्षण सूट पर। stackoverflow.com/questions/18082/... - CMS
मुझे विश्वास नहीं है कि नियमित अभिव्यक्तियों का उपयोग न करने के बारे में चेतावनी के बाद किसी ने नियमित अभिव्यक्ति (प्रतिस्थापन) के उपयोग की ओर इशारा नहीं किया है ... माना जाता है कि एक सफेद जगह प्रतिस्थापित एक संख्या पार्स से सरल है, लेकिन यह अभी भी निश्चित रूप से "icky" है। - Patrick M
@ ओरीओल यह एक बड़ी समस्या है ... उस तारीख के बाद जारी कोई सुरक्षा सुधार नहीं है, एक्सपी से दूर होना प्राथमिकता होना चाहिए। - Joel Coehoorn


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

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

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

// alert(TestIsNumeric());

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

मैंने उधार लिया कि से 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

58



// आपको अपने परीक्षण परिणामों में भी जोड़ा जाना चाहिए + = (! IsNumeric ('-')? "पास": "विफल") + ": IsNumeric ('-') => false \ n"; परिणाम + = (! IsNumeric ('01 ')? "पास": "विफल") + ": IsNumeric ('01') => झूठी \ n"; परिणाम + = (! IsNumeric ('- 01')? "पास": "विफल") + ": IsNumeric ('- 01') => झूठी \ n"; परिणाम + = (! IsNumeric ('000')? "पास": "विफल") + ": IsNumeric ('000') => झूठी \ n"; - Dan
यह क्या करता है? / ^ - {0,1} \ d * \। {0,1} \ d + $ / - call-me
"{0,1}" को "?" से प्रतिस्थापित किया जा सकता है, इसलिए आपका regexp इस तरह दिखेगा: /^-?\d*\.?\d+$/? - Cloud


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

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

45



यह संख्या की सामग्री के विपरीत वैरिएबल प्रकार की जांच कर रहा है। यह भी बनाई गई संख्याओं पर असफल हो जाएगा new Number(1)। - alex
जैसा कि एलेक्स कहते हैं, यह वास्तव में उत्पन्न प्रश्न का उत्तर नहीं देता है क्योंकि यह ओ = "1001" में विफल हो जाएगा। - Case


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

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


44



IsNumeric(''), IsNumeric(' '), IsNumeric(true), IsNumeric(false), IsNumeric(null) वापसी true के बजाय false। - Oriol
मैंने इसे बेहतर किया: stackoverflow.com/a/20712631/1985601 - daniel1426


स्वीकृत उत्तर आपके परीक्षण # 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.isArray, jquery $.isArray या प्रोटोटाइप Object.isArray के बजाय Object.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, ''));
  };
}());

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

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

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

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

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

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>


37



यह मेरे विचार में सबसे संरक्षित कार्य है; आखरी वाला। स्वीकार्य उत्तर कवर शायद सभी मामलों में 99.99% है, लेकिन इस मामले में शायद 100% ए) एक छोटे से ओवरहेड वाले मामले हैं। - Samuel
आप "99,999" फोटिंग-प्वाइंट शाब्दिक के बारे में भूल गए। यह ब्रिटेन के सभी ब्रिटेन में एक वैध संख्या है - Andrii Horda
यह भूल नहीं गया था, यह कुछ ऐसा नहीं था जिसे मैंने जावास्क्रिप्ट संख्याओं के अर्थ में एक संख्यात्मक माना, ओपी ने यह भी कहा IsNumeric('99,999') => false - Xotic750


हाँ, अंतर्निर्मित 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

30





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 एक मान्य संख्या है (हेक्सा)


14



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


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


14



नोट: !NNN (शून्य) == सत्य (शून्य) == 0 के बाद से सच है - Jonathan Lonowski
अगर (! (x == null || isNaN (x))) अलर्ट ("isNumeric"); // लेकिन यह समाधान 0x40 स्वीकार करता है, इसलिए यह अभी भी नहीं है कि ओप क्या चाहता था। - some
ध्यान दें कि एनएएनएन ("इन्फिनिटी") === झूठी है, जो शायद आप जो भी चाहते हैं वह भी नहीं है (लेकिन वास्तविक जीवन में भी नहीं होगा)। - Erik Hesselink


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

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

10



यह नहीं होना चाहिए === - powtac
यदि हम == का उपयोग कर रहे हैं, तो यह तारों के रूप में प्रस्तुत संख्याओं के लिए भी सही होगा। तो "42" को "==" के मामले में वैध संख्या के रूप में गिना जाएगा और === के मामले में अमान्य के रूप में गिना जाएगा - Aquatic
यह "-0।", "-.0", ".0" और "0." पर सत्य है - Janus Troelsen


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

$.isNumeric(val)

सरल।

https://api.jquery.com/jQuery.isNumeric/ (jQuery 1.7 के रूप में)


5