පැරණි VB6 IsNumeric()ශ්‍රිතයට සමාන සංකල්පීය අවකාශයක යමක් ඇතැයි මම බලාපොරොත්තු වෙමි ?

විචල්යයක් (නූලක් ඇතුළුව) අංකයක් දැයි පරීක්ෂා කිරීමට, එය අංකයක් නොවේදැයි පරීක්ෂා කරන්න:

විචල්ය අන්තර්ගතය නූල් හෝ අංකයක් නොසලකා මෙය ක්රියා කරයි.

isNaN(num)         // returns true if the variable does NOT contain a valid number

උදාහරණ

isNaN(123)         // false
isNaN('123')       // false
isNaN('1e10000')   // false (This translates to Infinity, which is a number)
isNaN('foo')       // true
isNaN('10px')      // true

ඇත්ත වශයෙන්ම, ඔබට අවශ්‍ය නම් මෙය ප්‍රතික්ෂේප කළ හැකිය. උදාහරණයක් ලෙස, IsNumericඔබ දුන් ආදර්ශය ක්‍රියාත්මක කිරීමට :

function isNumeric(num){
  return !isNaN(num)
}

අංකයක් අඩංගු නූලක් අංකයක් බවට පරිවර්තනය කිරීම සඳහා:

නූල් සංඛ්‍යාත්මක අක්ෂර පමණක් අඩංගු වන්නේ නම් පමණක් ක්‍රියාත්මක වේ, එසේ නොමැතිනම් එය නැවත පැමිණේ NaN.

+num               // returns the numeric value of the string, or NaN 
                   // if the string isn't purely numeric characters

උදාහරණ

+'12'              // 12
+'12.'             // 12
+'12..'            // NaN
+'.12'             // 0.12
+'..12'            // NaN
+'foo'             // NaN
+'12px'            // NaN

නූලක් ලිහිල්ව අංකයකට පරිවර්තනය කිරීම

'12px' 12 බවට පරිවර්තනය කිරීම සඳහා ප්‍රයෝජනවත් වේ, උදාහරණයක් ලෙස:

parseInt(num)      // extracts a numeric value from the 
                   // start of the string, or NaN.

උදාහරණ

parseInt('12')     // 12
parseInt('aaa')    // NaN
parseInt('12px')   // 12
parseInt('foo2')   // NaN      These last two may be different
parseInt('12a5')   // 12       from what you expected to see. 

පාවෙන

(නමට අනුව) මෙන් නොව +num, parseIntදශම ලක්ෂයට පසුව සෑම දෙයක්ම කපා හැරීමෙන් පාවෙන සංඛ්‍යාවක් පූර්ණ සංඛ්‍යාවක් බවට පරිවර්තනය වන බව මතක තබා ගන්න ( මෙම හැසිරීම parseInt() නිසා ඔබට භාවිතා කිරීමට අවශ්‍ය නම් , ඒ වෙනුවට වෙනත් ක්‍රමයක් භාවිතා කිරීමට වඩා හොඳය ) :

+'12.345'          // 12.345
parseInt(12.345)   // 12
parseInt('12.345') // 12

හිස් නූල්

හිස් නූල් ටිකක් ප්‍රති-බුද්ධිමත් විය හැකිය. +numහිස් නූල් හෝ නූල් අවකාශය ශුන්‍ය බවට පරිවර්තනය කරයි, සහ isNaN()එයම උපකල්පනය කරයි:

+''                // 0
+'   '             // 0
isNaN('')          // false
isNaN('   ')       // false

නමුත් parseInt()එකඟ නොවේ:

parseInt('')       // NaN
parseInt('   ')    // NaN

ඔබට RegExp මාර්ගයට යා හැකිය:

var num = "987238";

if(num.match(/^-{0,1}\d+$/)){
  //valid integer (positive or negative)
}else if(num.match(/^\d+\.\d+$/)){
  //valid float
}else{
  //not valid number
}

ඔබ නූලක් සම්පූර්ණ සංඛ්‍යාවක් දැයි බැලීමට උත්සාහ කරන්නේ නම් (දශම ස්ථාන නොමැත), රීජෙක්ස් යන්න හොඳ ක්‍රමයකි. isNaNඑතරම් සරල දෙයකට වඩා සංකීර්ණ වන වෙනත් ක්‍රම .

