(स्ट्रिंग में एक वैध संख्या है या नहीं, यह जाँचने के लिए जावास्क्रिप्ट में निर्मित)

Question

मुझे उम्मीद है कि पुराने VB6 IsNumeric()फ़ंक्शन के समान वैचारिक स्थान में कुछ है ?

Comments

इस संबंधित प्रश्न को देखें , जो मैंने कुछ समय पहले पूछा था।

— माइकल हरन

यदि आप इस प्रश्न पर जाते हैं, तो सभी RegEx उत्तरों को छोड़ने का प्रयास करें। यह सिर्फ ऐसा करने का तरीका नहीं है।

— जोएल कोएहॉर्न

जब तक कोई ऐसा नहीं करना चाहता है: यह जांचने के लिए कि किसी दिए गए स्ट्रिंग में अंकों की वैध धारा का प्रारूप है या नहीं। फिर गलत क्यों होना चाहिए?

— सासक्यू

चयनित उत्तर गलत है !!! अपनी टिप्पणी देखें, लेकिन मूल रूप से यह उदाहरण के साथ विफल isNaN(""), isNaN(" "), isNaN(false), आदि यह रिटर्न falseइन के लिए, जिसका अर्थ है कि वे नंबर हैं।

— एंड्रयू

इसलिए चयनित उत्तर गलत है, regexp ऐसा करने का तरीका नहीं है। कौन सा सही है फिर?

— हमें

Answer 1

यह जाँचने के लिए कि एक चर (एक स्ट्रिंग सहित) एक संख्या है, यह जाँच करें कि क्या यह संख्या नहीं है:

यह परवाह किए बिना काम करता है कि चर सामग्री एक स्ट्रिंग या संख्या है।

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

Comments

ParseInt के बारे में एक बहुत ही महत्वपूर्ण बात यह है कि यह आपको स्ट्रिंग को इंट में बदलने के लिए एक मूलांक निर्दिष्ट करने की अनुमति देगा। यदि आप इसे आपूर्ति नहीं करते हैं तो यह आपके लिए एक मूलांक का अनुमान लगाने की कोशिश करता है। तो, उदाहरण के लिए: parseInt ("17") का परिणाम 17 (दशमलव, 10) में होता है, लेकिन parseInt ("08") का परिणाम 0 (अष्टक, 8) में होता है। इसलिए, जब तक आप अन्यथा इरादा नहीं करते हैं, यह parseInt (संख्या, 10) का उपयोग करने के लिए सबसे सुरक्षित है, 10 को मूल रूप से स्पष्ट रूप से निर्दिष्ट करता है।

— एडम रनी

ध्यान दें कि! IsNaN (अपरिभाषित) गलत है।

— डेविड नरकंकाल

यह सिर्फ सादा गलत है - यह इतने सारे उत्थान कैसे हुए? आप isNaN"यह देखने के लिए जाँच नहीं कर सकते कि एक चर एक संख्या नहीं है"। "एक संख्या नहीं" "IEEE-794 NaN" के समान नहीं है, जो कि isNaNपरीक्षण है। विशेष रूप से, यह उपयोग विफल हो जाता है जब बूलियन और खाली तारों का परीक्षण किया जाता है, तो कम से कम। Developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… देखें ।

— EML

सबसे तेज़ संभव तरीका यह जांचने के लिए कि क्या कोई संख्या "स्व के बराबर" चेक है: var n = 'a'; if (+n === +n) { // is number }यह क्रोम के नवीनतम संस्करण में आईएनएएन की तुलना में ~ 3994% तेज है। प्रदर्शन परीक्षण यहाँ देखें: jsperf.com/isnan-vs-typeof/5

— केविन

** चेतावनी ** यह उत्तर गलत है। अपने जोखिम पार इस्तेमाल करें। उदाहरण:isNaN(1 + false + parseInt("1.do you trust your users?"))

— कीथजॉली

Answer 2

और आप RegExp-way जा सकते हैं:

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
}

