JavaScript లో Math & Date Objects: సంపూర్ణ మార్గదర్శి

సాధారణంగా జావాస్క్రిప్ట్ లో ఆబ్జెక్టులను సృష్టించేటప్పుడు లేదా క్లాసులను వాడేటప్పుడు మనం new కీవర్డ్ వాడతాం (ఉదాహరణకు new Date()). కానీ Math ఆబ్జెక్ట్ కి new వాడకూడదు.

ప్రముఖ స్థిరరాశులు (Constants):

• Math.PI ➔ 3.141592653589793 (వృత్తం వైశాల్యం, చుట్టుకొలత కోసం).
• Math.E ➔ 2.718281828459045 (యూలర్ సంఖ్య, కాంపౌండ్ ఇంట్రెస్ట్/లగారిథమ్స్ లో వాడతారు).

దశాంశ సంఖ్యలను (decimal numbers) పూర్ణాంకాలుగా (integers) మార్చడానికి జావాస్క్రిప్ట్ 4 ప్రాథమిక మెథడ్స్ అందిస్తుంది. బిగినర్స్ తరచుగా ధన సంఖ్యలు (positive) మరియు రుణ సంఖ్యల (negative) విషయంలో వీటి ఫలితాలను చూసి అయోమయానికి గురవుతారు:

Math.random() ని కాల్ చేసిన ప్రతిసారీ అది 0 నుండి 1 లోపు (0 రావచ్చు, కానీ ఎప్పటికీ ఖచ్చితమైన 1 రాదు: 0 <= x < 1) ఒక యాదృచ్ఛిక ఫ్లోటింగ్ పాయింట్ సంఖ్యను ఇస్తుంది (ఉదాహరణకు 0.4829148...).

కానీ వాస్తవ ప్రాజెక్టులలో మనకు ఇలాంటి దశాంశాలు సరిపోవు. ఉదాహరణకు లూడో గేమ్‌లో 1 నుండి 6 మధ్య సంఖ్య కావాలి, లేదా మొబైల్ OTP కోసం 100000 నుండి 999999 మధ్య సంఖ్య కావాలి. దీని కోసం ప్రపంచవ్యాప్తంగా డెవలపర్లు వాడే గోల్డెన్ ఫార్ములా ఇది:

జావాస్క్రిప్ట్ లో సాధారణ అంకగణితానికి ఉపయోగపడే మరికొన్ని ప్రముఖ పద్ధతులు:

కంప్యూటర్లకు మన క్యాలెండర్లు, వారాలు, గంటల పేర్లు సహజంగా తెలియవు. మరి ప్రోగ్రామింగ్ ప్రపంచంలో సమయాన్ని ఎలా లెక్కిస్తారు?

Date ఆబ్జెక్ట్‌ను సృష్టించే 4 పద్ధతులు:

1. new Date() ➔ ఈ క్షణపు ఖచ్చితమైన ప్రస్తుత తేదీ మరియు సమయం.
2. new Date("2026-10-24T15:30:00") ➔ ISO డేట్ స్ట్రింగ్ ద్వారా నిర్దిష్ట తేదీని ఇవ్వడం.
3. new Date(year, monthIndex, day, hours, minutes, seconds) ➔ విడివిడి సంఖ్యలతో క్రియేట్ చేయడం.
4. new Date(milliseconds) ➔ 1970 నుండి గడిచిన మిల్లీసెకన్లను నేరుగా ఇవ్వడం.

Date ఆబ్జెక్ట్ లోని డేటాను చదవడానికి (Get) మరియు మార్చడానికి (Set) అనేక బిల్ట్-ఇన్ మెథడ్స్ ఉన్నాయి. కానీ ఇందులో బిగినర్స్ ని భయపెట్టే 3 పెద్ద చిక్కులు (Gotchas) ఉన్నాయి:

Math రౌండింగ్, రాండమ్ సంఖ్యల సూత్రం, మరియు Date ఆబ్జెక్ట్ నుండి వివరాలు వెలికితీసే ఏకైక సమగ్ర కోడ్ ఉదాహరణ ఇది. Node.js v22 లో టెస్ట్ చేయబడిన వాస్తవ ఔట్‌పుట్‌ను గమనించండి:

