JavaScript-ലെ Math ഒബ്‌ജക്റ്റ് ആ ഭാഷയുടെ നിശബ്ദമായ ഒരു യൂട്ടിലിറ്റി ബെൽറ്റ് (utility belt) പോലെയാണ്. നിങ്ങൾ ഇത് ഇൻസ്റ്റൻഷ്യേറ്റ് (instantiate) ചെയ്യുകയോ ഇംപോർട്ട് (import) ചെയ്യുകയോ ഇല്ല. ഒരു പിക്സൽ വാല്യൂ റൗണ്ട് ചെയ്യുന്നത് മുതൽ ഒരു ഡൈസ് റോൾ ജനറേറ്റ് ചെയ്യുന്നത് വരെയുള്ള കാര്യങ്ങൾ കൈകാര്യം ചെയ്യാൻ ഓരോ റൺടൈമിലും ഇത് ലഭ്യമാണ്. Math ഒരു സ്റ്റാറ്റിക് ഒബ്‌ജക്റ്റ് ആയതുകൊണ്ട്, എല്ലാ മെത്തേഡുകളും പ്രോപ്പർട്ടികളും നേരിട്ട് അതിന്റെ നെയിംസ്പേസിൽ (namespace) ആണ് വരുന്നത്. നിങ്ങൾ Math.PI എന്നാണ് എഴുതേണ്ടത്, new Math().PI എന്നല്ല. ഈ ഡിസൈൻ രീതി കാര്യങ്ങൾ ലളിതമാക്കുന്നുണ്ടെങ്കിലും, പ്രൊഡക്ഷൻ ലോജിക്കിനായി ഇതിനെ ആശ്രയിക്കുന്നതിന് മുമ്പ് ഇതിന്റെ ചില സങ്കീർണ്ണതകൾ മനസ്സിലാക്കേണ്ടതുണ്ട്.

കൺസ്ട്രക്ടർ ഇല്ലാത്ത ഒരു സ്റ്റാറ്റിക് ഒബ്‌ജക്റ്റ്

മിക്ക ബിൽറ്റ്-ഇൻ JavaScript ഒബ്‌ജക്റ്റുകളും ഒരു ഇൻസ്റ്റൻസ് നിർമ്മിക്കാൻ ആവശ്യപ്പെടുന്നു. നിങ്ങൾ new Date() അല്ലെങ്കിൽ new Array() എന്ന് വിളിക്കുന്നു. എന്നാൽ Math അത് അനുവദിക്കില്ല. പ്രിമിറ്റീവ് Number ടൈപ്പിൽ പ്രവർത്തിക്കുന്ന സംബന്ധിച്ച ഫംഗ്ഷനുകളുടെയും കോൺസ്റ്റന്റുകളുടെയും ഒരു നെയിംസ്പേസ് ആയിട്ടാണ് ഇത് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. Math.sqrt(16) എന്ന് വിളിച്ചാൽ നിങ്ങൾക്ക് 4 ലഭിക്കും. new കീവേഡ് ഉപയോഗിക്കാൻ ശ്രമിച്ചാൽ എഞ്ചിൻ ഒരു TypeError കാണിക്കും. ഈ രീതി മെമ്മറി ശുദ്ധമായി സൂക്ഷിക്കാനും Math പൂർണ്ണമായും ഫങ്ഷണൽ (functional) ആണെന്ന് സൂചിപ്പിക്കാനും സഹായിക്കുന്നു. ഇത് ഇൻപുട്ടുകൾ സ്വീകരിക്കുന്നു, ഔട്ട്പുട്ടുകൾ നൽകുന്നു, എന്നാൽ നിലവിലുള്ള ഡാറ്റയിൽ മാറ്റം വരുത്തുന്നില്ല (mutates nothing).

ഓർമ്മിക്കേണ്ട ഒരു പ്രധാന പരിമിതിയുണ്ട്: Math പ്രവർത്തിക്കുന്നത് സ്റ്റാൻഡേർഡ് IEEE 754 നമ്പറുകൾ ഉപയോഗിച്ചാണ്. ഇതിന് BigInt-മായി പ്രവർത്തിക്കാൻ കഴിയില്ല. Math.round() അല്ലെങ്കിൽ Math.abs()-ലേക്ക് ഒരു BigInt നൽകിയാൽ നിങ്ങൾക്ക് ഒരു TypeError ലഭിക്കും. നിങ്ങളുടെ ആപ്ലിക്കേഷൻ 64-ബിറ്റ് ഇന്റീജറുകളോ അതിൽ കൂടുതലോ കൈകാര്യം ചെയ്യുന്നുണ്ടെങ്കിൽ, അവയെ കൺവേർട്ട് ചെയ്യുകയോ അല്ലെങ്കിൽ നേറ്റീവ് BigInt ഓപ്പറേറ്ററുകൾ ഉപയോഗിച്ച് കണക്കുകൂട്ടലുകൾ നടത്തുകയോ ചെയ്യേണ്ടതുണ്ട്.