function isNumeric(value) {
    return /^-{0,1}\d+$/.test(value);
}

console.log(isNumeric('abcd'));         // false
console.log(isNumeric('123a'));         // false
console.log(isNumeric('1'));            // true
console.log(isNumeric('1234567890'));   // true
console.log(isNumeric('-23'));          // true
console.log(isNumeric(1234));           // true
console.log(isNumeric('123.4'));        // false
console.log(isNumeric(''));             // false
console.log(isNumeric(undefined));      // false
console.log(isNumeric(null));           // false

ධනාත්මක සම්පූර්ණ සංඛ්‍යා වලට පමණක් ඉඩ දීම සඳහා මෙය භාවිතා කරන්න:

function isNumeric(value) {
    return /^\d+$/.test(value);
}

console.log(isNumeric('123'));          // true
console.log(isNumeric('-23'));          // false

මෙම ප්‍රශ්නයට පිළිගත් පිළිතුරෙහි අඩුපාඩු කිහිපයක් තිබේ (වෙනත් පරිශීලකයින් කිහිප දෙනෙකු විසින් ඉස්මතු කර ඇති පරිදි). මෙය ජාවාස්ක්‍රිප්ට් වලින් ප්‍රවේශ වීමට ඇති පහසුම සහ ඔප්පු කළ හැකි ක්‍රමයකි:

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

පහත දැක්වෙන්නේ හොඳ පරීක්ෂණ අවස්ථා කිහිපයක්:

console.log(isNumeric(12345678912345678912)); // true
console.log(isNumeric('2 '));                 // true
console.log(isNumeric('-32.2 '));             // true
console.log(isNumeric(-32.2));                // true
console.log(isNumeric(undefined));            // false

// the accepted answer fails at these tests:
console.log(isNumeric(''));                   // false
console.log(isNumeric(null));                 // false
console.log(isNumeric([]));                   // false

ඔබ ඇත්තටම විශ්වාසද වැලක් පමණක් අංකය, ඕනෑම අංකය (පූර්ණ සංඛ්යාවක් හෝ ඉපිලුම් ලක්ෂ්ය), සහ හරියටම ගණනාවක් අඩංගු කිරීමට අවශ්ය නම්, ඔබ කළ නොහැකි භාවිතා parseInt()/ parseFloat(), Number()හෝ !isNaN()තමන් විසින්. බව සටහන !isNaN()ඇත්තටම ආපසු පැමිනෙමින් trueවිට Number()ගණනාවක් ඇති බවත් නැවත, හා falseඑය ආපසු කවදාදNaN , ඒ නිසා මම සාකච්ඡා ඉතිරි සිට එය ඉවත් කරනු ඇත.

ඇති ප්රශ්නය parseFloat()එය, වැල ඕනෑම අංකය අඩංගු නම් ගණනාවක් නැවත බව වැල අඩංගු නොවේ පවා නම් වේ පමණක් සහ හරියටම ගණනාවක්:

parseFloat("2016-12-31")  // returns 2016
parseFloat("1-1") // return 1
parseFloat("1.2.3") // returns 1.2

ගැටළුව Number()වන්නේ සම්මත අගය කිසිසේත්ම සංඛ්‍යාවක් නොවන අවස්ථාවන්හිදී එය සංඛ්‍යාවක් ආපසු ලබා දීමයි!

Number("") // returns 0
Number(" ") // returns 0
Number(" \u00A0   \t\n\r") // returns 0

ඔබේම රීජෙක්ස් රෝල් කිරීමේ ගැටළුව නම්, ඔබ ජාවාස්ක්‍රිප්ට් විසින් හඳුනාගෙන ඇති පරිදි පාවෙන ලක්ෂ්‍ය අංකයක් ගැලපීම සඳහා නිශ්චිත රීජෙක්ස් නිර්මාණය නොකළහොත් ඔබට නඩු මඟ හැරීමට හෝ ඔබ නොකළ යුතු අවස්ථා හඳුනා ගැනීමට සිදුවීමයි. ඔබට ඔබේම රිජෙක්ස් රෝල් කළ හැකි වුවද, ඇයි? එය කිරීමට වඩා සරල නිමැවුම් ක්‍රම තිබේ.

