Js எண்ணாக மாற்றம். தரவை ஜாவாஸ்கிரிப்டாக மாற்றுகிறது. சரங்களை எண்களாக மாற்றுவதற்கான ஜாவாஸ்கிரிப்ட் முறைகள்

ஜாவாஸ்கிரிப்டில் ஒரு சரத்தை எண்ணாக மாற்ற இரண்டு முக்கிய வழிகள் உள்ளன. ஒரு வழி அதை அலசுவது, மற்றொரு வழி அதன் வகையை எண்ணாக மாற்றுவது. மற்ற பதில்களில் உள்ள அனைத்து நுணுக்கங்களும் (unary plus போன்றவை) சரத்தின் வகையை எண்ணுக்கு மறைமுகமாக கட்டாயப்படுத்துவதை உள்ளடக்கியது. எண் செயல்பாட்டைப் பயன்படுத்தியும் இதைச் செய்யலாம்.

தொடரியல்

Var பாகுபடுத்தப்பட்டது = parseInt("97", 10);

parseInt மற்றும் parseFloat ஆகியவை சரங்களை எண்களாக அலசுவதற்குப் பயன்படுத்தப்படும் இரண்டு செயல்பாடுகள். "92px" போன்ற சரங்களைப் பாகுபடுத்துவதற்குப் பயனுள்ளதாக இருக்கும், அது அடையாளம் காணாத ஒரு எழுத்தைத் தாக்கினால், பாகுபடுத்துதல் அமைதியாக நின்றுவிடும், ஆனால் உள்ளீடு மோசமாக இருந்தால் அது உங்களுக்கு எந்தப் பிழையையும் தராது என்பதால் இது ஓரளவு ஆபத்தானது, மாறாக நீங்கள் " சரம் ஒரு எண்ணுடன் தொடங்கவில்லை என்றால் NaN ஐ வழங்கும். சரத்தின் தொடக்கத்தில் ஒரு இடைவெளி புறக்கணிக்கப்படுகிறது. இது உங்களுக்குத் தேவையானதை வித்தியாசமாகச் செய்கிறது என்பதற்கான எடுத்துக்காட்டு இங்கே உள்ளது, மேலும் எதுவும் தவறாக நடந்ததைக் குறிக்காது:

வார் விட்ஜெட்ஸ்Sold = parseInt("97,800", 10); // விட்ஜெட்டுகள் விற்கப்பட்டது இப்போது 97 ஆக உள்ளது

அதை எப்போதும் இரண்டாவது வாதமாக குறிப்பிடுவது நல்ல நடைமுறை. பழைய உலாவிகளில், ஒரு சரம் 0 இல் தொடங்கினால், ஒரு ரேடிக்ஸ் மதிப்பு குறிப்பிடப்படாவிட்டால், அது ஆக்டல் என்று விளக்கப்படும், இது பலரை ஆச்சரியத்தில் ஆழ்த்தியது. ரேடிக்ஸ் மதிப்பு குறிப்பிடப்படாவிட்டால் சரம் 0x இல் தொடங்கினால் ஹெக்ஸாடெசிமல் தூண்டுதலுக்கான நடத்தை தூண்டப்படும். 0xff தரநிலை உண்மையில் எக்மாஸ்கிரிப்ட் 5 உடன் மாறியது, எனவே நவீன உலாவிகளில் ரேடிக்ஸ் மதிப்பு குறிப்பிடப்பட்டாலன்றி முன்னணி 0 குறிப்பிடப்பட்டால் ஆக்டல்களை இயக்காது. parseInt அடிப்படை 36 வரையிலான ரேடிக்கல்களைப் புரிந்துகொள்கிறது, இதில் பெரிய மற்றும் சிறிய எழுத்துக்கள் இரண்டும் சமமானதாகக் கருதப்படுகின்றன.

சரம் வகையை எண்ணாக மாற்றுதல்

parseInt ஐப் பயன்படுத்தாத மேலே குறிப்பிடப்பட்டுள்ள மற்ற அனைத்து தந்திரங்களும் சரத்தை ஒரு எண்ணுக்கு மறைமுகமாக கட்டாயப்படுத்துவதை உள்ளடக்கியது. நான் அதை வெளிப்படையாக செய்ய விரும்புகிறேன்

வார் நடிகர்கள் = எண்("97");

இது பாகுபடுத்தும் முறைகளிலிருந்து வேறுபட்டது (இருப்பினும் இது இடைவெளிகளை புறக்கணிக்கிறது). இது மிகவும் கண்டிப்பானது: அது NaN ஐ விட முழு சரத்தையும் புரிந்து கொள்ளவில்லை என்றால், 97px போன்ற சரங்களுக்கு நீங்கள் அதைப் பயன்படுத்த முடியாது. உங்களுக்கு ஒரு பழமையான எண் தேவை மற்றும் எண் ரேப்பர் பொருள் அல்ல என்பதால், எண் செயல்பாட்டிற்கு முன் புதியதை வைக்க வேண்டாம்.

வெளிப்படையாக, ஒரு எண்ணாக மாற்றுவது ஒரு முழு எண்ணை விட மிதவையாக இருக்கும் மதிப்பை வழங்குகிறது, எனவே நீங்கள் ஒரு முழு எண்ணை விரும்பினால் அதை மாற்ற வேண்டும். இதைச் செய்ய பல வழிகள் உள்ளன:

வர் வட்டமானது = Math.floor(எண்("97.654")); // மற்ற விருப்பங்கள் Math.ceil, Math.round var fixed = Number("97.654").toFixed(0); // வட்டமானது துண்டிக்கப்பட்ட var bitwised = எண்("97.654")|0; //பெரிய எண்களுக்குப் பயன்படுத்த வேண்டாம்

எந்த பிட்வைஸ் ஆபரேட்டரும் (இங்கே நான் பிட்வைஸ் அல்லது, ஆனால் முந்தைய பதில் அல்லது பிட்ஷிப்டில் நீங்கள் இரட்டை மறுப்பைச் செய்யலாம்) மதிப்பை 32-பிட் முழு எண்ணாக மாற்றும், மேலும் பெரும்பாலானவை கையொப்பமிடப்பட்ட முழு எண்ணாக மாற்றும். பெரிய முழு எண்களுக்கு இது தேவையில்லை என்பதை நினைவில் கொள்ளவும். ஒரு முழு எண்ணை 32 பிட்களில் குறிப்பிட முடியாவிட்டால், அது நிறுத்தப்படும்.

~~"3000000000.654" === -1294967296 // இது எண்ணைப் போலவே உள்ளது("3000000000.654")|0 "3000000000.654" >>> 0 === 30000000 பிட் 0 கூடுதல் 654"> >> 0 === 3647256576 // ஆனால் இன்னும் பெரிய எண்களில் தோல்வியடைகிறது

