JavaScript හි දශම සංඛ්‍යා වලංගු කරන්න - IsNumeric ()

ජාවාස්ක්‍රිප්ට් හි දශම සංඛ්‍යා වලංගු කිරීමට වඩාත්ම පිරිසිදු හා effective ලදායී ක්‍රමය කුමක්ද?

සඳහා ප්‍රසාද ලකුණු:

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

@ ජොයෙල්ගේ පිළිතුර ඉතා ආසන්න නමුත් එය පහත දැක්වෙන අවස්ථා වලදී අසාර්ථක වනු ඇත:

// 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 එය සංඛ්‍යාත්මක අගයක් අඩංගු විය හැකිය (මට on ාතීය අංකනය ද සලකා බැලිය යුතුව තිබුණි), Numberවස්තුවක්, කවර හෝ දෙයක් කටයුතු කිරීමට සමත් විය යුතු, මම ඕනෑම වර්ගයක් කම්මැලියි නොහැකි, වර්ගය බලහත්කාරය යොදා රැකබලා ගැනීම (උදා. +true == 1;නමුත් trueලෙස සැලකිය යුතු නැත "numeric").

බොහෝ ක්‍රියාකාරී ක්‍රියාවට නැංවීම සඳහා කරන ලද මෙම +30 ඒකක පරීක්ෂණ කට්ටලය බෙදා ගැනීම වටී යැයි මම සිතමි , තවද මගේ සියලු පරීක්ෂණ සමත් වූ ඒවා බෙදා ගන්න:

function isNumeric(n) {
    return !isNaN(parseFloat(n)) && isFinite(n);
}

බලහත්කාරයෙන් අංකයට පරිවර්තනය වීම නිසා PS 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));
}

ආහ්! සාමාන්‍ය ප්‍රකාශන පිළිතුරු වලට ඇහුම්කන් නොදෙන්න. RegEx මේ සඳහා සුදුසු නැත, මම කතා කරන්නේ කාර්ය සාධනය ගැන පමණක් නොවේ. සියුම් ප්‍රකාශනය සමඟ වැරදි හඳුනා ගැනීමට නොහැකි, සියුම් කිරීම පහසුය.

ඔබට භාවිතා කළ නොහැකි නම් isNaN(), මෙය වඩා හොඳින් ක්‍රියා කළ යුතුය:

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

එය ක්‍රියාත්මක වන ආකාරය මෙන්න:

මෙම (input - 0)ප්රකාශනය හමුදා JavaScript ඔබගේ ආදාන වටිනාකම මත වර්ගය බලහත්කාරය යොදා කරන්න; එය මුලින් අඩු කිරීමේ මෙහෙයුම සඳහා අංකයක් ලෙස අර්ථ දැක්විය යුතුය. අංකයක් බවට පරිවර්තනය කිරීම අසමත් වුවහොත්, ප්‍රකාශනය ප්‍රති in ලය වනු ඇත NaN. මෙම සංඛ්‍යාත්මක ප්‍රති result ලය ඔබ සම්මත කළ මුල් අගය සමඟ සැසඳේ. වම් අත දැන් සංඛ්‍යාත්මක බැවින්, බලහත්කාරය නැවත භාවිතා කරයි. දැන් දෙපැත්තෙන්ම ආදානය එකම මුල් අගයෙන් එකම වර්ගයට බල කෙරී ඇති බැවින්, ඔබ සිතන්නේ ඒවා සැමවිටම එක හා සමාන විය යුතු බවයි (සැමවිටම සත්‍ය). කෙසේ වෙතත්, NaNකිසි විටෙකත් සමාන නොවන බව පවසන විශේෂ රීතියක් ඇත NaN, එබැවින් අංකයකට පරිවර්තනය කළ නොහැකි අගයක් (සහ සංඛ්‍යා බවට පරිවර්තනය කළ නොහැකි අගයන් පමණක්) අසත්‍යයට හේතු වේ.

දිග පරීක්ෂා කිරීම හිස් නූල් සම්බන්ධ විශේෂ අවස්ථාවක් සඳහා වේ. එය ඔබගේ 0x89f පරීක්ෂණයට වැටෙන බව සලකන්න, නමුත් එයට හේතුව බොහෝ පරිසරයන් තුළ එය වචනානුසාරයෙන් අර්ථ දැක්වීමට සුදුසු ක්‍රමයකි. ඔබට එම විශේෂිත අවස්ථාව අල්ලා ගැනීමට අවශ්‍ය නම් ඔබට අතිරේක චෙක්පතක් එක් කළ හැකිය. ඊටත් වඩා හොඳයි, එය භාවිතා නොකිරීමට ඔබේ හේතුව නම්, isNaN()ඔබේම ක්‍රියාකාරිත්වය ඒ වටා ඔතා isNaN()අතිරේක චෙක්පතක් කළ හැකිය.

