ජාවාස්ක්‍රිප්ට් හි පූර්ණ සංඛ්‍යාවක් බවට නූලක් පරිවර්තනය කරන්නේ කෙසේද?

සරලම ක්‍රමය වනුයේ ස්වදේශීය Numberශ්‍රිතය භාවිතා කිරීමයි :

var x = Number("1000")

ඔබ හරියට වැඩ කරන්නේ නැත්නම්, පසුව ඇත parseInt , ඒකජ ප්ලස් , බිම සමග parseFloat , සහ Math.round ක්රම.

parseInt:

var x = parseInt("1000", 10); // you want to use radix 10
    // so you get a decimal number even with a leading 0 and an old browser ([IE8, Firefox 20, Chrome 22 and older][1])

unary plus ඔබේ නූල දැනටමත් නිඛිලයක ස්වරූපයෙන් තිබේ නම්:

var x = +"1000";

ඔබේ නූල පාවෙන හෝ විය හැකි නම් ඔබට පූර්ණ සංඛ්‍යාවක් අවශ්‍ය නම්:

var x = Math.floor("1000.01"); //floor automatically converts string to number

හෝ, ඔබ Math.floor කිහිප වතාවක් භාවිතා කිරීමට යන්නේ නම්:

var floor = Math.floor;
var x = floor("1000.01");

ඔබ parseInt අමතන විට රැඩික්ස් දැමීමට අමතක කරන වර්ගය ඔබ නම්, ඔබට parseFloat භාවිතා කර එය ඔබ කැමති ආකාරයට වට කර ගත හැකිය. මෙන්න මම බිම භාවිතා කරමි.

var floor = Math.floor;
var x = floor(parseFloat("1000.01"));

සිත්ගන්නා කරුණ නම්, Math.round (Math.floor වැනි) සංඛ්‍යා පරිවර්තනයට නූලක් කරනු ඇත, එබැවින් ඔබට අංකය වටකුරු කිරීමට අවශ්‍ය නම් (හෝ ඔබට නූල්වල පූර්ණ සංඛ්‍යාවක් තිබේ නම්), මෙය හොඳ ක්‍රමයක්, සමහර විට මගේ ප්‍රියතම:

var round = Math.round;
var x = round("1000"); //equivalent to round("1000",0)

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

var number = parseInt("10");

නමුත් ගැටලුවක් තිබේ. ඔබ parseInt ශ්‍රිතය භාවිතයෙන් "010" පරිවර්තනය කිරීමට උත්සාහ කරන්නේ නම්, එය අෂ්ටක අංකයක් ලෙස හඳුනාගෙන අංක 8 නැවත ලබා දෙනු ඇත. එබැවින් ඔබට රේඩික්ස් එකක් නියම කළ යුතුය (2 සිට 36 දක්වා). මෙම අවස්ථාවේ දී පදනම 10.

parseInt(string, radix)

උදාහරණයක්:

var result = parseInt("010", 10) == 10; // Returns true

var result = parseInt("010") == 10; // Returns false

parseIntවලංගු කිසිවක් විග්‍රහ කිරීමෙන් පසු නරක දත්ත නොසලකා හරින බව සලකන්න .
මෙම මාර්ගෝපදේශය 51 ලෙස විග්‍රහ කරනු ඇත:

var result = parseInt('51e3daf6-b521-446a-9f5b-a1bb4d8bac36', 10) == 51; // Returns true

ජාවාස්ක්‍රිප්ට් හි නූලක් අංකයක් බවට පරිවර්තනය කිරීමට ප්‍රධාන ක්‍රම දෙකක් තිබේ. එක් ක්‍රමයක් නම් එය විග්‍රහ කිරීම සහ අනෙක් ක්‍රමය එහි වර්ගය අංකයකට වෙනස් කිරීමයි. අනෙක් පිළිතුරු වල ඇති සියලුම උපක්‍රම (උදා: ඒකීය ප්ලස්), නූල් වර්ගය අංකයකට ව්‍යංගයෙන් බල කිරීම ඇතුළත් වේ. අංක ශ්‍රිතය සමඟ ඔබට එකම දේ පැහැදිලිවම කළ හැකිය.

විග්‍රහ කිරීම