// 1. Math Rounding విశ్లేషణ
console.log("--- Math Rounding ---");
console.log("Math.round(4.7):", Math.round(4.7)); // 5
console.log("Math.round(4.4):", Math.round(4.4)); // 4
console.log("Math.floor(4.9):", Math.floor(4.9)); // 4 (ఎల్లప్పుడూ కిందికి)
console.log("Math.ceil(4.1):", Math.ceil(4.1));   // 5 (ఎల్లప్పుడూ పైకి)
console.log("Math.trunc(-4.9):", Math.trunc(-4.9)); // -4 (దశాంశాలు కట్)
console.log("Math.floor(-4.9):", Math.floor(-4.9)); // -5 (మరింత చిన్న విలువకు)

// 2. నిర్దిష్ట రేంజ్ లో Random పూర్ణాంకం (Golden Formula)
function getRandomInt(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}
console.log("Random Dice Roll (1 to 6):", getRandomInt(1, 6));

// 3. Min, Max, Pow, Sqrt
const scores = [88, 95, 62, 99, 74];
console.log("Max Score:", Math.max(...scores));
console.log("Min Score:", Math.min(...scores));
console.log("2^5 (Pow):", Math.pow(2, 5));
console.log("Sqrt(144):", Math.sqrt(144));

// 4. Date Operations & 0-Index Gotchas
console.log("--- Date Operations ---");
const sampleDate = new Date(2026, 9, 24, 15, 30, 0); // Month 9 = October!
console.log("Year:", sampleDate.getFullYear());
console.log("Month (0-11):", sampleDate.getMonth(), "(October)");
console.log("Date (1-31):", sampleDate.getDate());
console.log("Day (0-6):", sampleDate.getDay(), "(Saturday)");

// 5. రెండు తేదీల మధ్య రోజుల వ్యత్యాసం (Timestamp Difference)
const d1 = new Date("2026-10-01");
const d2 = new Date("2026-10-25");
const diffMs = d2.getTime() - d1.getTime(); // మిల్లీసెకన్ల తేడా
const diffDays = diffMs / (1000 * 60 * 60 * 24); // రోజుల్లోకి మార్పు
console.log("Days between d1 and d2:", diffDays);

• Math.floor(-4.9) విలువ -5 గా మారడాన్ని గమనించండి, కానీ Math.trunc(-4.9) కేవలం -4 ని ఇచ్చింది.
• sampleDate.getMonth() మనకు 9 ని ఇచ్చింది, ఎందుకంటే జనవరి 0 నుండి ప్రారంభం అవుతుంది.
• తేదీల మధ్య వ్యవధిని లెక్కించడానికి getTime() ఇచ్చే మిల్లీసెకన్లను రోజులకు మార్చడానికి 1000 * 60 * 60 * 24 చేత భాగించాం.

డేటాబేస్‌లలో రికార్డులు ఎప్పుడు సృష్టించబడ్డాయో (created_at) ట్రాక్ చేయడానికి లేదా ఏదైనా ఒక ఫంక్షన్ రన్ అవ్వడానికి ఎన్ని మిల్లీసెకన్లు పట్టిందో కొలవడానికి Timestamp ఉపయోగిస్తాం.

ప్రస్తుత టైమ్‌స్టాంప్ పొందే 2 మార్గాలు:

• Date.now() ➔ ఎటువంటి ఆబ్జెక్ట్ సృష్టించకుండా నేరుగా ప్రస్తుత మిల్లీసెకన్ల సంఖ్యను ఇస్తుంది (అత్యంత వేగవంతమైనది).
• new Date().getTime() ➔ ఒక డేట్ ఆబ్జెక్ట్ ద్వారా టైమ్‌స్టాంప్ పొందడం.

Math మరియు Date కాన్సెప్టులతో పనిచేసేటప్పుడు బిగినర్స్ అనుకోకుండా చేసే ప్రధాన తప్పిదాలు:

