Number of days in any month

Question

How can I write a JavaScript function that accepts a number from 1 - 12 representing the months of the year, and then returns the number of days in that month?

Answer 1

function getDaysInMonth(m, y) {
   return /8|3|5|10/.test(--m)?30:m==1?(!(y%4)&&y%100)||!(y%400)?29:28:31;
}

Answer 2

Try this:

function numberOfDays(year, month) {
    var d = new Date(year, month, 0);
    return d.getDate();
}

Because of leap years you need to pass the year too.

Answer 3

Thirty days hath September,
April, June, and November;
All the rest have thirty-one,
Excepting February alone,
Which hath twenty-eight days clear,
And twenty-nine in each leap year.

<3 Wikipedia

Answer 4

Loved James' answer. Reformatted slightly for those interested.

function getDaysInMonth(m, y)
{
    // months in JavaScript start at 0 so decrement by 1 e.g. 11 = Dec
    --m;

    // if month is Sept, Apr, Jun, Nov return 30 days
    if( /8|3|5|10/.test( m ) ) return 30;

    // if month is not Feb return 31 days
    if( m != 1 ) return 31;

    // To get this far month must be Feb ( 1 )
    // if the year is a leap year then Feb has 29 days
    if( ( y % 4 == 0 && y % 100 != 0 ) || y % 400 == 0 ) return 29;

    // Not a leap year. Feb has 28 days.
    return 28;
}

Fiddle here

Answer 5

Everyone knows that counting Chuck's knuckle sandwich beats mere poetry any day of the week month..

If you can't get that to compile and run (like the poetry), then read on.

---

Without regex and minus 2 modulo remainder operations, also without leap-year problems or the Date-object.
Although javascript's Date object covers approximately 285616 years (100,000,000 days) on either side of January 1 1970, I was fed up with all kinds of unexpected date inconsistencies across different browsers (most notably year 0 to 99). I was also curious how to calculate it.

