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

আমার iscomparableNumber অন্য মার্জিত 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() কাছাকাছি আপনার নিজস্ব ফাংশন মোড়ানো করুন যা অতিরিক্ত চেক করতে পারে।

সংক্ষিপ্তভাবে, যদি আপনি একটি মান একটি সংখ্যা রূপান্তর করা যেতে পারে কিনা জানতে চান, আসলে এটি একটি সংখ্যা রূপান্তর করার চেষ্টা করুন।

আমি ফিরে গিয়েছিলাম এবং কেন একটি হোয়াইটস্পেস স্ট্রিংয়ের প্রত্যাশিত আউটপুট ছিল না তা নিয়ে কিছু গবেষণা করেছি, এবং আমার মনে হয় আমি এখন এটি পেয়েছি: একটি খালি স্ট্রিং NaN পরিবর্তে 0 NaN । দৈর্ঘ্য চেক আগে স্ট্রিং trimming এই ক্ষেত্রে হ্যান্ডেল হবে।

নতুন কোডের বিরুদ্ধে ইউনিট পরীক্ষাগুলি চালানো এবং এটি কেবল অসীম এবং বুলিয়ান লিটারালগুলিতে ব্যর্থ হয় এবং আপনি যদি কোডটি তৈরি করেন তবে শুধুমাত্র সময়টিই সমস্যা হতে পারে (প্রকৃতপক্ষে, কোন অক্ষরে টাইপ করবে এবং এটি সংখ্যাসূচক কিনা তা পরীক্ষা করে দেখুন? আপনি জানতে হবে ), এবং যে উৎপন্ন কিছু অদ্ভুত কোড হতে হবে।

কিন্তু, আবার, এটি ব্যবহার করার একমাত্র কারণ হল যদি কোন কারণে আপনাকে isNaN () এড়িয়ে চলতে হয়।


আমার কাছে, এটি সর্বোত্তম উপায়।

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

আমার সমাধান,

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

এটা প্রতিটি পরিস্থিতিতে কাজ বলে মনে হচ্ছে, কিন্তু আমি ভুল হতে পারে।


এই ভাবে ভাল কাজ বলে মনে হচ্ছে:

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 থেকে যে রেজেক্ট ধার করেছি। ব্যাখ্যা:

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

একটি পূর্ণসংখ্যা মান দ্বারা যাচাই করা যেতে পারে:

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

এই ভাবে সহজ এবং দ্রুত! সব পরীক্ষা চেক করা হয়!


এটা RegExp ছাড়া সম্পন্ন করা যেতে পারে

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

গ্রহনযোগ্য উত্তর আপনার পরীক্ষা # 7 ব্যর্থ হয়েছে এবং আমি মনে করি কারণ আপনি আপনার মন পরিবর্তন করেছেন। তাই এটি গৃহীত উত্তরটির প্রতিক্রিয়া, যার সাথে আমার সমস্যা ছিল।

কিছু প্রজেক্টের সময় আমাকে কিছু তথ্য যাচাই করতে হবে এবং যতটা সম্ভব নিশ্চিত হওয়া দরকার যে এটি জাভাস্ক্রিপ্ট সংখ্যাসূচক মান যা গণিত ক্রিয়াকলাপগুলিতে ব্যবহার করা যেতে পারে।

jQuery, এবং কিছু অন্যান্য জাভাস্ক্রিপ্ট লাইব্রেরি ইতিমধ্যে এই ধরনের একটি ফাংশন অন্তর্ভুক্ত, সাধারণত isNumeric বলা 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 বা prototype Object.isArray পরিবর্তে Object.prototype.toString.call(n) !== '[object Array]' 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, ''));
  };
}());

আমি তখন CMSs +30 পরীক্ষার ক্ষেত্রে গ্রহণ করেছি এবং জেএসফিল্ডের পরীক্ষায় ক্লোন করেছি আমার অতিরিক্ত পরীক্ষার ক্ষেত্রে এবং আমার উপরে বর্ণিত সমাধান যোগ করে।