பெரிய எண்களுடன் சரியாக வேலை செய்ய, நீங்கள் ரவுண்டிங் நுட்பங்களைப் பயன்படுத்த வேண்டும்

Math.floor("3000000000.654") === 3000000000 // இது Math.floor("3000000000.654"))

இந்த முறைகள் அனைத்தும் அதிவேகக் குறியீட்டைப் புரிந்துகொள்கின்றன என்பதை நினைவில் கொள்ளுங்கள், எனவே 2e2 என்பது 200 மற்றும் NaN அல்ல. மேலும், எண் "இன்ஃபினிட்டியை" புரிந்து கொள்ளும் அதே வேளையில் பாகுபடுத்தும் முறைகள் புரியவில்லை.

தனிப்பயன்

இந்த முறைகள் எதுவும் நீங்கள் விரும்பியதைச் சரியாகச் செய்கின்றன என்பது உண்மையல்ல. எடுத்துக்காட்டாக, பாகுபடுத்துதல் தோல்வியடையும் போது ஏற்படும் பிழையை நான் பொதுவாக விரும்புகிறேன், மேலும் எனக்கு முடிவிலி ஆதரவு, அடுக்குகள் அல்லது முன்னணி இடைவெளிகள் தேவையில்லை. உங்கள் பயன்பாட்டைப் பொறுத்து, சில நேரங்களில் தனிப்பயன் மாற்று செயல்பாட்டை எழுதுவது அர்த்தமுள்ளதாக இருக்கும்.

எண்ணின் வெளியீடு அல்லது பாகுபடுத்தும் முறைகளில் ஒன்று நீங்கள் எதிர்பார்க்கும் எண்ணாக உள்ளதா என்பதை எப்போதும் சரிபார்க்கவும். எண் NaN அல்ல என்பதை உறுதிப்படுத்த, நீங்கள் நிச்சயமாக isNaN ஐப் பயன்படுத்த விரும்புவீர்கள் (பொதுவாக பாகுபடுத்துதல் தோல்வியடைந்தது என்பதை அறிய ஒரே வழி).

ஜாவாஸ்கிரிப்ட் பல உள்ளமைக்கப்பட்ட தரவு வகைகளை வழங்குகிறது. இவை தவிர, இந்த கட்டுரை jQuery இல் உள்ள மெய்நிகர் வகைகளான தேர்வாளர்கள், நிகழ்வுகள் போன்ற நீட்டிக்கப்பட்ட போலி வகைகள் மற்றும் அனைத்து வகையான செயல்பாடுகளையும் உள்ளடக்கியது.

கீழே உள்ள பெரும்பாலான எடுத்துக்காட்டுகளை நீங்கள் முயற்சித்தால் சிறந்தது. பயர்பாக்ஸ் உலாவி நீட்டிப்பான ஃபயர்பக் கன்சோலில் இந்த எடுத்துக்காட்டுகளை நகலெடுப்பதன் மூலம் இதை எளிதாகச் செய்யலாம்.

எடுத்துக்காட்டுகள் பூலியன் சூழலில் (ஒப்பீடுகள் போன்றவை) செயல்பாடுகளைச் செய்யும்போதெல்லாம், ஒவ்வொரு தரவு வகையும் அந்தச் சூழலில் எவ்வாறு செயல்படுகிறது என்பதை அறிவது முக்கியம்:

Var x = "" என்றால் (x) console.log("x defaulted to true") else console.log("x defaulted to false")

இந்த வழக்கில், "x equals false" அச்சிடப்படும்.

எடுத்துக்காட்டுகளின் நீளத்தைக் குறைக்க, பூலியன் சூழலைக் காட்ட மறுப்பு ஆபரேட்டர் பயன்படுத்தப்படுகிறது:

X// உண்மை

jQuery தரவு வகைகள்

சரங்கள்

• சரங்களுக்கான உள்ளமைக்கப்பட்ட முறைகள்
• நீளம் சொத்து
• பூலியன் சூழல்

எண்கள்

• பூலியன் சூழல்
• பாகுபடுத்தும் எண்கள்
• சரங்களுக்கு எண்கள்
• NaN மற்றும் முடிவிலி
• முழு
• மிதவை

பூலியன் வகை

பொருள்கள்

• புள்ளி குறிப்பு
• வரிசை குறிப்பு
• மறு செய்கை
• பூலியன் இயல்புநிலை
• முன்மாதிரி

விருப்பங்கள்

அணிவரிசைகள்

• மறு செய்கை
• பூலியன் இயல்புநிலை
• வரிசை குறிப்பு

செயல்பாடுகள்

• வாதங்கள்
• சூழல், அழைப்பு மற்றும் விண்ணப்பிக்கவும்
• காணக்கூடிய பகுதி
• மூடல்கள்
• ப்ராக்ஸி பேட்டர்ன்

திரும்ப திரும்ப செயல்பாடுகள்

தேர்வாளர்கள்

நிகழ்வுகள்

கூறுகள்

jQuery வகை

XMLHttpRequest வகை

"இது ஒரு ஜாவாஸ்கிரிப்ட் சரம்!" "இதுவும் ஒரு வரி!"

ஜாவாஸ்கிரிப்டில் உள்ள சரம் என்பது பூஜ்ஜியம், ஒன்று அல்லது அதற்கு மேற்பட்ட எழுத்துக்களைக் கொண்ட ஒரு மாறாத பொருளாகும்.

சரங்களின் வகை "சரம்". இது போன்ற ஒரு சரத்தின் வகையை நீங்கள் கண்டுபிடிக்கலாம்:

"சில சரம்" வகை; // "லேசான கயிறு"

வரிகளில் மேற்கோள்களைப் பயன்படுத்துதல்

ஒற்றை அல்லது இரட்டை மேற்கோள்களைப் பயன்படுத்தி ஒரு சரத்தை வரையறுக்கலாம். இரட்டை மேற்கோள்கள் மற்றும் நேர்மாறாக இணைக்கப்பட்ட ஒரு சரத்திற்குள் ஒற்றை மேற்கோள்களைப் பயன்படுத்த நீங்கள் சுதந்திரமாக இருக்கிறீர்கள். இரட்டை மேற்கோள் வரிகளுக்குள் இரட்டை மேற்கோள்களைப் பயன்படுத்த, பின்சாய்வுக்கோடுடன் \ . இது ஒற்றை மேற்கோள்களுக்கும் பொருந்தும்.

"நீங்கள் என்னை வருத்தப்படுத்துகிறீர்கள்." "பரிசுத்த "கிராங்கிங்" மோசஸ்!" " வீடு" "வீடு"

சரங்களுக்கான உள்ளமைக்கப்பட்ட முறைகள்

ஜாவாஸ்கிரிப்ட் சரங்களை கையாளுவதற்கு பல உள்ளமைக்கப்பட்ட முறைகளைக் கொண்டுள்ளது, இதன் விளைவாக ஒரு சரம் அல்லது எடுத்துக்காட்டாக, ஒரு வரிசை:

"hello".charAt(0) // "h" - "hello".toUpperCase() // "HELLO" - சரத்தை "Hello".toLowerCase() / பெரிய எழுத்தாக மாற்றும். / "ஹலோ" - ஒரு சரத்தை சிற்றெழுத்து "ஹலோ" ஆக மாற்றுகிறது.replace(/e|o/g, "x") // "hxllx" - "1,2" என்ற வழக்கமான வெளிப்பாடு வடிவத்தைப் பயன்படுத்தி ஒரு சரத்தின் ஒரு பகுதியை துணைச்சரத்துடன் மாற்றுதல் ,3".பிளவு(", ") // ["1", "2", "3"] - ஒரு சரத்தை ஒரு குறிப்பிட்ட சப்ஸ்ட்ரிங் மூலம் வரிசையாகப் பிரித்தல்

நீளம் சொத்து

சரங்கள் சரத்தின் நீளத்தைக் குறிப்பிடும் நீளப் பண்புகளைக் கொண்டுள்ளன.

"ஹலோ".நீளம் // 5 "".நீளம் // 0

பூலியன் சூழல்

ஒரு வெற்று சரம் தவறானதை மதிப்பிடுகிறது:

!"" // உண்மை ! "ஹலோ" // பொய் ! "உண்மை" // பொய் !புதிய பூலியன்(தவறு) // பொய்

எண்கள் 12 3.543

ஜாவாஸ்கிரிப்டில் உள்ள எண்கள் IEEE 754 தரநிலையின்படி 64-பிட் இரட்டை துல்லியமான வடிவத்தில் உள்ளன. அவையும் மாறாதவை. எண்களுடன் பணிபுரிய, அனைத்து ஆபரேட்டர்களும் கிடைக்கும், C மொழியில் உள்ளதைப் போலவே (+, -, *, /, %, =, +=, -=, *=, /=, ++, --).

எண்களுக்கான வகை "எண்". இது போன்ற எண்களின் வகையை நீங்கள் சரிபார்க்கலாம்:

வகை 12 // "எண்" வகை 3.543 // "எண்"

பூலியன் சூழல்

எண் பூஜ்ஜியமாக இருந்தால், அது தவறுக்கு சமம்:

0 // உண்மை !1 // பொய் !-1 // பொய்

எண்கள் இரட்டை துல்லிய வடிவத்தில் செயல்படுத்தப்படுவதால், பின்வரும் எடுத்துக்காட்டின் வெளியீடு தவறாக இல்லை:

0.1 + 0.2 // 0.30000000000000004

கணித பொருள்

ஜாவாஸ்கிரிப்ட் ஒரு கணிதப் பொருளில் எண்களுடன் வேலை செய்வதற்கான செயல்பாடுகளை வழங்குகிறது:

Math.PI // 3.141592653589793 Math.cos(Math.PI) // -1

எண்களாக மாற்றவும்

parseInt மற்றும் parseFloat செயல்பாடுகள் சரங்களை எண்களாக மாற்றுகின்றன. எண் அமைப்பு குறிப்பிடப்படாவிட்டால், இரண்டு செயல்பாடுகளும் மறைமுகமான மாற்றத்தைச் செய்கின்றன:

ParseInt("123") = 123 (மறைமுக தசம மாற்றம்) parseInt("010") = 8 (மறைமுக எண்மாற்றம்) parseInt("0xCAFE") = 51966 (மறைமுக ஹெக்ஸ் மாற்றம்) parseInt, "010)" ரேடிக்ஸ் 10 உடன் வெளிப்படையான தசம மாற்றம்) parseInt("11", 2) = 3 (வெளிப்படையான பைனரி மாற்றம்) parseFloat("10.10") = 10.1

எண்களை சரங்களாக மாற்றுகிறது

"+" செயல்பாட்டைப் பயன்படுத்தி ஒரு சரத்தில் எண்களைச் சேர்த்தால், முடிவு எப்போதும் ஒரு சரமாகவே இருக்கும். ஒரு சரத்தில் எண்ணைச் சேர்ப்பதற்கு முன் கணக்கீடுகளைச் செய்ய, கணக்கீடுகளை அடைப்புக்குறிக்குள் இணைக்கவும்:

"" + 1 + 2; // "12" "" + (1 + 2); // "3" "" + 0.0000001; // "1e-7" parseInt(0.0000001); //1 (குறிப்பு!)

நீங்கள் JavaScript ஸ்ட்ரிங் வகுப்பையும் பயன்படுத்தலாம், இது அனுப்பப்பட்ட மதிப்பை சரமாக மாற்றுகிறது:

சரம்(1) + சரம்(2); // "12" சரம்(1 + 2); // "3"

NaN மற்றும் முடிவிலி வகைகள்

எண்கள் அல்லாத மதிப்புகளை மாற்றுவது NaN இல் விளைகிறது. isNaN செயல்பாடு அதற்கு அனுப்பப்பட்ட மதிப்பு NaN க்கு சமமாக உள்ளதா என்பதை தீர்மானிக்கிறது:

ParseInt("ஹலோ", 10) // NaN isNaN(parseInt("hello", 10)) // true

பூஜ்ஜியத்தால் வகுத்தால் முடிவிலி கிடைக்கும்:

1 / 0 // முடிவிலி

NaN மற்றும் Infinity மதிப்பு இரண்டும் "எண்" வகையைச் சேர்ந்தவை:

NaN வகை // "எண்" வகை முடிவிலி // "எண்"

NaN மதிப்புகளின் ஒப்பீடு தரமற்ற முறையில் நிகழ்கிறது என்பதை நினைவில் கொள்ளவும்:

NaN == NaN // பொய் (!)

முடிவிலி == முடிவிலி // உண்மை

முழு எண் வகை

முழு எண் என்பது ஒரு முழு எண் வகை.

மிதவை வகை

ஃப்ளோட் என்பது மிதக்கும் புள்ளி எண் வகை.

பூலியன் வகை

ஜாவாஸ்கிரிப்டில் உள்ள பூலியன் வகை உண்மையாகவோ அல்லது தவறாகவோ இருக்கலாம்:

(உண்மை) console.log ("எப்போதும்!") என்றால் (தவறான) console.log("ஒருபோதும்!")

எடுத்துக்காட்டாக, jQuery செருகுநிரல்களை இணைக்கும்போது அமைப்புகளை அமைக்கும் போது ஒரு பூலியன் வகை இதுபோல் தெரிகிறது:

$("...").somePlugin(( hideOnStartup: true, onlyOnce: false ));

பொருள்கள்

ஜாவாஸ்கிரிப்டில் உள்ள அனைத்தும் ஒரு பொருள். ஒரு பொருளை உருவாக்க எளிதான வழி:

Var x = (); var y = (பெயர்: "பீட்", வயது: 15 );

பொருள்களின் வகை "பொருள்":

வகை() // "பொருள்"

பொருள் பண்புகள்

புள்ளி குறியீட்டைப் பயன்படுத்தி ஒரு பொருளின் பண்புகளை மாற்றலாம் மற்றும் பெறலாம்:

Y.பெயர் // "பீட்" y.age // 15 x.name = y.name + " Pan" // "Pete Pan" x.age = y.age + 1 // 16

நீங்கள் பொருளை வரிசையாகவும் பயன்படுத்தலாம்:

Var செயல்பாடுகள் = (அதிகரிப்பு: "++", குறைப்பு: "--" ) var செயல்பாடு = "அதிகரிப்பு"; செயல்பாடுகள் // "++"; செயல்பாடுகள் ["பெருக்கி"] = "*"; // "*"

பொருள்களில் மறு செய்கைகள்

ஃபார்-இன் லூப் ஆபரேட்டரைப் பயன்படுத்தி, பொருள்களின் மேல் திரும்பச் செய்வது மிகவும் எளிதானது:

Var obj = (பெயர்: "பீட்", வயது: 15 ); for(obj இன் விசை) ( எச்சரிக்கை ("விசை "++", மதிப்பு "+obj); )

jQuery ஒரு செயல்பாட்டை வழங்குகிறது

பொருள் பண்புகள் அல்லது வரிசை கூறுகள் மீது மீண்டும் மீண்டும் செய்ய:

JQuery.each(obj, செயல்பாடு(விசை, மதிப்பு) (console.log("விசை", விசை, "மதிப்பு", மதிப்பு); ));

பூலியன் சூழல்

ஒரு பொருள், அது பண்புகளைக் கொண்டிருந்தாலும் இல்லாவிட்டாலும், எப்போதும் உண்மையே:

!() // பொய்

முன்மாதிரிகள்

அனைத்து பொருட்களுக்கும் ஒரு முன்மாதிரி பண்பு உள்ளது. மொழிபெயர்ப்பாளர் ஒரு பொருளின் மீது சொத்தை தேடும் போதெல்லாம், அது அதன் முன்மாதிரியையும் சரிபார்க்கிறது. jQuery இல், jQuery பொருள்களின் நிகழ்வுகளில் முறைகளைச் சேர்க்க இந்த வழிமுறை பரவலாகப் பயன்படுத்தப்படுகிறது.

Var வடிவம் = $("#myform"); form.clearForm; // undefined form.fn.clearForm = செயல்பாடு() ( this.find(":input")each(function() ( this.value = ""; ))end(); ); form.clearForm() // jQuery ஆப்ஜெக்ட்களின் அனைத்து நிகழ்வுகளுக்கும் பயன்படுத்தப்படலாம், ஏனெனில் முன்மாதிரியில் ஒரு புதிய முறை சேர்க்கப்பட்டது

வெளிப்பாட்டில் எந்த வகையான மாறி பயன்படுத்தப்படுகிறது என்பதில் எந்த வித்தியாசமும் இல்லை. வெளிப்பாடு கணிதமாக இருந்தால், அதன் அனைத்து மாறிகளும் தானாகவே எண்களாக விளக்கப்படும். சரங்கள் செயலாக்கப்பட்டால், வெளிப்பாட்டின் அனைத்து "பங்கேற்பாளர்களும்" சரங்களாகக் கருதப்படுவார்கள். இருப்பினும், ஜாவாஸ்கிரிப்டில் ஸ்டிரிங்-டு-எண் மாற்றத்தின் சவால் மிகவும் பரந்த சூழலில் உள்ளது.

சரங்களை எண்களாக மாற்றுவதற்கான ஜாவாஸ்கிரிப்ட் முறைகள்

சரங்களை எண்களாக மாற்றுவதற்கான முறைகளின் ஆயுதக் களஞ்சியம் பெரியதாக இல்லை, ஆனால் எல்லா எளிய நிகழ்வுகளிலும் இது போதுமானது. இங்கே ஜாவாஸ்கிரிப்ட் (குறிப்பாக ஆரம்பநிலைக்கு) என்பது நடைமுறை எடுத்துக்காட்டுகளைப் பயன்படுத்தி எளிமையானது முதல் சிக்கலானது.

உதாரணம் நான்கு வெவ்வேறு சரங்களை விவரிக்கிறது. வெளியீட்டின் முதல் தொகுதியில், வகை செயல்பாடு ஒவ்வொரு மாறியின் வகையையும் சரம் என வரையறுக்கிறது. ஒவ்வொரு சரமும் மிகவும் எளிமையாக எண்ணாக மாற்றப்படுகிறது. இரண்டாவது வெளியீட்டுத் தொகுதியில், மாற்றத்திற்குப் பிறகு மாறிகளில் ஏற்படும் மாற்றங்கள் தெரியும்; அவற்றின் வகை எண்ணாக மாறிவிட்டது. ஜாவாஸ்கிரிப்ட் parseFloat மாற்ற உதாரணம் குறிப்பாக விளக்கமாக உள்ளது: அது "12e+3" மற்றும் "12000" ஆனது.

ஒரு சரத்தை எண்ணாக மாற்றும்போது ஏற்படும் மாற்றங்கள் குறிப்பிடத்தக்கதாக இருக்கும்! ஆனால் முதல் எழுத்துக்கள் மட்டுமே முக்கியம்: அவை எண்களாக இருக்க வேண்டும். இலக்க எழுத்துக்கள் இல்லை என்றால், முடிவு NaN ஆக இருக்கும்.

ஒரு எண்ணாக "ஆகும்" சரத்தின் தலைகீழ் மாற்றம் எப்போதும் ஒரே சரமாக இருக்காது. எண் தகவல்களை உள்ளிடுவதன் சரியான தன்மையை சரிபார்க்க இந்த புள்ளி பயன்படுத்தப்படலாம்.

பொதுவான மாற்று முறைகள்

முறையே முழு எண்கள் உள்ளன மற்றும் பின்ன எண்கள் உள்ளன, ஜாவாஸ்கிரிப்ட் ஒரு சரத்தை எண்ணாக மாற்றுகிறது:

• parseInt;
• பாகுபடுத்து.

ஒரு எளிய கணித வெளிப்பாட்டில் சரத்தைப் பயன்படுத்துவதன் மூலம் பொது வழக்கு செயல்படுத்தப்படுகிறது.