කෙසේ වෙතත්, සංඛ්‍යාවක් හැරවිය යුතු සෑම අවස්ථාවකටම Number()(සහ isNaN()) නිවැරදි දේ කරන බව පෙනේ parseFloat(), සහ අනෙක් අතට. එබැවින් නූලක් හරියටම හරියටම හා සංඛ්‍යාවක් පමණක් දැයි සොයා ගැනීමට, ශ්‍රිත දෙකම අමතා ඒවා දෙකම සත්‍යයක් දැයි බලන්න :

function isNumber(str) {
  if (typeof str != "string") return false // we only process strings!
  // could also coerce to string: str = ""+str
  return !isNaN(str) && !isNaN(parseFloat(str))
}

IsNan ශ්‍රිතය උත්සාහ කරන්න :

IsNaN () ශ්‍රිතය මඟින් අගය නීති විරෝධී අංකයක්ද යන්න තීරණය කරයි (අංකයක් නොවේ).

අගය NaN ට සමාන නම් මෙම ශ්‍රිතය සත්‍ය වේ. එසේ නොමැතිනම් එය සාවද්‍ය ය.

මෙම ශ්‍රිතය සංඛ්‍යා විශේෂිත අංක. IsNaN () ක්‍රමයට වඩා වෙනස් වේ .

  ගෝලීය isNaN () ශ්‍රිතය, පරීක්ෂා කළ අගය අංකයක් බවට පරිවර්තනය කර එය පරීක්ෂා කරයි.

Number.isNan () මඟින් අගයන් සංඛ්‍යාවක් බවට පරිවර්තනය නොකරන අතර අංකයේ වර්ගයට අයත් නොවන කිසිදු අගයක් සඳහා සත්‍ය නොවේ.

පැරණි ප්‍රශ්නය, නමුත් ලබා දී ඇති පිළිතුරු වල කරුණු කිහිපයක් නොමැත.

විද්‍යාත්මක අංකනය.

!isNaN('1e+30')වන trueජනතාව අංක ඉල්ලන විට, ඔවුන් වැනි දේවල් ගැලපෙන ඕන නෑ කෙසේ වෙතත් බොහෝ සිදුවීම් තුල දී,1e+30 .

විශාල පාවෙන සංඛ්‍යා අමුතු ලෙස හැසිරෙනු ඇත

නිරීක්ෂණය කරන්න (Node.js භාවිතා කරමින්):

> var s = Array(16 + 1).join('9')
undefined
> s.length
16
> s
'9999999999999999'
> !isNaN(s)
true
> Number(s)
10000000000000000
> String(Number(s)) === s
false
>

අනිත් අතට:

> var s = Array(16 + 1).join('1')
undefined
> String(Number(s)) === s
true
> var s = Array(15 + 1).join('9')
undefined
> String(Number(s)) === s
true
>

ඉතින්, යමෙක් අපේක්ෂා කරන්නේ නම් String(Number(s)) === s , ඔබේ නූල් උපරිම වශයෙන් ඉලක්කම් 15 කට සීමා කරන්න (ප්‍රමුඛ ශුන්‍යයන් මඟ හැරීමෙන් පසු).

අනන්තය

> typeof Infinity
'number'
> !isNaN('Infinity')
true
> isFinite('Infinity')
false
>

මේ සියල්ල සැලකිල්ලට ගෙන, දී ඇති නූල පහත සඳහන් සියල්ල තෘප්තිමත් කරන සංඛ්‍යාවක් දැයි පරීක්ෂා කිරීම:

• විද්‍යාත්මක නොවන අංකනය
• පුරෝකථනය කළ හැකි පරිවර්තනය වෙත Numberසහ ආපසුString
• සීමිතයි

එතරම් පහසු කාර්යයක් නොවේ. මෙන්න සරල අනුවාදයක්:

  function isNonScientificNumberString(o) {
    if (!o || typeof o !== 'string') {
      // Should not be given anything but strings.
      return false;
    }
    return o.length <= 15 && o.indexOf('e+') < 0 && o.indexOf('E+') < 0 && !isNaN(o) && isFinite(o);
  }

කෙසේ වෙතත්, මෙය පවා සම්පුර්ණ නැත. ප්‍රමුඛ ශුන්‍යයන් මෙහි හසුරුවනු නොලැබේ, නමුත් ඒවා දිග පරීක්ෂණය ඉස්කුරුප්පු කරයි.