var parsed = parseInt("97", 10);

parseInt සහ parseFloat යනු සංඛ්‍යා වලට නූල් විග්‍රහ කිරීම සඳහා භාවිතා කරන ශ්‍රිත දෙකකි. "92px" වැනි නූල් විග්‍රහ කිරීම සඳහා එය ප්‍රයෝජනවත් විය හැකි, එය හඳුනා නොගත් අක්ෂරයකට පහර දුන්නොත් එය විග්‍රහ කිරීම නිහ ly ව නතර වනු ඇත, නමුත් එය ද තරමක් භයානක ය, මන්ද එය නරක ආදානයේ කිසිදු ආකාරයක දෝෂයක් ඔබට ලබා නොදෙන හෙයිනි, ඒ වෙනුවට ඔබ නූල් අංකයකින් ආරම්භ නොවන්නේ නම් NaN නැවත ලබා ගනිමි. නූල් ආරම්භයේ ඇති හිස් අවකාශය නොසලකා හරිනු ලැබේ. මෙන්න එය ඔබට අවශ්‍ය දේට වඩා වෙනස් දෙයක් කිරීම පිළිබඳ උදාහරණයක් වන අතර කිසිවක් වැරදී ඇති බවට කිසිදු ඇඟවීමක් නොකරයි:

var widgetsSold = parseInt("97,800", 10); // widgetsSold is now 97

සෑම විටම දෙවන තර්කය ලෙස රේඩික්ස් නියම කිරීම හොඳ පුරුද්දකි. පැරණි බ්‍රව්සර් වලදී, නූල 0 කින් ආරම්භ වූයේ නම්, රැඩිකල් නිශ්චිතව දක්වා නොමැති නම් එය අෂ්ටකයක් ලෙස අර්ථ දැක්විය හැකි අතර එය බොහෝ දෙනෙකු පුදුමයට පත් කළේය. රේඩෙක්ස් නියම කර නොමැති නම්, හෙක්සැඩිසිමල් සඳහා වන හැසිරීම 0x සමඟ ආරම්භ කිරීමෙන් අවුලුවන 0xff. ප්‍රමිතිය ඇත්ත වශයෙන්ම ecmascript 5 සමඟ වෙනස් වී ඇත, එබැවින් නවීන බ්‍රව්සර් කිසිදු රේඩික්ස් නියම කර නොමැති නම් ප්‍රමුඛ 0 ඇති විට අෂ්ටක අවුලුවන්නේ නැත. parseInt 36 වන පාදම දක්වා වූ රේඩික්ස් තේරුම් ගනී, එම අවස්ථාවේ දී ඉහළ සහ පහළ අකුරු දෙකම සමාන ලෙස සලකනු ලැබේ.

නූල් වර්ගයක් අංකයකට වෙනස් කිරීම

ParseInt භාවිතා නොකරන ඉහත සඳහන් කළ අනෙක් සියලු උපක්‍රම, සංඛ්‍යා වලට ව්‍යංගයෙන් බල කිරීම ඇතුළත් වේ. මම මෙය පැහැදිලිව කිරීමට කැමතියි,

var cast = Number("97");

මෙය විග්‍රහ කිරීමේ ක්‍රමවලට වෙනස් හැසිරීම් ඇත (එය තවමත් සුදු අවකාශය නොසලකා හැරියද). එය වඩාත් දැඩි ය: එය නැවත පැමිණීමට වඩා මුළු නූලම තේරුම් නොගන්නේ NaNනම්, ඔබට එය වැනි නූල් සඳහා භාවිතා කළ නොහැක 97px. ඔබට සංඛ්‍යා එතීමේ වස්තුවකට වඩා ප්‍රාථමික අංකයක් අවශ්‍ය බැවින්, ඔබ newසංඛ්‍යා ශ්‍රිතය ඉදිරිපිට නොතබන බවට වග බලා ගන්න .

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

var rounded = Math.floor(Number("97.654"));  // other options are Math.ceil, Math.round
var fixed = Number("97.654").toFixed(0); // rounded rather than truncated
var bitwised = Number("97.654")|0;  // do not use for large numbers