எழுத்துக்களின் சரத்திற்கு முன்னால் “+” அடையாளத்தை வைத்தால் போதும், அதில் எண் இருந்தால், வெளிப்பாட்டின் விளைவாக எண்ணாக இருக்கும். மாறியின் மதிப்பு மாறலாம், ஆனால் வகை எப்போதும் மாறும்: வகை எண்ணைக் காட்டும், சரம் அல்ல. ஒரு சரம் வெளிப்பாட்டில் மாற்றப்பட்ட மாறியைப் பயன்படுத்துவது முற்றிலும் மாறுபட்ட முடிவை உருவாக்கக்கூடும் என்பதைப் புரிந்துகொள்வது அவசியம்.

இந்த சூழலில் ஆரம்பநிலைக்கான ஜாவாஸ்கிரிப்ட் மிகவும் எளிமையானது. pasrseInt முறையைப் பயன்படுத்தி முழு எண் மாற்றத்தின் செயல்பாட்டைப் புரிந்துகொள்வது மிகவும் கடினம், ஏனெனில் இது தானாகவே தசம எண் அமைப்பில் வேலை செய்கிறது, ஆனால் சரத்தை எண் அல்லது ஹெக்ஸாடெசிமல் என்று விளக்கலாம். இருப்பினும், இந்த சூழ்நிலை எப்போதும் இரண்டாவது அளவுருவைப் பொறுத்தது அல்ல, இது எண் அமைப்பைக் குறிக்கிறது.

ஜாவாஸ்கிரிப்ட் எப்பொழுதும் ஒரு சரத்தை எண்ணாக மாற்றும், ஆனால் வரியின் தொடக்கத்தில் சரத்தில் ஒரு டிஜிட்டல் எழுத்து இல்லை என்றால், அதன் விளைவாக NaN ஆக இருக்கும்.

எண் அமைப்புகள், ஹெக்ஸாடெசிமல் (எண் "0x" உடன் தொடங்குகிறது) மற்றும் எண்ம எண்கள் (எண் "0" இல் தொடங்குகிறது) ஆகியவற்றை எவ்வாறு எழுதுவது என்பது பற்றிய புரிதல் அவசியம்.

ஜாவாஸ்கிரிப்ட் parseFloat முறையின் நுணுக்கங்களைப் புரிந்து கொள்ள, ஒரு உண்மையான எண்ணுக்கான கணிதக் குறியீடு என்ன என்பதைப் பற்றிய யோசனை இருந்தால் போதும்.

வரிசையாக்க நோக்கங்களுக்கான மாற்றம்

ஜாவாஸ்கிரிப்ட் ஒரு உலாவி மொழியாகும், அதனால்தான் லத்தீன் எழுத்துக்கள் மற்றும் எண்களின் அடிப்படை தொகுப்பிற்கு வெளியே உள்ள எழுத்துக்களுக்கு மற்ற மொழிகளை விட இது மிகவும் முக்கியமானது. வரிசையாக்கம் ஒரு பிரபலமான செயல்பாடு. ஆனால் வரிசையாக்க நோக்கங்களுக்காக சேவையகத்திற்கு தரவை அனுப்புவது எப்போதும் அர்த்தமுள்ளதாக இருக்காது; உலாவியில் உள்நாட்டில் வேலையைச் செய்வது எளிதானது மற்றும் நடைமுறையானது.

இந்தச் சிக்கலைத் தீர்க்க, ஒரு சரத்தின் எழுத்துக்களை அவற்றின் எண் குறியீடுகளாக மாற்றலாம் அல்லது எண்களின் வரிசையை எழுத்துகள் மற்றும் எண்களுக்கு ஒதுக்கலாம். ஒரு சரத்தில் பயன்படுத்தப்படும் charCodeAt() முறையானது iB என்ற மாறிக்கு எண் மதிப்பு 98ஐ ஒதுக்கும், அதாவது "b" என்ற எழுத்தின் குறியீடு. "a" என்ற எழுத்தின் குறியீட்டு மதிப்பு 97 என்பதைக் கருத்தில் கொண்டு, லத்தீன் எழுத்துக்களின் அனைத்து எழுத்துக்களின் எண்களையும் சிறிய மற்றும் பெரிய எழுத்துக்களில் ஏறுவரிசையில் பெறலாம். இதேபோல் ரஷ்ய எழுத்துக்களின் எழுத்துக்களுக்கும்.

எண்கள் மூலம் வரிசைப்படுத்துவதற்கான எங்கள் சொந்த பதிப்பு, தேவையான எழுத்துக்களை உருவாக்க உங்களை அனுமதிக்கிறது. எடுத்துக்காட்டாக, நீங்கள் சிரிலிக் மற்றும் லத்தீன் எழுத்துக்களை "மறுசீரமைக்கலாம்" அல்லது எழுத்துப்பிழையில் தனித்தனியாக இருக்கும் எழுத்துக்களை மட்டும் விட்டுவிட்டு அவற்றை கலக்கலாம் அல்லது செட்களில் டேப் மற்றும் ஸ்பேஸ் எழுத்துக்களைச் சேர்க்கலாம்.

தனித்துவமான சரம் எண்ணின் உருவாக்கம்

"a" என்ற எழுத்தின் குறியீடு 97 ஆக இருந்தால், எழுத்துக்கும் 97 என்ற எண்ணுக்கும் உள்ள வித்தியாசம், எழுத்துக்களில் உள்ள எழுத்தின் தனிப்பட்ட எண்ணைக் கொடுக்கும். ஒரு சரத்தின் ஒவ்வொரு எழுத்துக்கும் தனித்த எண்களைக் கூட்டினால், அந்த சரத்தின் தனிப்பட்ட எண்ணைப் பெறுவது கடினம்.

ஒரு சரத்தில் ஒவ்வொரு எழுத்து நிலைக்கும் எடையை ஒதுக்கினால், எடுத்துக்காட்டாக, நிலை:

• 0 எடை 1;
• 1 எடை 10;
• 2 எடை 100;

சரத்தில் உள்ள ஒவ்வொரு எழுத்தின் தனிப்பட்ட எண்ணையும் அது காணப்படும் நிலையின் எடையால் பெருக்கி, அனைத்து எண்களையும் தொகுத்து, நீங்கள் ஒரு தனித்துவமான எண்ணைப் பெறலாம் மற்றும் அதை அசல் ஒன்றிற்கு ஒன்று கடிதமாகப் பயன்படுத்தலாம். லேசான கயிறு.

இந்த சரத்தை எண்ணாக மாற்றுவது மீளக்கூடியது, அதாவது, எண்ணிலிருந்து அசல் சரத்தை நீங்கள் எப்போதும் பெறலாம். குறியாக்கம், சிரிலிக் மற்றும் தளப் பக்கத்தின் பிற உள்ளூர் அம்சங்கள், விண்ணப்பப் பகுதி மற்றும் பார்வையாளரின் நாடு ஆகியவற்றின் பின்னணியில் எந்தவொரு செயலையும் ஒரு எண்ணைக் கொண்டு பாதுகாப்பாகச் செய்ய முடியும் என்பதால், அத்தகைய மாற்றம் நன்மை பயக்கும்.