So I wrote a simple and above all, small algorithm (easily beating James' answer) to calculate the correct (Proleptic Gregorian / Astronomical / ISO 8601:2004 (clause 4.3.2.1), so year 0 exists and is a leap year and negative years are supported) number of day's for a given month and year.
It uses the short-circuit bitmask-modulo leapYear algorithm (slightly modified for js) and common mod-8 month algorithm (again modified to obtain the shortest path).

Note that in AD/BC notation, year 0 AD/BC does not exist: instead year 1 BC is the leap-year!
IF you need to account for BC notation then simply subtract one year of the (otherwise positive) year-value first!! (Or subtract the year from 1 for further year-calculations.)

function daysInMonth(m, y){
  return m===2?y&3||!(y%25)&&y&15?28:29:30+(m+(m>>3)&1);
}

<!-- example for the snippet -->
<input type="text" placeholder="enter year" onblur="
  for( var r='', i=0, y=+this.value
     ; 12>i++
     ; r+= 'Month: ' + i + ' has ' + daysInMonth(i, y) + ' days<br>'
     );
  this.nextSibling.innerHTML=r;
" /><div></div>

Note, months must be 1-based (as the question asked for)!

Note, this is a different algorithm then the magic number lookup I used in my Javascript calculate the day of the year (1 - 366) answer, because here the extra branch for the leap-year is only needed for February.

---

EDIT (-history):
I lifted my modified mod8 month algo

return(m===2?y&3||!(y%25)&&y&15?28:29:30)+(m+(m>>3)&1);   //algo 1

to the ternary and removed the now un-needed outer parenthesis (good call, TrueBlueAussie):

return m===2?y&3||!(y%25)&&y&15?28:29:30+(m+(m>>3)&1);    //algo 2

After severe testing this turned out to be the fastest algo (thanks TrueBlueAussie for the tests to which I chipped in for the caching jsperf setup). We guess the reason that this is faster then my (shorter and seemingly faster) algo 3 (the magic number bitwise lookup below), is that modern browsers can probably pre-optimise the constant bitshift in m>>3.

I figured.. well.. "and why again didn't I just do?:"

return m===2?y&3||!(y%25)&&y&15?28:29:30+(5546>>m&1);     // algo 3

It uses a a 'magic number' to do a simple bit-wise lookup of offsets:

DNOSAJJMAMFJ* = Months (right to left)
CBA9876543210 = Month === bit position in hex (we never use pos 0: January is 1)
1010110101010 = offset from 30 = binary === 5546 decimal

13 bits is less than 31 bits, so we can safely save another character on the bitshift instead of >>> (as we don't need to force unsigned 32 bit).

That eliminates one memory-call (var m), one addition and one precedence! (and it's one char shorter)

One would think that: obviously these 3 extra optimizations beat my first/second algo (which as TrueBlueAussie commented, was already the fastest)...
But as I already mentioned, it turned out that this (algo 3) is not faster on modern browsers (I know, rather unexpected), we think it is because the engine can no longer optimize the bitshift.
I'll leave it here, maybe one day it will be faster, who knows..

As it turned out my algo 2 was the fastest after-all (except TrueBlueAussie's full 2D array of-course, although that takes quite some more memory and still requires a fast algo to build it client-side), I followed TrueBlueAussie's advice to revert my answer to using my algo 2.

Still I had a blast collaborating and am grateful for the incentive to revisit my answer !

Answer 6

In computer terms, new Date() and regular expression solutions are slow! If you want a super-fast (and super-cryptic) one-liner, try this one (assuming m is in Jan=1 format as per the question):

The only real competition for speed is from @GitaarLab, so I have created a head-to-head JSPerf for us to test on: http://jsperf.com/days-in-month-head-to-head/5

I keep trying different code changes to get the best performance.

Current version

After looking at this related question Leap year check using bitwise operators (amazing speed) and discovering what the 25 & 15 magic number represented, I have come up with this optimized hybrid of answers:

function getDaysInMonth(m, y) {
    return m===2 ? y & 3 || !(y % 25) && y & 15 ? 28 : 29 : 30 + (m +(m >> 3) & 1);
}

JSFiddle: http://jsfiddle.net/TrueBlueAussie/H89X3/22/

JSPerf results: http://jsperf.com/days-in-month-head-to-head/5

For some reason, (m+(m>>3)&1) is more efficient than (5546>>m&1) on almost all browsers.

---

Previous Versions:

This one removed a single ! test by reversing the values (slight increase):

function getDaysInMonth(m, y) {
    return m === 2 ? (y % 4 || !(y % 100) && (y % 400)) ? 28 : 29 : 30 + (m + (m >> 3) & 1);
}

This one removed any the unnecessary brackets:

function getDaysInMonth2(m, y) {
    return m === 2 ? !(y % 4 || !(y % 100) && (y % 400)) ? 29 : 28 : 30 + (m + (m >> 3) & 1);
}

This one was down to + being a tad faster than XOR (^)

function getDaysInMonth(m, y) {
    return (m === 2) ? (!((y % 4) || (!(y % 100) && (y % 400))) ? 29 : 28) : 30 + ((m + (m >> 3)) & 1);
}

This was my original stab at it:

function getDaysInMonth(m, y) {
    return m == 2 ? (!((y % 4) || (!(y % 100) && (y % 400))) ? 29 : 28) : (30 + ((m >> 3 ^ m) & 1));
}

It works based on my leap year answer here: javascript to find leap year this answer here Leap year check using bitwise operators (amazing speed) as well as the following binary logic.

---

A quick lesson in binary months:

If you interpret the index of the desired months (Jan = 1) in binary you will notice that months with 31 days either have bit 3 clear and bit 0 set, or bit 3 set and bit 0 clear.

Jan = 1  = 0001 : 31 days
Feb = 2  = 0010
Mar = 3  = 0011 : 31 days
Apr = 4  = 0100
May = 5  = 0101 : 31 days
Jun = 6  = 0110
Jul = 7  = 0111 : 31 days
Aug = 8  = 1000 : 31 days
Sep = 9  = 1001
Oct = 10 = 1010 : 31 days
Nov = 11 = 1011
Dec = 12 = 1100 : 31 days

That means you can shift the value 3 places with >> 3, XOR the bits with the original ^ m and see if the result is 1 or 0 in bit position 0 using & 1. Note: It turns out + is slightly faster than XOR (^) and (m >> 3) + m gives the same result in bit 0.

JSPerf results: http://jsperf.com/days-in-month-perf-test/6 (23 times faster than the accepted answer).

---

Update: I ran a comparison of the top two answers + latest (@James, @Caleb & @GitaarLAB) against this one to ensure they gave consistent results and all 4 return the same values for all months in all years from year 1 to year 4000: http://jsfiddle.net/TrueBlueAussie/8Lmpnpz4/6/. Year 0 is the same for all except @Caleb.

Another update:

If absolute speed were the only goal, and you do not mind wasting memory, then storing the results for a given span of years, in a 2-dimensional table is probably the fastest possible way:

function DIM(m, y) { //TrueBlueAussie
    return m===2?(y%4||!(y%100)&&(y%400))?28:29:30+(m+(m>>3)&1);
}
array = new Array(4000);
for (var y = 1; y < 4000; y++){
    array[y] = [];
    for (var m = 1; m < 13; m++)
    {
        array[y][m] = DIM(m, y);
    }
}

// This just does a lookup into the primed table - wasteful, but fast
function getDaysInMonth2(m, y){
    return array[y][m];
}

JSPerf: http://jsperf.com/days-in-month-head-to-head/5

Answer 7

In the spirit of not doing your homework for you, I present a version in POVRay (sorry, not JS) I did many years ago.

In POVRay, there are no boolean variables. The method I came up with was to create a polynomial in 'm' which gave an answer > 0 for months with 31 days and < 0 for months with 30 days.

#declare m0 = (m-0.5)*(m-1.5)*(m-2.5)*(m-3.5)*(m-4.5)*(m-5.5);
#declare m0 = m0*(m-6.5)*(m-8.5)*(m-9.5)*(m-10.5)*(m-11.5);
#if (m0 > 0)
  #declare maxdays = 31;
#else
  #declare maxdays = 30;
#end

The tricky part is to decide when the year is a leap year. This is the full test for leap years. Most people are aware of the 4-year rule, and since 2000, some know about the 100 and 400 year rules, there is no 4000 year rule.

#declare LEAPYEAR = 2.0;
#if (mod(YEAR,4.0)=0)
  #declare LEAPYEAR = 1.0;
  #if (mod(YEAR,100.0)=0)
    #declare LEAPYEAR = 2.0;
  #end
  #if (mod(YEAR,400.0)=0
    #declare LEAPYEAR = 1.0;
  #end
#end
#if (MONTH = 2.0)
  #declare maxdays = maxdays - LEAPYEAR;
#end
#if (DAY > maxdays)
  #declare MONTH = MONTH + 1;
  #declare DAY = DAY - maxdays;
#end
#if (MONTH > 12)
  #declare YEAR = YEAR + 1;
  #declare MONTH = MONTH - 12;
#end

Answer 8

Loved James' answer as well as Bruno's explanation of it. However, got annoyed at the overly cryptic nature of the solution. So here is the same solution but cleaned of any unnecessary over encryption.

function getDaysInMonth(m, y) {
   return /4|6|9|11/.test(m)?30:m==2?(!(y%4)&&y%100)||!(y%400)?29:28:31;
}

Specifics:

1. Seems there's no need to decrease month - javascript has nothing to do with it, since we only use it for comparison, so I used the real month numbers for clarity.

2. Why write the number of april, june, september and november out of order? That's just confusing.

3. *Optionally, we can increase the month (++m) to get a version that accepts (new Date()).getMonth() as input

Answer 9

I came across this question whilst playing with a C/C++/C# hobby project. So, although this answer may not be pertinent to the OP, the remainder of the answers/comments seem to concern JavaScript "golf"; which is a bit of a black art due to the vagaries of JS JIT, but fun nonetheless.

Standing on the shoulders of GitaarLAB, TrueBlueAussie, et al, I propose:

return m===2?y&3||!(y%25)&&y&15?28:29:30|(m+(m>>3));

Answer 10

try this:

function DaysinMonth(aDate)  {
    return aDate.setMonth(aDate.getMonth()+1, 0).getDate();
}    

Answer 11

Try this:

function daysInMonth(year, month) {
    var isLeap = ( (!(year % 4)) && ( (year % 100) || (!(year % 400)) ) );

    if (month == 2)
        return (isLeap) ? 29 : 28;
    return 30 + (month % 2);
}