Comments

इस मामले में, RegExp == बुरा

— जोएल कोएहॉर्न

यह हेक्साडेसिमल नंबरों (0x12, उदाहरण के लिए) पर विफल रहता है, एक अग्रणी शून्य (.42, उदाहरण के लिए) और नकारात्मक संख्या के बिना तैरता है।

— ओरियल

@JoelCoehoorn देखभाल के बारे में विस्तृत करने के लिए क्यों RegExp == यहाँ बुरा है? मुझे एक वैध उपयोग मामला लगता है।

— कॉम्प्यूट्रियस

संख्या बनाने के लिए और अधिक तरीके हैं (एक टिप्पणी में हेक्स संख्या केवल एक उदाहरण है), और कई संख्याएं हैं जिन्हें वैध नहीं माना जा सकता (अतिप्रवाह प्रकार, बहुत सटीक, आदि)। इसके अलावा, रेगेक्स दोनों बिल्ट-इन मेकेनिज्म का उपयोग करने की तुलना में धीमा और अधिक जटिल है

— जोएल कोएहॉर्न

वैज्ञानिक संकेतन से भी मेल खाना चाहिए ... 1e10 आदि

— जोसेफ

Answer 3

यदि आप केवल यह जांचने की कोशिश कर रहे हैं कि क्या एक स्ट्रिंग एक पूर्ण संख्या (कोई दशमलव स्थान) नहीं है, तो regex जाने का एक अच्छा तरीका है। अन्य विधियाँ जैसे कि 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

Comments

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

— योंगनान

console.log (isNumeric ( '2E2'));

— गाल बारबिन

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

— gus3001

यह मैं देख रहा था, php

— ctype_digit

/^-?\d+$/सही?

— सुकिमा

Answer 4

क्या तुम सच में लगता है कि एक स्ट्रिंग केवल एक नंबर, किसी भी संख्या (पूर्णांक या चल बिन्दु), और वास्तव में एक संख्या में शामिल हैं सुनिश्चित करना चाहते हैं, तो आप नहीं कर सकते हैं का उपयोग करें 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

अपने स्वयं के रेगेक्स को रोल करने में समस्या यह है कि जब तक आप फ्लोटिंग पॉइंट नंबर के मिलान के लिए सटीक रेगेक्स नहीं बनाते हैं क्योंकि जावास्क्रिप्ट यह पहचानता है कि आप मामलों को मिस करने जा रहे हैं या उन मामलों को पहचानते हैं जहां आपको नहीं करना चाहिए। और यहां तक ​​कि अगर आप अपने स्वयं के रेगेक्स को रोल कर सकते हैं, तो क्यों? इसे करने के सरल तरीके हैं।

हालांकि, यह पता चलता है कि 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))
}

Comments

यह तब सही होता है जब स्ट्रिंग में अग्रणी या अनुगामी स्थान होते हैं। ' 1', '2 'और ' 3 'सब सच लौटा।

— 20

रिटर्न-स्टेटमेंट में इस तरह से कुछ जोड़ने से वह हल हो जाएगा: &&! / ^ \ S + | \ s + $ / g.test (str)

— अल्ट्रोमन द टैकोमैन

@RuudLenders - ज्यादातर लोग परवाह नहीं करेंगे अगर वहाँ अनुगामी रिक्त स्थान हैं जो स्ट्रिंग को एक वैध संख्या बनाने के लिए बंद हो जाते हैं, क्योंकि इसकी आसानी से गलती से अतिरिक्त इंटरफेस में बहुत सारे इंटरफेस डाल दिए जाते हैं।

— इयान

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

— रुडी

Answer 5

इस प्रश्न के लिए स्वीकृत उत्तर में कुछ खामियां हैं (जैसा कि अन्य उपयोगकर्ताओं के युगल द्वारा हाइलाइट किया गया है)। यह जावास्क्रिप्ट में इसे प्राप्त करने का सबसे आसान और सिद्ध तरीका है:

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