ఈ క్రింది ప్రాజెక్ట్‌లో మనం ఒక యూజర్ పుట్టిన తేదీని బట్టి వారి ప్రస్తుత పూర్తి వయస్సు (Years), వారి తర్వాతి పుట్టినరోజుకు ఇంకా ఎన్ని రోజుల సమయం మిగిలి ఉందో కౌంట్‌డౌన్, మరియు లాగిన్ సెక్యూరిటీ కోసం ఒక రాండమ్ 6-అంకెల OTP ని జనరేట్ చేసే ప్రొడక్షన్-గ్రేడ్ ఫంక్షన్‌ను నిర్మిస్తున్నాం:

// 1. సెక్యూర్ 6-అంకెల రాండమ్ OTP జనరేటర్
function generateSecurityOTP(digits = 6) {
  const min = Math.pow(10, digits - 1); // 100000
  const max = Math.pow(10, digits) - 1; // 999999
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

// 2. వయస్సు మరియు తర్వాతి బర్త్‌డే కౌంట్‌డౌన్ కాలిక్యులేటర్
function calculateAgeAndCountdown(birthDateString) {
  const now = new Date("2026-10-24T12:00:00"); // స్థిర ప్రస్తుత తేదీ (టెస్టింగ్ కోసం)
  const birth = new Date(birthDateString);

  // పూర్తి సంవత్సరాలలో వయస్సు లెక్క
  let years = now.getFullYear() - birth.getFullYear();
  const monthDiff = now.getMonth() - birth.getMonth();

  // ఈ సంవత్సరం బర్త్‌డే ఇంకా రాకపోతే 1 సంవత్సరం తగ్గించాలి
  if (monthDiff < 0 || (monthDiff === 0 && now.getDate() < birth.getDate())) {
    years--;
  }

  // తర్వాతి బర్త్‌డే తేదీని నిర్ణయించడం
  let nextBirthday = new Date(now.getFullYear(), birth.getMonth(), birth.getDate());
  if (now > nextBirthday) {
    // ఈ ఏడాది పుట్టినరోజు అయిపోతే వచ్చే ఏడాదికి సెట్ చేయాలి
    nextBirthday.setFullYear(now.getFullYear() + 1);
  }

  // మిల్లీసెకన్ల తేడా నుండి రోజులను కనుగొనడం
  const diffMs = nextBirthday.getTime() - now.getTime();
  const daysLeft = Math.ceil(diffMs / (1000 * 60 * 60 * 24));

  return {
    ageInYears: years,
    daysUntilNextBirthday: daysLeft,
    generatedSecurityOTP: generateSecurityOTP(6)
  };
}

// నవంబర్ 15, 2000 న జన్మించిన యూజర్ డేటా
const profile = calculateAgeAndCountdown("2000-11-15");
console.log("ప్రస్తుత వయస్సు (సంవత్సరాలు):", profile.ageInYears);
console.log("తర్వాతి బర్త్‌డేకి మిగిలిన రోజులు:", profile.daysUntilNextBirthday);
console.log("సెక్యూరిటీ లాగిన్ OTP:", profile.generatedSecurityOTP);

ఈ క్రింది ప్రశ్నలకు స్వయంగా సమాధానం చెప్పడానికి ప్రయత్నించండి, ఆపై డ్రాప్‌డౌన్ తెరిచి వివరణను సరిచూసుకోండి:

1. Math.floor(-3.1) మరియు Math.trunc(-3.1) ల ఔట్‌పుట్ ఏమిటి? ఎందుకు?
2. Math.random() ఉపయోగించి 10 నుండి 20 మధ్య (10 మరియు 20 కలుపుకొని) రాండమ్ పూర్ణాంకం ఎలా పొందాలి?
3. const d = new Date(2025, 0, 15); లోని నెల ఏది?
4. రెండు డేట్ ఆబ్జెక్టులు ఒకే క్షణాన్ని సూచిస్తున్నాయో లేదో తెలుసుకోవడానికి d1 === d2 ఎందుకు పని చేయదు?
5. ఒక అప్లికేషన్‌లో ప్రస్తుత సమయానికి సరిగ్గా 7 రోజుల తర్వాత ఎక్స్‌పైరీ అయ్యే తేదీని ఎలా సెట్ చేయాలి?
6. Math.max() లో ఏ ఆర్గ్యుమెంట్స్ ఇవ్వకపోతే ఔట్‌పుట్ ఏమి వస్తుంది?