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




validation numbers (24)

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

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

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

  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

मेरे लिए, यह सबसे अच्छा तरीका है:

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

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

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

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

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

/^(?:(?:(?:[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

knockoutJs इनबिल्ड पुस्तकालय सत्यापन समारोह

इसे विस्तारित करके फ़ील्ड मान्य हो जाती है

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 ({digit: true}) ;

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

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 ({min: 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

JQuery 1.7 के बाद से, आप api.jquery.com/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 एक मान्य संख्या है (हेक्सा)


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

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

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

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


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

यह ध्यान दिया जाना चाहिए कि यह मानता है कि '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.

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

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

मेरा समाधान,

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

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



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

यह ES2015 बाद से भाषा का हिस्सा है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

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

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

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

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

समाधान कवर:

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

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

// 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 के लिए मजबूर रूपांतरण के कारण एक भ्रमित व्यवहार है। 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));
}

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

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

व्याख्या की:

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

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

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


@ सीएमएस के answer साथ मेरी समस्या केवल 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

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


आप इस फ़ंक्शन को बहुत से कम से कम कर सकते हैं, और आप इसे नकारात्मक मानों या कस्टम चार्ट के लिए कस्टम रेगेक्स के साथ भी कार्यान्वित कर सकते हैं:

$('.number').on('input',function(){
    var n=$(this).val().replace(/ /g,'').replace(/\D/g,'');
    if (!$.isNumeric(n))
        $(this).val(n.slice(0, -1))
    else
        $(this).val(n)
});

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

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

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

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


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

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

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

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

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

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

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

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

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

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

संक्षेप में, यदि आप जानना चाहते हैं कि कोई मान किसी संख्या में परिवर्तित किया जा सकता है, तो वास्तव में इसे किसी संख्या में परिवर्तित करने का प्रयास करें।

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

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

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


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

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

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


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

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

@ सीएमएस 'उत्तर : आपकी स्निपेट नोडजेज़ का उपयोग करके मेरी मशीन पर व्हाइटस्पेस मामलों पर विफल रही। तो मैंने इसे निम्नलिखित के लिए @ जोएल के जवाब के साथ जोड़ा :

is_float = function(v) {
    return !isNaN(v) && isFinite(v) &&
        (typeof(v) == 'number' || v.replace(/^\s+|\s+$/g, '').length > 0);
}

मैंने उन मामलों के साथ इसे बेकार कर दिया जो फ्लोट हैं:

var t = [
        0,
        1.2123,
        '0',
        '2123.4',
        -1,
        '-1',
        -123.423,
        '-123.432',
        07,
        0xad,
        '07',
        '0xad'
    ];

और उन मामलों में कोई फ्लोट नहीं है (खाली सफेद जगहों और वस्तुओं / सरणी सहित):

    var t = [
        'hallo',
        [],
        {},
        'jklsd0',
        '',
        "\t",
        "\n",
        ' '
    ];

सबकुछ यहां अपेक्षित काम करता है। शायद यह मदद करता है।

इसके लिए पूर्ण स्रोत कोड here पाया जा सकता here





numbers