ඕනෑම බිට්වේස් ක්‍රියාකරුවෙකු (මෙහි මම ටිකක් ක්‍රියා කර ඇත්තෙමි, නමුත් ඔබට පෙර පිළිතුරක හෝ බිට්ෂිෆ්ට් එකක මෙන් ද්විත්ව නිෂේධනයක් කළ හැකිය) අගය 32bit නිඛිලයක් බවට පරිවර්තනය කරනු ඇති අතර ඒවායින් බොහොමයක් අත්සන් කළ පූර්ණ සංඛ්‍යාවක් බවට පරිවර්තනය වේ. විශාල සංඛ්‍යා සඳහා ඔබට අවශ්‍ය නොවන බව සලකන්න . 32bit වලින් නිඛිලය නිරූපණය කළ නොහැකි නම්, එය ඔතා ඇත.

~~"3000000000.654" === -1294967296
// This is the same as
Number("3000000000.654")|0
"3000000000.654" >>> 0 === 3000000000 // unsigned right shift gives you an extra bit
"300000000000.654" >>> 0 === 3647256576 // but still fails with larger numbers

විශාල සංඛ්‍යා සමඟ නිවැරදිව වැඩ කිරීමට, ඔබ වටකුරු ක්‍රම භාවිතා කළ යුතුය

Math.floor("3000000000.654") === 3000000000
// This is the same as
Math.floor(Number("3000000000.654"))

Coeercion ඝාතීය අංකනය 'හා ඉන්ෆිනිටි අවබෝධ බව අප මතක තබාගත යුතුයි, ඒ නිසා 2e2ය 200අතර පේළියේ ක්රම නැහැ, ඒ වෙනුවට නන් වඩා.

චාරිත්රය

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

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

ParseInt () සහ + වෙනස් වේ

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

වේගවත්ම

var x = "1000"*1;

පරීක්ෂණය

මෙන්න වේගය හා සැසඳීම සුළුයි (මැක් ඕස් පමණි) ... :)

ක්‍රෝම් 'ප්ලස්' සහ 'මෝල්' වේගවත්ම (> 700,000,00 ඕප / තත්පර) සඳහා, 'Math.floor' මන්දගාමී වේ. ෆයර්ෆොක්ස් සඳහා 'ප්ලස්' මන්දගාමී වේ (!) 'මුල්' වේගවත් වේ (> තත්පර 900,000,000). සෆාරි හි 'parseInt' යනු නිරාහාරය, 'අංකය' මන්දගාමී වේ (නමුත් නැවත සකස් කිරීම් තරමක් සමාන වේ,> 13,000,000 <31,000,000). එබැවින් අනෙක් බ්‍රව්සර් වලට වඩා 10x ට වඩා මන්දගාමී වේ. ඉතින් ජයග්‍රාහකයා ‘ මුල් ’ :)

මෙම සබැඳිය මඟින් ඔබට එය ඔබගේ බ්‍රව්සරයේ ධාවනය කළ හැකිය https://jsperf.com/js-cast-str-to-number/1

යාවත්කාලීන කරන්න

මම ද පරීක්ෂා කරමි var x = ~~"1000";- ක්‍රෝම් සහ සෆාරි var x = "1000"*1(<1%) ට වඩා ටිකක් මන්දගාමී වේ , ෆයර්ෆොක්ස් මත ටිකක් වේගවත් වේ (<1%). මම ඉහත පින්තූරය යාවත්කාලීන කර පරීක්‍ෂා කරමි

පැරණි ප්‍රශ්නයක් වුවද සමහර විට මෙය යමෙකුට ප්‍රයෝජනවත් විය හැකිය.

මම මේ ආකාරයෙන් භාවිතා කරන්නේ නූල් int අංකයට පරිවර්තනය කිරීමයි

var str = "25";       // string
var number = str*1;   // number

එබැවින්, 1 න් ගුණ කරන විට, අගය වෙනස් නොවේ, නමුත් js ස්වයංක්‍රීයව අංකයක් ලබා දෙයි.

නමුත් එය පහත පෙන්වා ඇති පරිදි, මෙය සංඛ්‍යාවක් බව ඔබට විශ්වාස strනම් (හෝ අංකයක් ලෙස නිරූපණය කළ හැකිය) මෙය භාවිතා කළ යුතුය, එසේ නොවුවහොත් එය NaN නැවත ලබා දෙනු ඇත - අංකයක් නොවේ.

