JavaScript యొక్క Math object అనేది ఈ భాష యొక్క నిశ్శబ్ద యుటిలిటీ బెల్ట్ (utility belt) వంటిది. మీరు దీనిని ఎప్పుడూ instantiate చేయరు. దీనిని ఎప్పుడూ import చేయరు. పిక్సెల్ విలువను రౌండ్ చేయడం నుండి రాండమ్ డైస్ రోల్ (random dice roll) జనరేట్ చేయడం వరకు ప్రతిదాన్ని హ్యాండిల్ చేయడానికి ఇది ప్రతి runtime లోనూ సిద్ధంగా ఉంటుంది. Math అనేది ఒక static object కాబట్టి, ప్రతి method మరియు property నేరుగా namespace నుండి అందుబాటులో ఉంటాయి. మీరు new Math().PI అని కాకుండా Math.PI అని రాస్తారు. ఈ డిజైన్ ఎంపిక విషయాలను సరళంగా ఉంచుతుంది, కానీ మీరు దీనిని production logic కోసం ఉపయోగించే ముందు, ఇందులో ఉన్న కొన్ని క్లిష్టమైన అంశాలను (sharp edges) అర్థం చేసుకోవడం అవసరం.

కన్స్ట్రక్టర్ లేని ఒక Static Object

చాలా built-in JavaScript objects మీరు ఒక instanceను సృష్టించాలని కోరుకుంటాయి. మీరు new Date() లేదా new Array() అని పిలుస్తారు. కానీ Math నిరాకరిస్తుంది. ఇది primitive Number టైప్‌పై పనిచేసే సంబంధిత ఫంక్షన్‌లు మరియు కాన్స్టంట్‌ల యొక్క namespace గా రూపొందించబడింది. Math.sqrt(16) అని పిలిస్తే మీకు 4 వస్తుంది. new కీవర్డ్‌ని ఉపయోగించడానికి ప్రయత్నిస్తే engine TypeErrorను ఇస్తుంది. ఈ పద్ధతి మెమరీని శుభ్రంగా ఉంచుతుంది మరియు Math అనేది పూర్తిగా functional అని సూచిస్తుంది. ఇది ఇన్‌పుట్‌లను తీసుకుంటుంది, అవుట్‌పుట్‌లను తిరిగి ఇస్తుంది మరియు దేనినీ మారుస్తుంది (mutate) కాదు.

గుర్తుంచుకోవలసిన ఒక కఠినమైన పరిమితి ఉంది: Math అనేది standard IEEE 754 నంబర్లతో పనిచేస్తుంది. ఇది BigIntతో పనిచేయదు. Math.round() లేదా Math.abs()కి BigIntని పంపితే మీకు TypeError వస్తుంది. మీ అప్లికేషన్ 64-bit ఇంటిజర్‌లు లేదా అంతకంటే పెద్ద వాటితో వ్యవహరిస్తుంటే, మీరు వాటిని కన్వర్ట్ చేయాలి లేదా నేటివ్ BigInt ఆపరేటర్లతో అరిథమెటిక్‌ను హ్యాండిల్ చేయాలి.

మీరు నిజంగా ఉపయోగించే Constants

Math object కొన్ని సంఖ్యాపరమైన constantsను అందిస్తుంది, ఇవి మీరు మాజిక్ నంబర్లను (magic numbers) నేరుగా కోడ్‌లో రాయకుండా (hard-coding) కాపాడతాయి.

  • Math.PI అనేది మనకు తెలిసిన 3.14159..., ఇది వృత్తాలు (circles), త్రికోణమితి (trigonometry), లేదా డిగ్రీలను రేడియన్లుగా మార్చడం వంటి వాటికి అవసరం.
  • Math.E అనేది Euler's number, సుమారుగా 2.718. ఇది ఎక్స్‌పోనెన్షియల్ గ్రోత్ కర్వ్స్ (exponential growth curves), కాంపౌండ్ ఇంట్రెస్ట్ లెక్కలు మరియు లాగరిథమిక్ స్కేల్స్‌లో కనిపిస్తుంది.
  • Math.SQRT2 అనేది రెండు యొక్క వర్గమూలం (square root of two), సుమారు 1.414. మీకు చతురస్రం యొక్క కర్ణం (diagonal) కావాలన్నా లేదా సింపుల్ జియోమెట్రీలో వెక్టర్లను నార్మలైజ్ చేయాలన్నా ఇది ఉపయోగపడుతుంది.
  • Math.LN2 అనేది 2 యొక్క నేచురల్ లాగరిథమ్, సుమారుగా 0.693. బైనరీ ట్రీలు, ఇన్ఫర్మేషన్ ఎంట్రోపీ లేదా log-base-2 మ్యాథ్స్ ఉన్న టైమ్ కాంప్లెక్సిటీ అనాలిసిస్‌లో మీరు దీనిని చూస్తారు.