සාරාංශයක් ලෙස, ඔබට අගයක් සංඛ්‍යාවක් බවට පරිවර්තනය කළ හැකිදැයි දැන ගැනීමට අවශ්‍ය නම්, ඇත්ත වශයෙන්ම එය අංකයක් බවට පරිවර්තනය කිරීමට උත්සාහ කරන්න.

නැවත ගොස් සඳහා යම් යම් පර්යේෂණ කළේ ඇයි එය whitespace string අෙප්ක්ෂිත නිෂ්පාදන සිටියේ නැත, මම දැන් එය ලබා හිතන්නේ: හිස් අගයක් ඡදමළ ඇත 0වෙනුවට NaN. දිග පරීක්‍ෂණයට පෙර නූල් කැපීම මෙම නඩුව හසුරුවනු ඇත.

නව කේතයට එරෙහිව ඒකක පරීක්ෂණ ක්‍රියාත්මක කිරීම අසමත් වන අතර එය අනන්තය සහ බූලියන් සාක්ෂරතාවන් මත පමණක් වන අතර ගැටළුවක් විය යුතු එකම අවස්ථාව වන්නේ ඔබ කේත ජනනය කරන්නේ නම් පමණි (ඇත්ත වශයෙන්ම, වචනානුසාරයෙන් ටයිප් කර එය සංඛ්‍යාත්මකදැයි පරීක්ෂා කරන්නේ කවුද? ඔබ දැනගත යුතුය ), එය ජනනය කිරීමට අමුතු කේතයක් වනු ඇත.

එහෙත්, නැවතත්, මෙය භාවිතා කිරීමට ඇති එකම හේතුව කිසියම් හේතුවක් නිසා ඔබට වැළකී සිටිය යුතු නම් නම් ().

මෙම ක්‍රමය හොඳින් ක්‍රියාත්මක වන බව පෙනේ:

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

එක් පේළියක:

const IsNumeric = (num) => /^-{0,1}\d*\.{0,1}\d+$/.test(num);

එය පරීක්ෂා කිරීමට:

const IsNumeric = (num) => /^-{0,1}\d*\.{0,1}\d+$/.test(num);
    
    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;
    }

console.log(TestIsNumeric());

.as-console-wrapper { max-height: 100% !important; top: 0; }

මම එම රීජෙක්ස් ණයට ගත්තේ 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

යාහූ! UI මෙය භාවිතා කරයි:

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

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

මෙය 0x23 වර්ගයේ අංක සඳහාද ක්‍රියා කරයි.

පිළිගත් පිළිතුර ඔබේ පරීක්ෂණය # 7 අසමත් වූ අතර මම හිතන්නේ ඔබ ඔබේ අදහස වෙනස් කළ නිසාය. එබැවින් මෙය පිළිගත් පිළිතුරට ප්‍රතිචාරයක් වන අතර එය මට ගැටළු ඇති විය.

සමහර ව්‍යාපෘති වලදී මට සමහර දත්ත වලංගු කිරීමට අවශ්‍ය වී ඇති අතර එය ගණිතමය මෙහෙයුම් සඳහා භාවිතා කළ හැකි ජාවාස්ක්‍රිප්ට් සංඛ්‍යාත්මක අගයක් බව හැකි තරම් ස්ථිර විය යුතුය.

jQuery, සහ තවත් සමහර ජාවාස්ක්‍රිප්ට් පුස්තකාලවල දැනටමත් එවැනි ශ්‍රිතයක් ඇතුළත් වේ isNumeric. තවද එහි ඇති stackoverflow පශ්චාත් පුළුල් ලෙස පිළිතුරු ලෙස පිළිගන්නා කර ඇති බව, පැවරීම කර පුස්තකාල භාවිතා කරන විට, එම පොදු චර්යාවක් ඇත.

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.isArrayjquery $.isArrayහෝ මූලාකෘති Object.isArrayභාවිතා කළ හැකියObject.prototype.toString.call(n) !== '[object Array]'