ඔබට භාවිතා කිරීමට සරල ශ්‍රිතයක් නිර්මාණය කළ හැකිය, උදා

function toNumber(str) {
   return str*1;
}

ParseInt උත්සාහ කරන්න.

var number = parseInt("10", 10); //number will have value of 10.

මම වැරදි පිළිතුර මෙහි පළ කළා, සමාවෙන්න. ස්ථාවරයි.

මෙය පැරණි ප්‍රශ්නයකි, නමුත් මම මෙම උපක්‍රමයට කැමතියි:

~~"2.123"; //2
~~"5"; //5

ද්විත්ව බිට්වයිස් negative ණ දශම ලක්ෂ්‍යයෙන් පසුව ඕනෑම දෙයක් අතහැර එය සංඛ්‍යා ආකෘතියකට පරිවර්තනය කරයි. ඇමතුම් කාර්යයන් සහ වොට්නොට් වලට වඩා එය තරමක් වේගවත් බව මට පවසා ඇත, නමුත් මට සම්පූර්ණයෙන්ම ඒත්තු ගැන්වී නැත.

සංස්කරණය: මම දැක්කා තවත් ක්රමයක් මෙහි (අ ශුන්ය-තෘප්තියට දකුණු පැත්තට වන ජාවාස්ක්රිප්ට් >>> ක්රියාකරු, ගැන ප්රශ්නයක්) මෙම ක්රියාකරු 0 විසින් අංකය මාරු කිරීමට සංඛ්යාව පරිවර්තනය කරන ලද දර්ශන uint32 නම් ඔබ ලස්සන වන එය අත්සන් නොකිරීමටද අවශ්‍යය . නැවතත්, මෙය අත්සන් නොකළ පූර්ණ සංඛ්‍යාවක් බවට පරිවර්තනය කරයි , ඔබ අත්සන් කළ අංකයක් භාවිතා කරන්නේ නම් එය අමුතු හැසිරීම් වලට තුඩු දිය හැකිය.

"-2.123" >>> 0; // 4294967294
"2.123" >>> 0; // 2
"-5" >>> 0; // 4294967291
"5" >>> 0; // 5

විද්‍යාත්මක අංකනයෙහි පාවීමක් පරිවර්තනය කිරීම සඳහා ඔබ parseInt භාවිතා කරන්නේ නම් පරිස්සම් වන්න! උදාහරණයක් වශයෙන්:

parseInt("5.6e-14") 

ප්‍රති in ලය වනු ඇත

5 

වෙනුවට

0

නූලක් පූර්ණ සංඛ්‍යාවක් බවට පරිවර්තනය කිරීම සඳහා, මම නිර්දේශ කරන්නේ parseFloat සහ NOT parseInt භාවිතා කිරීමයි. මෙන්න හේතුව:

ParseFloat භාවිතා කිරීම:

parseFloat('2.34cms')  //Output: 2.34
parseFloat('12.5')     //Output: 12.5
parseFloat('012.3')    //Output: 12.3

ParseInt භාවිතා කිරීම:

parseInt('2.34cms')  //Output: 2
parseInt('12.5')     //Output: 12
parseInt('012.3')    //Output: 12

එබැවින් ඔබ දැක තිබේ නම් parseInt දශමයෙන් පසු අගයන් බැහැර කරයි, නමුත් parseFloat ඔබට පාවෙන ලක්ෂ්‍ය සංඛ්‍යා සමඟ වැඩ කිරීමට ඉඩ සලසයි. එබැවින් ඔබට දශමයෙන් පසු අගයන් රඳවා ගැනීමට අවශ්‍ය නම් වඩාත් සුදුසු වේ. ඔබට පූර්ණ සංඛ්‍යා අගය අවශ්‍ය බව ඔබට විශ්වාස නම් පමණක් parseInt භාවිතා කරන්න.

පැති සටහනක් ලෙස: ඕනෑම දේශීය නූලක (හෝ පාවෙන (හෝ නිඛිල)) භාවිතා කරන ඉන්ට් () ට මූටූල්ස් ශ්‍රිතය ඇත.

"2".toInt()   // 2
"2px".toInt() // 2
2.toInt()     // 2

