ටිකොන් උස්කොව්, Zabbix ඒකාබද්ධතා කණ්ඩායම් ඉංජිනේරු
Zabbix යනු ඕනෑම ආකාරයක දත්ත නිරීක්ෂණය කිරීමට භාවිතා කරන අභිරුචිකරණය කළ හැකි වේදිකාවකි. Zabbix හි මුල්ම අනුවාද වල සිට, අධීක්ෂණ පරිපාලකයින්ට විවිධ ස්ක්‍රිප්ට් ධාවනය කිරීමේ හැකියාව ඇත. කොටස් ඉලක්ක ජාල නෝඩ් වල චෙක්පත් සඳහා. ඒ අතරම, ස්ක්‍රිප්ට් දියත් කිරීම ස්ක්‍රිප්ට් සඳහා සහය දැක්වීමේ අවශ්‍යතාවය, සන්නිවේදන නෝඩ් සහ ප්‍රොක්සි වෙත ඒවා බෙදා හැරීම මෙන්ම විවිධ අනුවාද සඳහා සහය වැනි දුෂ්කරතා ගණනාවකට හේතු විය.
Zabbix සඳහා JavaScript
2019 අප්‍රේල් මාසයේදී, Zabbix 4.2 JavaScript පෙර සැකසුම් සමඟ හඳුන්වා දෙන ලදී. දත්ත කොතැනක හෝ ගෙන යන, එය ජීර්ණය කර Zabbix හට තේරුම් ගත හැකි ආකෘතියකින් ලබා දෙන සහ Zabbix විසින් ගබඩා කිරීමට සහ සැකසීමට සූදානම් නැති දත්ත ලැබෙන සරල පරීක්‍ෂණ සිදු කරන ලිඛිත ස්ක්‍රිප්ට් අත්හැරීමේ අදහස ගැන බොහෝ අය උද්යෝගිමත් වූහ. ඉන්පසු Zabbix සහ JavaScript මෙවලම් භාවිතයෙන් මෙම දත්ත ප්‍රවාහය සකසන්න. Zabbix 3.4 හි දර්ශනය වූ පහත් මට්ටමේ සොයාගැනීම් සහ යැපෙන අයිතම සමඟ ඒකාබද්ධව, ලැබුණු දත්ත වර්ග කිරීම සහ කළමනාකරණය කිරීම සඳහා අපට තරමක් නම්‍යශීලී සංකල්පයක් ලැබුණි.
Zabbix 4.4 හි, ජාවාස්ක්‍රිප්ට් හි පෙර-සැකසුම් කිරීමේ තාර්කික අඛණ්ඩ පැවැත්මක් ලෙස, නව දැනුම්දීම් ක්රමයක් දර්ශනය වී ඇත - Webhook, තෙවන පාර්ශවීය යෙදුම් සමඟ Zabbix දැනුම්දීම් පහසුවෙන් ඒකාබද්ධ කිරීමට භාවිතා කළ හැකිය.
JavaScript සහ Duktapes
JavaScript සහ Duktape තෝරාගත්තේ ඇයි? භාෂා සහ එන්ජින් සඳහා විවිධ විකල්ප සලකා බලන ලදී:
- Lua - Lua 5.1
- Lua - LuaJIT
- Javascript - Duktape
- Javascript - JerryScript
- Embedded Python
- Embedded Perl
ප්‍රධාන තේරීම් නිර්ණායක වූයේ ව්‍යාප්තිය, එන්ජිම නිෂ්පාදනයට ඒකාබද්ධ කිරීමේ පහසුව, අඩු සම්පත් පරිභෝජනය සහ එන්ජිමේ සමස්ත ක්‍රියාකාරීත්වය සහ අධීක්ෂණය සඳහා මෙම භාෂාවෙන් කේතය හඳුන්වා දීමේ ආරක්ෂාවයි. දර්ශක සංයෝජනය මත පදනම්ව, Duktape එන්ජිම මත JavaScript ජයග්රහණය කළේය.
තේරීම් නිර්ණායක සහ කාර්ය සාධන පරීක්ෂාව
Duktape හි විශේෂාංග:
- සම්මත
- Duktape සඳහා Zabbix මොඩියුල:
- Zabbix.log() - ඔබට විවිධ මට්ටමේ විස්තර සහිත පණිවිඩ කෙලින්ම Zabbix Server ලොගයට ලිවීමට ඉඩ සලසයි, එමඟින් දෝෂ සහසම්බන්ධ කිරීමට හැකි වේ, උදාහරණයක් ලෙස, Webhook හි, සේවාදායක තත්ත්වය සමඟ.
- CurlHttpRequest() - Webhook භාවිතය පදනම් වූ ජාලයට HTTP ඉල්ලීම් කිරීමට ඔබට ඉඩ සලසයි.
- atob() සහ btoa() - ඔබට Base64 ආකෘතියෙන් තන්තු කේතනය කිරීමට සහ විකේතනය කිරීමට ඉඩ සලසයි.
සටහන. Duktape ACME ප්‍රමිතීන්ට අනුකූල වේ. Zabbix පිටපතේ 2015 අනුවාදය භාවිතා කරයි. පසුකාලීන වෙනස්කම් සුළු වේ, එබැවින් ඒවා නොසලකා හැරිය හැක..
JavaScript මැජික්
JavaScript හි සියලුම මායාවන් ගතික ටයිප් කිරීම සහ ටයිප් වාත්තු කිරීම තුළ පවතී: නූල්, සංඛ්‍යාත්මක සහ බූලියන්.
මෙයින් අදහස් කරන්නේ විචල්‍යය අගයක් ලබා දිය යුත්තේ කුමන ආකාරයේද යන්න කල්තියා ප්‍රකාශ කිරීම අවශ්ය නොවන බවයි.
ගණිතමය මෙහෙයුම් වලදී, ශ්‍රිත ක්‍රියාකරුවන් විසින් ආපසු ලබා දෙන අගයන් සංඛ්‍යා බවට පරිවර්තනය වේ. එවැනි මෙහෙයුම් සඳහා ව්‍යතිරේකය එකතු කිරීමකි, මන්ද අවම වශයෙන් එක් නියමයක් තන්තුවක් නම්, සියලුම නියමයන් සඳහා තන්තු පරිවර්තනය යෙදේ.
සටහන. එවැනි පරිවර්තනයන් සඳහා වගකිව යුතු ක්‍රම සාමාන්‍යයෙන් වස්තුවේ මව් මූලාකෘති තුළ ක්‍රියාත්මක වේ. වටිනාකම и ස්ට්‍රිං වෙත. වටිනාකම සංඛ්‍යාත්මක පරිවර්තනය අතරතුර සහ සෑම විටම ක්‍රමයට පෙර කැඳවනු ලැබේ ස්ට්‍රිං වෙත. ක්රමය වටිනාකම ප්රාථමික අගයන් ආපසු ලබා දිය යුතුය, එසේ නොමැති නම් එහි ප්රතිඵලය නොසලකා හරිනු ලැබේ.
වස්තුවක් මත ක්රමයක් ලෙස හැඳින්වේ වටිනාකම. එය සොයාගත නොහැකි නම් හෝ ප්රාථමික අගයක් ලබා නොදුන්නේ නම්, ක්රමය හැඳින්වේ ස්ට්‍රිං වෙත. ක්රමය නම් ස්ට්‍රිං වෙත හමු නොවීය, සොයමින් වටිනාකම වස්තුවේ මූලාකෘතියේ, සහ අගය සැකසීම අවසන් වන තෙක් සියල්ල පුනරාවර්තනය වන අතර ප්‍රකාශනයේ ඇති සියලුම අගයන් එකම වර්ගයට දමනු ලැබේ. වස්තුව ක්රමයක් ක්‍රියාත්මක කරන්නේ නම් ස්ට්‍රිං වෙත, එය ප්රාථමික අගයක් ලබා දෙයි, එවිට එය තන්තු පරිවර්තනය සඳහා භාවිතා වේ. කෙසේ වෙතත්, මෙම ක්රමය යෙදීමේ ප්රතිඵලය අනිවාර්යයෙන්ම නූල් එකක් නොවේ.
උදාහරණයක් ලෙස, වස්තුව සඳහා නම් 'විරුද්ධ' ක්රමය නිර්වචනය කර ඇත ස්ට්‍රිං වෙත,
`var obj = { toString() { return "200" }}` ක්රමය ස්ට්‍රිං වෙත හරියටම නූලක් ආපසු ලබා දෙන අතර, අංකයක් සමඟ නූලක් එකතු කරන විට, අපට ඇලවූ නූලක් ලැබේ:
`obj + 1 // '2001'`
`obj + 'a' // ‘200a'`නමුත් ඔබ නැවත ලියන්නේ නම් ස්ට්‍රිං වෙත, එම ක්රමය මඟින් සංඛ්‍යාවක් ලබා දෙන පරිදි, වස්තුව එකතු කළ විට, සංඛ්‍යාත්මක පරිවර්තනයක් සහිත ගණිතමය මෙහෙයුමක් සිදු කරනු ලබන අතර ගණිතමය එකතු කිරීමේ ප්රතිඵලය ලැබෙනු ඇත.
`var obj = { toString() { return 200 }}`
`obj + 1 // '2001'`මෙම අවස්ථාවේදී, අපි නූලක් සමඟ එකතු කිරීමක් සිදු කරන්නේ නම්, නූල් පරිවර්තනයක් සිදු කරනු ලබන අතර, අපි ඇලවූ නූල් ලබා ගනිමු.
`obj + 'a' // ‘200a'`නවක ජාවාස්ක්‍රිප්ට් භාවිතා කරන්නන්ගේ වැරදි විශාල සංඛ්‍යාවකට හේතුව මෙයයි.
ක්රමය ස්ට්‍රිං වෙත වස්තුවේ වත්මන් අගය 1 කින් වැඩි කරන ශ්‍රිතයක් ඔබට ලිවිය හැක.
විචල්‍යය 3 ට සමාන වන අතර එය 4 ට ද සමාන නම්, ස්ක්‍රිප්ට් ක්‍රියාත්මක කිරීම.
වාත්තු (==) සමඟ සසඳන විට, ක්රමය සෑම අවස්ථාවකම ක්‍රියාත්මක වේ ස්ට්‍රිං වෙත අගය වැඩි කිරීමේ කාර්යය සමඟ. ඒ අනුව, එක් එක් පසු සංසන්දනය සමඟ, අගය වැඩි වේ. වාත්තු නොවන සංසන්දනය (===) භාවිතා කිරීමෙන් මෙය වළක්වා ගත හැකිය.
වර්ගය වාත්තු කිරීමකින් තොරව සංසන්දනය කිරීම
සටහන. අනවශ්‍ය ලෙස Cast Comparison භාවිතා නොකරන්න.
වර්ග වාත්තු කිරීම සමඟ සංසන්දනය කිරීම අවශ්ය වන සංකීර්ණ තර්කනය සහිත Webhooks වැනි සංකීර්ණ ස්ක්‍රිප්ට් සඳහා, විචල්‍යයන් ආපසු ලබා දෙන සහ නොගැලපීම් සහ දෝෂ හසුරුවන අගයන් සඳහා චෙක්පත් පූර්ව ලිවීම නිර්දේශ කෙරේ.
Webhook මාධ්‍ය
2019 අග සහ 2020 මුල් භාගයේදී, Zabbix ඒකාබද්ධතා කණ්ඩායම Zabbix බෙදාහැරීම සමඟ එන Webhooks සහ out-of-the-box ඒකාබද්ධ කිරීම් සක්‍රියව සංවර්ධනය කරමින් සිටී.
වෙත සබැඳිය
පෙර සැකසුම්
- ජාවාස්ක්‍රිප්ට් හි පෙර සැකසුම් පැමිණීම නිසා බොහෝ බාහිර ස්ක්‍රිප්ට් අතහැර දැමීමට හැකි වූ අතර දැනට Zabbix හි ඔබට ඕනෑම අගයක් ලබාගෙන එය සම්පූර්ණයෙන්ම වෙනස් අගයකට පරිවර්තනය කළ හැකිය.
- Zabbix හි පෙර සැකසුම් ජාවාස්ක්‍රිප්ට් කේතය මඟින් ක්‍රියාත්මක කරනු ලැබේ, එය බයිට්කේත බවට සම්පාදනය කරන විට, පරාමිතියක් ලෙස තනි අගයක් ගන්නා ශ්‍රිතයක් බවට පරිවර්තනය වේ. අගය තන්තුවක් ලෙස (තන්තුවක ඉලක්කමක් සහ අංකයක් අඩංගු විය හැක).
- ප්‍රතිදානය ශ්‍රිතයක් බැවින්, ස්ක්‍රිප්ට් අවසානයේ අවශ්ය වේ ආපසු.
- කේතය තුළ අභිරුචි මැක්‍රෝ භාවිතා කළ හැකිය.
- සම්පත් මෙහෙයුම් පද්ධති මට්ටමින් පමණක් නොව, වැඩසටහන්මය වශයෙන්ද සීමා කළ හැක. පෙර සැකසුම් පියවර සඳහා උපරිම මෙගාබයිට් 10ක RAM සහ තත්පර 10ක ධාවන කාල සීමාවක් වෙන් කර ඇත.
සටහන. තත්පර 10ක කල් ඉකුත්වීමේ අගය ඉතා විශාලය, මන්ද තරමක් “බර” පෙර සැකසුම් තත්ත්වයකට අනුව තත්පර 1ක් තුළ කොන්දේසි සහිත දහස් ගණන් දත්ත අයිතම එකතු කිරීම Zabbix වේගය අඩු කළ හැකි බැවිනි. එබැවින්, පෙර සැකසුම් සිදු කිරීමට පමණක් ක්‍රියාත්මක වන ඊනියා සෙවනැලි දත්ත මූලද්‍රව්‍ය (ව්‍යාජ අයිතම) හරහා සම්පූර්ණ ජාවාස්ක්‍රිප්ට් ස්ක්‍රිප්ට් ක්‍රියාත්මක කිරීමට පෙර සැකසුම් භාවිතා කිරීම නිර්දේශ නොකරයි..
ඔබට පෙර සැකසුම් පරීක්ෂණය හරහා හෝ උපයෝගිතා භාවිතයෙන් ඔබේ කේතය පරීක්ෂා කළ හැක zabbix_js:
`zabbix_js -s *script-file -p *input-param* [-l log-level] [-t timeout]`
`zabbix_js -s script-file -i input-file [-l log-level] [-t timeout]`
`zabbix_js -h`
`zabbix_js -V`
ප්රායෝගික කාර්යයන්
අරමුණු 1
ගණනය කළ අයිතමය පෙර සැකසුම් සමඟ ප්‍රතිස්ථාපනය කරන්න.
තත්වය: සෙල්සියස් වලින් ගබඩා කිරීමට සංවේදකයෙන් උෂ්ණත්වය ෆැරන්හයිට් වලින් ලබා ගන්න.
මීට පෙර, අපි ෆැරන්හයිට් අංශක වලින් උෂ්ණත්වය එකතු කරන අයිතමයක් නිර්මාණය කරමු. ඊට පසු, සූත්‍රයක් භාවිතයෙන් ෆැරන්හයිට් සෙල්සියස් බවට පරිවර්තනය කරන තවත් දත්ත අයිතමයක් (ගණනය කර ඇත).
ගැටළු:
- දත්ත මූලද්‍රව්‍ය අනුපිටපත් කිරීම සහ දත්ත සමුදායේ සියලුම අගයන් ගබඩා කිරීම අවශ්ය වේ.
- සූත්‍රයේ ගණනය කර භාවිතා කරන "මාපිය" දත්ත අයිතමය සහ ගණනය කළ දත්ත අයිතමය සඳහා වන කාල පරතරයන් පිළිබඳව ඔබ එකඟ විය යුතුය. එසේ නොමැතිනම්, ගණනය කළ අයිතමය සහය නොදක්වන තත්වයකට යාමට හෝ පෙර අගයක් ගණනය කළ හැකිය, එය නිරීක්ෂණ ප්රතිඵලවල විශ්වසනීයත්වයට බලපානු ඇත.
එක් විසඳුමක් වූයේ දත්ත ලබා ගන්නා අයිතමයට පසුව (අපගේ නඩුවේ, ෆැරන්හයිට් අංශකවල උෂ්ණත්වය) ගණනය කළ අයිතමය ඇගයීමට ලක් කරන බව සහතික කිරීම සඳහා ස්ථාවර කාල අන්තරයන් සඳහා නම්‍යශීලී පිරික්සුම් කාල පරතරයන්ගෙන් ඉවත් වීමයි.
නමුත් උදාහරණයක් ලෙස, අපි උපාංග විශාල සංඛ්‍යාවක් පරීක්ෂා කිරීමට අච්චුව භාවිතා කරන්නේ නම් සහ සෑම තත්පර 30 කට වරක් චෙක්පත සිදු කරන්නේ නම්, Zabbix තත්පර 29 ක් "හැක්" කරයි, සහ අවසාන තත්පරයේදී එය පරීක්ෂා කිරීම සහ ගණනය කිරීම ආරම්භ කරයි. මෙය පෝලිමක් නිර්මාණය කර කාර්ය සාධනයට බලපායි. එබැවින්, එය ඇත්ත වශයෙන්ම අවශ්ය නම් පමණක් ස්ථාවර කාල පරතරයන් භාවිතා කිරීම රෙකමදාරු කරනු ලැබේ.
මෙම ගැටලුවේදී, ප්‍රශස්ත විසඳුම වන්නේ ෆැරන්හයිට් අංශක සෙල්සියස් අංශක බවට පරිවර්තනය කරන එක් පේළි ජාවාස්ක්‍රිප්ට් පෙර සැකසුමකි:
`return (value - 32) * 5 / 9;`එය වේගවත් සහ පහසුයි, ඔබට අනවශ්‍ය දත්ත අයිතම නිර්මාණය කිරීමට සහ ඒවා මත ඉතිහාසයක් තබා ගැනීමට අවශ්ය නොවන අතර, ඔබට චෙක්පත් සඳහා නම්‍යශීලී කාල අන්තරයන්ද භාවිතා කළ හැක.
`return (parseInt(value) + parseInt("{$EXAMPLE.MACRO}"));`එහෙත්, උපකල්පිත තත්වයකදී ලැබුණු දත්ත මූලද්‍රව්‍යය එකතු කිරීමට අවශ්ය නම්, උදාහරණයක් ලෙස, සාර්වයේ නිර්වචනය කර ඇති ඕනෑම නියතයක් සමඟ, පරාමිතිය බව සැලකිල්ලට ගත යුතුය. අගය තන්තුවක් දක්වා විහිදේ. නූල් එකතු කිරීමේ මෙහෙයුමකදී, නූල් දෙකක් සරලව එකකට ඒකාබද්ධ වේ.
`return (value + "{$EXAMPLE.MACRO}");`ගණිතමය මෙහෙයුමක ප්‍රති result ලය ලබා ගැනීම සඳහා, ලබාගත් අගයන් සංඛ්‍යාත්මක ආකෘතියකට පරිවර්තනය කිරීම අවශ්ය වේ. මේ සඳහා ඔබට කාර්යය භාවිතා කළ හැකිය parseInt(), එය පූර්ණ සංඛ්‍යාවක්, ශ්‍රිතයක් නිපදවයි parseFloat(), දශමයක් හෝ ශ්‍රිතයක් නිපදවන අංකය, එය පූර්ණ සංඛ්‍යාවක් හෝ දශමයක් ලබා දෙයි.
කාර්යය 2
සහතිකය අවසන් වන තෙක් තත්පර කිහිපයකින් කාලය ලබා ගන්න.
තත්වය: සේවාවක් "පෙබරවාරි 12 12:33:56 2022 GMT" ආකෘතියෙන් සහතික කල් ඉකුත්වන දිනයක් නිකුත් කරයි.
ECMAScript 5 හි date.parse() ISO 8601 ආකෘතියෙන් දිනයක් පිළිගනී (YYYY-MM-DDTHH:mm:ss.sssZ). MMM DD YYYY HH:mm:ss ZZ ආකෘතියෙන් එයට තන්තුවක් දැමීම අවශ්ය වේ.
ප්රශ්නය: මාසික අගය ප්‍රකාශ වන්නේ අංකයක් ලෙස නොව පෙළ ලෙසය. මෙම ආකෘතියේ දත්ත Duktape විසින් පිළිගනු නොලැබේ.
විසඳුම උදාහරණය:
-
පළමුවෙන්ම, අගයක් ගන්නා විචල්‍යයක් ප්‍රකාශ කරනු ලැබේ (සම්පූර්ණ ස්ක්‍රිප්ට් යනු කොමාවෙන් වෙන් කර ඇති විචල්‍යයන්ගේ ප්‍රකාශනයකි).
-
පළමු පේළියේ අපි පරාමිතියේ දිනය ලබා ගනිමු අගය සහ ක්රමය භාවිතයෙන් හිස්තැන් සමඟ එය වෙන් කරන්න බෙදුණු. මේ අනුව, අපට අරාවක් ලැබේ, එහිදී අරාවේ සෑම මූලද්‍රව්‍යයක්ම, 0 දර්ශකයෙන් ආරම්භ වන අතර, අවකාශයකට පෙර සහ පසු එක් දින මූලද්‍රව්‍යයකට අනුරූප වේ. බෙදීම (0) - මස, බෙදීම (1) - අංකය, බෙදීම (2) - කාලය සමඟ තන්තුවක්, ආදිය. ඉන් පසුව, දිනයේ සෑම අංගයක්ම අරාව තුළ ඇති දර්ශකය මඟින් ප්‍රවේශ විය හැක.
`var split = value.split(' '),`- සෑම මාසයකම (කාලානුක්‍රමයෙන්) අරාවෙහි (0 සිට 11 දක්වා) එහි පිහිටීමෙහි දර්ශකයට අනුරූප වේ. පෙළ අගයක් සංඛ්‍යාත්මක අගයකට පරිවර්තනය කිරීම සඳහා, එකක් මාසික දර්ශකයට එකතු කරනු ලැබේ (මාස අංක 1 න් ආරම්භ වන නිසා). මෙම අවස්ථාවෙහිදී, එකක් එකතු කිරීම සමඟ ප්‍රකාශනය වරහන් තුළ ගනු ලැබේ, මන්ද එසේ නොවුවහොත් අංකයක් නොව තන්තුවක් ලැබෙනු ඇත. අවසානයේ අපි කරන්නෙමු පෙත්ත () - අක්ෂර දෙකක් පමණක් ඉතිරි කිරීමට අරාව අවසානයේ සිට කපා දමන්න (එය ඉලක්කම් දෙකේ අංකයක් සමඟ මාස සඳහා වැදගත් වේ).
`MONTHS_LIST = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],`
`month_index = ('0' + (MONTHS_LIST.indexOf(split[0]) + 1)).slice(-2),`- සාමාන්‍ය අනුපිළිවෙලට නූල් එකතු කිරීමෙන් ලබාගත් අගයන්ගෙන් අපි ISO ආකෘතියෙන් තන්තුවක් සාදන්නෙමු.
`ISOdate = split[3] + '-' + month_index + '-' + split[1] + 'T' + split[2],`ප්රතිඵල ආකෘතියේ දත්ත 1970 සිට අනාගතයේ යම් ස්ථානයක් දක්වා තත්පර ගණන වේ. ලැබුණු ආකෘතියෙන් දත්ත ප්‍රේරක තුළ භාවිතා කිරීම පාහේ කළ නොහැක්කකි, මන්ද Zabbix ඔබට මැක්‍රෝස් සමඟ පමණක් ක්‍රියා කිරීමට ඉඩ සලසයි. {දිනය} и {කාලය}, පරිශීලක-හිතකාමී ආකෘතියකින් දිනය සහ වේලාව ලබා දෙන.
- එවිට අපට ජාවාස්ක්‍රිප්ට් හි වත්මන් දිනය Unix Timestamp ආකෘතියෙන් ලබා ගත හැකි අතර, සහතිකය කල් ඉකුත් වන තෙක් මිලි තත්පර ගණන ලබා ගැනීමට ප්‍රතිඵලයක් ලෙස ලැබෙන සහතික කල් ඉකුත්වන දිනයෙන් එය අඩු කළ හැක.
`now = Date.now();`- Zabbix හි තත්පර ලබා ගැනීමට අපි ලැබුණු අගය දහසකින් බෙදන්නෙමු.
`return parseInt((Date.parse(ISOdate) - now) / 1000);`ප්‍රේරකයේදී, ඔබට ප්‍රකාශනය නියම කළ හැක 'අවසන්' ඔබට ප්‍රතිචාර දැක්වීමට අවශ්ය කාලපරිච්ඡේදයේ තත්පර ගණනට අනුරූප වන ඉලක්කම් කට්ටලයක් අනුගමනය කරයි, උදාහරණයක් ලෙස සති වලින්. මේ අනුව, ප්‍රේරකය සහතිකය සතියකින් කල් ඉකුත් වන බව දැනුම් දෙනු ඇත.
සටහන. භාවිතය කෙරෙහි අවධානය යොමු කරන්න parseInt() කාර්යයේ ආපසුමිලි තත්පර බෙදීමෙන් ලැබෙන භාගික සංඛ්‍යාව පූර්ණ සංඛ්‍යාවකට පරිවර්තනය කිරීමට. ඔබට ද භාවිතා කළ හැකිය parseFloat() සහ භාගික දත්ත ගබඩා කරන්න.
මූලාශ්රය: www.habr.com