මම පරීක්ෂා කර ඇති අතර මයිකල්ගේ විසඳුම හොඳම වේ. ඉහත ඔහුගේ පිළිතුර සඳහා ඡන්දය දෙන්න (එය සොයා ගැනීම සඳහා "ඔබට ඇත්තටම අවශ්‍ය නම්" යනුවෙන් මෙම පිටුව සොයන්න). සාරාංශයක් ලෙස, ඔහුගේ පිළිතුර මෙයයි:

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

මා මෙහි ලේඛනගත කළ සෑම පරීක්ෂණ අවස්ථාවකටම එය ක්‍රියා කරයි: https://jsfiddle.net/wggehvp9/5/

මෙම විසඳුම් සඳහා වෙනත් බොහෝ විසඳුම් අසමත් වේ: '', ශුන්‍ය, "", සත්‍ය සහ []. න්‍යාය අනුව, නිසි දෝෂ හැසිරවීමෙන් ඔබට ඒවා භාවිතා කළ හැකිය: උදාහරණයක් ලෙස:

return !isNaN(num);

හෝ

return (+num === +num);

/ \ s /, ශුන්‍ය, "", සත්‍ය, අසත්‍ය, [] (සහ වෙනත් අය?)

තර්කයක් එහි ඉදිකිරීම්කරු වෙත යොමු කිරීමේදී ඔබට අංකයේ ප්‍රති result ලය භාවිතා කළ හැකිය .

තර්කය (නූලක්) අංකයක් බවට පරිවර්තනය කළ නොහැකි නම්, එය NaN නැවත ලබා දෙයි, එබැවින් ලබා දී ඇති නූල වලංගු අංකයක්ද නැද්ද යන්න ඔබට තීරණය කළ හැකිය.

සටහන්: සටහන හිස් අගයක් හෝ එක්විමට '\t\t'හා '\n\t'අංකය 0 ආපසු කවෙර්ද; සත්‍යය පසු කිරීමෙන් 1 සහ ව්‍යාජ ප්‍රතිලාභ 0 ලැබේ.

    Number('34.00') // 34
    Number('-34') // -34
    Number('123e5') // 12300000
    Number('123e-5') // 0.00123
    Number('999999999999') // 999999999999
    Number('9999999999999999') // 10000000000000000 (integer accuracy up to 15 digit)
    Number('0xFF') // 255
    Number('Infinity') // Infinity  

    Number('34px') // NaN
    Number('xyz') // NaN
    Number('true') // NaN
    Number('false') // NaN

    // cavets
    Number('    ') // 0
    Number('\t\t') // 0
    Number('\n\t') // 0

සමහර විට මෙම ප්‍රශ්නයට එක් අයෙකු හෝ දෙදෙනෙකු පැමිණ ඇති අතර ඔවුන්ට වෙනදාට වඩා දැඩි පරීක්ෂණයක් අවශ්‍ය වේ (මා කළාක් මෙන්). එවැනි අවස්ථාවක, මෙය ප්‍රයෝජනවත් විය හැකිය:

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

පරෙස්සම් වන්න! මේ වගේ නූල් ප්රතික්ෂේප කරනු ඇත .1, 40.000, 080, 00.1. එය ඉතා අච්චාරු - නූල් " අවම අවම ආකෘතියට අනුරූප විය යුතුය මෙම පරීක්ෂණය සමත් වීම සඳහා ” අනුරූප විය යුතුය.

එය අංකයකට නැවත නැවත වාත්තු කිරීම සඳහා Stringසහ Numberඉදිකිරීම්කරු භාවිතා කරන අතර එමඟින් ජාවාස්ක්‍රිප්ට් එන්ජිමේ “පරිපූර්ණ අවම ස්වරූපය” (ආරම්භක Numberඉදිකිරීම්කරු සමඟ එය පරිවර්තනය කර ඇති ) මුල් නූලට ගැලපේදැයි පරීක්ෂා කරයි.

parseInt (), නමුත් මෙම ශ්‍රිතය ටිකක් වෙනස් බව මතක තබා ගන්න, එය උදාහරණයක් ලෙස parseInt සඳහා 100 ක් ලබා දෙයි ("100px").

2019: ප්‍රායෝගික හා තද සංඛ්‍යාත්මක වලංගුභාවය පරීක්ෂා කිරීම