നിങ്ങൾ യഥാർത്ഥത്തിൽ ഉപയോഗിക്കുന്ന കോൺസ്റ്റന്റുകൾ

മാജിക് നമ്പറുകൾ (magic numbers) നേരിട്ട് കോഡിൽ ഉപയോഗിക്കുന്നതിന് പകരം Math ഒബ്‌ജക്റ്റ് ഉപയോഗപ്രദമായ ചില നമ്പറുകൾ നൽകുന്നു.

  • Math.PI എന്നത് വൃത്തങ്ങൾ, ത്രികോണമിതി (trigonometry), അല്ലെങ്കിൽ ഡിഗ്രിയെ റേഡിയൻ ആക്കി മാറ്റുന്നത് എന്നിവയുമായി ബന്ധപ്പെട്ട കാര്യങ്ങൾക്ക് അത്യാവശ്യമായ 3.14159... ആണ്.
  • Math.E എന്നത് യൂലർ നമ്പർ (Euler's number) ആണ്, ഏകദേശം 2.718. എക്സ്പോണൻഷ്യൽ ഗ്രോത്ത് കർവുകൾ, കോമ്പൗണ്ട് ഇൻട്രസ്റ്റ് കണക്കുകൂട്ടലുകൾ, ലോഗരിതമിക് സ്കെയിലുകൾ എന്നിവയിൽ ഇത് ഉപയോഗിക്കുന്നു.
  • Math.SQRT2 എന്നത് രണ്ട് యొక్క വർഗ്ഗമൂലം (square root) ആണ്, ഏകദേശം 1.414. ഒരു ചതുരത്തിന്റെ വികർണ്ണം (diagonal) കാണാനോ ലളിതമായ ജ്യാമിതിയിൽ വെക്റ്ററുകൾ നോർമലൈസ് ചെയ്യാനോ ഇത് ഉപകരിക്കും.
  • Math.LN2 എന്നത് 2-ന്റെ നാച്ചുറൽ ലോഗരിതം (natural logarithm) ആണ്, ഏകദേശം 0.693. ബൈനറി ട്രീകൾ, ഇൻഫർമേഷൻ എൻട്രോപ്പി, അല്ലെങ്കിൽ ലോഗ്-ബേസ്-2 കണക്കുകൂട്ടലുകൾ ആവശ്യമുള്ള ടൈം കോംപ്ലക്സിറ്റി അനാലിസിസ് എന്നിവയിൽ ഇത് കാണാം.

ഈ മൂല്യങ്ങൾ ഡബിൾ-പ്രസിഷൻ ഫ്ലോട്ടുകൾ (double-precision floats) ആണ്. ഇവ മെത്തേഡുകൾ അല്ലാത്തതിനാൽ ബ്രാക്കറ്റുകൾ ഇല്ലാതെ തന്നെ നിങ്ങൾക്ക് ഇവ ഉപയോഗിക്കാം.

റൗണ്ടിംഗ്, ചിഹ്നങ്ങൾ, അബ്സല്യൂട്ട് വാല്യൂസ്

നമ്പറുകൾ ക്രമീകരിക്കുന്നതാണ് Math-ലെ ഏറ്റവും സാധാരണമായ ജോലികൾ. JavaScript നാല് റൗണ്ടിംഗ് മെത്തേഡുകൾ നൽകുന്നുണ്ട്, അവയുടെ പ്രവർത്തനം പോസിറ്റീവ് നമ്പറുകളിൽ നിന്ന് വ്യത്യസ്തമായിരിക്കാം.

Math.abs(x) ഒരു നമ്പറിന്റെ മാഗ്നിറ്റ്യൂഡ് (magnitude) നൽകുന്നു. -42 നൽകിയാൽ 42 ലഭിക്കും. ദിശയേക്കാൾ ദൂരത്തിനാണ് പ്രാധാന്യമെങ്കിൽ ഇത് ഉപയോഗിക്കാം. ടൈംസ്റ്റാമ്പുകൾ താരതമ്യം ചെയ്യാനോ, UI-യിലെ ഡ്രാഗ് ഡെൽറ്റകൾ കണക്കാക്കാനോ, ഒരു ഊഹം തെറ്റാണോ എന്ന് പരിശോധിക്കാനോ ഇത് സഹായിക്കും.

Math.round(x) എന്നത് സാധാരണ റൗണ്ടിംഗ് രീതിയാണ്. ഇത് ഏറ്റവും അടുത്തുള്ള പൂർണ്ണസംഖ്യ (integer) നൽകുന്നു, പകുതി değerകൾ (halves) അടുത്ത പോസിറ്റീവ് പൂർണ്ണസംഖ്യയിലേക്ക് റൗണ്ട് ചെയ്യുന്നു. അതിനാൽ 4.4 എന്നത് 4 ആയും 4.5 എന്നത് 5 ആയും മാറും.

Math.ceil(x) എപ്പോഴും അടുത്തുള്ള ഉയർന്ന പൂർണ്ണസംഖ്യയിലേക്ക് റൗണ്ട് ചെയ്യുന്നു. 4.1 എന്നത് 5 ആയും -4.9 എന്നത് -4 ആയും മാറും. നെഗറ്റീവ് നമ്പറുകളിൽ -4 എന്നത് -4.9-നേക്കാൾ വലുതായതുകൊണ്ട് ഇത് ആളുകളെ അത്ഭുതപ്പെടുത്താറുണ്ട്.

Math.floor(x) ഇതിന് നേരെ വിപരീതമാണ്. ഇത് എപ്പോഴും താഴെയുള്ള പൂർണ്ണസംഖ്യയിലേക്ക് റൗണ്ട് ചെയ്യുന്നു. 4.9 എന്നത് 4 ആയും -4.1 എന്നത് -5 ആയും മാറും. സെർച്ച് റിസൾട്ടുകൾ പേജിനേറ്റ് ചെയ്യാനോ മെമ്മറി ബ്ലോക്കുകൾ അനുവദിക്കാനോ ഇത് സാധാരണയായി ഉപയോഗിക്കുന്നു.

Math.trunc(x) ദശാംശ ഭാഗം (decimal part) പൂർണ്ണമായും ഒഴിവാക്കി പൂർണ്ണസംഖ്യ മാത്രം നൽകുന്നു. ഇത് ചിഹ്നം (sign) നോക്കാതെ പൂജ്യത്തിലേക്ക് നീങ്ങുന്നു. 4.9 എന്നത് 4 ആയും -4.9 എന്നത് -4 ആയും മാറും. ഫ്ലോട്ടുകളെ ഇന്റീജറുകളാക്കി മാറ്റുന്ന മറ്റ് ഭാഷകളിൽ നിന്നുള്ള ലോജിക് ഉപയോഗിക്കുമ്പോൾ ഇത് ഉപകരിക്കും.

അവസാനമായി, Math.sign(x) ഒരു മൂല്യം പൂജ്യത്തിന്റെ ഏത് വശത്താണെന്ന് പറഞ്ഞുതരുന്നു. പോസിറ്റീവ് ആണെങ്കിൽ 1, നെഗറ്റീവ് ആണെങ്കിൽ -1, പോസിറ്റീവ് സീറോ ആണെങ്കിൽ 0, നെഗറ്റീവ് സീറോ ആണെങ്കിൽ -0, നമ്പറല്ലെങ്കിൽ NaN എന്നിവയാണ് ഇത് നൽകുന്നത്. ഒരു if-else ചെയിൻ എഴുതാതെ തന്നെ ദിശ തിരിച്ചറിയാൻ ഇത് സഹായിക്കുന്നു.

റാൻഡം നമ്പറുകൾ ജനറേറ്റ് ചെയ്യുക

Math.random() എന്നത് 0 (ഉൾപ്പെടെ) മുതൽ 1 (ഒഴികലെ) വരെയുള്ള ഒരു റാൻഡം ഫ്ലോട്ട് (pseudo-random float) നൽകുന്നു. ഇത് ക്രിപ്റ്റോഗ്രാഫിക്കൽ സുരക്ഷയുള്ളതല്ല (not cryptographically secure), അതിനാൽ പാസ്‌വേഡ് നിർമ്മാണം, ടോക്കൺ നിർമ്മാണം അല്ലെങ്കിൽ പണമിടപാടുകൾ എന്നിവയ്ക്കായി ഇത് ഉപയോഗിക്കരുത്.