To Foot

Week Number Calculation.

Week Number Routines

Requests for "a function to return the week number of a date" are common. It is essential
  •   to check which definition is to be used;
  •   and, for some definitions, to return also the proper year number, because of the overlaps.
Such a function can also return a Day-of-Week number.

Algorithms here are shown mostly in JavaScript. If translating to VBScript (see via VBScript Date and Time Index), DateSerial can be useful. For Pascal/Delphi, see my Borland Pascal Time and Date and unit dateprox.pas.

Here, when using JavaScript, Week Number Dates are commonly held in arrays [y,w,d] and years are assumed to be AD 100 or later. The possibility of a Date Object representing a time other than 00:00h has largely been disregarded. JavaScript's Math.floor(X/Y) and ((X/Y)|0) are equivalent, the latter being faster, and match VBScript/C's X\Y amd Pascal's X div Y.

Each function giving [y, w, d] here should have a corresponding reverse function.

It should generally be easy enough to convert a week-of-year algorithm to a corresponding week-of-month one.

Refer to the corresponding parts of Calendar Weeks for the associated descriptive material.

It is possible that some code may inadvertently assume either that local time is GMT or that local time is less than 12 hours away from GMT. RSVP if you see signs of that here, unless specific warning is given.

Correctness and Efficiency

The conversion routines are believed to give correct results, and the JavaScript ones can be tested on this page.

The underlying algorithms are reasonably efficient, They go directly to the result, without looping; except that some have a single recursion.

The implementation of some of the JavaScript algorithms that run on this page may not be fully optimum. In particular, I have noticed that using UTC date object functions internally is much faster, and have been converting more routines. Also, code converting via DayCount is comparatively fast. See also in JavaScript Date and Time 1 : Date Arithmetic.

Pascal/Delphi code in my dateprox.pas etc. is mostly older, and may be less efficient.

Day-of-Week

Day-of-Week of a given date in early January of a known Gregorian year number is often needed; that can be rapidly determined with expressions such as used by Zeller.

For 1901-2099, to get Day-of-Week of January 1st, using Sun=0 :-
(5*(y-1) div 4) mod 7    or    Trunc(1.25*(y-1)) mod 7

function Jan1DoWJ(y) { // Sun=0, Gregorian, for 1901-2099 only return ( (1.25*(y-1)|0) ) % 7 } function Jan1DoWG(y) { y-- // Jan 1's DoW, Sun=0, any Gregorian year // see weekcalc.htm#DoW return ( (1.25*y|0) - (y/100|0) + (y/400|0) + 1 ) % 7 } function Jan1line(y) { var D, Q, X, Z D = new Date(y, 0, 1) // January 1st Q = D.getDay() // Sun=0 to Sat=6 X = Jan1DoWJ(y) ; Z = Jan1DoWG(y) return D.YMDDstr() + '\t' + Q + '\t' + X + ' ' + (Q==X) + '\t\t' + Z + ' ' + (Q==Z) } function Jan1lists() { var y, D, Q, X, Z, Ar Ar = ["<pre>\n\t\t#\tDoWJ\t\tDoWG\n"] for (y=1500; y<2901; y+=100) Ar.push(Jan1line(y)) Ar.push("\n") for (y=1896; y<2106; y++) Ar.push(Jan1line(y)) Ar.push("<\/pre>") NewPage("Jan 1 List", Ar.join("\n")) }

An Error

Note that Appendix B of a draft Internet standard, dated in the 1990's, has a C routine (based on Zeller's) for getting day-of-week from Y M D in which the left operand of a mod operator goes negative for some dates early in a century, giving a wrong result. Uncorrected copies are still on the Net.

Imported Functions and Added Methods

See JavaScript Include Files.

• General :-
  • function LZ(N) to a two-digit string
• ISO 8601 :-
  • method D.ISOlocaldateStr() to local yyyy-mm-dd
  • method D.YMDDstr() to local yyyy-mm-dd DoW
  • function YMD2YWD(y, m, d) to [Y, W, D]
  • function CMJDtoYWD(CMJD) to [Y, W, D]
  • function YWDtoCMJD([Y, W, D]) to CMJD
  • function CMJDzuYMD(CMJD) to [Y, M, D]
  • function YMDzuCMJD(y, m, d) to CMJD

ISO Week Number Programming

For a discussion of ISO 8601 week numbers in general, see in Calendar Weeks.

All ISO weeks are Monday = 1 to Sunday = 7, and week 01 of the numbering year is the one containing the first Thursday of the Gregorian year. Thus up to three days of the first and last weeks for a year number can be in the adjacent Gregorian year; December 29 to January 03 can have a numbering year differing from the Gregorian.

A complete ISO Week Number function must also return the Year Number. It is easy enough also to return the Day-of-Week number, DoW.

Some methods give the Year directly. Otherwise, if the Calendar Month Number is large and the ISO Week Number is small then increment the Year, and vice versa, or otherwise.

String forms such as "yyyy-Www" or "yyyy-Www-d" or "yyyy-ww" or "yyyy-ww-d" can be used, depending on context; or arrays [Y, W, D].

Common Functions

This returns a string "yyyy-Www-d" from an array [y, w, d], to represent ISO 8601 week numbers.

function ISOWstr(A) { return A[0] + "-W" + LZ(A[1]) + "-" + A[2] }

General Considerations

In practice, the best method of implementation will depend on the nature and speed of the available primitive operations, and on whether the date is represented as a string, as Y-M-D, as Y-D, or as a count of time or whatever.

If using a [milli-]seconds-based method for DayCount, consider carefully Summer Time, remembering that it can span a New Year. So rounding the time from January 4th is better than truncating the time from January 1st.

It can be useful to know that CJD 0 was a Monday, and that 1970-01-01 was a Thursday.

Date to Week Number and Day-of-Week

When calculating ISO 8601 Week Number, giving the Year Number is essential. The Day Number will normally be easy to find en passant.

Absolute Week Number and Day-of-Week

If a DayCount is known, then
  (DayCount+K) div 7       gives an Absolute Week Number (AWN),
  1 + (DayCount+K) mod 7   gives the Day-of-Week (DoW).
where K allows for the Day-of-Week of DayCount zero, and ensures that the arguments of mod & div are never negative.

Start of Given Week Numbering Year

• Round Year-Jan-1st, or truncate Year-Jan-4th, to Monday.

Start of Current Week Numbering Year

• Truncate the date to Monday and add 3, truncate to Jan 1 and add 3, truncate to Monday.

Week Number, A

• The Week of any day is that of its nearest Thursday :-
  • to get that Thursday, one can use either of :-
    • Date = Date + 4 - DoW days
    • DayCount = DayCount + 3 - (DayCount+K) mod 7 days,
    in the course of which Day-of-Week is determined.
• The Year is the Calendar Year of that Thursday
• The First Thursday of a Calendar Year is in Week Number 1
• The Week Number of that nearest Thursday is thus its Zero-Based Day-of-Calendar-Year, divided by 7, truncated, plus one
• Actually finding the First Thursday is, therefore, not necessary
• Coded in DobToYWDarr(DArg) using a JavaScript Date Object
• Coded in ???(Y, M, D) using only explicit arithmetic - TO BE ADDED

