JavaScript નું Math object એ ભાષાનું એક શાંત ઉપયોગી સાધન (utility belt) છે. તમે તેને ક્યારેય instantiate કરતા નથી. તમે તેને ક્યારેય import કરતા નથી. તે દરેક runtime માં ફક્ત અસ્તિત્વ ધરાવે છે, જે પિક્સેલ વેલ્યુ રાઉન્ડ કરવાથી લઈને રેન્ડમ ડાઈસ રોલ જનરેટ કરવા સુધી બધું જ હેન્ડલ કરવા માટે તૈયાર હોય છે. કારણ કે Math એક static object છે, તેથી દરેક method અને property સીધી namespace પર હોય છે. તમે Math.PI લખો છો, new Math().PI નહીં. આ ડિઝાઇન પસંદગી વસ્તુઓને સરળ રાખે છે, પરંતુ તેનો અર્થ એ પણ છે કે આ object માં કેટલીક એવી બાબતો છે જે તેને production logic માટે વાપરતા પહેલા સમજવી જરૂરી છે.

કન્સ્ટ્રક્ટર વગરનું એક Static Object

મોટાભાગના built-in JavaScript objects ઈચ્છે છે કે તમે તેનું instance બનાવો. તમે new Date() અથવા new Array() કોલ કરો છો. Math નાકારમાં છે. તે સંબંધિત functions અને constants ના namespace તરીકે ડિઝાઇન કરવામાં આવ્યું છે જે primitive Number type પર કામ કરે છે. Math.sqrt(16) કોલ કરો અને તમને 4 મળશે. new keyword વાપરવાનો પ્રયાસ કરો અને engine TypeError ફેંકશે. આ પેટર્ન મેમરીને સ્વચ્છ રાખે છે અને સંકેત આપે છે કે Math શુદ્ધ રીતે functional છે. તે inputs લે છે, outputs રિટર્ન કરે છે, અને કંઈપણ બદલતું (mutate) નથી.

યાદ રાખવા જેવી એક કડક મર્યાદા છે: Math પ્રમાણભૂત IEEE 754 નંબરો સાથે કામ કરે છે. તે BigInt સાથે કામ કરતું નથી. જો તમે Math.round() અથવા Math.abs() માં BigInt પાસ કરશો તો તમને TypeError મળશે. જો તમારું application 64-bit integers અથવા તેનાથી મોટા નંબરો સાથે કામ કરતું હોય, તો તમારે તેને convert કરવું પડશે અથવા તેના બદલે native BigInt operators સાથે અંકગણિત (arithmetic) હેન્ડલ કરવું પડશે.

તમે ખરેખર ઉપયોગમાં લેતા Constants

Math object કેટલાક સંખ્યાત્મક constants પ્રદર્શિત કરે છે જે તમને magic numbers hard-code કરવામાંથી બચાવે છે.

  • Math.PI એ જાણીતો 3.14159... છે, જે વર્તુળો, ત્રિકોણમિતિ (trigonometry), અથવા ડિગ્રીને રેડિયનમાં રૂપાંતરિત કરવા જેવી કોઈપણ બાબત માટે આવશ્યક છે.
  • Math.E એ Euler's number છે, જે અંદાજે 2.718 છે. તે exponential growth curves, ચક્રવૃદ્ધિ વ્યાજની ગણતરીઓ (compound interest calculations), અને લોગરીધમિક સ્કેલ્સમાં જોવા મળે છે.
  • Math.SQRT2 એ બેનો વર્ગમૂળ (square root) છે, લગભગ 1.414. જ્યારે તમારે ચોરસના વિકર્ણ (diagonal) ની જરૂર હોય અથવા સાદી ભૂમિતિમાં vectors ને normalize કરવા હોય ત્યારે તે ઉપયોગી છે.
  • Math.LN2 એ 2 નો natural logarithm છે, અંદાજે 0.693. તમે આને એવા algorithms માં જોશો જે binary trees, information entropy, અથવા log-base-2 math સાથે સંકળાયેલ time complexity analysis સાથે કામ કરે છે.

આ મૂલ્યો સંપૂર્ણ રીતે double-precision floats છે. કારણ કે તે properties છે અને methods નથી, તમે તેને કૌંસ (parentheses) વગર એક્સેસ કરી શકો છો.