Answer 6

प्रयास करें isNan समारोह :

IsNaN () फ़ंक्शन निर्धारित करता है कि क्या मान एक अवैध संख्या है (नॉट-ए-नंबर)।

यदि मान NaN के बराबर है, तो यह फ़ंक्शन सही है। अन्यथा यह झूठे लौटता है।

यह फ़ंक्शन संख्या विशिष्ट Number.isNaN () विधि से अलग है ।

  वैश्विक एनएनएएन () फ़ंक्शन, परीक्षण किए गए मान को एक संख्या में परिवर्तित करता है, फिर उसका परीक्षण करता है।

Number.isNan () मानों को संख्या में परिवर्तित नहीं करता है, और किसी भी मान के लिए सही नहीं लौटेगा जो कि प्रकार का नहीं है ...

Comments

सुनिश्चित करें कि आप खाली स्ट्रिंग के लिए एक चेक जोड़ें। isNaN ('') गलत है, लेकिन आप शायद इस मामले में सही लौटना चाहते हैं।

— माइकल हरेन

IsFinite एक बेहतर जाँच है - यह इन्फिनिटी के अजीब कोने के मामले से संबंधित है

— जॉनी राया

@MichaelHaren पर्याप्त नहीं है! किसी भी स्ट्रिंग के लिए isNaN()रिटर्न जिसमें केवल व्हाट्सएप वर्ण हैं, जिसमें '\ u00A0' जैसी चीजें शामिल हैं। false

— माइकल

चेतावनी: मानों के लिए काम नहीं करता है: अशक्त, "" (खाली स्ट्रिंग) और गलत।

— जेनी ओ'रिली ने

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

— Dan Dascalescu

Answer 7

पुराना सवाल है, लेकिन दिए गए उत्तरों में कई बिंदु गायब हैं।

वैज्ञानिक संकेत।

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

हालांकि, यहां तक ​​कि यह पूरी तरह से दूर है। अग्रणी शून्य को यहां संभाला नहीं जाता है, लेकिन वे लंबाई परीक्षण को पेंच करते हैं।

Comments

"हालांकि अधिकांश मामलों में जब लोग संख्या पूछते हैं, तो वे 1e + 30 जैसी चीजों का मिलान नहीं करना चाहते हैं" आप यह क्यों कहेंगे? यदि कोई जानना चाहता है कि क्या एक स्ट्रिंग में एक संख्या है, तो मुझे लगता है कि वे जानना चाहते हैं कि क्या इसमें कोई संख्या है, और 1e + 30 एक संख्या है। निश्चित रूप से अगर मैं जावास्क्रिप्ट में एक संख्यात्मक मान के लिए एक स्ट्रिंग का परीक्षण कर रहा था, तो मैं चाहता हूं कि वह मेल खाए।

— डैन जोन्स

Answer 8

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

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

यह प्रत्येक परीक्षण मामले के लिए काम करता है, जिसे मैंने यहां दस्तावेज दिया था: https://jsfiddle.net/wggehvp9/5/

अन्य कई समाधान इन धार मामलों के लिए विफल होते हैं: '', अशक्त, "", सत्य और []। सिद्धांत रूप में, आप उनका उपयोग कर सकते हैं, उदाहरण के लिए उचित त्रुटि से निपटने के साथ:

return !isNaN(num);

या

return (+num === +num);

/ \ / s, null, "", true, false, [] (और अन्य?) के लिए विशेष हैंडलिंग के साथ?

Comments

यह अभी भी अनुगामी / अग्रणी स्थानों के साथ सही है। रिटर्न-स्टेटमेंट में इस तरह से कुछ जोड़ने से वह हल हो जाएगा: &&! / ^ \ S + | \ s + $ / g.test (str)

— अल्ट्रोमन द टैकोमॉन

