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




validation numbers (20)

@ सीएमएस के 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 करीब है, लेकिन संख्याओं के हेक्स और अन्य स्ट्रिंग प्रस्तुतियों को संभालता है।

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

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

  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

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

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

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


अगर मुझे गलत नहीं लगता है, तो यह किसी भी वैध जावास्क्रिप्ट नंबर मान से मेल खाता है, जिसमें स्थिरांक ( 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

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

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

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

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

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

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

समाधान कवर:

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

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


मेरा समाधान,

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

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


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

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

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

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

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


स्वीकृत उत्तर आपके परीक्षण # 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);
}

बेशक, आप Object.prototype.toString.call(n) !== '[object Array]' बजाय Array.isArray , jquery $.isArray या prototype 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 परीक्षण के मामलों को लिया और जेएसफिड पर परीक्षण को क्लोन किया, मेरे अतिरिक्त परीक्षण मामलों और मेरे उपरोक्त वर्णित समाधान को जोड़ा।

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

संपादित करें: Bergi द्वारा 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>


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

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


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

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

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

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

$('.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)
});

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

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

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

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

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

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

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

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

व्याख्या की:

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

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

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


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

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


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

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






numbers