මගේ දෙවන ගැටළුව වූයේ Neg ණාත්මක ෂඩාස්රාකාර පූර්ණ සංඛ්‍යා වචන ("-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 පරීක්ෂණ අවස්ථා ගෙන jsfiddle හි පරීක්ෂාව ක්ලෝන කිරීමෙන් මගේ අමතර පරීක්ෂණ අවස්ථා සහ ඉහත විස්තර කළ විසඳුම එකතු කළෙමි .

එය පුළුල් ලෙස පිළිගත් / භාවිතා කළ පිළිතුර ප්‍රතිස්ථාපනය නොකරනු ඇත, නමුත් මෙය ඔබගේ isNumeric ශ්‍රිතයේ ප්‍රති results ල ලෙස ඔබ අපේක්ෂා කරන දෙයට වඩා වැඩි නම් මෙය යම් උපකාරයක් වනු ඇතැයි අපේක්ෂා කරමු.

සංස්කරණය කරන්න: බර්ගී විසින් පෙන්වා දුන් පරිදි , සංඛ්‍යාත්මක ලෙස සැලකිය හැකි වෙනත් වස්තූන් ඇති අතර අසාදු ලේඛනයට වඩා සුදු ලැයිස්තු ගත කිරීම වඩා හොඳය. මෙය මනසේ තබාගෙන මම නිර්ණායක එකතු කරමි.

මගේ isNumeric ශ්‍රිතය අංක හෝ නූල් පමණක් සලකා බැලීමට මට අවශ්‍යය

මෙය මනසේ තබාගෙන භාවිතා කිරීම වඩා හොඳය

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>

ඔව්, ඉදිකරන ලද isNaN(object)ඕනෑම රීජෙක්ස් විග්‍රහයකට වඩා වේගවත් වනු ඇත, මන්ද එය මැස්සන් මත අර්ථ නිරූපණය කරනවා වෙනුවට එය ගොඩනගා සම්පාදනය කර ඇති බැවිනි.

ප්‍රති results ල ඔබ සොයන දෙයට වඩා තරමක් වෙනස් වුවද ( එය උත්සාහ කරන්න ):

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

ශ්‍රිතය භාවිතා කරන්න isNaN . මම විශ්වාස කරන්නේ ඔබ !isNaN(yourstringhere)එය පරීක්‍ෂා කරන්නේ නම් මෙම ඕනෑම තත්වයක් සඳහා හොඳින් ක්‍රියා කරයි.

JQuery 1.7 සිට, ඔබට මෙය භාවිතා කළ හැකිය jQuery.isNumeric():

$.isNumeric('-1');      // true
$.isNumeric('-1.5');    // true
$.isNumeric('0');       // true
$.isNumeric('0.42');    // true
$.isNumeric('.42');     // true
$.isNumeric('0x89f');   // true (valid hexa number)
$.isNumeric('99,999');  // false
$.isNumeric('#abcdef'); // false
$.isNumeric('1.2.3');   // false
$.isNumeric('');        // false
$.isNumeric('blah');    // false

ඔබ කී දෙයට වඩා 0x89fවලංගු අංකයක් (හෙක්සා) බව සලකන්න.

RegExp නොමැතිව එය කළ හැකිය

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

මුල් ප්‍රශ්නය jQuery ගැන සඳහන් කර නැති බව මට වැටහී ඇත, නමුත් ඔබ jQuery භාවිතා කරන්නේ නම්, ඔබට කළ හැක්කේ:

$.isNumeric(val)

සරල.

https://api.jquery.com/jQuery.isNumeric/ (jQuery 1.7 අනුව)

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

මට වැඩ කළේ නැහැ. මම සීරුවෙන් තබා පරීක්ෂා කරන විට, input.lengthවිය undefined. පූර්ණ සංඛ්‍යා දිග පරීක්ෂා කිරීමට දේපලක් නොමැති බව මම සිතමි. ඉතින් මම කළේ එයයි

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

එය හොඳින් ක්‍රියාත්මක විය.

මම වරදවා වටහා නොගත්තොත්, මෙය නියත ( Infinity, NaN) සහ සං sign ා ක්‍රියාකරුවන් +/ හැර සෙසු වලංගු ජාවාස්ක්‍රිප්ට් අංක අගයකට ගැලපේ.- (ඔවුන් මම හිතන තරම් සංඛ්යාව කොටසක් ඇත්තටම නැති නිසා, ඔවුන් වෙන වෙනම සමාගම් වේ):

මට මෙය ටෝකනයිසර් සඳහා අවශ්‍ය විය, එහිදී ඇගයීම සඳහා ජාවාස්ක්‍රිප්ට් වෙත අංකය යැවීම විකල්පයක් නොවීය ... එය නියත වශයෙන්ම හැකි කෙටිම නිත්‍ය ප්‍රකාශනය නොවේ, නමුත් එය ජාවාස්ක්‍රිප්ට් අංක සින්ටැක්ස් හි සියුම් සියුම් බව අල්ලා ගන්නා බව මම විශ්වාස කරමි.

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

@ CMS හි පිළිතුර සමඟ මට ඇති එකම ගැටළුව 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 තවත් අලංකාර පිළිතුරකට ඉතා ආසන්නයි , නමුත් හෙක්ස් සහ වෙනත් සංඛ්‍යා නිරූපණයන් හසුරුවයි.

මට නම් මෙය හොඳම ක්‍රමයයි:

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

මම පහත සඳහන් දෑ එකතු කිරීමට කැමතියි:

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

ධනාත්මක හෙක්ස් අංක වලින් ආරම්භ වන 0xඅතර negative ණ හෙක්ස් අංක ආරම්භ වේ -0x. ධනාත්මක අෂ්ටක සංඛ්‍යා ආරම්භ වන 0අතර negative ණ අෂ්ටක සංඛ්‍යා ආරම්භ වේ -0. මෙය දැනටමත් සඳහන් කර ඇති බොහෝ දේ සැලකිල්ලට ගනී, නමුත් හෙක්ස් සහ අෂ්ටක සංඛ්‍යා, negative ණ විද්‍යාත්මක, අනන්තය සහ දශම විද්‍යාත්මක ඉවත් කර ඇත ( 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));
}