तो 123 ’गलत होना चाहिए, नंबर नहीं, जबकि '1234’ नंबर होना चाहिए? मुझे यह पसंद है कि यह कैसा है, ताकि "123" एक संख्या है, लेकिन यह डेवलपर के विवेक पर निर्भर हो सकता है यदि प्रमुख या अनुगामी रिक्त स्थान मान को बदलना चाहिए।

— JohnP2

Answer 9

आप संख्या के परिणाम का उपयोग कर सकते हैं इसके कंस्ट्रक्टर को एक तर्क देते समय ।

यदि तर्क (एक स्ट्रिंग) को एक संख्या में परिवर्तित नहीं किया जा सकता है, तो यह 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

Comments

Numberनिर्माता बिल्कुल के रूप में एक ही है +x।

— ग्रेग्रास

एक साइड नोट के रूप में, ध्यान रखें कि ES6 Number()फ्लोट नंबरों को भी संभालता है, जैसे Number.parseFloat()नहींNumber.parseInt()

— zurfyx

Answer 10

हो सकता है कि इस सवाल पर एक या दो लोग आ रहे हों, जिन्हें सामान्य से अधिक सख्त जांच की जरूरत होती है (जैसे मैंने किया)। उस स्थिति में, यह उपयोगी हो सकता है:

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

सावधान रहें! इस तरह तार को अस्वीकार कर देंगे .1, 40.000, 080, 00.1। यह बहुत picky है - स्ट्रिंग को " सबसे न्यूनतम परिपूर्ण रूप से मेल खाना चाहिए इस परीक्षण को पास करने के " से ।

यह स्ट्रिंग को एक नंबर पर वापस भेजने के लिए Stringऔर Numberकंस्ट्रक्टर का उपयोग करता है और इस प्रकार जांचता है कि क्या जावास्क्रिप्ट इंजन का "सही न्यूनतम रूप" (आरंभिक Numberकंस्ट्रक्टर के साथ परिवर्तित हो गया ) मूल स्ट्रिंग से मेल खाता है।

Comments

धन्यवाद @JoeRocc। मुझे भी इसकी आवश्यकता थी, लेकिन सिर्फ पूर्णांकों के लिए, इसलिए मैंने जोड़ा (str === String(Math.round(Number(str)))):।

— कीथ्पजोलले

ध्यान रखें कि "Infinity", "-Infinity"है, और "NaN"इस परीक्षा उत्तीर्ण। हालांकि, यह एक अतिरिक्त Number.isFiniteपरीक्षण का उपयोग करके तय किया जा सकता है ।

— ग्रेगरोस

यह बिल्कुल वैसा ही है str === ("" + +str)। यह मूल रूप से जांचता है कि क्या स्ट्रिंग एक जेएस संख्या को संशोधित करने का परिणाम है। यह जानने के बाद, हम एक समस्या भी देख सकते हैं: परीक्षा उत्तीर्ण होती है, 0.000001लेकिन इसके लिए असफल हो जाता है 0.0000001, जो कि 1e-7इसके बजाय पास हो जाता है। बहुत बड़ी संख्या के लिए समान।

— ग्रेगोस

Answer 11

parseInt (), लेकिन ध्यान रखें कि यह फ़ंक्शन इस अर्थ में थोड़ा अलग है कि यह उदाहरण के लिए parseInt ("100px") के लिए 100 रिटर्न देता है।

Comments

और 11 के लिए parseInt(09)।

— djechlin

क्योंकि आपको उपयोग करने की आवश्यकता हैparaseInt(09, 10)

— गेविन

ECMAScript 5 के रूप में , जिसमें विस्तृत ब्राउज़र समर्थन (IE )9) है, आपको , 10किसी भी तर्क की आवश्यकता नहीं है । parseInt('09')अब बराबर 9.

— रोरी ओ'केन

Answer 12

उद्धरण:

यदि कोई वैरिएबल नंबर नहीं है तो isNaN (संख्या) // रिटर्न सही है

