వార సంఖ్యను తేదీ పరిధిగా ఎలా మార్చాలి — పూర్తి గైడ్

ఎవరైనా మీకు ఒక షెడ్యూల్ పంపారు. “డెలివరీ W23 లో.” మీరు క్యాలెండర్ తెరిచి చూస్తారు. అసలు అది ఏ తేదీలు, ఖచ్చితంగా?

వార సంఖ్యలు ప్రాజెక్ట్ ప్లానింగ్, తయారీ, రిటైల్, లాజిస్టిక్స్ లో ఎక్కడైనా వాడతారు — కానీ చాలామందికి అవి లేబుళ్లలా మాత్రమే తెలుసు. వార సంఖ్యను తిరిగి క్యాలెండర్ తేదీలుగా మార్చడం అంత సహజంగా అనిపించదు, పైగా సంవత్సరం మారే దగ్గర (year boundary) సందర్భాలు అనుభవజ్ఞులైన డెవలపర్లకూ చిక్కులు పెడతాయి.

ఈ గైడ్ పూర్తి కన్వర్షన్‌ని కవర్ చేస్తుంది: వార సంఖ్య నుండి సోమవారం, వార సంఖ్య నుండి పూర్తి తేదీ పరిధి (సోమవారం–ఆదివారం), అలాగే రివర్స్ (తేదీ నుండి వార సంఖ్య). Python, JavaScript, Excel, SQL కోసం కోడ్ కూడా ఉంది.

ఒక వార సంఖ్య నిజంగా ఏమి చెబుతుంది

ఏదైనా లెక్కించడానికి ముందుగా, ఆ సంఖ్య ఏ వార-నంబరింగ్ సిస్టమ్ నుంచి వచ్చిందో తెలుసుకోవాలి.

ISO 8601 (అంతర్జాతీయ ప్రమాణం): సంవత్సరం యొక్క మొదటి గురువారాన్ని కలిగిన వారం = వారం 1. వారాలు సోమవారం నుంచి ఆదివారం వరకు నడుస్తాయి. ఒక సంవత్సరంలో 52 లేదా 53 ISO వారాలు ఉంటాయి. ముఖ్యంగా — ISO “వార సంవత్సరం” (week year) క్యాలెండర్ సంవత్సరంతో భిన్నంగా ఉండొచ్చు. డిసెంబర్ చివరి రోజులు కొన్నిసార్లు తదుపరి సంవత్సరం వారం 1 లో పడతాయి.

US-style: జనవరి 1 ఉండే వారం = వారం 1. టూల్‌ని బట్టి వారాలు ఆదివారం–శనివారం లేదా సోమవారం–ఆదివారం నడవొచ్చు. జనవరి 1 ఎప్పుడూ వారం 1 లోనే ఉంటుంది.

ఈ గైడ్‌లో “వార సంఖ్య” అంటే ప్రత్యేకంగా చెప్పనంతవరకు ISO 8601 అని అర్థం. మీరు US-ఆధారిత టూల్ (ఉదా: డిఫాల్ట్ Excel WEEKNUM) నుంచి వార సంఖ్య పొందితే, ఫార్ములా వేరే — కింద ఉన్న సెక్షన్ చూడండి.

మీకు సంవత్సరం కూడా అవసరం. “వారం 23” అన్నది సంవత్సరం లేకపోతే అర్థం లేదు. ఎప్పుడూ వార సంఖ్యను (year, week) జంటగా చూడండి. 2025 లోని వారం 23 జూన్ 2న మొదలవుతుంది. 2026 లోని వారం 23 జూన్ 1న మొదలవుతుంది. 2026 లోని వారం 1 అయితే 2025 డిసెంబర్ 29న మొదలవుతుంది.

ప్రధాన ఫార్ములా: ISO వార సంఖ్య → సోమవారం

ప్రతి ISO వారం సోమవారం ప్రారంభమవుతుంది. సంవత్సరం Y లోని ISO వారం W కి సోమవారం కనుగొనడానికి:

Monday = Jan 4 of Y + (W - 1) × 7 days - weekday(Jan 4 of Y) + 1

ఇక్కడ లాజిక్: ISO నిర్వచనం ప్రకారం జనవరి 4 ఎప్పుడూ ISO వారం 1 లోనే ఉంటుంది. జనవరి 4 ఉన్న వారానికి సోమవారం ఎక్కడ ఉందో కనుగొని, అక్కడి నుంచి (W - 1) వారాలు ముందుకు వెళ్తే లక్ష్య వారం సోమవారం వస్తుంది.

ఇదే మరింత క్లీన్గా:

Monday of W1 = Jan 4 of Y - weekday(Jan 4 of Y) + 1
Monday of W  = Monday of W1 + (W - 1) × 7

ఇక్కడ weekday అనేది ISO weekday నంబరింగ్ ప్రకారం సోమవారం=1 నుంచి ఆదివారం=7 వరకు రిటర్న్ చేస్తుంది.

ఉదాహరణ: 2026 లో వారం 23

• 2026 జనవరి 4 ఆదివారం. ISO weekday = 7.
• W1 సోమవారం: Jan 4 − 7 + 1 = 2025 డిసెంబర్ 29.
• W23 సోమవారం: 2025 డిసెంబర్ 29 + 22 × 7 = 154 రోజులు తర్వాత = 2026 జూన్ 1.
• W23 ఆదివారం: 2026 జూన్ 1 + 6 = 2026 జూన్ 7.

2026 లో వారం 23 అంటే 2026 జూన్ 1 (సోమవారం) నుంచి 2026 జూన్ 7 (ఆదివారం) వరకు.

సంవత్సరం సరిహద్దు (Year Boundary) ట్రాప్

అత్యంత సాధారణ పొరపాటు: సంవత్సరం Y లో వారం 1 ఎప్పుడూ సంవత్సరం Y లోనే మొదలవుతుందని అనుకోవడం.

అలా కాదు.

ISO లో వారం 1 అంటే “సంవత్సరం యొక్క మొదటి గురువారాన్ని కలిగిన వారం”. ఆ గురువారం జనవరి ప్రారంభంలో ఉంటే, వారం 1 సోమవారం గత సంవత్సరం డిసెంబర్‌లో పడొచ్చు.

ఉదాహరణలు:

2025 లో W1 డిసెంబర్ 2024 లో మొదలవుతుంది. 2026 లో W1 డిసెంబర్ 2025 లో మొదలవుతుంది.

అర్థం:

• 2025 డిసెంబర్ 29–31 అనేవి 2025 కాదు — ISO వారం 1 of 2026 లోకి వస్తాయి.
• ఎవరు “W1 2026 లో డెలివరీ” అన్నా, ఆ డెడ్‌లైన్ 2025 డిసెంబర్ 29న మొదలయ్యే వారం.

రివర్స్ ట్రాప్ కూడా ఉంటుంది: కొన్ని సంవత్సరాల్లో చివరి డిసెంబర్ రోజులు తదుపరి సంవత్సరంలోని వారం 1 లోకి పడతాయి. వారాన్ని లేబుల్ చేయేటప్పుడు క్యాలెండర్ సంవత్సరం కాదు, ISO week year (%G in Python, isoyear in PostgreSQL) వాడాలి.

ఏ వార సంఖ్యకైనా పూర్తి తేదీ పరిధి

సోమవారం దొరికాక మిగతా రోజులు సింపుల్:

వారం W కి తేదీ పరిధి: [Monday, Monday + 6 days].

కేవలం పని దినాలు (Mon–Fri): [Monday, Monday + 4 days].

Python

from datetime import date, timedelta

def iso_week_to_monday(year: int, week: int) -> date:
    # Jan 4 is always in ISO week 1
    jan4 = date(year, 1, 4)
    # Move back to Monday of that week
    week1_monday = jan4 - timedelta(days=jan4.weekday())
    # Step forward to the target week
    return week1_monday + timedelta(weeks=week - 1)

def iso_week_to_range(year: int, week: int) -> tuple[date, date]:
    monday = iso_week_to_monday(year, week)
    sunday = monday + timedelta(days=6)
    return monday, sunday

# Examples
monday, sunday = iso_week_to_range(2026, 23)
print(monday)   # 2026-06-01
print(sunday)   # 2026-06-07

monday, sunday = iso_week_to_range(2026, 1)
print(monday)   # 2025-12-29  ← note: starts in 2025
print(sunday)   # 2026-01-04

Python లో రివర్స్ (date → ISO week) కోసం బిల్ట్-ఇన్ ఉంది:

d = date(2026, 6, 4)
iso_year, iso_week, iso_weekday = d.isocalendar()
print(iso_year, iso_week)  # 2026 23

ISO సంవత్సరం కావాలంటే d.isocalendar().year వాడండి (సరిహద్దుల్లో d.year తో భిన్నంగా ఉండొచ్చు).

Python 3.8+ లో fromisocalendar ఉపయోగించి రివర్స్‌గా:

# Get Monday of ISO week 23, 2026 directly
monday = date.fromisocalendar(2026, 23, 1)  # weekday 1 = Monday
print(monday)  # 2026-06-01