ఈ విలువలు పూర్తిగా double-precision floats. ఇవి methods కాకుండా properties కాబట్టి, మీరు వీటిని బ్రాకెట్లు (parentheses) లేకుండా యాక్సెస్ చేయవచ్చు.

Rounding, Signs, మరియు Absolute Values

అత్యంత సాధారణ Math పనులు ఒక సంఖ్యను శుభ్రం చేయడం (cleaning up a number). JavaScript మీకు నాలుగు రౌండింగ్ పద్ధతులను ఇస్తుంది, అవి ఒకేలా పనిచేయవు, ముఖ్యంగా మీరు పాజిటివ్ పరిధిని దాటినప్పుడు.

Math.abs(x) ఒక సంఖ్య యొక్క పరిమాణాన్ని (magnitude) తిరిగి ఇస్తుంది. దీనికి -42 అని పంపితే మీకు 42 వస్తుంది. దిశ (direction) కంటే దూరం (distance) గురించి మీరు శ్రద్ధ చూపినప్పుడు ఇది ఉపయోగకరంగా ఉంటుంది. టైమ్‌స్టాంప్‌లను పోల్చడం, UIలో drag deltas లెక్కించడం లేదా ఒక అంచనా (guess) ఎర్రర్ మార్జిన్ లోపల ఉందో లేదో తనిఖీ చేయడం వంటి సందర్భాలను తీసుకోండి.

Math.round(x) అనేది సాధారణ రౌండింగ్ పద్ధతి. ఇది దగ్గరి పూర్ణాంకాన్ని (nearest integer) తీసుకుంటుంది, సగం విలువలు (halves) ఉన్నప్పుడు తదుపరి పాజిటివ్ ఇంటిజర్‌కు రౌండ్ చేస్తుంది. కాబట్టి 4.4 అనేది 4 అవుతుంది, మరియు 4.5 అనేది 5 అవుతుంది.

Math.ceil(x) ఎల్లప్పుడూ తదుపరి ఇంటిజర్‌కు పైకి (upward) రౌండ్ చేస్తుంది. 4.1 అనేది 5 అవుతుంది, మరియు -4.9 అనేది -4 అవుతుంది. ఈ చివరిది చాలా మందిని ఆశ్చర్యపరుస్తుంది. ఎందుకంటే నంబర్ లైన్‌పై -4 అనేది -4.9 కంటే పెద్దది, కాబట్టి నెగటివ్ నంబర్ల విషయంలో ceiling సున్నా (zero) వైపు కదులుతుంది.

Math.floor(x) దీనికి విరుద్ధం. ఇది ఎల్లప్పుడూ కిందికి (downward) రౌండ్ చేస్తుంది. 4.9 అనేది 4 అవుతుంది, మరియు -4.1 అనేది -5 అవుతుంది. మీరు సెర్చ్ రిజల్ట్స్‌ను పేజినేట్ చేస్తున్నా లేదా ఫిక్స్‌డ్-సైజ్ మెమరీ బ్లాక్‌లను కేటాయిస్తున్నా, సాధారణంగా మీకు floor పద్ధతే కావాలి.

Math.trunc(x) డెసిమల్‌ను పూర్తిగా తొలగించి, కేవలం ఇంటిజర్ భాగాన్ని మాత్రమే ఉంచుతుంది. ప్రభావవంతంగా చెప్పాలంటే, ఇది గుర్తు (sign)తో సంబంధం లేకుండా సున్నా వైపు కదులుతుంది. 4.9 అనేది 4 అవుతుంది, మరియు -4.9 అనేది -4 అవుతుంది. మీరు ఫ్లోట్‌లను ఇంటిజర్‌లుగా మార్చడానికి truncating పద్ధతిని ఉపయోగించే భాషల నుండి లాజిక్‌ను పోర్ట్ చేస్తున్నట్లయితే, ఇది మీకు బాగా ఉపయోగపడుతుంది.

చివరగా, Math.sign(x) ఒక విలువ సున్నాకి ఏ వైపు ఉందో చెబుతుంది. ఇది పాజిటివ్ కోసం 1, నెగటివ్ కోసం -1, పాజిటివ్ సున్నా కోసం 0, నెగటివ్ సున్నా కోసం -0, మరియు నంబర్ కాని వాటి కోసం NaN ను తిరిగి ఇస్తుంది. if-else చైన్‌ను రాయకుండా దిశను బట్టి బ్రాంచ్ చేయడానికి ఇది ఒక సంక్షిప్త మార్గం.

రాండమ్ నంబర్లను జనరేట్ చేయడం

Math.random() అనేది 0 (కలుపుకొని) నుండి 1 (కలుపుకోకుండా) మధ్య ఒక pseudo-random floatను ఉత్పత్తి చేస్తుంది. ఇది cryptographically secure కాదు, కాబట్టి పాస్‌వర్డ్ జనరేషన్, టోకెన్ క్రియేషన్ లేదా నిజమైన డబ్బుతో సంబంధం ఉన్న దేనికీ దీనిని ఉపయోగించకండి.