JavaScript's Math object is the quiet utility belt of the language. You never instantiate it. You never import it. It si

JavaScript-ன் Math object என்பது இந்த மொழியின் அமைதியான கருவிப் பெட்டி (utility belt) போன்றது. நீங்கள் இதை ஒருபோதும் instantiate செய்ய மாட்டீர்கள். இதை import செய்யத் தேவையில்லை. ஒரு pixel மதிப்பைச் சுருக்குவது முதல் ஒரு பகடையை (dice) உருட்டுவது வரை அனைத்தையும் கையாளத் தயாராக, இது ஒவ்வொரு runtime-லும் இயல்பாகவே இருக்கும். Math என்பது ஒரு static object என்பதால், அதன் ஒவ்வொரு method மற்றும் property-யும் நேரடியாக namespace-லிருந்து அணுக முடியும். நீங்கள் new Math().PI என்று எழுதாமல், Math.PI என்று எழுதுவீர்கள். இந்த வடிவமைப்பு எளிமையைத் தருகிறது, ஆனால் நீங்கள் இதை production logic-களுக்குப் பயன்படுத்தும் முன், இதில் உள்ள சில நுணுக்கங்களைப் புரிந்துகொள்வது அவசியம்.

Constructor இல்லாத ஒரு Static Object

பெரும்பாலான built-in JavaScript objects நீங்கள் ஒரு instance-ஐ உருவாக்க வேண்டும் என்று எதிர்பார்க்கும். நீங்கள் new Date() அல்லது new Array() என்று அழைப்பீர்கள். ஆனால் Math அதை மறுக்கிறது. இது primitive Number வகையின் மீது செயல்படும் தொடர்புடைய functions மற்றும் constants ஆகியவற்றின் namespace ஆக வடிவமைக்கப்பட்டுள்ளது. Math.sqrt(16) என்று அழைத்தால் உங்களுக்கு 4 கிடைக்கும். new keyword-ஐப் பயன்படுத்த முயன்றால், engine ஒரு TypeError-ஐத் தரும். இந்த முறை நினைவகத்தை (memory) சுத்தமாக வைத்திருக்கவும், Math முற்றிலும் functional என்பதை உணர்த்தவும் உதவுகிறது. இது உள்ளீடுகளை (inputs) எடுத்துக்கொண்டு, வெளியீடுகளை (outputs) வழங்குகிறது, ஆனால் எதையும் மாற்றியமைப்பதில்லை (mutates nothing).

நினைவில் கொள்ள வேண்டிய ஒரு முக்கியமான கட்டுப்பாடு உள்ளது: Math என்பது நிலையான IEEE 754 எண்களுடன் மட்டுமே செயல்படும். இது BigInt உடன் செயல்படாது. Math.round() அல்லது Math.abs() ஆகியவற்றிற்கு ஒரு BigInt-ஐ அனுப்பினால், உங்களுக்கு TypeError கிடைக்கும். உங்கள் பயன்பாடு 64-bit integers அல்லது அதற்கு மேற்பட்டவற்றை கையாள வேண்டுமென்றால், நீங்கள் அவற்றை மாற்றியமைக்க வேண்டும் அல்லது அதற்குப் பதிலாக native BigInt operators-களைப் பயன்படுத்த வேண்டும்.

நீங்கள் உண்மையில் பயன்படுத்தும் மாறிலிகள் (Constants)

Math object பல எண் மாறிலிகளை (numeric constants) வழங்குகிறது, இது நீங்கள் magic numbers-களை நேரடியாகக் குறியீட்டில் (hard-coding) எழுதுவதைத் தவிர்க்க உதவுகிறது.

• Math.PI என்பது நன்கு அறியப்பட்ட 3.14159..., இது வட்டங்கள், முக்கோணவியல் (trigonometry) அல்லது டிகிரிகளை ரேடியன்களாக (radians) மாற்றுவது போன்றவற்றுக்கு அவசியமானது.
• Math.E என்பது Euler-ன் எண், தோராயமாக 2.718. இது exponential growth curves, கூட்டு வட்டி கணக்கீடுகள் மற்றும் logarithmic scales ஆகியவற்றில் பயன்படுத்தப்படுகிறது.
• Math.SQRT2 என்பது இரண்டின் வர்க்கமூலம் (square root), சுமார் 1.414. ஒரு சதுரத்தின் மூலைவிட்டத்தை (diagonal) கணக்கிட அல்லது எளிய வடிவியலில் (geometry) vectors-களை normalize செய்ய இது பயனுள்ளதாக இருக்கும்.
• Math.LN2 என்பது 2-ன் இயற்கை மடக்கை (natural logarithm), தோராயமாக 0.693. binary trees, தகவல் என்ட்ரோபி (information entropy) அல்லது log-base-2 கணிதத்தைக் கையாளும் algorithms ஆகியவற்றில் இதைக் காணலாம்.

