Ndtyjky

This works across Daylight Savings Time changes in all countries (the "noon" one above doesn't work in Australia):

Date.prototype.isLeapYear = function() {

    var year = this.getFullYear();

    if((year & 3) != 0) return false;

    return ((year % 100) != 0 || (year % 400) == 0);

};



// Get Day of Year

Date.prototype.getDOY = function() {

    var dayCount = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];

    var mn = this.getMonth();

    var dn = this.getDate();

    var dayOfYear = dayCount[mn] + dn;

    if(mn > 1 && this.isLeapYear()) dayOfYear++;

    return dayOfYear;

};

I find it very interesting that no one considered using UTC since it is not subject to DST. Therefore, I propose the following:

function daysIntoYear(date){

    return (Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()) - Date.UTC(date.getFullYear(), 0, 0)) / 24 / 60 / 60 / 1000;

}

You can test it with the following:

[new Date(2016,0,1), new Date(2016,1,1), new Date(2016,2,1), new Date(2016,5,1), new Date(2016,11,31)]

    .forEach(d => 

        console.log(`${d.toLocaleDateString()} is ${daysIntoYear(d)} days into the year`));

Which outputs for the leap year 2016 (verified using http://www.epochconverter.com/days/2016):

1/1/2016 is 1 days into the year

2/1/2016 is 32 days into the year

3/1/2016 is 61 days into the year

6/1/2016 is 153 days into the year

12/31/2016 is 366 days into the year

Date.prototype.dayOfYear= function(){

    var j1= new Date(this);

    j1.setMonth(0, 0);

    return Math.round((this-j1)/8.64e7);

}



alert(new Date().dayOfYear())

Luckily this question doesn't specify if the number of the current day is required, leaving room for this answer.

Also some answers (also on other questions) had leap-year problems or used 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 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) day of the year based on year, month and day.

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!!

I modified (for javascript) the short-circuit bitmask-modulo leapYear algorithm and came up with a magic number to do a bit-wise lookup of offsets (that excludes jan and feb, thus needing 10 * 3 bits (30 bits is less than 31 bits, so we can safely save another character on the bitshift instead of >>>)).

Note that neither month or day may be 0. That means that if you need this equation just for the current day (feeding it using .getMonth()) you just need to remove the -- from --m.

Note this assumes a valid date (although error-checking is just some characters more).

function dayNo(y,m,d){

  return --m*31-(m>1?(1054267675>>m*3-6&7)-(y&3||!(y%25)&&y&15?0:1):0)+d;

}

<!-- some examples for the snippet -->

<input type=text value="(-)Y-M-D" onblur="

  var d=this.value.match(/(-?d+)[^d]+(dd?)[^d]+(dd?)/)||;

  this.nextSibling.innerHTML=' Day: ' + dayNo(+d[1], +d[2], +d[3]);

" /><span></span>



<br><hr><br>



<button onclick="

  var d=new Date();

  this.nextSibling.innerHTML=dayNo(d.getFullYear(), d.getMonth()+1, d.getDate()) + ' Day(s)';

">get current dayno:</button><span></span>

Here is the version with correct range-validation.

function dayNo(y,m,d){

  return --m>=0 && m<12 && d>0 && d<29+(  

           4*(y=y&3||!(y%25)&&y&15?0:1)+15662003>>m*2&3  

         ) && m*31-(m>1?(1054267675>>m*3-6&7)-y:0)+d;

}

<!-- some examples for the snippet -->

<input type=text value="(-)Y-M-D" onblur="

  var d=this.value.match(/(-?d+)[^d]+(dd?)[^d]+(dd?)/)||;

  this.nextSibling.innerHTML=' Day: ' + dayNo(+d[1], +d[2], +d[3]);

" /><span></span>

Again, one line, but I split it into 3 lines for readability (and following explanation).

The last line is identical to the function above, however the (identical) leapYear algorithm is moved to a previous short-circuit section (before the day-number calculation), because it is also needed to know how much days a month has in a given (leap) year.

The middle line calculates the correct offset number (for max number of days) for a given month in a given (leap)year using another magic number: since 31-28=3 and 3 is just 2 bits, then 12*2=24 bits, we can store all 12 months. Since addition can be faster then subtraction, we add the offset (instead of subtract it from 31). To avoid a leap-year decision-branch for February, we modify that magic lookup-number on the fly.

That leaves us with the (pretty obvious) first line: it checks that month and date are within valid bounds and ensures us with a false return value on range error (note that this function also should not be able to return 0, because 1 jan 0000 is still day 1.), providing easy error-checking: if(r=dayNo(/*y, m, d*/)){}.

If used this way (where month and day may not be 0), then one can change --m>=0 && m<12 to m>0 && --m<12 (saving another char).

The reason I typed the snippet in it's current form is that for 0-based month values, one just needs to remove the -- from --m.

Extra:

Note, don't use this day's per month algorithm if you need just max day's per month. In that case there is a more efficient algorithm (because we only need leepYear when the month is February) I posted as answer this question: What is the best way to determine the number of days in a month with javascript?.