यदि आप अग्रणी / अनुगामी स्थानों के लिए जाँच करने की आवश्यकता पूरी तरह से सच नहीं है - उदाहरण के लिए जब अंकों की एक निश्चित मात्रा की आवश्यकता होती है, और आपको संभवतः 11 पिन के लिए '1111' और '111' या '111' प्राप्त करने की आवश्यकता होती है। इनपुट।

उपयोग करने के लिए बेहतर:

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

Comments

मूल्य '-1', '0.1'और '1e10'सभी झूठे लौटते हैं। इसके अलावा, सकारात्मक अनन्तता से बड़ा मान या ऋणात्मक अनन्तता की तुलना में छोटा होना सही है, जबकि उन्हें संभवतः गलत लौटना चाहिए।

— रुडी

Answer 13

JQuery का कार्यान्वयन पर्याप्त रूप से अच्छा क्यों नहीं है?

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

माइकल ने कुछ इस तरह का सुझाव दिया (हालाँकि मैंने "user1691651 चुराया है - जॉन का यहाँ बदला हुआ संस्करण):"

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

मैंने इनमें से किसी का भी बहुत परीक्षण नहीं किया है, अन्य उपयोगों की तुलना में मैन्युअल रूप से कुछ उपयोग-मामलों का परीक्षण कर रहा हूं, जो मैं अपने वर्तमान विधेय के साथ मार रहा हूं, जो सभी बहुत मानक सामान हैं। यह एक "स्टैंडिंग-ऑन-द-कंधों-ऑफ-दिग्गज" स्थिति है।

Answer 14

यह टाइपस्क्रिप्ट के लिए मान्य नहीं है:

declare function isNaN(number: number): boolean;

टाइपस्क्रिप्ट के लिए आप उपयोग कर सकते हैं:

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

Answer 15

खैर, मैं इस एक का उपयोग कर रहा हूँ ...

यह अब तक काम कर रहा है:

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

यदि आप इसके साथ कोई समस्या रखते हैं, तो कृपया मुझे बताएं।

Comments

यह खाली स्ट्रिंग, खाली सरणी, गलत और अशक्त के लिए गलत परिणाम देता है।

— ओरिएंट

यह एक बराबर नहीं होना चाहिए?

— 9:13

मेरे आवेदन में हम केवल az AZ और 0-9 वर्णों की अनुमति दे रहे हैं। मैंने ऊपर काम किया जब तक कि स्ट्रिंग 0xnn के साथ शुरू नहीं हुई और तब यह इसे संख्यात्मक के रूप में लौटा देगा जब यह नहीं होना चाहिए। मैंने नीचे टिप्पणी में पोस्ट किया है ताकि स्वरूपण बरकरार रहे।

— rwheadon

आप बस 'रिटर्न वैल्यू% 1 === 0' कर सकते हैं

— ब्रायन श्मेरहॉर्न

बस करोreturn !isNaN(parseInt(value, 10));

— DarkNeuron

Answer 16

अगर किसी को कभी भी यह दूर हो जाता है, तो मैंने कुछ समय हैक करने में बिताया। इस पल को पैच करने की कोशिश कर रहा था । ( 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

किसी भी सुझाव का स्वागत करते हैं। :]

Comments

के बारे में isNumeric(' ')और क्या isNumeric('')?

— एलेक्स कोरी

मैं && (val.replace(/\s/g,'') !== '') //Empty && (val.slice(-1) !== '.') //Decimal without Numberउपर्युक्त मुद्दे को स्वीकार करने के लिए जोड़ूंगा और एक मैं खुद था।

— फ्रैंकनैप्स

Answer 17

सादे जावास्क्रिप्ट का उपयोग करना:

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

लोडश का उपयोग करना:

_.isNaN(_.toNumber('1')); // false
_.isNaN(_.toNumber('asdf')); // true

Comments

Stackoverflow.com/questions/46677774/…

— फिलिप

Answer 18

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

Comments

धन्यवाद, महान जवाब!

— M.Abulsoud

Answer 19

2019: ES3, ES6 और टाइपस्क्रिप्ट उदाहरण सहित

हो सकता है कि यह कई बार फिर से शुरू किया गया हो, लेकिन मैं आज भी इससे लड़ता हूं और अपना जवाब पोस्ट करना चाहता हूं, क्योंकि मुझे ऐसा कोई अन्य जवाब नहीं मिला जो इसे बस या अच्छी तरह से करता हो:

ES3

var isNumeric = function(num){
    return (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num);  
}

ES6

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

टाइपप्रति

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

यह काफी सरल लगता है और मैंने कई अन्य पदों पर देखे गए सभी ठिकानों को कवर किया है और खुद को समझा है:

// Positive Cases
console.log(0, isNumeric(0) === true);
console.log(1, isNumeric(1) === true);
console.log(1234567890, isNumeric(1234567890) === true);
console.log('1234567890', isNumeric('1234567890') === true);
console.log('0', isNumeric('0') === true);
console.log('1', isNumeric('1') === true);
console.log('1.1', isNumeric('1.1') === true);
console.log('-1', isNumeric('-1') === true);
console.log('-1.2354', isNumeric('-1.2354') === true);
console.log('-1234567890', isNumeric('-1234567890') === true);
console.log(-1, isNumeric(-1) === true);
console.log(-32.1, isNumeric(-32.1) === true);
console.log('0x1', isNumeric('0x1') === true);  // Valid number in hex
// Negative Cases
console.log(true, isNumeric(true) === false);
console.log(false, isNumeric(false) === false);
console.log('1..1', isNumeric('1..1') === false);
console.log('1,1', isNumeric('1,1') === false);
console.log('-32.1.12', isNumeric('-32.1.12') === false);
console.log('[blank]', isNumeric('') === false);
console.log('[spaces]', isNumeric('   ') === false);
console.log('null', isNumeric(null) === false);
console.log('undefined', isNumeric(undefined) === false);
console.log([], isNumeric([]) === false);
console.log('NaN', isNumeric(NaN) === false);

आप भी अपनी कोशिश कर सकते हैं isNumeric फ़ंक्शन और इन उपयोग के मामलों में बस अतीत और उन सभी के लिए "सही" के लिए स्कैन कर सकते हैं।

या, उन मूल्यों को देखने के लिए जिन्हें प्रत्येक वापस लौटाता है:

Answer 20

2019: प्रैक्टिकल और टाइट न्यूमेरिकल वैलिडिटी चेक

अक्सर, 'वैध संख्या' का मतलब NaN और Infinity को छोड़कर एक जावास्क्रिप्ट संख्या है, जिसका अर्थ है 'परिमित संख्या'।

किसी मान की संख्यात्मक वैधता की जाँच करने के लिए (उदाहरण के लिए किसी बाहरी स्रोत से), आप 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');
}