මම හිතන්නේ parseFloat ශ්‍රිතයට මෙහි සියලු වැඩ කළ හැකිය. පහත දැක්වෙන ශ්‍රිතය මෙම පිටුවේ ඇති සියලුම පරීක්ෂණ සමත් වේ isNumeric(Infinity) == true:

function isNumeric(n) {

    return parseFloat(n) == n;
}

එකතු කිරීමට පරීක්ෂණ කිහිපයක්:

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

මම මෙය ඉදිරිපත් කළෙමි:

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

විසඳුම ආවරණය කරයි:

• ආරම්භයේ දී විකල්ප negative ණ ලකුණක්
• තනි ශුන්‍යයක්, හෝ ඉලක්කම් එකක් හෝ වැඩි ගණනක් 0 සමඟ ආරම්භ නොවේ, හෝ කාල පරිච්ඡේදයක් පවතින තාක් කල් කිසිවක් නැත
• අංක 1 ක් හෝ වැඩි ගණනක් අනුගමනය කරන කාල පරිච්ඡේදයකි

පූර්ණ සංඛ්‍යා අගයක් මගින් සත්‍යාපනය කළ හැක්කේ:

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

මෙම මාර්ගය පහසු සහ වේගවත් වේ! සියලුම පරීක්ෂණ පරීක්ෂා කරනු ලැබේ!

මෙන්න මම හරියටම jQuery හි ප්‍රභේදය වෙනුවට භාවිතා කරන ලිල් බිට් වැඩිදියුණු කළ අනුවාදයක් (බොහෝ විට එහි ඇති වේගවත්ම ක්‍රමය), ඔවුන් මෙය භාවිතා නොකරන්නේ මන්දැයි මම නොදනිමි:

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

JQuery ගේ අනුවාදය එහි අවාසිය ඔබ ප්රධාන පෙළේ numerics හා සමාන අවර ලිපි වැලක් සමත් වන්නේ නැති බව "123abc"ද parseFloat | parseIntසංඛ්යා භාගය සිදු උපුටා අතර 123 නැවත, නමුත්, දෙවන නිලධාරියා isFiniteඑය කෙසේ හෝ අසාර්ථක වනු ඇත. +එවැනි දෙමුහුන් සඳහා NaN විසි කරන බැවින් ඒකීය ක්‍රියාකරු සමඟ එය පළමු ආරක්ෂකයා මතම මිය යනු ඇත :) සුළු කාර්ය සාධනයක් වුවද මම සිතන්නේ ශක්තිමත් අර්ථකථන වාසියක්.

මගේ විසඳුම,

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 isNumber(num) {
    return parseFloat(num).toString() == num
}