"வளரும்" தளப் பக்கத் தேர்வாளர்கள்

வலைத்தள பக்கங்களில் தேர்வாளர்களை உருவாக்கும் பணி பெரும்பாலும் எழுகிறது, அவற்றின் மதிப்புகளை முன்கூட்டியே குறிப்பிட முடியாது, ஆனால் காலப்போக்கில் அவை கூடுதலாக வழங்கப்படுகின்றன. முதல் பயன்பாட்டில், முதல் பார்வையாளருக்கு தகவலை உள்ளிட ஒரு வெற்று தேர்வாளர் கிடைக்கிறது.

தேர்வாளரில் (எந்தவொரு பார்வையாளராலும்) தகவலின் ஒவ்வொரு புதிய உள்ளீடும் எண்ணாக மாற்றப்படுகிறது, இது அசல் உடன், சேமிப்பகத்திற்காக சேவையகத்திற்கு அனுப்பப்படும். புதிய அமர்வு தொடங்கும் போது அல்லது புதிய பார்வையாளர் வரும்போது, ​​தேர்வாளர் காலியாக இருக்காது. பக்கம் ஏற்றப்பட்டதும், அது காலியாக இல்லாத தேர்வியுடன் உலாவிக்கு வரும்.

ஒவ்வொரு புதிய தேர்வி மதிப்புக்கும், ஒருமுறை மட்டுமே அது சேமிப்பிற்காக சேவையகத்திற்கு அனுப்பப்படும், மேலும் ஒருமுறை மட்டுமே அதற்கு தனித்துவமான எண் குறியீடு ஒதுக்கப்படும்.

இந்தச் சிக்கலைத் தீர்க்க, JavaScript string to number முறையைப் பயன்படுத்த முடியாது. வழக்கமான முறைகளான parseInt மற்றும் parseFloat ஆகியவை பிற பயன்பாடுகளுக்காக வடிவமைக்கப்பட்டுள்ளன, ஆனால் நீங்கள் ஒரு சரத்தை சந்தேகத்திற்கு இடமின்றி எண்ணாக மாற்றுவதற்கான வழிமுறையைக் கொண்டு வரலாம், மேலும் அது தலைகீழாக இருக்க வேண்டிய அவசியமில்லை. ஒரு சரத்தில் உள்ள வெவ்வேறு எழுத்துக்களின் தொகுப்புகளில் மாற்று வழிமுறை மீண்டும் செய்யப்படாமல் இருந்தால் போதும்.

போக்குவரத்து மேம்படுத்தல் மற்றும் பகுப்பாய்வு

ஒரு பக்கத்தை உருவாக்கும் போது, ​​டெவலப்பர் குறிப்பிடத்தக்க அளவு தகவல்களைப் பயன்படுத்துகிறார். பார்வையாளரை தகவலை உள்ளிட அனுமதிப்பது, அதன் மோசமான செயல்பாட்டின் காரணமாக தளத்தின் தரவரிசையை குறைக்கவும், பார்வையாளரை ஏமாற்றவும் ஒரு சிறந்த வழியாகும்.

குறிப்பிட்ட சில தகவல்களுக்குப் பார்வையாளரின் செயல்களுக்கு JavaScript செயல்பாட்டின் வடிவத்தில் ஒரு நிகழ்வு கையாளுதலை வழங்குவதன் மூலம், பார்வையாளரைத் துல்லியமாக இலக்கை அமைக்கவும், தேவையான தகவலைக் கண்டறியவும் மற்றும் விரும்பிய தீர்வைப் பெறவும் அனுமதிக்கும் வடிப்பானை உருவாக்க முடியும். .

இங்கே சரம் தகவலின் மாற்றம் சரம் பகுதியில் தன்னிச்சையாக பெரியதாகவும் எண் பகுதியில் மிகச் சிறியதாகவும் இருக்கலாம். வேறு வார்த்தைகளில் கூறுவதானால், டெவலப்பர் தனது சொந்த அல்காரிதத்தைப் பயன்படுத்தி ஜாவாஸ்கிரிப்ட் சரத்தை எண்ணாக மாற்றுகிறார். பார்வையாளர் புரிந்துகொள்ளக்கூடிய தகவலைக் கையாளுகிறார், மேலும் குறைந்தபட்ச தரவு அளவு - ஒரு எண் - சேவையகத்திற்கு அனுப்பப்படும்.

துல்லியமாக அறியப்பட்ட தகவல்களின் பின்னணியில் அனைத்து பார்வையாளர்களுக்கான எண்களின் இயக்கவியல், AJAX பொறிமுறையின் மூலம் சேவையகப் பதிலுக்காக அழைக்கப்படும் மற்றொரு ஜாவாஸ்கிரிப்ட் செயல்பாட்டை (ஹேண்ட்லர் அல்ல), நிகழ்நேரத்தில் அனைத்து பார்வையாளர்களுக்கும் ஒரே நேரத்தில் தேவையான தகவல்களை விரைவாக வழங்க அனுமதிக்கிறது. . இப்படித்தான் இந்த அமைப்பு செயல்படுகிறது.

ஜாவாஸ்கிரிப்ட் சரத்தை எண்ணாக மாற்றுவதற்கான இந்த விருப்பம் ஆன்லைன் கேம்கள், ஊடாடும் மாநாடுகள், உடனடி செய்தி அனுப்புதல் மற்றும் பலவற்றின் வளர்ச்சியில் மிகவும் பிரபலமானது.

உருமாற்றங்களின் கருவி பயன்பாடு

எண் தகவல்களை செயலாக்கும் சூழலில் JavaScript மற்றும் CSS ஆகியவை சேவையக ஈடுபாடு இல்லாமல் ஒரு பக்கத்தின் காட்சியைக் கட்டுப்படுத்த உங்களை அனுமதிக்கின்றன. CSS விதிகள் சப்ஸ்ட்ரிங்க்களாக மீண்டும் மீண்டும் கட்டமைக்கப்பட்டுள்ளன. பொதுவாக அளவுரு என்பது பல எழுத்துக்களைத் தொடர்ந்து ஒரு எண்ணாகும் (எடுத்துக்காட்டாக, "px", "pt", "em", ...). அளவுரு என்பது விதியில் ஒரு துணைச்சரமாகும், மேலும் விதி என்பது வகுப்பு அல்லது அடையாளங்காட்டி பாணியில் உள்ள துணைச்சரமாகும்.

JavaScript recursion.Substring.Substring... விரும்பிய எண்ணைக் கண்டுபிடித்து, அதை ஒரு சரத்திலிருந்து எண்ணாக மாற்றி, அதை மாற்றியமைத்து, விரும்பிய இடத்திற்குத் திரும்ப எழுதும். விதி தானாகவே மாறும். இது எளிமையானது மற்றும் வசதியானது, சர்வர் ஈடுபாடு இல்லை.