Well, if I understand you correctly, you want 366 on a leap year, 365 otherwise, right? A year is a leap year if it's evenly divisible by 4 but not by 100 unless it's also divisible by 400:

function daysInYear(year) {

    if(year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)) {

        // Leap year

        return 366;

    } else {

        // Not a leap year

        return 365;

    }

}

Edit after update:

In that case, I don't think there's a built-in method; you'll need to do this:

function daysInFebruary(year) {

    if(year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)) {

        // Leap year

        return 29;

    } else {

        // Not a leap year

        return 28;

    }

}



function dateToDay(date) {

    var feb = daysInFebruary(date.getFullYear());

    var aggregateMonths = [0, // January

                           31, // February

                           31 + feb, // March

                           31 + feb + 31, // April

                           31 + feb + 31 + 30, // May

                           31 + feb + 31 + 30 + 31, // June

                           31 + feb + 31 + 30 + 31 + 30, // July

                           31 + feb + 31 + 30 + 31 + 30 + 31, // August

                           31 + feb + 31 + 30 + 31 + 30 + 31 + 31, // September

                           31 + feb + 31 + 30 + 31 + 30 + 31 + 31 + 30, // October

                           31 + feb + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31, // November

                           31 + feb + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30, // December

                         ];

    return aggregateMonths[date.getMonth()] + date.getDate();

}

(Yes, I actually did that without copying or pasting. If there's an easy way I'll be mad)

This is a simple way to find the current day in the year, and it should account for leap years without a problem:

Javascript:

Math.round((new Date().setHours(23) - new Date(new Date().getYear()+1900, 0, 1, 0, 0, 0))/1000/60/60/24);

Javascript in Google Apps Script:

Math.round((new Date().setHours(23) - new Date(new Date().getYear(), 0, 1, 0, 0, 0))/1000/60/60/24);

The primary action of this code is to find the number of milliseconds that have elapsed in the current year and then convert this number into days. The number of milliseconds that have elapsed in the current year can be found by subtracting the number of milliseconds of the first second of the first day of the current year, which is obtained with new Date(new Date().getYear()+1900, 0, 1, 0, 0, 0) (Javascript) or new Date(new Date().getYear(), 0, 1, 0, 0, 0) (Google Apps Script), from the milliseconds of the 23rd hour of the current day, which was found with new Date().setHours(23). The purpose of setting the current date to the 23rd hour is to ensure that the day of year is rounded correctly by Math.round().

Once you have the number of milliseconds of the current year, then you can convert this time into days by dividing by 1000 to convert milliseconds to seconds, then dividing by 60 to convert seconds to minutes, then dividing by 60 to convert minutes to hours, and finally dividing by 24 to convert hours to days.

Note: This post was edited to account for differences between JavaScript and JavaScript implemented in Google Apps Script. Also, more context was added for the answer.

This method takes into account timezone issue and daylight saving time

function dayofyear(d) {   // d is a Date object

    var yn = d.getFullYear();

    var mn = d.getMonth();

    var dn = d.getDate();

    var d1 = new Date(yn,0,1,12,0,0); // noon on Jan. 1

    var d2 = new Date(yn,mn,dn,12,0,0); // noon on input date

    var ddiff = Math.round((d2-d1)/864e5);

    return ddiff+1; 

}

(took from here)

See also this fiddle

If you don't want to re-invent the wheel, you can use the excellent date-fns (node.js) library:

var getDayOfYear = require('date-fns/get_day_of_year')



var dayOfYear = getDayOfYear(new Date(2017, 1, 1)) // 1st february => 32

Math.round((new Date().setHours(23) - new Date(new Date().getFullYear(), 0, 1, 0, 0, 0))/1000/86400);

further optimizes the answer.

Moreover, by changing setHours(23) or the last-but-two zero later on to another value may provide day-of-year related to another timezone.
For example, to retrieve from Europe a resource located in America.

I think this is more straightforward:

var date365 = 0;



var currentDate = new Date();

var currentYear = currentDate.getFullYear();

var currentMonth = currentDate.getMonth(); 

var currentDay = currentDate.getDate(); 



var monthLength = [31,28,31,30,31,30,31,31,30,31,30,31];



var leapYear = new Date(currentYear, 1, 29); 

if (leapYear.getDate() == 29) { // If it's a leap year, changes 28 to 29

    monthLength[1] = 29;

}



for ( i=0; i < currentMonth; i++ ) { 

    date365 = date365 + monthLength[i];

}

date365 = date365 + currentDay; // Done!

I've made one that's readable and will do the trick very quickly, as well as handle JS Date objects with disparate time zones.

I've included quite a few test cases for time zones, DST, leap seconds and Leap years.

P.S. ECMA-262 ignores leap seconds, unlike UTC. If you were to convert this to a language that uses real UTC, you could just add 1 to oneDay.

// returns 1 - 366