කරුණාකර පහත උදාහරණය බලන්න. එය ඔබගේ සැකය දුරු කිරීමට උපකාරී වේ

Example                  Result

parseInt("4")            4
parseInt("5aaa")         5
parseInt("4.33333")      4
parseInt("aaa");         NaN (means "Not a Number")

parseint ශ්‍රිතය භාවිතා කිරීමෙන් එය ලබා දෙන්නේ පූර්ණ සංඛ්‍යා වර්ගය මිස නූල් නොවේ

අපට භාවිතා +(stringOfNumber)කරනවා වෙනුවට භාවිතා කළ හැකියparseInt(stringOfNumber)

උදා: +("21")21 වැනි int නැවත ලබා දෙයි parseInt("21").

පාවෙන විග්‍රහ කිරීම සඳහා අපට මෙම ඒකීය "+" ක්‍රියාකරු භාවිතා කළ හැකිය ...

උත්සාහ කරන්න str - 0බවට පරිවර්තනය කිරීමට stringකිරීමට number.

> str = '0'
> str - 0
  0
> str = '123'
> str - 0
  123
> str = '-12'
> str - 0
  -12
> str = 'asdf'
> str - 0
  NaN
> str = '12.34'
> str - 0
  12.34

නූල් int බවට පරිවර්තනය කිරීම සඳහා ක්‍රම කිහිපයක ක්‍රියාකාරිත්වය සංසන්දනය කිරීම සඳහා සබැඳි දෙකක් මෙන්න

https://jsperf.com/number-vs-parseint-vs-plus

http://phrogz.net/js/string_to_number.html

ජාවාස්ක්‍රිප්ට් හි නූලක් සංඛ්‍යා අගයක් බවට පරිවර්තනය කිරීමට බොහෝ ක්‍රම තිබේ ... සියල්ලම සරල හා පහසුය, ඔබ වෙනුවෙන් වැඩ කරන ආකාරය තෝරන්න:

var num = Number("999.5"); //999.5
var num = parseInt("999.5", 10); //999
var num = parseFloat("999.5"); //999.5
var num = +"999.5"; //999.5

ඕනෑම ගණිත මෙහෙයුමක් ඒවා අංකයක් බවට පරිවර්තනය කරයි, උදාහරණයක් ලෙස ...

var num = "999.5" / 1; //999.5
var num = "999.5" * 1; //999.5
var num = "999.5" - 1 + 1; //999.5
var num = "999.5" - 0; //999.5
var num = Math.floor("999.5"); //999
var num = ~~"999.5"; //999

+ජාවාස්ක්‍රිප්ට් හි නූලක් අංකයක් බවට පරිවර්තනය කිරීමේ අලංකාර ක්‍රමය වන ලකුණ භාවිතා කිරීම මගේ වඩාත් කැමති ක්‍රමයයි .

ගූගල් මට මෙම පිළිතුර ලබා දුන්නේ ප්‍රති result ලයක් ලෙස ...

සී සහ ජාවාස්ක්‍රිප්ට් අතර බන්ධනයක් සඳහා මට පූර්ණ සංඛ්‍යාවක් ලෙස නූලක් "සුරැකීමට" අවශ්‍ය විය, එබැවින් මම නූල පූර්ණ සංඛ්‍යා අගයක් බවට පරිවර්තනය කරමි:

/*
    Examples:
        int2str( str2int("test") ) == "test" // true
        int2str( str2int("t€st") ) // "t¬st", because "€".charCodeAt(0) is 8364, will be AND'ed with 0xff
    Limitations:
        max 4 chars, so it fits into an integer
*/
function str2int(the_str) {
    var ret = 0;
    var len = the_str.length;
    if (len >= 1) ret += (the_str.charCodeAt(0) & 0xff) <<  0;
    if (len >= 2) ret += (the_str.charCodeAt(1) & 0xff) <<  8;
    if (len >= 3) ret += (the_str.charCodeAt(2) & 0xff) << 16;
    if (len >= 4) ret += (the_str.charCodeAt(3) & 0xff) << 24;
    return ret;
}
function int2str(the_int) {
    var tmp = [
        (the_int & 0x000000ff) >>  0,
        (the_int & 0x0000ff00) >>  8,
        (the_int & 0x00ff0000) >> 16,
        (the_int & 0xff000000) >> 24
    ];
    var ret = "";
    for (var i=0; i<4; i++) {
        if (tmp[i] == 0)
            break;
        ret += String.fromCharCode(tmp[i]);
    }
    return ret;
}