බොහෝ විට, 'වලංගු අංකයක්' යනු NaN සහ Infinity හැර ජාවාස්ක්‍රිප්ට් අංකයකි, එනම් 'සීමිත අංකයකි'.

අගයක සංඛ්‍යාත්මක වලංගුභාවය පරීක්ෂා කිරීම සඳහා (උදාහරණයක් ලෙස බාහිර ප්‍රභවයකින්), ඔබට ESlint Airbnb ශෛලියෙන් අර්ථ දැක්විය හැකිය:

/**
 * Returns true if 'candidate' is a finite number or a string referring (not just 'including') a finite number
 * To keep in mind:
 *   Number(true) = 1
 *   Number('') = 0
 *   Number("   10  ") = 10
 *   !isNaN(true) = true
 *   parseFloat('10 a') = 10
 *
 * @param {?} candidate
 * @return {boolean}
 */
function isReferringFiniteNumber(candidate) {
  if (typeof (candidate) === 'number') return Number.isFinite(candidate);
  if (typeof (candidate) === 'string') {
    return (candidate.trim() !== '') && Number.isFinite(Number(candidate));
  }
  return false;
}

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

if (isReferringFiniteNumber(theirValue)) {
  myCheckedValue = Number(theirValue);
} else {
  console.warn('The provided value doesn\'t refer to a finite number');
}

උපුටා ගැනීම:

විචල්‍යයේ වලංගු අංකයක් නොමැති නම් isNaN (num) // සත්‍ය වේ

ඔබට ප්‍රමුඛ / පසුපස අවකාශයන් පරික්ෂා කිරීමට අවශ්‍ය නම් එය සම්පූර්ණයෙන්ම සත්‍ය නොවේ - නිදසුනක් ලෙස නිශ්චිත ඉලක්කම් ප්‍රමාණයක් අවශ්‍ය වූ විට, සහ ඔබට අවශ්‍ය වන්නේ '1111' යැයි පැවසිය යුතු අතර සමහර විට PIN සඳහා '111' හෝ '111' නොවේ. ආදානය.

භාවිතා කිරීමට වඩා හොඳ:

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

JQuery ක්‍රියාත්මක කිරීම ප්‍රමාණවත් නොවන්නේ ඇයි?

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