මෙය ක්‍රියාත්මක විය යුතුය. මෙහි සපයා ඇති සමහර කාර්යයන් දෝෂ සහිත වන අතර මෙහි වෙනත් ඕනෑම කාර්යයකට වඩා වේගවත් විය යුතුය.

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

පැහැදිලි කළේ:

තමන් විසින්ම පිටපතක් සාදන්න, පසුව එම අංකය පාවෙන බවට පරිවර්තනය කර, මුල් අංකය සමඟ සංසන්දනය කරන්න, එය තවමත් සංඛ්‍යාවක් නම්, (පූර්ණ සංඛ්‍යාවක් හෝ පාවෙන වේවා), සහ මුල් අංකයට ගැලපේ, එයින් අදහස් වන්නේ එය සැබවින්ම සංඛ්‍යාවක් බවයි.

එය සංඛ්‍යාත්මක නූල් මෙන්ම සරල සංඛ්‍යා සමඟ ක්‍රියා කරයි. ෂඩාස්රාකාර සංඛ්‍යා සමඟ ක්‍රියා නොකරයි.

අවවාදයයි: ඔබේම අවදානමකට භාවිතා කරන්න, සහතිකයක් නැත.

කිසිදු පිළිතුරක් falseහිස් නූල් සඳහා ආපසු නොඑයි, ඒ සඳහා විසඳුමක් ...

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

විචල්‍යයක වලංගු අංකයක් තිබේද යන්න පරීක්ෂා කිරීම සඳහා අංකයක් මෙන් පෙනෙන නූලක් Number.isFinite(value)පමණක් භාවිතා කළ නොහැක.

මෙය 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

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

N සංඛ්‍යාත්මක Number(n)නම් සංඛ්‍යාත්මක අගය toString()නැවත ලබා දෙන අතර එය නැවත නූලකට හරවනු ඇත. නමුත් n සංඛ්යා නොවේ නම් Number(n)ආපසු NaNඑය මුල් නොගැලපේ එසේ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');
}

මෙහි අදහස නම් සෑම සංඛ්‍යාවක් හෝ පූර්ණ සංඛ්‍යාවක් සඳහා එක් “කැනොනිකල්” නූල් නිරූපණයක් ඇති අතර කැනොනිකල් නොවන සෑම නිරූපණයක්ම ප්‍රතික්ෂේප කළ යුතුය. එබැවින් අපි අංකයකට සහ පසුපසට දමමු, ප්‍රති result ලය මුල් නූලදැයි බලන්න.

මෙම කාර්යයන් ඔබට ප්‍රයෝජනවත් වේද යන්න භාවිතා කිරීමේ අවස්ථාව මත රඳා පවතී. එක් අංගයක් වන්නේ එකිනෙකට වෙනස් වූ නූල් එකිනෙකට වෙනස් සංඛ්‍යා නිරූපණය කිරීමයි (දෙකම isNumber()පරීක්ෂණයෙන් සමත් වුවහොත් ).

මෙය වස්තු දේපල නම් ලෙස සංඛ්‍යා සඳහා අදාළ වේ.

var obj = {};
obj['4'] = 'canonical 4';
obj['04'] = 'alias of 4';
obj[4];  // prints 'canonical 4' to the console.

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 ({ඉලක්කම්: සත්‍ය}) ;

ටෙස්ට් කේස්

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

ඔබට විශේෂ දශම කට්ටලයක් වලංගු කිරීමට අවශ්‍ය නම් ඔබට මෙම සරල ජාවාස්ක්‍රිප්ට් භාවිතා කළ හැකිය:

http://codesheet.org/codesheet/x1kI7hAD

<input type="text" name="date" value="" pattern="[0-9]){1,2}(\.){1}([0-9]){2}" maxlength="6" placeholder="od npr.: 16.06" onchange="date(this);" />

ජාවාස්ක්‍රිප්ට්:

function date(inputField) {        
  var isValid = /^([0-9]){1,2}(\.){1}([0-9]){2}$/.test(inputField.value);   
  if (isValid) {
    inputField.style.backgroundColor = '#bfa';
  } else {
    inputField.style.backgroundColor = '#fba';
  }
  return isValid;
}

isNumeric=(el)=>{return Boolean(parseFloat(el)) && isFinite(el)}

ඊට වඩා වෙනස් කිසිවක් නැත නමුත් අපට බූලියන් ඉදිකිරීම්කරු භාවිතා කළ හැකිය