Python 3.8 లేదా తర్వాతైతే date.fromisocalendar(year, week, weekday) అత్యంత క్లీనైన పద్ధతి.

JavaScript

JavaScript కి native ISO week support లేదు. మాన్యువల్ ఇంప్లిమెంటేషన్:

function isoWeekToMonday(year, week) {
  // Jan 4 is always in ISO week 1
  const jan4 = new Date(year, 0, 4)
  const dayOfWeek = jan4.getDay() || 7  // convert Sun=0 to 7
  const week1Monday = new Date(jan4)
  week1Monday.setDate(jan4.getDate() - dayOfWeek + 1)
  
  const monday = new Date(week1Monday)
  monday.setDate(week1Monday.getDate() + (week - 1) * 7)
  return monday
}

function isoWeekToRange(year, week) {
  const monday = isoWeekToMonday(year, week)
  const sunday = new Date(monday)
  sunday.setDate(monday.getDate() + 6)
  return { monday, sunday }
}

// Examples
const { monday, sunday } = isoWeekToRange(2026, 23)
console.log(monday.toISOString().slice(0, 10))  // 2026-06-01
console.log(sunday.toISOString().slice(0, 10))  // 2026-06-07

const w1 = isoWeekToRange(2026, 1)
console.log(w1.monday.toISOString().slice(0, 10))  // 2025-12-29

date-fns ఉపయోగిస్తే:

import { setISOWeek, setISOWeekYear, startOfISOWeek, endOfISOWeek } from 'date-fns'

function isoWeekToRange(year, week) {
  let d = new Date(year, 0, 4)  // any date in the target year
  d = setISOWeekYear(d, year)
  d = setISOWeek(d, week)
  return {
    monday: startOfISOWeek(d),
    sunday: endOfISOWeek(d)
  }
}

date-fns అన్ని edge-case లను సరిగ్గా హ్యాండిల్ చేస్తుంది; ప్రొడక్షన్ కోడ్‌కు ఇది సిఫార్సు చేయబడిన పద్ధతి.

Excel మరియు Google Sheets

Excel లో “week number → date” కోసం direct ఫంక్షన్ లేదు, కానీ ఫార్ములాతో నిర్మించవచ్చు.

Year Y లో ISO Week W కి సోమవారం:

=DATE(Y,1,4) - WEEKDAY(DATE(Y,1,4),2) + 1 + (W-1)*7

ఇది ఇలా పని చేస్తుంది:

• DATE(Y,1,4) — ఆ సంవత్సరంలోని జనవరి 4
• WEEKDAY(...,2) — సోమవారం=1, ఆదివారం=7
• తీసివేస్తే Week 1 సోమవారం వస్తుంది
• (W-1)*7 జోడిస్తే లక్ష్య వారానికి వెళ్తుంది

పూర్తి రేంజ్ కోసం ఆదివారం:

=Monday_formula + 6

షీట్ ఉదాహరణ (A1 = year, B1 = week number):

Monday: =DATE(A1,1,4) - WEEKDAY(DATE(A1,1,4),2) + 1 + (B1-1)*7
Sunday: =Monday_cell + 6

రెండింటినీ తేదీ ఫార్మాట్‌లో పెట్టండి. 2026, week 1 కోసం ఇది Monday గా 2025 డిసెంబర్ 29 ఇస్తుంది — అది సరైనదే.

రివర్స్ (date → ISO week number): ISOWEEKNUM(date) వాడండి. ISO year కోసం Excel లో native ఫంక్షన్ లేదు; ISOWEEKNUM వ్యాసంలో ఉన్న workaround ఉపయోగించాలి.

SQL

PostgreSQL లో ISO support బలంగా ఉంటుంది:

-- Monday of ISO week W in year Y
SELECT
  make_date(2026, 1, 4)
    + (23 - 1) * 7  -- step to week 23
    - EXTRACT(isodow FROM make_date(2026, 1, 4))::int + 1
    AS week_monday;
-- 2026-06-01

-- Or more cleanly using generate_series for a range lookup
SELECT
  d::date AS week_monday,
  (d + 6)::date AS week_sunday,
  EXTRACT(isoyear FROM d) AS iso_year,
  EXTRACT(week FROM d) AS iso_week
FROM generate_series(
  DATE '2026-01-01',
  DATE '2026-12-31',
  INTERVAL '7 days'
) d
WHERE EXTRACT(week FROM d) = 23
  AND EXTRACT(isoyear FROM d) = 2026;