Answer 21

PFB काम कर समाधान:

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

Answer 22

एक "अंतर्निहित" समाधान खोजने की कोशिश करने के लिए अपने आप को बचाएं।

वहाँ एक अच्छा जवाब नहीं है, और इस धागे में बेहद उत्कट उत्तर गलत है।

npm install is-number

जावास्क्रिप्ट में, यह हमेशा उतना सीधा नहीं होता है जितना कि एक संख्या होने पर मज़बूती से जांचना चाहिए। देवियों के लिए +, -, या नंबर () का उपयोग करके एक स्ट्रिंग मान को एक संख्या में डालना है (उदाहरण के लिए, जब मान उपयोगकर्ता इनपुट, रेगेक्स मैचों, पार्सर्स, आदि से लौटाए जाते हैं)। लेकिन कई गैर-सहज ज्ञान युक्त किनारे मामले हैं जो अप्रत्याशित परिणाम देते हैं:

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

Answer 23

मैंने हाल ही में एक वेरिएबल को सुनिश्चित करने के तरीकों के बारे में एक लेख लिखा है जो एक वैध संख्या है: https://github.com/jehugaleahsa/artifacts/blob/master/2018/typescript_num_hack.md लेख बताता है कि फ़्लोटिंग पॉइंट या पूर्णांक कैसे सुनिश्चित किया जाए, यदि महत्वपूर्ण ( +xबनाम~~x )।