findDayOfYear = function (date) {

  var oneDay = 1000 * 60 * 60 * 24; // A day in milliseconds

  var og = {                        // Saving original data

    ts: date.getTime(),

    dom: date.getDate(),            // We don't need to save hours/minutes because DST is never at 12am.

    month: date.getMonth()

  }

  date.setDate(1);                  // Sets Date of the Month to the 1st.

  date.setMonth(0);                 // Months are zero based in JS's Date object

  var start_ts = date.getTime();    // New Year's Midnight JS Timestamp

  var diff = og.ts - start_ts;



  date.setDate(og.dom);             // Revert back to original date object

  date.setMonth(og.month);          // This method does preserve timezone

  return Math.round(diff / oneDay) + 1; // Deals with DST globally. Ceil fails in Australia. Floor Fails in US.

}



// Tests

var pre_start_dst = new Date(2016, 2, 12);

var on_start_dst = new Date(2016, 2, 13);

var post_start_dst = new Date(2016, 2, 14);



var pre_end_dst_date = new Date(2016, 10, 5);

var on_end_dst_date = new Date(2016, 10, 6);

var post_end_dst_date = new Date(2016, 10, 7);



var pre_leap_second = new Date(2015, 5, 29);

var on_leap_second = new Date(2015, 5, 30);

var post_leap_second = new Date(2015, 6, 1);



// 2012 was a leap year with a leap second in june 30th

var leap_second_december31_premidnight = new Date(2012, 11, 31, 23, 59, 59, 999);



var january1 = new Date(2016, 0, 1);

var january31 = new Date(2016, 0, 31);



var december31 = new Date(2015, 11, 31);

var leap_december31 = new Date(2016, 11, 31);



alert( ""

  + "nPre Start DST: " + findDayOfYear(pre_start_dst) + " === 72"

  + "nOn Start DST: " + findDayOfYear(on_start_dst) + " === 73"

  + "nPost Start DST: " + findDayOfYear(post_start_dst) + " === 74"

      

  + "nPre Leap Second: " + findDayOfYear(pre_leap_second) + " === 180"

  + "nOn Leap Second: " + findDayOfYear(on_leap_second) + " === 181"

  + "nPost Leap Second: " + findDayOfYear(post_leap_second) + " === 182"

      

  + "nPre End DST: " + findDayOfYear(pre_end_dst_date) + " === 310"

  + "nOn End DST: " + findDayOfYear(on_end_dst_date) + " === 311"

  + "nPost End DST: " + findDayOfYear(post_end_dst_date) + " === 312"

      

  + "nJanuary 1st: " + findDayOfYear(january1) + " === 1"

  + "nJanuary 31st: " + findDayOfYear(january31) + " === 31"

  + "nNormal December 31st: " + findDayOfYear(december31) + " === 365"

  + "nLeap December 31st: " + findDayOfYear(leap_december31) + " === 366"

  + "nLast Second of Double Leap: " + findDayOfYear(leap_second_december31_premidnight) + " === 366"

);

I would like to provide a solution that does calculations adding the days for each previous month:

function getDayOfYear(date) {

    var month = date.getMonth();

    var year = date.getFullYear();

    var days = date.getDate();

    for (var i = 0; i < month; i++) {

        days += new Date(year, i+1, 0).getDate();

    }

    return days;

}

var input = new Date(2017, 7, 5);

console.log(input);

console.log(getDayOfYear(input));

This way you don't have to manage the details of leap years and daylight saving.

A alternative using UTC timestamps. Also as others noted the day indicating 1st a month is 1 rather than 0. The month starts at 0 however.

var now = Date.now();

var year =  new Date().getUTCFullYear();

var year_start = Date.UTC(year, 0, 1);

var day_length_in_ms = 1000*60*60*24;

var day_number = Math.floor((now - year_start)/day_length_in_ms)

console.log("Day of year " + day_number);

You can pass parameter as date number in setDate function:

var targetDate = new Date();

targetDate.setDate(1);



// Now we can see the expected date as: Mon Jan 01 2018 01:43:24

console.log(targetDate);



targetDate.setDate(365);



// You can see: Mon Dec 31 2018 01:44:47

console.log(targetDate)

This might be useful to those who need the day of the year as a string and have jQuery UI available.

You can use jQuery UI Datepicker:

day_of_year_string = $.datepicker.formatDate("o", new Date())

Underneath it works the same way as some of the answers already mentioned ((date_ms - first_date_of_year_ms) / ms_per_day):

function getDayOfTheYearFromDate(d) {

    return Math.round((new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime() 

- new Date(d.getFullYear(), 0, 0).getTime()) / 86400000);

}



day_of_year_int = getDayOfTheYearFromDate(new Date())

It always get's me worried when mixing maths with date functions (it's so easy to miss some leap year other detail). Say you have:

var d = new Date();

I would suggest using the following, days will be saved in day:

for(var day = d.getDate(); d.getMonth(); day += d.getDate())

    d.setDate(0);

Can't see any reason why this wouldn't work just fine (and I wouldn't be so worried about the few iterations since this will not be used so intensively).

/*USE THIS SCRIPT */

var today = new Date();

var first = new Date(today.getFullYear(), 0, 1);

var theDay = Math.round(((today - first) / 1000 / 60 / 60 / 24) + .5, 0);

alert("Today is the " + theDay + (theDay == 1 ? "st" : (theDay == 2 ? "nd" : (theDay == 3 ? "rd" : "th"))) + " day of the year");