මයිකල් මේ වගේ දෙයක් යෝජනා කළා (මම "user1691651 - ජෝන් මෙහි වෙනස් කළ අනුවාදය සොරකම් කළත්):

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

පහත දැක්වෙන්නේ බොහෝ දුරට නරක ක්‍රියාකාරිත්වය සහිත විසඳුමකි, නමුත් solid න ප්‍රති .ල. එය jQuery 1.12.4 ක්‍රියාත්මක කිරීම සහ මයිකල්ගේ පිළිතුර, ප්‍රමුඛ / පසුපස අවකාශයන් සඳහා අමතර පරීක්‍ෂණයක් සමඟ සාදන ලද ප්‍රතිවිරෝධයකි (මක්නිසාද යත් මයිකල්ගේ අනුවාදය ප්‍රමුඛ / පසුපස අවකාශයන් සහිත සංඛ්‍යා සඳහා සත්‍ය වන බැවිනි):

function isNumeric(a) {
    var str = a + "";
    var b = a && a.toString();
    return !$.isArray(a) && b - parseFloat(b) + 1 >= 0 &&
           !/^\s+|\s+$/g.test(str) &&
           !isNaN(str) && !isNaN(parseFloat(str));
};

දෙවන අනුවාදයට නව විචල්‍යයන් දෙකක් ඇත. එසේ කිරීමෙන් කෙනෙකුට එයින් එකක් ලබා ගත හැකිය:

function isNumeric(a) {
    if ($.isArray(a)) return false;
    var b = a && a.toString();
    a = a + "";
    return b - parseFloat(b) + 1 >= 0 &&
            !/^\s+|\s+$/g.test(a) &&
            !isNaN(a) && !isNaN(parseFloat(a));
};

මම මේ කිසිවක් එතරම් පරීක්‍ෂා කර නැත, වෙනත් ආකාරයකින් මා භාවිතා කරන අවස්ථා කිහිපයක් අතින් පරීක්‍ෂා කිරීම හැරෙන්නට, මගේ වර්තමාන අවාසනාවන්ත තත්ත්වයට මම පහර දෙමි. මෙය "යෝධයන්ගේ උරහිස් මත සිටගෙන සිටීම" තත්වයකි.

2019: ES3, ES6 සහ TypeScript උදාහරණ ඇතුළුව

සමහර විට මෙය බොහෝ වාර ගණනක් නැවත සකස් කර ඇත, කෙසේ වෙතත් මම අදත් මේ සමඟ සටන් කර මගේ පිළිතුර පළ කිරීමට කැමැත්තෙමි, මන්ද එය වෙනත් පිළිතුරක් සරලව හෝ තරයේම දැක නැති නිසාය:

ES3

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

ES6

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

යතුරු ලියනය

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

මෙය තරමක් සරල යැයි පෙනෙන අතර වෙනත් බොහෝ තනතුරු වල මා දුටු සියලු පදනම් ආවරණය කර මා ගැනම සිතුවෙමි:

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

ඔබට ඔබේම උත්සාහ කළ හැකිය isNumeric ක්‍රියාකාරිත්වය අතර මෙම භාවිත අවස්ථා වලදී අතීතයට ගොස් ඒවා සියල්ලටම “සත්‍ය” සඳහා පරිලෝකනය කළ හැකිය.

නැතහොත්, එක් එක් ප්‍රතිලාභ ලබා දෙන අගයන් බැලීමට:

හොඳයි, මම මේක හැදුවා ...

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

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

ඔබට එහි කිසියම් ගැටළුවක් ඇත්නම්, කරුණාකර මට කියන්න.

කවුරුහරි මෙය බොහෝ දුරට පහතට වැටුනහොත්, මම මේ මොහොත සමතයකට පත්කිරීමට යම් කාලයක් ගත කළෙමි. ( Https://github.com/moment/moment ). මෙන්න මම එයින් ඉවතට ගත් දෙයක්:

function isNumeric(val) {
    var _val = +val;
    return (val !== val + 1) //infinity check
        && (_val === +val) //Cute coercion check
        && (typeof val !== 'object') //Array/object check
}

පහත සඳහන් අවස්ථා හසුරුවයි:

සැබෑ! :

isNumeric("1"))
isNumeric(1e10))
isNumeric(1E10))
isNumeric(+"6e4"))
isNumeric("1.2222"))
isNumeric("-1.2222"))
isNumeric("-1.222200000000000000"))
isNumeric("1.222200000000000000"))
isNumeric(1))
isNumeric(0))
isNumeric(-0))
isNumeric(1010010293029))
isNumeric(1.100393830000))
isNumeric(Math.LN2))
isNumeric(Math.PI))
isNumeric(5e10))

බොරු! :

isNumeric(NaN))
isNumeric(Infinity))
isNumeric(-Infinity))
isNumeric())
isNumeric(undefined))
isNumeric('[1,2,3]'))
isNumeric({a:1,b:2}))
isNumeric(null))
isNumeric([1]))
isNumeric(new Date()))

හාස්‍යයට කරුණක් නම්, මම වැඩිපුරම අරගල කරන්නේ:

isNumeric(new Number(1)) => false

ඕනෑම යෝජනා සාදරයෙන් පිළිගනිමු. :]

සරල ජාවාස්ක්‍රිප්ට් භාවිතා කිරීම:

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

ලොඩාෂ් භාවිතා කිරීම:

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

function isNumberCandidate(s) {
  const str = (''+ s).trim();
  if (str.length === 0) return false;
  return !isNaN(+str);
}

console.log(isNumberCandidate('1'));       // true
console.log(isNumberCandidate('a'));       // false
console.log(isNumberCandidate('000'));     // true
console.log(isNumberCandidate('1a'));      // false 
console.log(isNumberCandidate('1e'));      // false
console.log(isNumberCandidate('1e-1'));    // true
console.log(isNumberCandidate('123.3'));   // true
console.log(isNumberCandidate(''));        // false
console.log(isNumberCandidate(' '));       // false
console.log(isNumberCandidate(1));         // true
console.log(isNumberCandidate(0));         // true
console.log(isNumberCandidate(NaN));       // false
console.log(isNumberCandidate(undefined)); // false
console.log(isNumberCandidate(null));      // false
console.log(isNumberCandidate(-1));        // true
console.log(isNumberCandidate('-1'));      // true
console.log(isNumberCandidate('-1.2'));    // true
console.log(isNumberCandidate(0.0000001)); // true
console.log(isNumberCandidate('0.0000001')); // true
console.log(isNumberCandidate(Infinity));    // true
console.log(isNumberCandidate(-Infinity));    // true