लेख मानता है कि चर एक stringया 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
}

Answer 24

थोड़ा भ्रमित करने का मेरा प्रयास, फेरप्स सबसे अच्छा समाधान नहीं है

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

Comments

यह बहुत बुरा नहीं है, दो खराब यह किसी भी गैर-दशमलव अंकन के लिए काम नहीं करता है, जैसे (1) वैज्ञानिक संकेतन और (2) आधार -10 संकेतन, जैसे कि अष्टक ( 042) और हेक्साडेसिमल ( 0x45f)

— डॉमी

यह संख्यात्मक मान की तलाश के सवाल का जवाब नहीं देता है, यह केवल एक इंट की तलाश में है।

— जेरेमी

Answer 25

मेरे आवेदन में हम केवल az AZ और 0-9 वर्णों की अनुमति दे रहे हैं। मैं का उपयोग कर "ऊपर जवाब मिला स्ट्रिंग % 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;}

चेतावनी : यह जावास्क्रिप्ट और एक्टेशनस्क्रिप्ट [संख्या ("1" + the_string)% 1 === 0) में एक लंबे समय तक चलने वाले बग का दोहन हो सकता है], मैं उसके लिए नहीं बोल सकता, लेकिन यह ठीक उसी तरह है जो हमें चाहिए था।

Comments

जावास्क्रिप्ट में एक बग क्यों होगा?

— बर्गी जूल

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

— रवहिऑन

वैसे, जावास्क्रिप्ट टाइप इम्प्लांट टाइप कास्टिंग के बारे में थोड़ा टेढ़ा है, लेकिन एक बार जब आप जानते हैं कि आप आसानी से समझ सकते हैं कि यह कैसे काम करता है। आप संख्याओं को स्ट्रिंग कर रहे हैं ( % 1उन पर संख्यात्मक ऑपरेशन को लागू करके), और यह स्ट्रिंग को हेक्स या फ्लोट शाब्दिक के रूप में व्याख्या करेगा।

— बेर्गी

Answer 26

मेरा समाधान:

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

आप विशेष आवश्यकताओं को पूरा करने के लिए, लूप के अंदर अतिरिक्त शर्तें जोड़ सकते हैं।

Answer 27

आप स्थिर, संकलन समय की जाँच करने के लिए, प्रवाह लाइब्रेर वाई के साथ प्रकारों का उपयोग कर सकते हैं । बेशक उपयोगकर्ता इनपुट के लिए बहुत उपयोगी नहीं है।

// @flow

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

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

Answer 28

यदि sNumएक वैध संख्यात्मक मान है, तो यह जांचने के लिए यहां एक-लाइनर है ; विभिन्न प्रकार के इनपुट के लिए इसका परीक्षण किया गया है:

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

Answer 29

बस उपयोग करें isNaN(), यह स्ट्रिंग को एक संख्या में बदल देगा और यदि एक वैध संख्या मिलती है , तो वापस आ जाएगी false...

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

Answer 30

मैं निम्नलिखित का उपयोग कर रहा हूं:

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

Comments

अपेक्षाकृत अच्छी तरह से काम करता है कई मामलों है, लेकिन तरह के मामलों में विफल रहता है 1..1, 1,1, -32.1.12, और अधिक महत्वपूर्ण विफल रहता है undefinedऔर NaN। यदि आप उत्तीर्ण हुए हैं undefinedया NaNयह कि यह एक संख्या है, तो यह कहकर आपको एक झूठी सकारात्मक लौटा देगा।

— जेरेमी