Rounding, Signs, અને Absolute Values

સૌથી સામાન્ય Math કાર્યોમાં સંખ્યાને વ્યવસ્થિત (clean up) કરવાનો સમાવેશ થાય છે. JavaScript તમને ચાર rounding methods આપે છે, અને તેઓ સમાન રીતે વર્તતા નથી, ખાસ કરીને જ્યારે તમે ધન (positive) વિસ્તારની બહાર હોવ.

Math.abs(x) સંખ્યાનું મૂલ્ય (magnitude) રિટર્ન કરે છે. તેને -42 પાસ કરો અને તમને 42 મળશે. જ્યારે તમને દિશાને બદલે અંતરની ચિંતા હોય ત્યારે તે ઉપયોગી છે. ટાઈમસ્ટેમ્પની સરખામણી કરવા, UI માં drag deltas ની ગણતરી કરવા, અથવા અનુમાન error margin ની અંદર છે કે નહીં તે તપાસવા માટે આનો વિચાર કરો.

Math.round(x) એ સામાન્ય રાઉન્ડિંગ પદ્ધતિ છે. તે નજીકની પૂર્ણાંક સંખ્યા (integer) લે છે, અને અડધા (halves) ને આગલા ધન પૂર્ણાંકમાં રાઉન્ડ કરે છે. તેથી 4.4 નું 4 થશે, અને 4.5 નું 5 થશે.

Math.ceil(x) હંમેશા ઉપરની તરફ આગલા પૂર્ણાંકમાં રાઉન્ડ કરે છે. 4.1 નું 5 થશે, અને -4.9 નું -4 થશે. આ છેલ્લું લોકો માટે આશ્ચર્યજનક છે. કારણ કે નંબર લાઇન પર -4 એ -4.9 કરતા મોટું છે, તેથી ceiling નેગેટિવ નંબરો માટે શૂન્ય તરફ જાય છે.

Math.floor(x) તેનાથી વિપરીત છે. તે હંમેશા નીચેની તરફ રાઉન્ડ કરે છે. 4.9 નું 4 થશે, અને -4.1 નું -5 થશે. જો તમે સર્ચ રિઝલ્ટનું પેજીનેશન કરી રહ્યા હોવ અથવા fixed-size memory blocks ફાળવી રહ્યા હોવ, તો સામાન્ય રીતે floor એ જ જોઈએ છે જે તમારે જોઈએ છે.

Math.trunc(x) દશાંશ ભાગને સંપૂર્ણપણે દૂર કરે છે, ફક્ત પૂર્ણાંક ભાગ જ રાખે છે. અસરકારક રીતે, તે ચિહ્ન (sign) ગમે તે હોય, શૂન્ય તરફ જાય છે. 4.9 નું 4 થશે, અને -4.9 નું -4 થશે. જો તમે એવા લેંગ્વેજમાંથી લોજિક પોર્ટ કરી રહ્યા હોવ જે floats ને truncating દ્વારા ints માં રૂપાંતરિત કરે છે, તો આ તમારો મિત્ર છે.

અંતે, Math.sign(x) તમને જણાવે છે કે કિંમત શૂન્યની કઈ બાજુ છે. તે ધન માટે 1, ઋણ માટે -1, પોઝિટિવ ઝીરો માટે 0, નેગેટિવ ઝીરો માટે -0, અને જે સંખ્યા નથી તેના માટે NaN રિટર્ન કરે છે. તે if-else ચેઈન લખ્યા વગર દિશા પર નિર્ણય લેવાની એક સંક્ષિપ્ત રીત છે.

રેન્ડમ નંબરો જનરેટ કરવા

Math.random() 0 (સમાવેશક) થી 1 (બાકાત) વચ્ચેનો pseudo-random float બનાવે છે. તે ક્રિપ્ટોગ્રાફિકલી સુરક્ષિત નથી, તેથી તેનો ઉપયોગ પાસવર્ડ જનરેશન, ટોકન ક્રિએશન અથવા વાસ્તવિક પૈસા સાથે સંકળાયેલ કોઈપણ બાબત માટે કરશો નહીં.