இந்த மதிப்புகள் முழுமையான double-precision floats ஆகும். இவை methods அல்ல, properties என்பதால், நீங்கள் இவற்றை அடைப்புக்குறிகள் (parentheses) இன்றி அணுகலாம்.

சுருக்குதல் (Rounding), குறிகள் (Signs) மற்றும் முழுமையான மதிப்புகள் (Absolute Values)

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

Math.abs(x) ஒரு எண்ணின் அளவை (magnitude) வழங்குகிறது. -42 என்று கொடுத்தால் 42 கிடைக்கும். திசையை விட தூரத்திற்கு நீங்கள் முக்கியத்துவம் கொடுக்கும்போது இது பயனுள்ளதாக இருக்கும். Timestamps-களை ஒப்பிடுவது, UI-ல் drag deltas-களைக் கணக்கிடுவது அல்லது ஒரு யூ猜 (guess) பிழை வரம்பிற்குள் உள்ளதா என்று சரிபார்ப்பது போன்றவற்றை இதற்கு உதாரணமாகக் கொள்ளலாம்.

Math.round(x) என்பது பள்ளிப் பாடங்களில் கற்பிக்கப்படும் சுருக்குதல் முறை. இது அருகிலுள்ள முழு எண்ணை எடுக்கும், அதில் .5 வரும்போது அடுத்த நேர்மறை எண்ணிற்குச் சுருக்கும். எனவே 4.4 என்பது 4 ஆகவும், 4.5 என்பது 5 ஆகவும் மாறும்.

Math.ceil(x) எப்போதும் அடுத்த முழு எண்ணிற்கு மேல் நோக்கிச் சுருக்கும். 4.1 என்பது 5 ஆகவும், -4.9 என்பது -4 ஆகவும் மாறும். இந்த கடைசி மாற்றம் பலரை ஆச்சரியப்படுத்தும். ஏனெனில் எண் கோட்டில் (number line) -4 என்பது -4.9-ஐ விடப் பெரியது, எனவே ceiling எதிர்மறை எண்களுக்கு பூஜ்ஜியத்தை நோக்கி நகர்கிறது.

Math.floor(x) இதற்கு நேர்மாறானது. இது எப்போதும் கீழ் நோக்கிச் சுருக்கும். 4.9 என்பது 4 ஆகவும், -4.1 என்பது -5 ஆகவும் மாறும். நீங்கள் தேடல் முடிவுகளைப் பக்கங்களாகப் பிரிக்கிறீர்கள் (paginating) அல்லது நிலையான அளவு நினைவகத் தொகுதிகளை (fixed-size memory blocks) ஒதுக்குகிறீர்கள் என்றால், floor முறையே உங்களுக்குத் தேவைப்படும்.

Math.trunc(x) தசமப் பகுதியை முழுமையாக நீக்கிவிட்டு, முழு எண் பகுதியை மட்டும் வைத்திருக்கும். சொல்லப்போனால், இது குறியின் (sign) பொருளைப் பொருட்படுத்தாமல் பூஜ்ஜியத்தை நோக்கி நகர்கிறது. 4.9 என்பது 4 ஆகவும், -4.9 என்பது -4 ஆகவும் மாறும். நீங்கள் floats-களை truncating மூலம் ints-களாக மாற்றும் மொழிகளில் இருந்து தர்க்கத்தைக் கொண்டு வருகிறீர்கள் என்றால், இது உங்களுக்கு உதவும்.

இறுதியாக, Math.sign(x) ஒரு மதிப்பு பூஜ்ஜியத்தின் எந்தப் பக்கம் உள்ளது என்பதைக் கூறும். இது நேர்மறை எண்ணிற்கு 1, எதிர்மறை எண்ணிற்கு -1, positive zero-விற்கு 0, negative zero-விற்கு -0 மற்றும் எண் அல்லாத எதற்கு NaN ஆகியவற்றைத் தரும். if-else சங்கிலியை எழுதாமல் திசையைத் தீர்மானிக்க இது ஒரு சுருக்கமான வழியாகும்.

சீரற்ற எண்களை உருவாக்குதல் (Generating Random Numbers)

Math.random() என்பது 0 (உள்ளடக்கியது) முதல் 1 (உள்ளடங்காதது) வரையிலான ஒரு pseudo-random float-ஐ உருவாக்குகிறது. இது கிரிப்டோகிராஃபிக் ரீதியாகப் பாதுகாப்பானது (cryptographically secure) அல்ல, எனவே கடவுச்சொல் உருவாக்கம் (password generation), டோக்கன் உருவாக்கம் அல்லது நிஜப் பணம் சம்பந்தப்பட்ட எதற்கும் இதைப் பயன்படுத்த வேண்டாம்.