මගේ මතය අනුව, පාවෙන විග්‍රහ කිරීම දෝෂයක් විය යුතු බැවින් කිසිදු පිළිතුරක් සියලු අද්දර අවස්ථා ආවරණය නොකරයි.

function parseInteger(value) {
    if(value === '') return NaN;
    const number = Number(value);
    return Number.isInteger(number) ? number : NaN;
}

parseInteger("4")            // 4
parseInteger("5aaa")         // NaN
parseInteger("4.33333")      // NaN
parseInteger("aaa");         // NaN

මෙන්න පහසුම විසඳුම

let myNumber = "123" | 0;

වඩාත් පහසු විසඳුමක්

let myNumber = +"123";

ඉහත සියල්ල නිවැරදි ය. කරුණාකර මෙය යතුරු ලියනයක අංකයක් බව සහතික කර "typeot x === 'number'" වෙනත් නුවණින් එය NaN නැවත ලබා දෙනු ඇත.

 var num = "fsdfsdf242342";
 typeof num => 'string';

 var num1 = "12423";
 typeof num1 => 'number';
 +num1 = > 12423`

තවත් විකල්පයක් වන්නේ XOR අගය දෙගුණ කිරීම ය:

var i = 12.34;
console.log('i = ' + i);
console.log('i ⊕ i ⊕ i = ' + (i ^ i ^ i));

මෙය ප්‍රතිදානය කරනු ඇත:

i = 12.34
i ⊕ i ⊕ i = 12

මම නූල් වලට පෙර එක් ප්ලස් (+) පමණක් එකතු කළ අතර එය විසඳුමකි!

+"052254" //52254

එය උපකාරී වේ යැයි සිතමි;)

ඉලක්කම්වල ගුණනය ඒවායේ දහයේ බලය සමඟ සාරාංශ කිරීම:

එනම්: 123 = 100 + 20 + 3 = 1 * 100 + 2 + 10 + 3 * 1 = 1 * (10 ^ 2) + 2 * (10 ^ 1) + 3 * (10 ^ 0)

function atoi(array) {

// use exp as (length - i), other option would be to reverse the array.
// multiply a[i] * 10^(exp) and sum

let sum = 0;

for (let i = 0; i < array.length; i++) {
    let exp = array.length-(i+1);
    let value = array[i] * Math.pow(10,exp);
    sum+=value;
}

return sum;

}

function parseIntSmarter(str) {
    // ParseInt is bad because it returns 22 for "22thisendsintext"
    // Number() is returns NaN if it ends in non-numbers, but it returns 0 for empty or whitespace strings.
    return isNaN(Number(str)) ? NaN : parseInt(str, 10);
}

මම මෙය භාවිතා කරමි

String.prototype.toInt = function (returnval) { 
    var i = parseInt(this);
    return isNaN(i) ? returnval !== undefined ? returnval : - 1  :      i; 
}

මේ ආකාරයෙන් මම සෑම විටම නැවත ලබා ගන්නෙමි.

ඔබට වලංගු පූර්ණ සංඛ්‍යාවක් ලබා ගැනීම සහතික කිරීම සඳහා ආරක්ෂිතම ක්‍රමය:

let integer = (parseInt(value, 10) || 0);

උදාහරණ:

// Example 1 - Invalid value:
let value = null;
let integer = (parseInt(value, 10) || 0);
// => integer = 0

// Example 2 - Valid value:
let value = "1230.42";
let integer = (parseInt(value, 10) || 0);
// => integer = 1230

// Example 3 - Invalid value:
let value = () => { return 412 };
let integer = (parseInt(value, 10) || 0);
// => integer = 0

ඔබට ප්ලස් භාවිතා කළ හැකිය. උදාහරණයක් වශයෙන්:

var personAge = '24';
var personAge1 = (+personAge)

එවිට ඔබට typeof personAgeඅංකයක් දැකිය හැකිය