அனைவருக்கும் நல்ல நாள். அலெக்ஸி குலினின் தொடர்பில் உள்ளார். கடந்த கட்டுரையில், ஜாவாஸ்கிரிப்டில் உள்ள தரவு வகைகளைப் பற்றி அறிந்து கொண்டீர்கள். இந்த கட்டுரையில் நான் ஜாவாஸ்கிரிப்டில் வகை மாற்றத்தைப் பற்றி பேச விரும்புகிறேன். ஜாவாஸ்கிரிப்ட் மற்றும் எந்த நிரலாக்க மொழியிலும் வகை மாற்றங்கள் அடிக்கடி செய்யப்படுகின்றன. முதலில் நான் மாறிகள் அல்லது உண்மை அல்லது பொய்யை விளைவிக்கும் பிற நிபந்தனைகளை ஒப்பிடும்போது வகை மாற்றத்தைப் பற்றி பேச விரும்பினேன். வெவ்வேறு வகைகளின் மாறிகளை ஒப்பிடும் போது, ​​பின்னணி மாற்றங்கள் செய்யப்படுகின்றன. இங்கே முக்கிய விஷயம் என்னவென்றால், அத்தகைய பின்னணி மாற்றங்களின் போது, ​​மாறியில் சேமிக்கப்பட்ட மதிப்பு மாறாது. செயல்பாட்டைச் செய்வதற்குத் தேவையான தரவு வகைக்கு மாறி (மாறியின் தற்காலிக மதிப்பு உருவாக்கப்படுகிறது) மாற்றப்படுகிறது. நான் உங்களுக்கு ஒரு உதாரணம் தருகிறேன்:

சரம் வகை மற்றும் எண் வகையின் மாறிகள் ஒப்பிடப்படுகின்றன. ஒப்பிடும்போது, ​​இந்த மாறிகளின் மதிப்புகள் அதே தரவு வகைக்கு குறைக்கப்படுகின்றன. ஒப்பீடு ஒரு பூலியன் மதிப்பை வழங்குகிறது மற்றும் மாற்றப்பட்ட தற்காலிக மதிப்புகள் அகற்றப்படும். அனைத்து மாற்றங்களும் சூழலைப் பொறுத்தது - அவற்றில் செயல்களைச் செய்யும் ஆபரேட்டர்கள். மாதிரி குறியீடு:

Var a = 5; var b = "15"; என்றால் (அ< b) alert("a < b"); else alert("a >b");

இந்த வழக்கில், மாறி b ஒரு எண்ணாக மாற்றப்படும் (சரம் வகையின் பின்னணியை எண் வகைக்கு மாற்றியமைக்கப்பட்டது, மேலும் b வகை எண் = 15 இன் மாறி b இன் தற்காலிக மதிப்பு பெறப்படும், இது பின்னர் நீக்கப்படும். ஒப்பீட்டு செயல்பாடு செய்யப்படுகிறது), இதன் விளைவாக ஒரு .

ஒரு தரவு வகை மற்றொன்றாக எவ்வாறு மாற்றப்படுகிறது என்பதைக் காட்டும் அட்டவணை கீழே உள்ளது:

மதிப்பு வகை	மதிப்பு பயன்படுத்தப்படும் சூழல்
	லேசான கயிறு	எண்ணியல்	தருக்க	பொருள்
வரையறுக்கப்படாத மதிப்பு	'வரையறுக்கப்படாத'	NaN	பொய்	பிழை
ஏதுமில்லை	'ஏதுமில்லை'	0	பொய்	பிழை
வெற்று வரி	வெற்று வரி	0	பொய்	சரம் பொருள்
காலியாக இல்லாத சரம்	காலியாக இல்லாத சரம்	எண் சர மதிப்பு அல்லது NaN	உண்மை	சரம் பொருள்
0	’0′	0	பொய்	எண் பொருள்
NaN	'NaN'	NaN	பொய்	எண் பொருள்
முடிவிலி	'முடிவிலி'	முடிவிலி	உண்மை	எண் பொருள்
- முடிவிலி	'-முடிவிலி'	- முடிவிலி	உண்மை	எண் பொருள்
வேறு எந்த எண்	ஒரு எண்ணின் சரம் பிரதிநிதித்துவம்	எண் தானே	உண்மை	எண் பொருள்
உண்மை	'உண்மை'	1	உண்மை	பூலியன் பொருள்
பொய்	'பொய்'	0	பொய்	பூலியன் பொருள்
பொருள், செயல்பாடு	toString()	valueOf(), toString() அல்லது NaN	உண்மை	பொருள், செயல்பாடு

தரவு வகை மாற்றங்கள்

எந்த தரவு வகையிலிருந்தும் பூலியன் தரவு வகையைப் பெறலாம். இது மறுப்பு ஆபரேட்டர் அல்லது இரட்டை மறுப்பைப் பயன்படுத்தி செய்யப்படுகிறது. உதாரணமாக:

Var a = 20; var b = !a; //திரும்ப தவறான var c = !!a; //உண்மையாகத் திரும்பு

எந்தவொரு பொருளிலிருந்தும் ஒரு சரத்தைப் பெறலாம். உதாரணமாக:

Var a = 20; var b = a.toString(); //திரும்ப "20" var c = a + ""; //திரும்ப "20" வகை b; //திரும்ப சரம் வகை c; //திரும்ப சரம்

ஒரு சரத்திலிருந்து எண்ணைப் பெறுதல். உதாரணமாக:

Var a = "20"; var b = a * 1; //திரும்ப 20 var c = + a; //20 வகை b; //வருகை எண் வகை c; //திரும்ப எண்

இப்போது, ​​பெற்ற அறிவின் அடிப்படையில், தருக்க “AND” (&&) மற்றும் தருக்க “OR” (||): ஆகியவற்றின் நடத்தையை பகுப்பாய்வு செய்வோம்:

தருக்க "AND" (&&):

இந்த ஆபரேட்டர் சரியாகச் செயல்பட, அனைத்து செயல்பாடுகளின் மதிப்புகளையும் உண்மையாக மாற்றுவது அவசியம். அனைத்து செயல்களின் மதிப்புகளும் உண்மையாக மாற்றப்பட்டால், கடைசியாக ஒப்பிடப்பட்ட செயல்பாட்டின் அசல் மதிப்பு திரும்பப் பெறப்படும். குறைந்தபட்சம் ஒரு செயலியின் மதிப்பு தவறானதாக மாற்றப்பட்டால், அந்த ஓபராண்டின் அசல் மதிப்பு வழங்கப்படும். உதாரணமாக:

Var a = 15; var b = "abc"; var c = 0; var முடிவு; முடிவு = a && b && c; //திரும்ப 0 முடிவு = c && b && a; //ரிடர்ன் 0 ரிசல்ட் = 7 && அ; //திரும்ப 15 முடிவு = 7 && b; //"abc" திரும்பவும்