to_date తో ISO format codes ఉపయోగించే క్లీనర్ పద్ధతి:

-- Convert ISO year + week to Monday
SELECT to_date('2026' || '23' || '1', 'IYYYIWid') AS monday;
-- 2026-06-01

-- Format: IYYY=ISO year, IW=ISO week, id=ISO day (1=Monday)

MySQL:

-- Monday of ISO week 23, 2026
SELECT STR_TO_DATE('202623 Monday', '%X%V %W');
-- 2026-06-01

-- Or step-based:
SELECT DATE_ADD(
  DATE_ADD(STR_TO_DATE('2026-01-04', '%Y-%m-%d'),
    INTERVAL (-(WEEKDAY(STR_TO_DATE('2026-01-04', '%Y-%m-%d')))) DAY),
  INTERVAL (23 - 1) * 7 DAY
) AS week_monday;

SQL Server:

-- Monday of ISO week 23, 2026
DECLARE @year INT = 2026, @week INT = 23

SELECT DATEADD(
  DAY,
  (@week - 1) * 7
    - (DATEPART(WEEKDAY, DATEFROMPARTS(@year, 1, 4)) + 5) % 7,
  DATEFROMPARTS(@year, 1, 4)
) AS week_monday;
-- 2026-06-01

US-style వార సంఖ్య → తేదీలు

మీ వార సంఖ్య US-style సిస్టమ్ నుండి వస్తే (Week 1 లో January 1 ఉంటుంది, వారాలు Sunday లేదా Monday నుంచి మొదలవుతాయి), year-boundary సమస్య ఉండదు కాబట్టి ఫార్ములా సులువు:

Week start (Sunday-based):

Week_start = DATE(Y, 1, 1) + (W - 1) × 7 - WEEKDAY(DATE(Y, 1, 1), 1)

ఇక్కడ WEEKDAY Sunday=1 నుంచి Saturday=7 వరకు ఇస్తుంది.

కానీ షెడ్యూలింగ్, లాజిస్టిక్స్‌లో US week numbers కంటే ISO ఎక్కువగా కనిపిస్తాయి. ఎవరు సిస్టమ్ చెప్పకుండా వార సంఖ్య ఇచ్చినా, ముఖ్యంగా అంతర్జాతీయ/యూరోపియన్ సందర్భాల్లో ISO అని ఊహించడం సాధారణంగా సరైనది.

2026 త్వరిత సూచన: ISO వారాలు 1–10 మరియు 48–53

గమనిక: 2026 లో W1 2025 డిసెంబర్ 29న మొదలవుతుంది. అలాగే 2026 లో W53 2027 జనవరి 3న ముగుస్తుంది — 2026 అనేది 53 వారాల సంవత్సరం.

సాధారణ పొరపాట్లు — సంక్షిప్తంగా

సంవత్సరం ఇవ్వకపోవడం. “Week 8” అనేది అస్పష్టంగా ఉంటుంది. ఎప్పుడూ 2026-W08 లాంటి ఫార్మాట్‌లో వాడండి.

ISO week year బదులు calendar year వాడడం. 2025 డిసెంబర్ 29 అనేది 2025 కాదు — 2026 యొక్క ISO వారం 1 లో ఉంటుంది. 2025 క్రింద స్టోర్ చేస్తే తప్పు బకెట్‌లో పడుతుంది.

Week 1 జనవరి 1న మొదలవుతుందని అనుకోవడం. చాలాసార్లు ఇది డిసెంబర్ 29, 30 లేదా 31న మొదలవుతుంది. January 1 ఎప్పుడూ Week 1 లో ఉండాలి అంటే మీరు ISO కాదు, US సిస్టమ్‌ని వాడుతున్నారు.

సోమవారం ఫార్ములాలో off-by-one. Jan 4 anchor చాలా ముఖ్యం — Jan 1 కాదు (అది గత సంవత్సరం చివరి వారంలో ఉండొచ్చు). Jan 1ని anchor గా వాడితే కొన్ని సంవత్సరాల్లో తప్పు ఫలితాలు వస్తాయి.

year-boundary తేదీలను టెస్ట్ చేయకపోవడం. తేదీలను హ్యాండిల్ చేసే కోడ్‌ని 28–31 డిసెంబర్ మరియు 1–4 జనవరి తేదీలతో టెస్ట్ చేయాలి. అన్ని edge cases అక్కడే ఉంటాయి.

ISO Week Number Calculator తో ఏ వార సంఖ్యకైనా తేదీ పరిధిని చూడండి, లేదా current week number మరియు నేటి ISO వార పరిధిని చెక్ చేయండి.