console.log(isNumberCandidate('Infinity'));  // true

if (isNumberCandidate(s)) {
  // use +s as a number
  +s ...
}

TypeScript සඳහා එය වලංගු නොවේ:

declare function isNaN(number: number): boolean;

TypeScript සඳහා ඔබට භාවිතා කළ හැකිය:

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

මෙය අසීමිත ලෙස පෙනෙන දාර ගණන අල්ලා ගන්නා බව පෙනේ:

function isNumber(x, noStr) {
    /*

        - Returns true if x is either a finite number type or a string containing only a number
        - If empty string supplied, fall back to explicit false
        - Pass true for noStr to return false when typeof x is "string", off by default

        isNumber(); // false
        isNumber([]); // false
        isNumber([1]); // false
        isNumber([1,2]); // false
        isNumber(''); // false
        isNumber(null); // false
        isNumber({}); // false
        isNumber(true); // false
        isNumber('true'); // false
        isNumber('false'); // false
        isNumber('123asdf'); // false
        isNumber('123.asdf'); // false
        isNumber(undefined); // false
        isNumber(Number.POSITIVE_INFINITY); // false
        isNumber(Number.NEGATIVE_INFINITY); // false
        isNumber('Infinity'); // false
        isNumber('-Infinity'); // false
        isNumber(Number.NaN); // false
        isNumber(new Date('December 17, 1995 03:24:00')); // false
        isNumber(0); // true
        isNumber('0'); // true
        isNumber(123); // true
        isNumber(123.456); // true
        isNumber(-123.456); // true
        isNumber(-.123456); // true
        isNumber('123'); // true
        isNumber('123.456'); // true
        isNumber('.123'); // true
        isNumber(.123); // true
        isNumber(Number.MAX_SAFE_INTEGER); // true
        isNumber(Number.MAX_VALUE); // true
        isNumber(Number.MIN_VALUE); // true
        isNumber(new Number(123)); // true
    */

    return (
        (typeof x === 'number' || x instanceof Number || (!noStr && x && typeof x === 'string' && !isNaN(x))) &&
        isFinite(x)
    ) || false;
};

PFB වැඩ කරන විසඳුම:

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

"සාදන ලද" විසඳුමක් සොයා ගැනීමට උත්සාහ කිරීමේ හිසරදය ඔබම ඉතිරි කරගන්න.

හොඳ පිළිතුරක් නොමැති අතර, මෙම ත්‍රෙඩ් එකේ විශාල ලෙස ඉහළට ඔසවා ඇති පිළිතුර වැරදිය.

npm install is-number

ජාවාස්ක්‍රිප්ට් හි, අගය සැමවිටම සංඛ්‍යාවක් දැයි විශ්වාසදායක ලෙස පරික්ෂා කිරීම තරම් සරල නොවේ. අංකයකට නූල් අගයක් දැමීම සඳහා devs +, -, හෝ Number () භාවිතා කිරීම සාමාන්‍ය දෙයකි (නිදසුනක් ලෙස, පරිශීලක ආදානය, රීජෙක්ස් ගැලපීම්, පාර්සර් ආදියෙන් අගයන් ආපසු ලබා දෙන විට). නමුත් අනපේක්ෂිත ප්‍රති results ල ලබා දෙන බොහෝ බුද්ධිමය නොවන අවස්ථා තිබේ:

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

මෙය ගොඩනගා ඇත්තේ පෙර පිළිතුරු සහ අදහස් කිහිපයක් මත ය. පහත දැක්වෙන්නේ සියළුම දාර අවස්ථා සහ තරමක් සංක්ෂිප්තව ආවරණය කරයි:

const isNumRegEx = /^-?(\d*\.)?\d+$/;

function isNumeric(n, allowScientificNotation = false) {
    return allowScientificNotation ? 
                !Number.isNaN(parseFloat(n)) && Number.isFinite(n) :
                isNumRegEx.test(n);
}