தருக்க "OR" (||):

ஆபரேட்டர்கள் மற்றும் இயக்கங்கள் பற்றி கொஞ்சம் விளக்குகிறேன். வெளிப்பாடு முடிவு = a && b && c . இங்கே ஆபரேட்டர்கள் "=" மற்றும் "&&" , அதாவது. இவை செயல்கள். செயல்பாடுகள்: முடிவு, a, b, c. இதன் மீது நடவடிக்கை எடுக்கப்பட்டுள்ளது.

கடைசியாக புதுப்பித்தது: 11/1/2015

பெரும்பாலும் ஒரு தரவை மற்றொன்றாக மாற்ற வேண்டிய அவசியம் உள்ளது. உதாரணத்திற்கு:

வர் எண்1 = "46"; var எண்2 = "4"; var முடிவு = எண்1 + எண்2; console.log(முடிவு); //464

இரண்டு மாறிகளும் சரங்களைக் குறிக்கின்றன, அல்லது இன்னும் துல்லியமாக எண்களின் சரம் பிரதிநிதித்துவங்கள். இறுதியில் 50 என்ற எண்ணை அல்ல, சரம் 464 ஐப் பெறுவோம். ஆனால் அவற்றையும் கூட்டி, கழித்து, பொதுவாக சாதாரண எண்களைப் போலவே வேலை செய்தால் நன்றாக இருக்கும்.

இந்த வழக்கில், நாம் மாற்று செயல்பாடுகளைப் பயன்படுத்தலாம். ஒரு சரத்தை எண்ணாக மாற்ற, parseInt() செயல்பாட்டைப் பயன்படுத்தவும்:

வர் எண்1 = "46"; var எண்2 = "4"; var முடிவு = parseInt(number1) + parseInt(number2); console.log(முடிவு); //50

சரங்களை பின்ன எண்களாக மாற்ற, parseFloat() செயல்பாட்டைப் பயன்படுத்தவும்:

வர் எண்1 = "46.07"; var எண்2 = "4.98"; var முடிவு = parseFloat(number1) + parseFloat(number2); console.log(முடிவு); //51.05

இந்த வழக்கில், வரியில் கலவையான உள்ளடக்கம் இருக்கலாம், எடுத்துக்காட்டாக, “123ஹலோ”, அதாவது, இந்த விஷயத்தில் எண்கள் உள்ளன, ஆனால் வழக்கமான எழுத்துக்களும் உள்ளன. ஆனால் parseInt() முறை இன்னும் மாற்றத்தை செய்ய முயற்சிக்கும்:

வர் எண்1 = "123ஹலோ"; var num2 = parseInt(num1); console.log(எண்2); // 123

முறை மாற்றத் தவறினால், அது NaN (ஒரு எண் அல்ல) ஐ வழங்குகிறது, இது சரம் ஒரு எண்ணைக் குறிக்கவில்லை மற்றும் மாற்ற முடியாது என்பதைக் குறிக்கிறது.

ஒரு சரம் எண்ணைக் குறிக்கிறதா என்பதைச் சரிபார்க்க, isNaN() என்ற சிறப்புச் செயல்பாட்டைப் பயன்படுத்தலாம். சரம் ஒரு எண்ணாக இல்லாவிட்டால், செயல்பாடு உண்மையாக இருக்கும், அது ஒரு எண்ணாக இருந்தால், தவறானது:

வர் எண்1 = "ஜாவாஸ்கிரிப்ட்"; var எண்2 = "22"; var முடிவு = isNaN(num1); console.log(முடிவு); // true - num1 என்பது எண் முடிவு அல்ல = isNaN(num2); console.log(முடிவு); // தவறு - எண்2 என்பது ஒரு எண்

மேலே தசம அமைப்பில் சரங்களை எண்களாக மாற்றுவதைப் பார்த்தோம். இருப்பினும், எண்களை எந்த அமைப்பிற்கும் மாற்றலாம். முன்னிருப்பாக, ஜாவாஸ்கிரிப்ட் மொழிபெயர்ப்பாளரே நாம் சரத்தை எந்த எண் அமைப்பிற்கு மாற்ற விரும்புகிறோம் என்பதை யூகிக்கிறது (பொதுவாக தசம அமைப்பு தேர்ந்தெடுக்கப்படும்). ஆனால் ஒரு குறிப்பிட்ட அமைப்பில் சரத்தை ஒரு எண்ணாக மாற்ற விரும்புகிறோம் என்பதை வெளிப்படையாகக் குறிக்க இரண்டாவது அளவுருவைப் பயன்படுத்தலாம். எடுத்துக்காட்டாக, பைனரியில் எண்ணாக மாற்றுதல்:

வர் எண்1 = "110"; var num2 = parseInt(num1, 2); console.log(எண்2); // 6

பைனரியில் 110 என்பது தசமத்தில் 6 ஆக இருப்பதால் முடிவு 6 ஆகும்.

இப்போது ஒரு சிறிய நிரலை எழுதுவோம், அதில் மாறிகள் கொண்ட செயல்பாடுகளைப் பயன்படுத்துகிறோம்:

JavaScript var strSum = prompt("டெபாசிட் தொகையை உள்ளிடவும்", 1000); var strPercent = prompt("வட்டி விகிதத்தை உள்ளிடவும்", 10); var sum = parseInt(strSum); var சதவீதம் = parseInt(strPercent); தொகை = தொகை + தொகை * சதவீதம் / 100; எச்சரிக்கை("வட்டி கணக்கிடப்பட்ட பிறகு, வைப்புத் தொகை: " + தொகை);

prompt() செயல்பாடு உலாவியில் ஒரு உரையாடல் பெட்டியைக் காண்பிக்கும், இது ஒரு மதிப்பை உள்ளிடும்படி கேட்கும். இந்தச் செயல்பாட்டிற்கான இரண்டாவது வாதமானது இயல்புநிலையாகப் பயன்படுத்தப்படும் மதிப்பைக் குறிப்பிடுகிறது.

இருப்பினும், prompt() செயல்பாடு ஒரு சரத்தை வழங்குகிறது. எனவே, இந்த சரத்தை ஒரு எண்ணாக மாற்ற வேண்டும், அதில் செயல்பாடுகளைச் செய்ய வேண்டும்.

உலாவியில் பக்கத்தைத் திறந்த பிறகு, வைப்புத் தொகையை உள்ளிடுவதற்கான ஒரு அறிவிப்பைக் காண்போம்:

சதவீதத்தை உள்ளிடுவதற்கு இதே போன்ற செய்தி தோன்றும். இறுதியில் நிரல் தரவைப் பெற்று, அதை எண்களாக மாற்றி கணக்கீட்டைச் செய்யும்.