এটি ব্যাপকভাবে গৃহীত / ব্যবহৃত উত্তরটিকে প্রতিস্থাপন করতে পারে না তবে আপনার সংখ্যাসূচক ফাংশন থেকে ফলাফল হিসাবে আপনি যা আশা করছেন তার চেয়ে বেশি হলে আশা করা যায় এটি কিছু সাহায্যের জন্য হবে।

সম্পাদন করুন: 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>


যদি আমি ভুল না করি তবে এটি কোনও বৈধ জাভাস্ক্রিপ্ট নম্বরের মান, স্ট্রাকচার ( Infinity , NaN ) এবং সাইন অপারেটরগুলিকে বাদ দিয়ে + / - (কারণ সেগুলি আসলেই যতটা আমি উদ্বিগ্ন থাকুক না কেন, তারা আলাদা অপারেটর ):

আমি একটি টোকেনাইজারের জন্য এটি প্রয়োজন ছিল, যেখানে মূল্যায়নের জন্য জাভাস্ক্রিপ্টে সংখ্যা প্রেরণ করা একটি বিকল্প ছিল না ... এটি অবশ্যই সর্বনিম্ন সম্ভব নিয়মিত অভিব্যক্তি নয়, তবে আমি বিশ্বাস করি এটি জাভাস্ক্রিপ্টের সংখ্যাত সংখ্যার সব সূক্ষ্ম সংকেতগুলিকে ধরবে।

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

বৈধ সংখ্যা অন্তর্ভুক্ত করা হবে:

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

অবৈধ সংখ্যা হবে

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

যোগ করার জন্য কয়েকটি পরীক্ষা:

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

আমি এই সঙ্গে এসেছিলেন:

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

সমাধান কভার:

  • শুরুতে একটি ঐচ্ছিক নেতিবাচক সাইন
  • একটি শূন্য শূন্য, বা এক বা একাধিক সংখ্যা 0 দিয়ে শুরু হয় না, অথবা একটি নির্দিষ্ট সময়কালের মতো এত দীর্ঘ নয়
  • একটি সময় যা 1 বা তার বেশি সংখ্যা দ্বারা অনুসরণ করা হয়

@ সিএমএস এর উত্তর : আপনার স্ন্যিপেট নোডজে ব্যবহার করে আমার মেশিনে হোয়াইটস্পেস ক্ষেত্রে ব্যর্থ হয়েছে। তাই আমি @ জোয়েলের এই প্রশ্নের উত্তর দিয়ে এটি সংযোজন করেছি :

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

আমি floats যে ক্ষেত্রে সঙ্গে unittested:

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

এবং যে ক্ষেত্রে কোন floats (খালি হোয়াইটস্পেস এবং বস্তু / অ্যারে সহ):

    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 Inbuild লাইব্রেরি বৈধতা ফাংশন

এটা প্রসারিত করে ক্ষেত্র যাচাই করা হয়

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})। প্রসারিত করুন ({max: 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)
});

আমি নিম্নলিখিত যোগ করতে চাই:

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

ইতিবাচক হেক্স সংখ্যা দিয়ে শুরু করুন 0xএবং নেতিবাচক হেক্স সংখ্যা দিয়ে শুরু করুন -0x। ইতিবাচক oct সংখ্যা দিয়ে শুরু করুন 0এবং নেতিবাচক oct সংখ্যা দিয়ে শুরু করুন -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 isNumber(num) {
    return parseFloat(num).toString() == num
}

উত্তরগুলির কোনও 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;
}

যদি n সংখ্যাসূচক Number(n)সংখ্যাসূচক মান প্রদান করে এবং toString()এটি একটি স্ট্রিং এ ফিরিয়ে দেবে। কিন্তু যদি এন সাংখ্যিক নয় Number(n)ফিরে আসবে NaNতাই এটি আসল মিল করা হবে নাn






numbers