Week Number, B

• Go ahead 3 days, as this method offsets weeks by 3 days
• Get the DayCount from 0 = any Thursday (e.g. 1970-01-01)
• Get the AWN, from Week 0 starting on DayCount 0, by div 7
• Get the Gregorian Year, Wyr, of the start of week AWN
• Decrement the AWN by that of Wyr-01-00
• Return [Wyr, AWN, DoW]
• Coded in YMD2YWD(y, m, d)

Week Number and Day-of-Week to Date

• Determine the date of the start of Week 1, Monday Year-01-1, using one of :-
  • Find the Day-of-Week of January 4th of the Year, and the Offset (-6..0 days) from there to the Monday of that Week
  • Find the Day-of-Week of January 1st of the Year, and the Offset (-3..+3 days) from there to the nearest Monday;
• Increment January 1st/4th by Offset + 7*(Week-1) + (DoW-1) days.

Demonstrations

Using JavaScript,

Manually tested above :-

function DemoYMDtoYWD(F) { with (F) { TDob.value = NThu.value = ZBDY.value = '?' var DOb = new Date(YMD.value.replace(/-/g, '/')) if (isNaN(DOb)) return false var D = DOb.getDay() if (D==0) D=7 ; TDob.value = DOb.YMDDstr() + '; D=' + D DOb.setDate(DOb.getDate() + (4-D)) ; NThu.value = DOb.YMDDstr() var YN = DOb.getFullYear() var ZBDoCY = ZBDY.value = // Jan 1; -6h allows for Summer Time Math.floor( (DOb.getTime() - new Date(YN, 0, 1, -6)) / 864e5 ) var WN = Math.floor(ZBDoCY/7) + 1 YWD.value = YN + '-W' + LZ(WN) + '-' + D return true } } function DemoYWDtoYMD(F) { with (F) { WSit.value = Jan4.value = Incr.value = '?' if (!/(\d+)-W(\d+)-(\d)/.test(YWD.value)) return false WSit.value = [RegExp.$1, RegExp.$2, RegExp.$3] var DOb = new Date(RegExp.$1, 0, 4) ; Jan4.value = DOb.YMDDstr() var D = DOb.getDay() ; if (D==0) D=7 ; var Off = -(D-1) Incr.value = ' ' + Off + ' + 7\u00D7' + (RegExp.$2-1) + ' + ' + (RegExp.$3-1) DOb.setDate(DOb.getDate() + Off + 7*(RegExp.$2-1) + (RegExp.$3-1)) YMD.value = DOb.ISOlocaldateStr() } return true } function InitFrmZ() { var F = document.forms.FrmZ F.YMD.value = new Date().ISOlocaldateStr() DemoYMDtoYWD(F) ; DemoYWDtoYMD(F) }

Y M D to/from Y W D Arithmetically

Here, JavaScript Date Objects are used only in testing. The methods therefore can be implemented in any language.

First Method

The following determines ISO Week Number by explicit arithmetic from IsLeapYear, Month, Day, and Day-of-Week, and vice versa, without going explicitly via a day-count.

It shows the possibility of calculating ISO Week Number Www-d from IsLeapYear, Month, Day, and day-of-week-of-January-1st, since those suffice to determine the current Day-of-Week, and vice versa.

Algorithm of function NewWN :-

• Determine the Day-of-Week
• The Nearest Thursday gives the Year Number
• Its position in that Calendar Year gives the Week Number.

Algorithm of function RevWN :-

• Determine the Day-of-Week of January 3rd
• Use that to convert Day-of-ISO-Year to Day-of-Calendar-Year
• Convert to Month and Day
• Deal with year overflow.

function LeapYr(y) { if (y%4) return false if (y%100) return true ; return !(y%400) } function ZelDoW(y, m, d) { // Sun = 0 if (m<3) { m += 12 ; y-- } return (2 + d + (((13*m-2)/5)|0) + // y + ((y/4)|0) - ((y/100)|0) + ((y/400)|0) ) % 7 } // <20060127 ((5*y)>>2) - ((y/100)|0) + ((y/400)|0) ) % 7 } function NewWN(Yr, Mo, Dy) { var DoW, Thu, DoY // by JRS ; OK // see <URL:http://www.merlyn.demon.co.uk/zeller-c.htm> etc. DoW = ZelDoW(Yr, Mo, Dy) // to be Zeller or Keith ; Sun=0 if (DoW==0) DoW = 7 // ISO 8601, Mon=1 .. Sun=7 Thu = Dy + 4 - DoW // Nearest Thursday if (Mo==12 && Thu>31) return [Yr+1, 1, DoW] if (Mo== 1 && Thu< 1) { Yr-- ; Mo = 12 ; Thu += 31 } DoY = Math.floor(275*Mo/9) + Thu - 31 // see daycount.htm#Meeus if (Mo>2) DoY += LeapYr(Yr) - 2 return [Yr, 1 + Math.floor(DoY/7), DoW] // 6 days of 7, LeapYr does not affect the WN result ... // The first return can be replaced by { Yr++;Mo=1;Thu-=31 } ? // It's probably better to use an array of month data. } function Jan1DoWG(y) { y-- // Jan 1's DoW, Sun=0, any Gregorian year // see weekcalc.htm#DoW return ( (1.25*y|0) - (y/100|0) + (y/400|0) + 1 ) % 7 } function DoYLtoMonth(J, L) { // J is Day of Year, Jan1=1, L is Leap return J<32 ? 1 : 1 + Math.floor((303 + 5*(J - 59 - L))/153) } function DoYMLtoDate(J, M, L) { // J is DoY, M is Month, L is Leap return J - (M<3 ? 31*(M-1) : (((153*M-2)/5)|0) - 32 + L) } function RevWN(YWDA) { // [Y,W,D] to [Y,M,D] ??? // seems right now var X, J, Yr = YWDA[0], Leap = LeapYr(Yr), Mth, Dte X = (Jan1DoWG(Yr)+2) % 7 // DoW of Jan 3, Sun=0 J = 7*YWDA[1] + YWDA[2] - X - 4 // Answer is Yr Jan J // return new Date(Yr, 0, J) // OK; next with arithmetic Mth = DoYLtoMonth(J, Leap) ; Dte = DoYMLtoDate(J, Mth, Leap) // It's probably better to use an array of month data if (Mth==13) { Yr++ ; Mth = 1 } if (Dte < 1) { Yr-- ; Mth = 12 ; Dte +=31 } return [Yr, Mth, Dte] } function TryArithWN() { var J, Y, M, D, DD, WN1, WN2, OK, ERR=0, XD, St, A = ["<pre>\nErrors will be marked *", "\n\t\t OK\t\tNewWN\t\tRevWN\t\tErr\n"] for (J=-4; J<11111; J++) { with (DD = new Date(2005, 0, J)) { Y = getFullYear() ; M = getMonth()+1 ; D = getDate() OK = YMD2YWD(Y, M, D) // known good WN2 = NewWN(Y, M, D) ; XD = RevWN(WN2) St = DD.YMDDstr() + "\t " + OK + "\t" + WN2 + "\t" + XD if (WN2[0]!=OK[0] || WN2[1]!=OK[1] || WN2[2]!=OK[2] || XD[0]!=DD.getFullYear() || XD[1]-1!=DD.getMonth() || XD[2]!=DD.getDate() ) { St += "\t*" ; ERR++ } A.push(St) if (D==6) { A.push("") ; J+=354 } // shortens test } } A.push("<\/pre>") if (ERR) A[0] += " Errors seen: " + ERR NewPage("TryArithWN", A.join("\n")) }

Second Method

For Day-of-Year, see also in Date Object Information.

Function MathWNo is differently derived and independent of imported functions and Date Objects. It is somewhat optimised in function WNoMath.

function DoWoJ1(Y) { // ISO 8601, Y>0 : DayOfWeek of January 1 return 1 + ( --Y + (Y/4|0) - (Y/100|0) + (Y/400|0) ) % 7 } function DoYoW11(Y) { // ISO 8601, Y>0 : DayOfYear of (Mon) W01-1 return (11 - DoWoJ1(Y))%7 - 2 } function DaysBeforeMonth(Y, M) { // M=1..12; JRS-derived from Zeller return M-- < 3 ? M*31 : ( Y%4==0 && ( Y%100!=0 || Y%400==0) ) + (M*306-17)/10|0 } function MathWNo(Y, M, D) { var DoY, DN, WN // ISO 8601 DoY = DaysBeforeMonth(Y, M) + D DN = 1 + (DoWoJ1(Y) + DoY - 2) % 7 WN = 1 + ( ( DoY - DoYoW11(Y) ) / 7 )|0 if (WN==0) return MathWNo(Y-1, 12, D+31) if (WN==53 && DoYoW11(Y+1)<3) { WN = 1 ; Y++ } // 3? return [Y, WN, DN] } function WNoMath(Y, M, D) { var DoY, DJ1, DN, WN // Faster DoY = D + ( M-- < 3 ? M*31 : ( Y%4==0 && ( Y%100!=0 || Y%400==0) ) + (M*306-17)/10|0 ) DJ1 = DoWoJ1(Y) DN = 1 + (DJ1 + DoY - 2) % 7 WN = ( 9 + DoY - (11 - DJ1)%7 ) / 7 | 0 if (WN==0) return MathWNo(Y-1, 12, D+31) if (WN==53 && (11 - DoWoJ1(Y+1))%7<5) { WN = 1 ; Y++ } return [Y, WN, DN] } function TestAux() { var Y, M, A = [], S, K, J A.push("Start of Year 2000+ :") for (J in [0,1]) { K = 2000 + 15*J S = "Yr" ; for (Y=K ; Y<K+15 ; Y++) S += SpcsTo(LZ(Y%100), 3) A.push(S) S = "J1" ; for (Y=K ; Y<K+15 ; Y++) S += SpcsTo(DoWoJ1(Y), 3) A.push(S) S = "D1" ; for (Y=K ; Y<K+15 ; Y++) S += SpcsTo(DoYoW11(Y), 3) A.push(S) } A.push("\nDaysBeforeMonth :") ; S = "Month :" for (M=1 ; M<=14 ; M++) S += SpcsTo(M, 4) A.push(S) ; S = " 2007 :" for (M=1 ; M<=14 ; M++) S += SpcsTo(DaysBeforeMonth(2007, M), 4) A.push(S) ; S = " 2008 :" for (M=1 ; M<=14 ; M++) S += SpcsTo(DaysBeforeMonth(2008, M), 4) A.push(S) ; return A.join("\n") } function TestWNo() { var A, J, OB, Y, M, D, AA, BB, CC, DD, Errs=0 A = [ "ERRORS : ", "\n By : YMD2YWD MathWNo WNoMath" + (UserWeekNo?" UserWeekNo":"") + "\nYYYY MM DD YYYY WW D YYYY WW D YYYY WW D" + (UserWeekNo?" YYYY WW D":"") ] for (J=1; J<11111; J++) { // 11111 is over 28 years with (OB = new Date(Date.UTC(2000, 0, J-22))) { Y = getUTCFullYear(); M = getUTCMonth()+1; D = getUTCDate() } AA = ISOWstr(YMD2YWD(Y, M, D)) // known good BB = ISOWstr(MathWNo(Y, M, D)) CC = ISOWstr(WNoMath(Y, M, D)) if (UserWeekNo) DD = ISOWstr(UserWeekNo(Y, M, D)) if (BB!=AA || CC!=AA || (DD && DD!=AA) ) { Errs++ A.push(OB.utcYMDstr() + SpcsTo(AA, 12) + SpcsTo(BB, 12) + SpcsTo(CC, 12) + SpcsTo(DD?DD:"", 12)) } if (Errs>9) { A[0] += "QUIT at " ; break } } A[0] += Errs ; return A.join("\n") } function Define(UW) { // UnDefine does UserWeekNo=null eval("UserWeekNo=function(Y,M,D) { // UserWeekNo\n" + UW + "}") }

DayCount to/from Y W D Arithmetically

Some languages handle dates as DayCounts, often with Day 0 being 1899-12-30 and Day 25569 being 1970-01-01. Conversion of DayCount to/from Y W D is easier than conversion to/from Y M D, and does not need system date routines.

In January 2008 I derived, now in unit programs/dateutys.pas, efficient Pascal/Delphi routines for DateTime to/from YWD, covering the (extendable) range AD 0001 to 9999. The following JavaScript routines mimic them.

// DT should be integer. Zero = 1899-12-30. Years >= 0 ? function DTofJan1(Y) { // Delphi DT base date 1899-12-30 = 0 var Base = -693593 // = 2 - 1899*365 - ((1899/4)|0) + ((1899/100)|0) - ((1899/400)|0) return Base + (Y--)*365 + ((Y/4)|0) - ((Y/100)|0) + ((Y/400)|0) } function ISODTtoYWD(DT) { var YN, WN, DN, NThu DN = 1 + (DT+777777775) % 7 // Day Number, Mon=1 to Sun=7 NThu = DT + 4 - DN // NThu is the Nearest Thursday YN = Math.floor(1900 + NThu/365.2425) // estimated Year Number if (NThu < DTofJan1(YN)) YN-- // corrected Year Number WN = 1 + ( (NThu-DTofJan1(YN)) / 7) | 0 // Count of Thursdays return [YN, WN, DN] } function ISOYWDtoDT(YWDarr) { var DT, DW // YWDarr = [YN, WN, DN] DT = DTofJan1(YWDarr[0]) + 3 // YN Jan 4, which is in YN Week 1 DW = 1 + (DT+7777775) % 7 // Mon=1..Sun=7 DT = DT - DW // go to day before Week 1 return DT + (YWDarr[1]-1)*7 + YWDarr[2] /* incr for WN & DN */ } function ParseDate(S) { // Permit ISO DateSeps, caveat Y<100 return new Date( S.replace(/-/g, "/") ) } function ParseWithUTC(S) { return ParseDate( S + " UTC" ) } function DTfromUTCstr(S) { return ParseWithUTC(S)/864e5 +25569 } function UTCstrfromDT(DT) { return new Date((DT-25569)*864e5).utcYMDstr() } function TestOnceArith(F) { var DT, X1, X2 DT = DTfromUTCstr(F.In.value) F.x0.value = DT X1 = ISODTtoYWD(DT) X2 = ISOYWDtoDT(X1) F.x1.value = X1 ; F.x2.value = X2 F.x3.value = UTCstrfromDT(X2) } function TestAllArith(S0, S1) { // fix ParseWithUTC for Y<100? var DT, XX, d0 = DTfromUTCstr(S0), d1 = DTfromUTCstr(S1) ; if (!(d0<=d1)) { alert("Bad input") ; return } for (DT = d0 ; DT <= d1 ; DT++) { XX = ISOYWDtoDT(ISODTtoYWD(DT)) if (XX != DT) { alert("Bad @ " + DT + ", get " + XX) ; return } if (DT%10000 == 0) window.status = UTCstrfromDT(DT) } alert("OK " + UTCstrfromDT(d0) + " to " + UTCstrfromDT(d1)) }

General Testing

Comparison results which can be used by testers, showing Weeks 1, 52 & 53 for over 28 years, are in wknotest.txt.

The following checks should suffice - all weeks have 7 days, Monday is Day 1 of 1..7, January 4th is in Week Number 1 of 1..52/53, Year usually matches, numbers YYYYWWD are in increasing order, testing over 28 years with quadrennial Leap Years (or at least over all 14 year types). That does not fully test the effects of the 100 and 400 year rules introduced by Pope Gregory XIII.

Test cases should include those tabled in Calendar Weeks.

ISO Week Numbers in Specific Languages

JavaScript is placed first merely for the convenience of contiguity with the demonstration above.

JavaScript

Where Math.round(X) is used, X|0 may be faster, and is equivalent for 0≤X<2³¹; but beware operator precedences.

Code not using Date Objects is currently above.

As Demo Code Above

These should be evidently the same algorithms as demonstrated. It shows errors in Opera 9; see in JavaScript Date and Time Troubles :-

function DobToYWDarr(DArg) { var DOb = new Date(DArg) // <- errors with Opera 9 if (isNaN(DOb)) return false var D = DOb.getDay() ; if (D==0) D=7 // D = ISO DoW DOb.setDate(DOb.getDate() + (4-D)) // To nearest Thu, mid-week var YN = DOb.getFullYear() // YN = ISO W-N Year var ZBDoCY = // uses Jan 1 of YN; -6h allows for Summer Time Math.floor( (DOb.getTime() - new Date(YN, 0, 1, -6)) / 864e5 ) var WN = 1 + Math.floor(ZBDoCY/7) return [YN, WN, D] /* ISO 8601 */ } function StrYWD(D) { return ISOWstr(DobToYWDarr(D)) } function YWDarrToDob(AYWD) { // Arg : ISO 8601 : [Y, W, D] var DOb = new Date(+AYWD[0], 0, 3) // Jan 3 if (isNaN(DOb)) return false DOb.setDate( 3 - DOb.getDay() + (AYWD[1]-1)*7 + +AYWD[2] ) return DOb }

The next routine is in include3.js; YMD2YWD uses a different method and parameters to the above.

NOTE the change of 2007-04-03 in YMD2YWD, to allow for a problem with the browser Firefox 2.0.0.3.

function YMD2YWD(y, m, d) { // ISO 8601 WkNo. m=1..12 var ms1d = 864e5, ms7d = 7*ms1d var DC3 = Date.UTC(y, m-1, d+3)/ms1d // an Absolute Day Number var DoW = 1 + (DC3+7777777)%7 var AWN = Math.floor(DC3/7) // an Absolute Week Number var Wyr = new Date(AWN*ms7d).getUTCFullYear() // return [Wyr, AWN - Math.floor(Date.UTC(Wyr, 0, 0)/ms7d), DoW ] } // 2007-04-03 : Firefox 2.0.0.3-14 is bad for d<1 !!! return [Wyr, AWN - Math.floor(Date.UTC(Wyr, 0, 7)/ms7d)+1, DoW ] } function YMDtoYWDtest() { var D with (D = new Date()) { var dy=getDate(), mo=getMonth()+1, yr=getFullYear() } document.write( 'By YMDtoYWDtest() : Today is ', D.YMDDstr(), '\nso it is', ' ISO 8601 year-week-day ', ISOWstr(YMD2YWD(yr, mo, dy))) }

By YMDtoYWDtest() : Today is 2025-03-11 Tue
so it is ISO 8601 year-week-day 2025-W11-2

YYYY-MM-DD to YYYY-WW-D, in two ways

function YMDaToYWDa(S) { // 2005-03-28 : now UTC - much faster with (new Date(Date.UTC(S[0], S[1]-1, S[2]))) { var DoW = getUTCDay() setUTCDate(getUTCDate() - (DoW+6)%7 + 3 ) // Nearest Thu var ms = valueOf() // GMT setUTCMonth(0, 4) // Jan 4 is in Week 1 for ISO 8601 var WN = Math.round( (ms-valueOf()) / (7*864e5) ) + 1 return [getUTCFullYear(), WN, DoW==0 ? 7 : DoW] } } function TryMtoW(F) { var A1=[], A2=[], X='Not d+-dd-dd', Y='Bad S' S = ReadISO8601date(F.TDSV.value.trim()) F.RDSV.value = S<-1?X:S<0?Y: A1 = YMDaToYWDa(S) F.Incl.value = S<-1?X:S<0?Y: A2 = YMD2YWD(S[0],S[1],S[2]) if (A1.join() != A2.join()) alert('Code Error') F.Rev.value = YWDaToYMDa(A1) F.TDSV.focus() }

First Validate. Then save Day-of-Week, get nearest Thursday, save Time; go to January 4th, subtract from Time, round the Week difference.

YYYY-WW-D to YYYY-MM-DD, Array or Object

function YWDaToYMDa(A) { // 2005-03-28 : now UTC - much faster with (new Date(Date.UTC(A[0], 0, 4))) { // ISO 8601 setUTCDate(getUTCDate() - (getUTCDay()+6)%7 + 7*A[1] + A[2]-8 ) return [getUTCFullYear(), getUTCMonth()+1, getUTCDate()] } } function YWDtoDatOb(Y, W, D) { // ISO 8601 var DOb = new Date(Y, 0, 3) DOb.setDate( 3 - DOb.getDay() + (W-1)*7 + +D ) return DOb } function ReadISO8601YWD(Q) { // does not validate field ranges if (Q.search(/^\d+-W\d\d-\d$/)!=0) { return -2 } // bad format var j, T = Q.split(/\D+/) for (j=0; j<=2; j++) T[j] = +T[j] // needed return T } function TryWtoM(F) { var A = [], Q = 'Not d+-Wdd-d', S = ReadISO8601YWD(F.TDSV.value.trim()) F.RDSV.value = S<0 ? Q : A = YWDaToYMDa(S) F.Dobj.value = S<0 ? Q : YWDtoDatOb(S[0], S[1], S[2]) F.Rev.value = YMDaToYWDa(A) F.TDSV.focus() }

Basically, put Year Jan 4th into a date object, getDay(), then use setDate() to move back 0..6 days to Monday and to add (WW-1)*7 days for the start of the week.

Week Number without Date Object

Contents moved upwards.

DayCount Routines

A direct routine for CMJD to Year-Week-Day, and a new direct reverse routine, with CMJD to/from Year-Month-Day and Year-Month-Day to/from Year-Week-Day using them :-

function CMJDtoYWD(CMJD) { // cf. Calendar FAQ 2.7, Stefan Potthast var d4, L, d1, WeekNumber, Bodge, DoW // Bodge, DoW added by JRS CJD = CMJD + 2400001 ; DoW = CJD % 7 d4 = (CJD+31741 - DoW) % 146097 % 36524 % 1461 // 0..1460 L = +(d4==1460) // was L = (d4/1460)|0 d1 = ((d4-L) % 365) + L WeekNumber = ((d1/7)|0) + 1 // ISO 8601 Bodge = CJD - 7*(WeekNumber-26) // mid-year Bodge = ((Bodge/365.2425)|0) - 4712 return [Bodge, WeekNumber, 1+DoW] } function YWDtoCMJD(YWD) { var CJD, y // By JRS 2005-02-23+ y = YWD[0]-1 // for CJD of Jan 4, modified from YMDzuCMJD CJD = 1721429 + (1461*y>>2) - ((y/100)|0) + ((y/400)|0) CJD -= CJD%7 // Round down to Monday; CJD 0 is Monday. CJD += YWD[1]*7 + +YWD[2] - 8 // Contributions of W and D return CJD - 2400001 /* ISO 8601 */ } function CMJDzuYMD(CMJD) { var Y=0, M=0, t, d = CMJD + 678881 // 0000-03-01 : Julian, add 2 t = (( (4*(d+36525))/146097 )|0) - 1 // Gregorian Added Rules Y += 100*t ; d -= 36524*t + (t>>2) t = (( (4*(d+366))/1461 )|0) - 1 // Julian Rules Y += t ; d -= 365*t + (t>>2) M = ( (5*d+2)/153 )|0 // 153=5*28+13 months from March, M = 0... d -= ((2+M*153)/5)|0 // remove full months, d = 0... if (M > 9) { M -= 12 ; Y++ } return [Y, M+3, ++d] } function YMDzuCMJD(y, m, d) { // Fast. if (m<3) { m += 12 ; y-- } // Initial m *must* be in 1..12 return -678973 + d + (((153*m-2)/5)|0) + // 153 = 13 + 5*28 (1461*y>>2) - ((y/100)|0) + ((y/400)|0) } function YMDCMJDYWD(A) { return CMJDtoYWD(YMDzuCMJD(A[0], A[1], A[2])) } function YWDCMJDYMD(A) { return CMJDzuYMD(YWDtoCMJD(A)) } function TryCMJDtoYWD(F) { var CMJD F.CMJD.value = CMJD = 40587 + new Date(F.YMD.value.split(/\D+/).join('/')+' GMT')/864e5 F.YWD.value = ISOWstr(CMJDtoYWD(CMJD)) } function TryYWDtoCMJD(F) { var D F.CMJD.value = D = YWDtoCMJD(F.YWD.value.split(/\D+/)) D = new Date((D - 40587)*864e5) F.YMD.value = D.getUTCFullYear() + '-' + LZ(D.getUTCMonth()+1) + '-' + LZ(D.getUTCDate()) } function BigTest() { var CMJD, CMJD0=150000, YWD, Res, Dif, Errs=Sum=0, A A = ["<pre> CMJD\tyyyy-Www-d\tCMJD Dif"] for (CMJD=CMJD0-140000 ; CMJD < CMJD0 ; CMJD+=363) { // > 400 yrs YWD = CMJDtoYWD(CMJD) Res = YWDtoCMJD(YWD) Dif = Res - CMJD Sum += Dif ; if (Dif) Errs++ A.push(CMJD + "\t" + ISOWstr(YWD) + "\t" + Res + " " + Dif + (Dif?" #":"")) } A[0] += "\tErrors " + Errs + ", Sum " + Sum A.push("<\/pre>") NewPage("BigTest", A.join("\n")) }

Note that routines using CMJD are comparatively fast.

Try Above JavaScript ISO Week Number Conversions

Given the straightforward handling of the Week and Day components in conversions from YWD to ordinary date, it seemed sufficient to test just over one day per year for over 400 years.

function YMDarrToDob(A) { return new Date(A[0], A[1]-1, A[2]) } function TestAllISO(F) { // F.Rpt.rows = 4 function Report(ENo) { F.Rpt.rows = 3 return "Error in test " + ENo + "\nInput\t" + DobIn + " = " + YWDstr + "\nGives " } function ChkYWD(ENo, YWDarr) { var Str = ISOWstr(YWDarr) var Bad = Str != YWDstr if (Bad) F.Rpt.value = Report(ENo) + "WkNo\t" + Str return Bad } function ChkObj(ENo, Obj) { var Bad = +Obj != +DobIn if (Bad) F.Rpt.value = Report(ENo) + "DObj\t" + Obj return Bad } var CMJD, YWD, Res, YWDstr, DobIn, Str, YR, MO, DY, OpX=0 for (CMJD=0 ; CMJD < 150000 ; CMJD+=121) { // 400+ yrs DobIn = new Date(1858, 10, 17+CMJD) // local, 00:00h if (DobIn.getHours() != 0) { // AVOID OPERA 9 BUG DATES OpX++ ; continue } YR = DobIn.getFullYear() MO = DobIn.getMonth()+1 DY = DobIn.getDate() YWD = CMJDtoYWD(CMJD) ; Res = YWDtoCMJD(YWD) // thought good YWDstr = ISOWstr(YWD) if (Res != CMJD) { // check agreement F.Rpt.value = "Error in initial test :- " + CMJD + " " + YWDstr + " " + Res return } if ( ChkYWD(100, DobToYWDarr(DobIn)) ) return if ( ChkObj(101, YWDarrToDob(YWD)) ) return if ( ChkYWD(102, YMD2YWD(YR, MO, DY)) ) return if ( ChkYWD(103, YMDaToYWDa([YR, MO, DY])) ) return if ( ChkObj(104, YWDtoDatOb(YWD[0], YWD[1], YWD[2])) ) return if ( ChkYWD(105, OddWkNo2(DobIn, 1, 4)) ) return if ( ChkObj(106, OffWkNo2( YWD, 1, 4)) ) return if ( ChkObj(107, YMDarrToDob(YWDaToYMDa(YWD))) ) return if ( ChkObj(108, YWDarrToDob(YMDCMJDYWD(YWDCMJDYMD(YWD)))) ) return if ( ChkYWD(109, MathWNo(YR, MO, DY)) ) return if ( ChkYWD(110, WNoMath(YR, MO, DY)) ) return if ( ChkYWD(111, NewWN(YR, MO, DY)) ) return if ( ChkObj(112, YMDarrToDob(RevWN(YWD))) ) return } F.Rpt.rows = 1 F.Rpt.value = OpX ? OpX + " days skipped - Opera flaw" : " OK " } function TimeAllISO(F) { var D = [], J, K, N = 0, X, A = [2005, 11, 6], Dno = +new Date() + 14*F.T.value while (Dno > +new Date()) N++ // initialise loop count N J = 0 D[J++] = new Date() ; K = N ; while (K--) X = Dno // dummy D[J++] = new Date() ; K = N ; while (K--) X = YMDtoCMJD(2222,6,2) D[J++] = new Date() ; K = N ; while (K--) X = CMJDtoYMD(6e4) D[J++] = new Date() ; K = N ; while (K--) X = YMDzuCMJD(2222,6,2) D[J++] = new Date() ; K = N ; while (K--) X = CMJDzuYMD(6e4) D[J++] = new Date() ; K = N ; while (K--) X = CMJDtoYWD(6e4) D[J++] = new Date() ; K = N ; while (K--) X = YWDtoCMJD(A) D[J++] = new Date() ; K = N ; while (K--) X = DobToYWDarr(Dno) D[J++] = new Date() ; K = N ; while (K--) X = OddWkNo2(Dno, 1, 4) D[J++] = new Date() ; K = N ; while (K--) X = YMDCMJDYWD(2222,6,2) D[J++] = new Date() ; K = N ; while (K--) X = YMD2YWD(2222,6,2) D[J++] = new Date() ; K = N ; while (K--) X = NewWN(2222,6,2) D[J++] = new Date() ; K = N ; while (K--) X = MathWNo(2222,6,2) D[J++] = new Date() ; K = N ; while (K--) X = WNoMath(2222,6,2) D[J++] = new Date() ; K = N ; while (K--) X = YMDaToYWDa(A) D[J++] = new Date() ; K = N ; while (K--) X = YWDarrToDob(A) D[J++] = new Date() ; K = N ; while (K--) X = YWDtoDatOb(2222,6,2) D[J++] = new Date() ; K = N ; while (K--) X = YWDCMJDYMD(A) D[J++] = new Date() ; K = N ; while (K--) X = RevWN(2222,6,2) D[J++] = new Date() ; K = N ; while (K--) X = YWDaToYMDa(A) D[J++] = new Date() ; K = N ; while (K--) X = OffWkNo2(A, 1, 4) D[J++] = new Date() F.Rpt.rows = J+5 J = 0 F.Rpt.value = "\t" + N + " loops\t:\tTime, ms" + "\n\toverhead\t:\t" + -(D[J]-D[++J]) + "\nCMJD To/from YMD :" + "\n\tYMDtoCMJD\t:\t" + -(D[J]-D[++J]) + "\n\tCMJDtoYMD\t:\t" + -(D[J]-D[++J]) + "\n\tYMDzuCMJD\t:\t" + -(D[J]-D[++J]) + "\n\tCMJDzuYMD\t:\t" + -(D[J]-D[++J]) + "\nCMJD To/from YWD :" + "\n\tCMJDtoYWD\t:\t" + -(D[J]-D[++J]) + "\n\tYWDtoCMJD\t:\t" + -(D[J]-D[++J]) + "\nObj to [YWD] :" + "\n\tDobToYWDarr\t:\t" + -(D[J]-D[++J]) + "\n\tOddWkNo2\t:\t" + -(D[J]-D[++J]) + "\nGreg to [YWD] :" + "\n\tYMDCMJDYWD\t:\t" + -(D[J]-D[++J]) + "\n\tYMD2YWD \t:\t" + -(D[J]-D[++J]) + "\n\tNewWN \t:\t" + -(D[J]-D[++J]) + "\n\tMathWNo \t:\t" + -(D[J]-D[++J]) + "\n\tWNoMath \t:\t" + -(D[J]-D[++J]) + "\n\tYMDaToYWDa\t:\t" + -(D[J]-D[++J]) + "\nYWD or[YWD] to Obj :" + "\n\tYWDarrToDob\t:\t" + -(D[J]-D[++J]) + "\n\tYWDtoDatOb\t:\t" + -(D[J]-D[++J]) + "\nYWD or [YWD] to Greg :" + "\n\tYWDCMJDYMD\t:\t" + -(D[J]-D[++J]) + "\n\tRevWN \t:\t" + -(D[J]-D[++J]) + "\n\tYWDaToYMDa\t:\t" + -(D[J]-D[++J]) + "\n\tOffWkNo2\t:\t" + -(D[J]-D[++J]) + "\nTotal test time\t\t:\t" + (D[J]-D[0] + ", ms") }

I have some more JavaScript for date conversions, and a little VBScript.

DOS Batch

In unaided DOS..Win98/ME, date calculations cannot reasonably be done.

My NOWMINUS and ENVICALC are batch-enhancing programs for date/time work and for integer arithmetic; get Pascal source and executable via programs.

  NOWMINUS F5  J0 L6 Eisoweekno	; set env. ISOWEEKNO to ISO     YYYYWW
  NOWMINUS F33 J0 L6 Etaxweekno	; set env. TAXWEEKNO to UK HMRC YYYYWW

For an absolute week count, from BC 4713,

  NOWMINUS F9 EDN		  ; set CJD in env. DN, then
  ENVICALC    CDN 3 - 7 / B6 EWN  ; set Local AbsWkNo in env. WN

Adjust the value of 3 by up to ±3 to get the desired first day of the
week (..., Mon, ...); put   N -   after / to alter the zero week by N.

See also in MS-DOS Batch Files, and WSH below this.

NT/XP Batch

In Windows NT, XP, etc., batch, it should be possible to code most or all common date/time work. In particular, CMD.EXE FAQ ZIP #149. But it will often be easier to use WSH with VBS or JS.

Batch file iso-wkno.bat contains and tests CMD.EXE code for obtaining y w d and yyyy-Www-d from yyyy mm dd, for 1900-03-01 to 2100-02-28 inclusive.

VBScript

See my code in VBScript Date and Time 2 - for all valid years.

Note that DatePart("ww", Date, vbMonday, vbFirstFourDays) is not always satisfactory.

Windows Scripting Host

WSH can execute JavaScript and VBScript; see in MS-DOS Batch Files.

Microsoft .Net

See ISO 8601 Week of Year format in Microsoft .Net.

Apparently, the general algorithm above should be easy to implement using only basic DateTime routines.

PowerShell

Code by Joel Bennett is at poshcode; I understand that its results agree with mine, though the algorithm seems to differ.

Also, the thread with this article, by Kiron, dated Sat, 21 Mar 2009 10:38:41 -0600, looks good.

Pascal/Delphi

My Pascal unit dateprox.pas, tested by program mjd_date.pas with included version.pas (BP7; Delphi 3 at least) can calculate week number (ISO, Tax & otherwise) from date, by first principles. Program mjd_date.exe was used for :-

• Page week-cal.txt showing ISO 8601 weeks, with numbers, for 1970-2030.
• Page uktaxcal.txt showing HM Revenue and Customs Tax weeks, with numbers, for 1970-2030.

Peter Haas has written Delphi Week Number code, ISO & otherwise (ZIP).

Recent Delphi has WeekOfTheYear to give ISO Week Numbers (NOTE: verified over full 9999 years; wrong within Mondays before 1900). It is longer than necessary, as I can do the job correctly , better and slightly faster, in five commented one-line statements. I can do the reverse in four one-line statements. Routines are now in dateprox.pas and demonstrated in mjd_date.pas; versions in unit programs/dateutys.pas may be even better.

GAWK & C

GAWK code for ISO week number, valid for 1970-2099, independent of strftime(), is tested in programs/iso-wkno.awk. Where different, the result of strftime (which is then expected to be 53) is appended.

Presumably C code would be similar.

See also Week Numbers in UNIX & C Utilities.

SQL Server

I've been sent the following code to determine the start of the ISO Week-Numbering Year; I think it's for SQL Server.

Truncate(date_0, 'IY') =
  Truncate(Truncate(Truncate(date_0, 'IW') + 3, 'YEAR') + 3, 'IW')

"Truncate(date, 'IW') truncates an input date to the nearest Monday (ISO Week start), Truncate(date, 'YEAR') returns calendar year start, and '+ 3' means 'plus 3 days'". That amounts to "go to the nearest Thursday, go to January 4th of that calendar year, go to the start of that week", which is appropriate.

Perl

I don't know, or have, Perl.

Revised Perl code contributed by Robert Urban (2002-08-13), which I have not been able to test, is in programs/what-cw.pl. It uses only basic arithmetic operations. Check it before use.

However, Harry Broomhall wrote (2002-08-18) :-

There are many time/date-based modules/libraries for Perl, but, IMHO, the one known as Date::Calc is the most comprehensive, and the most mature. Quoting this name is generally the standard response to questions about date-handling in newsgroups/lists.

Date::Calc can be retrieved from CPAN (the major repository of Perl libraries). The module includes a *lot* of utilities to cover most requirements for 'normal' civil uses (i.e. it doesn't include astro requirements, or odd calendars such as Mayan).

A working example (weekno.pl) to get week-numbers from a date (passed on the command line) is as follows :-

#!/usr/bin/perl -w
use strict;
use Date::Calc qw(Week_of_Year);
my ($wn, $yr);
($wn, $yr) = Week_of_Year($ARGV[0], $ARGV[1], $ARGV[2]);
print "$wn of $yr\n";

The author of Date::Calc clearly recognises ISO 8601 as the standard to use.

DateTime code via Dave Rolsky may have ISO week numbers. Looks promising. May be part of The Perl DateTime Project.

I don't know, or have, Perl.

GNU R

A function in GNU R, derived by Theodore Lytras of Athens from the algorithm which I use.

isoweek <- function(x) {
  x.date<-as.Date(x)
  x.weekday<-as.integer(format(x.date,"%w"))
  x.weekday[x.weekday==0]=7
  x.nearest.thu<-x.date-x.weekday+4
  x.isoyear<-as.integer(substring(x.nearest.thu,1,4))
  x.isoweek<-(as.integer(x.nearest.thu-as.Date(paste(x.isoyear,"-1-1",sep="")))%/%7)+1
  paste(x.isoweek,x.isoyear,sep="/")
  }

HTML

HTML 5 introduced various input control types to handle dates/times. So far, I have only seen these implemented in Opera 9.64+, where they do not yet work well.

See also at JavaScript Date and Time 3 : Input and Lengths.

Etc.

• Python - isocalendar()
• Java : try BigDate

Non-ISO Week Number Programming

See in Calendar Weeks.

These examples are in JavaScript, but might be adapted for other languages. Adapting for Week-of-Month should be obvious.

Alas, Financial Years may not approximate to Calendar or ISO Week-Numbering Years; then, the code for Types 1 & 2 will need modification.

For specific uses, the fixed parameter values can be incorporated into the code.

In each case, the Date Object should represent a time near midnight, and is not altered; and Week Number is an array [Y, W, D] of Numbers.

Common Functions

This returns a string to represent non-standard week numbers.

function ywkdStr(A) { return A[0] + "wk" + LZ(A[1]) + "d" + A[2] }

Type 1. Year Number is always Calendar Year

Therefore, weeks 01 and 52 may be, and 53 will, be partial.

function OddWkNo1(D, d1, d2) { // D a Date Object with time ~ 0 // d1 fixes JS day 0..6 that starts each week; undef to use Jan 1 // if d2 is defined, then it shifts the week; calendar-row count var Yr = D.getFullYear(), Jan1 = new Date(Yr, 0, 1), Q Q = Math.round((D-Jan1)/864e5) // 0-based day of year if (d1!=null) Q -= ( 7+d1 - Jan1.getDay() ) % 7 if (d2!=null) Q += d2 return [ Yr, (1 + Q/7)|0, 1+(7+Q)%7 ] } function OffWkNo1(A, d1, d2) { var Q=0 // comment as above if (d1!=null) Q = ( 7+d1 - new Date(A[0], 0, 1).getDay() ) % 7 if (d2!=null) Q -= d2 return new Date(A[0], 0, (A[1]-1)*7 + A[2] + Q) } function TryNSWN1(F) { var D = new Date(F.MyYMD1.value) function ZS(x) { var u ; return x==u ? " " : x } function QQ1(D, d1, d2) { var Q return ZS(d1) + " " + ZS(d2) + " " + ywkdStr(Q=OddWkNo1(D, d1, d2)) + " " + OffWkNo1(Q, d1, d2).ISOlocaldateStr() } F.MyRslt.value = D.YMDDstr() + "\t\t d1 d2 OddWkNo1 OffWkNo1" + "\n+ For Week 1 = Jan 1st-7th : " + QQ1(D) + "\n* For Week 1 = 1st Sun-Sat : " + QQ1(D, 0) + "\n* For Week 1 = 1st Mon-Sun : " + QQ1(D, 1) + "\n# For Week 1 = Sun-Sat row : " + QQ1(D, 6, 6) + "\n# For Week 1 = Mon-Sun row : " + QQ1(D, 0, 6) }

Week 1 = Sun-Sat row seems to be what Microsoft VBS datepart("ww", D) gives.

Type 2. Every Week has Seven Days

Therefore, the Year Number can differ from the Calendar Year, and must be returned. ISO 8601 Week Numbers are a specific case.

These examples are for numberings in which Week 1 is more-or-less at the start of the calendar year.

function OddWkNo2(D, d1, d2) { // D a Date Object with time ~ 0 // d1 is JS day 0..6 of the first day of every week : ISO, d1=1 // d2 is JS day 0..6, first d2 of year fixes week 1 : ISO, d2=4 var ND, QQ, Y1, Yr, Wk, Dy ND = new Date(+D) ; Dy = (7 + ND.getDay() - d1) % 7 QQ = (7 + d2 - d1) % 7 // Fixing-day d2 of week d1 as 0..6 ND.setDate(ND.getDate() - Dy + QQ) // Go to d2 of same d1 week Yr = ND.getFullYear() Y1 = new Date(Yr, 0, 1) ; QQ = Y1.getDay() Y1.setDate(Y1.getDate() + (7 + d2 - QQ) % 7) // 1st d2 of CalYear Wk = Math.round((ND - Y1)/(7*864e5)) // Round lest SummerTime // return [ Yr, ++Wk, ++Dy ] } return [ Yr, Wk + (d2>=d1), ++Dy ] /* but why? */} function OffWkNo2(A, d1, d2) { var Q // comment as above Q = ( 7 + d2 - new Date(A[0], 0, 1).getDay() ) % 7 // reach a d2 Q -= (7 + d2 - d1) % 7 // to start of d1 week // return new Date(A[0], 0, (A[1]-1)*7 + A[2] + Q) } return new Date(A[0], 0, (A[1]-(d2>=d1))*7 + A[2] + Q) } function TryNSWN2(F) { var D = new Date(F.MyYMD2.value) function QQ2(D, d1, d2) { var Q return d1 + " " + d2 + " " + ywkdStr(Q=OddWkNo2(D, d1, d2)) + " " + OffWkNo2(Q, d1, d2).ISOlocaldateStr() } F.MyRslt.value = D.YMDDstr() + "\t\t d1 d2 OddWkNo2 OffWkNo2" + "\n* For Week 1 = 1st Sun-Sat : " + QQ2(D, 0, 0) + "\n* For Week 1 = 1st Mon-Sun : " + QQ2(D, 1, 1) + "\n# For Week 1 = Sun-Sat row : " + QQ2(D, 0, 6) + "\n# For Week 1 = Mon-Sun row : " + QQ2(D, 1, 0) + "\n? For Week 1 = matches BBC : " + QQ2(D, 6, 4) + "\n~ For Week 1 = matches ISO : " + QQ2(D, 1, 4) + "\nFor ISO standard 8601:2004 : " + StrYWD(D) }

2009-01-18 : a somewhat ad hoc fix has been applied, on finding that "BBC" was a week out. See comment in View Source. Check the previous line too.

Type 3. Week 01 begins on a Given Date

Therefore (unless that date is January 1st), the Year Number can differ from the Calendar Year, and Week 53 has one or two days.

function OddWkNo3(D, m1, d1) { // m1 = 1..12 & d1 are Week 1 Day 1 var dd, fy, m, d // UK FY m1=4 d1=6 m = D.getMonth()+1 ; d = D.getDate() fy = D.getFullYear() - ( m*99+d < m1*99+d1 ) dd = Math.round((D - new Date(fy, m1-1, d1))/864e5) return [ fy, (1+dd/7)|0, 1+dd%7 ] } function OffWkNo3(A, m1, d1) { // comment as above return new Date(+A[0], m1-1, d1 + A[1]*7 + A[2] - 8) } function TryNSWN3(F) { var Q, S = " ", D = new Date(F.MyYMD3.value), A = F.FoY.value.split(/\D+/), m1 = +A[0], d1 = +A[1] F.MyRslt.value = D.YMDDstr() + S + ywkdStr(Q=OddWkNo3(D, m1, d1)) + S + OffWkNo3(Q, m1, d1).YMDDstr() }

HM Revenue and Customs Tax Weeks

UK HMRC (HM Revenue and Customs; was HM Inland Revenue) Tax Weeks are a particular case of Type 3. See in Calendar Weeks.

These string functions are in include3.js, take different parameters, and return text.

function UKtaxWNstr(y, m, d) { var dd, fy = y // m = 1..12 if (m*32+d<134) fy-- dd = (Date.UTC(y, m-1, d) - Date.UTC(fy, 3, 6))/864e5 return 'UK Revenue & Customs:' + ' Year ' + fy + ' week ' + LZ(Math.floor(dd/7)+1) + ' day ' + (dd%7+1) + ';' } function UKtaxMNstr(y, m, d) { var yy = y, mm = m // m = 1..12 if (d<6) mm-- if (mm<4) { yy-- ; mm += 12 } return ' Year ' + yy + ' month ' + LZ(mm-3) + '.' }

function TaxTest() { var D = new Date(), dy = D.getDate(), mo = D.getMonth()+1, yr = D.getFullYear() document.write('By TaxTest() : Today is ', D.YMDDstr(), ' ; thus it is :\n', UKtaxWNstr(yr, mo, dy), UKtaxMNstr(yr, mo, dy), '\nOddWkNo3(D, 4, 6) : ', ywkdStr(D=OddWkNo3(new Date(yr, mo-1, dy), 4, 6)), "; OffWkNo3 : ", OffWkNo3(D, 4, 6).ISOlocaldateStr() ) }

By TaxTest() : Today is 2025-03-11 Tue ; thus it is :
UK Revenue & Customs: Year 2024 week 49 day 4; Year 2024 month 12.
OddWkNo3(D, 4, 6) : 2024wk49d4;  OffWkNo3 : 2025-03-11

Those can easily be generalised for Month 1 and Week 1 starting on any date of the calendar year; in the code, 134 is just 4×32+6 for Month 4 Day 6.

Type 4. Absolute Week Numbers

These start the week count on Monday, Julian BC 4713-01-01, 00:00:00 GMT or local time (which corresponds with CJD). Modification for other starts is easy. Subtracting two such numbers gives what might be called the difference in ISO Week Number.

function AbsWkNo(D) { // D is Date Object or ms, not before JD -0.5 return ((2440588 + D/864e5)/7)|0 /* 719162 for AD1 */ } function LclWkNo(D) { // D is Date Object, not before CJD 0. return AbsWkNo(D - D.getTimezoneOffset()*6e4) } function AWNstart(N) { return new Date((N*7 - 2440588)*864e5) } function LWNstart(N) { return new Date(-4713, 10, 24+7*N) } function TryAbsLclWN(F) { var D = new Date(F.MyDT.value), S = 'Abs Wk No ', T F.MyRslt.value = 'GMT ' + S + (T=AbsWkNo(D)) + '\tfrom : ' + AWNstart(T).toSt() + '\nLCT ' + S + (T=LclWkNo(D)) + '\tfrom : ' + LWNstart(T).toSt() }

See in Calendar Weeks.

Week Numbers in UNIX & C Utilities

Check the definitions carefully, and test the implementation well too. Consider the TZ environment variable, and determine whether it is fully used, including the transition dates. Check what day and what number begin each week, and what happens around the change in year number.

Any Week Number program whuch may use strftime .. %V for ISO 8601 Week Number should be tested for 2001-12-30 2001-12-31 2002-01-01 to see whether it shows an erroneous Week 53 for Mon 2001-12-31 only; cf. ISO Week Number Using DatePart.

Function strftime()

A 1999 man page in unixhelp (*) includes ISO formats %G %g for the year of %V the week number, %u for Mon=1..Sun=7. Also, it has other versions of week data.

GAWK

2002-03-30 ff.

An older GAWK man page (FSF, 1994-11-24) implied that the corresponding GAWK strftime() followed the ANSI C standard; and tests on a particular older GAWK show that it includes non-ISO week numbering. Beware.

2002-07-12 ff.

But Markus Kuhn has written :-
- ANSI C is obsolete. The current C standard is ISO C (1999), which has %V in strftime() for ISO 8601 week numbers.

Tests show that my old copy of GAWK (Gnu Awk (gawk) 2.15, patchlevel 6) does have %V but that it is implemented incorrectly for many year rollovers; and does not know %G which should give the proper year. I have code to fix this.