විචල්‍යයක් වලංගු අංකයක් බව සහතික කිරීමට ක්‍රම ගැන මම මෑතකදී ලිපියක් ලිව්වෙමි : https://github.com/jehugaleahsa/artifacts/blob/master/2018/typescript_num_hack.md පාවෙන ලක්ෂ්‍යය හෝ නිඛිලය සහතික කරන්නේ කෙසේදැයි ලිපිය පැහැදිලි කරයි. වැදගත් ( +xඑදිරිව~~x ).

ලිපිය උපකල්පනය කරන්නේ විචල්‍යය ආරම්භ කිරීමට a stringහෝ a වන numberඅතර trimඑය ලබා ගත හැකි / බහුපද කර ඇති බවයි. වෙනත් වර්ග හැසිරවීමට එය දිගු කිරීම අපහසු නොවනු ඇත. මෙන්න එහි මස්:

// Check for a valid float
if (x == null
    || ("" + x).trim() === ""
    || isNaN(+x)) {
    return false;  // not a float
}

// Check for a valid integer
if (x == null
    || ("" + x).trim() === ""
    || ~~x !== +x) {
    return false;  // not an integer
}

තරමක් අවුල් සහගත මගේ උත්සාහය, හොඳම විසඳුම නොවේ

function isInt(a){
    return a === ""+~~a
}


console.log(isInt('abcd'));         // false
console.log(isInt('123a'));         // false
console.log(isInt('1'));            // true
console.log(isInt('0'));            // true
console.log(isInt('-0'));           // false
console.log(isInt('01'));           // false
console.log(isInt('10'));           // true
console.log(isInt('-1234567890'));  // true
console.log(isInt(1234));           // false
console.log(isInt('123.4'));        // false
console.log(isInt(''));             // false

// other types then string returns false
console.log(isInt(5));              // false
console.log(isInt(undefined));      // false
console.log(isInt(null));           // false
console.log(isInt('0x1'));          // false
console.log(isInt(Infinity));       // false

මගේ යෙදුමේදී අපි ඉඩ දෙන්නේ az AZ සහ අක්ෂර 0-9 පමණි. 0xnn (0x10 වැනි) සමඟ ආරම්භ නොවන්නේ නම් " string % 1 === 0" භාවිතා කරමින් ඉහත පිළිතුර ක්‍රියාත්මක වන බව මට පෙනී ගියේය, එවිට අපට එය අවශ්‍ය නොවන විට එය සංඛ්‍යාත්මකව ලබා දෙනු ඇත. මගේ සංඛ්‍යාත්මක පරීක්‍ෂණයේ පහත දැක්වෙන සරල උගුල අපගේ විශේෂිත අවස්ථාවන්හි උපක්‍රමය කරන බව පෙනේ.

function isStringNumeric(str_input){   
    //concat a temporary 1 during the modulus to keep a beginning hex switch combination from messing us up   
    //very simple and as long as special characters (non a-z A-Z 0-9) are trapped it is fine   
    return '1'.concat(str_input) % 1 === 0;}

අවවාදයයි : මෙය ජාවාස්ක්‍රිප්ට් සහ ක්‍රියා පිටපතේ දීර් number කාලයක් තිස්සේ පැවති දෝෂයක් ගසාකෑමක් විය හැකිය [අංකය ("1" + the_string)% 1 === 0)], මට ඒ සඳහා කතා කළ නොහැක, නමුත් එය අපට අවශ්‍ය දේම වේ.

මගේ විසඳුම:

// returns true for positive ints; 
// no scientific notation, hexadecimals or floating point dots

var isPositiveInt = function(str) { 
   var result = true, chr;
   for (var i = 0, n = str.length; i < n; i++) {
       chr = str.charAt(i);
       if ((chr < "0" || chr > "9") && chr != ",") { //not digit or thousands separator
         result = false;
         break;
       };
       if (i == 0 && (chr == "0" || chr == ",")) {  //should not start with 0 or ,
         result = false;
         break;
       };
   };
   return result;
 };

ඔබට විශේෂ අවශ්‍යතාවන්ට සරිලන පරිදි ලූපය තුළ අමතර කොන්දේසි එකතු කළ හැකිය.

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

// @flow

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

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

sNumවලංගු සංඛ්‍යාත්මක අගයක් තිබේදැයි පරීක්ෂා කිරීමට මෙන්න එක් ලයිනර් ; එය විවිධාකාර යෙදවුම් සඳහා පරීක්ෂා කර ඇත:

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