Javascript обчислює день року (1 - 366)

Як використовувати javascript для обчислення дня в році від 1 до 366? Наприклад:

• 3 січня має бути 3 .
• 1 лютого має бути 32 .

Після редакції ОП:

var now = new Date();
var start = new Date(now.getFullYear(), 0, 0);
var diff = now - start;
var oneDay = 1000 * 60 * 60 * 24;
var day = Math.floor(diff / oneDay);
console.log('Day of year: ' + day);

Редагувати: Код, наведений вище , не вдасться, коли nowдата буде між 26 березня та 29 жовтня, а nowчас до 1:00 (наприклад, 00:59:59). Це пояснюється тим, що код не враховує літній час. Ви повинні компенсувати це:

var now = new Date();
var start = new Date(now.getFullYear(), 0, 0);
var diff = (now - start) + ((start.getTimezoneOffset() - now.getTimezoneOffset()) * 60 * 1000);
var oneDay = 1000 * 60 * 60 * 24;
var day = Math.floor(diff / oneDay);
console.log('Day of year: ' + day);

Це працює в межах літнього часу в усіх країнах ("полудень" вище в Австралії не працює):

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;
};

Мені здається дуже цікавим, що ніхто не думав використовувати UTC, оскільки він не підлягає DST. Тому я пропоную наступне:

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

Ви можете перевірити його за допомогою наступного:

[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`));

Які результати для високосного 2016 року (перевірено за допомогою 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())

На щастя, це питання не визначає, чи потрібний номер поточного дня, що залишає місце для цієї відповіді.
Також деякі відповіді (також і на інші запитання) мали проблеми високосного року або використовували об'єкт Date. Незважаючи на те, що JavaScript Date objectохоплює приблизно 285616 років (100 000 000 днів) з будь-якої сторони 1 січня 1970 року, мене набридли всілякі несподівані невідповідності дати у різних браузерах (особливо це стосується року 0 до 99). Мені також було цікаво, як це обчислити.

Тому я написав простий і, перш за все, невеликий алгоритм для обчислення правильного ( Proleptic Gregorian / Astronomical / ISO 8601: 2004 (п. 4.3.2.1), тому рік0 існує і є високосним, і негативні роки підтримуються ) день року на основі року , місяця та дня .
Зауважте, що в AD/BCпозначенні рік 0 AD / BC не існує: замість цього року1 BC - високосний! Якщо вам потрібно врахувати позначення BC, тоді просто віднімайте один рік (інакше позитивного) значення року спочатку !!

Я змінив (для javascript) алгоритм короткого замикання бітмаски-модуля leapYear і придумав магічне число, щоб зробити трохи розумний пошук компенсацій (що виключає Ян і Feb, тому потрібно 10 * 3 біт (30 біт менше, ніж 31 біт, тому ми можемо безпечно зберегти інший символ на бітсифта замість >>>)).

Зауважте, що ні місяць, ні день не можуть бути 0. Це означає, що якщо вам потрібно це рівняння просто на поточний день (годуючи його за допомогою .getMonth()), вам просто потрібно видалити --з --m.

Зверніть увагу, це передбачає дійсну дату (хоча перевірка помилок - це лише деякі символи більше).

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]+(\d\d?)[^\d]+(\d\d?)/)||[];
  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>

Ось версія з правильною діапазоном перевірки.

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]+(\d\d?)[^\d]+(\d\d?)/)||[];
  this.nextSibling.innerHTML=' Day: ' + dayNo(+d[1], +d[2], +d[3]);
" /><span></span>

Знову один рядок, але я розділив його на 3 рядки для читабельності (та наступного пояснення).

Останній рядок ідентичний функції, наведеній вище, однак алгоритм (ідентичний) високосний рік переміщується до попереднього розділу короткого замикання (перед розрахунком числа дня), оскільки він також повинен знати, скільки днів у місяці має даний (високосний) рік.

Середній рядок обчислює правильне число зміщення (за максимальну кількість днів) за даний місяць у даному (високосному) році, використовуючи інше магічне число: оскільки 31-28=3і 3це лише 2 біти, то 12*2=24біти, ми можемо зберігати всі 12 місяців. Оскільки додавання може бути швидшим, ніж віднімання, ми додаємо зміщення (замість того, щоб відняти його від 31). Щоб уникнути розгалуження річного року у лютому, ми змінюємо цей магічний номер пошуку на ходу.

Це залишає нас із (досить очевидним) першим рядком: він перевіряє, що місяць та дата знаходяться в межах допустимих меж і забезпечує нам falseзначення повернення за помилкою діапазону (зауважте, що ця функція також не повинна мати змогу повернути 0, оскільки 1 січня 0000 ще день 1.), забезпечуючи легкі перевірки помилок: if(r=dayNo(/*y, m, d*/)){}.
Якщо використовується таким чином (де місяць і день не може бути 0), то можна змінити --m>=0 && m<12на m>0 && --m<12(збереження іншого знака).
Тому я надрукував уривок в його нинішньому вигляді є те , що для значень місяця 0 на основі, тільки потрібно , щоб видалити --з--m .

Додатково:
Зауважте, не використовуйте алгоритм цього дня на місяць, якщо вам потрібно лише максимум дня на місяць. У цьому випадку є більш ефективний алгоритм (оскільки нам потрібен лише рік, коли місяць - лютий), я розмістив відповідь на це запитання: який найкращий спосіб визначити кількість днів у місяці за допомогою JavaScript? .

Якщо ви не хочете переосмислити колесо, можете скористатися чудовою бібліотекою date-fns (node.js):

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

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

Ну, якщо я вас правильно зрозумів, ви хочете 366 у високосний рік, 365 в іншому випадку, правда? Рік - це високосний рік, якщо він рівномірно ділиться на 4, але не на 100, якщо також він не ділиться на 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;
    }
}

Редагувати після оновлення:

У цьому випадку я не думаю, що існує вбудований метод; вам потрібно зробити це:

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();
}

(Так, я насправді це зробив, не копіюючи і не вставляючи. Якщо є простий спосіб, я буду злий)

Це простий спосіб знайти поточний день у році, і він повинен без проблем пояснювати високосні роки:

Javascript:

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

Javascript у сценарії Google Apps:

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

Основна дія цього коду - знайти кількість мілісекунд, що минули в поточному році, а потім перетворити це число в дні. Кількість мілісекунд, що минули в поточному році, можна визначити, віднявши число мілісекунд першої секунди першого дня поточного року, отримане за допомогою new Date(new Date().getYear()+1900, 0, 1, 0, 0, 0)(Javascript) або new Date(new Date().getYear(), 0, 1, 0, 0, 0)(Google Apps Script), від мілісекунд 23-ї години поточного дня, яку знайшли с new Date().setHours(23). Метою встановлення поточної дати на 23 годину є забезпечення правильного округлення дня року Math.round().

Коли у вас є кількість мілісекунд поточного року, ви можете перетворити цей час на дні, поділивши на 1000, щоб перетворити мілісекунди на секунди, потім розділити на 60, щоб перетворити секунди на хвилини, потім поділити на 60, щоб перетворити хвилини в години, і, нарешті, ділиться на 24, щоб перетворити години на дні.

Примітка. Ця публікація була відредагована для врахування відмінностей між JavaScript і JavaScript, реалізованими в Google Apps Script. Також для відповіді було додано більше контексту.

Я думаю, що це простіше:

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!

Цей метод враховує питання часового поясу та переходу на літній час

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; 
}

(взяв звідси )

Дивіться також цю загадку

Math.round ((нова дата (). SetHours (23) - нова дата (нова дата (). GetFullYear (), 0, 1, 0, 0, 0)) / 1000/86400);

далі оптимізує відповідь.

Крім того, змінивши setHours (23) або нуль останніх, але два, пізніше на інше значення може забезпечити день року, пов'язаний з іншим часовим поясом. Наприклад, витягнути з Європи ресурс, розташований в Америці.

Math.floor((Date.now() - Date.parse(new Date().getFullYear(), 0, 0)) / 86400000)

це моє рішення

Я зробив такий, який можна прочитати і дуже швидко виконає трюк, а також оброблятиме об’єкти JS Date з різними часовими поясами.

Я включив досить багато тестових випадків для часових поясів, DST, високосних секунд та високосних років.

PS ECMA-262 ігнорує високосні секунди, на відміну від UTC. Якщо ви перетворили це на мову, яка використовує реальний UTC, ви можете просто додати 1 до 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"
);

Я хотів би запропонувати рішення, яке робить розрахунки, додаючи дні для кожного попереднього місяця:

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));

Таким чином, вам не доведеться керувати деталями високосних років та літнього часу.

Альтернатива за допомогою часових позначок UTC. Також, як зазначають інші, день, що вказує на 1-й місяць, є 1, а не 0. Місяць починається з 0, однак.

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);

Ви можете передати параметр як номер дати у setDateфункції:

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)

Це може бути корисним для тих, хто потребує день року у якості рядка та має доступний інтерфейс jQuery.

Ви можете використовувати jQuery UI Datepicker:

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

Під ним працює так само, як і деякі відповіді, які вже згадувались ( (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())

Для тих серед нас, хто хоче швидкого альтернативного рішення.

(function(){"use strict";
function daysIntoTheYear(dateInput){
    var fullYear = dateInput.getFullYear()|0;
	// "Leap Years are any year that can be exactly divided by 4 (2012, 2016, etc)
 	//	except if it can be exactly divided by 100, then it isn't (2100, 2200, etc)
 	//		except if it can be exactly divided by 400, then it is (2000, 2400)"
	// (https://www.mathsisfun.com/leap-years.html).
    var isLeapYear = ((fullYear & 3) | (fullYear/100 & 3)) === 0 ? 1 : 0;
	// (fullYear & 3) = (fullYear % 4), but faster
    //Alternative:var isLeapYear=(new Date(currentYear,1,29,12)).getDate()===29?1:0
    var fullMonth = dateInput.getMonth()|0;
    return ((
        // Calculate the day of the year in the Gregorian calendar
        // The code below works based upon the facts of signed right shifts
        //    • (x) >> n: shifts n and fills in the n highest bits with 0s 
        //    • (-x) >> n: shifts n and fills in the n highest bits with 1s
        // (This assumes that x is a positive integer)
        (31 & ((-fullMonth) >> 4)) + // January // (-11)>>4 = -1
        ((28 + isLeapYear) & ((1-fullMonth) >> 4)) + // February
        (31 & ((2-fullMonth) >> 4)) + // March
        (30 & ((3-fullMonth) >> 4)) + // April
        (31 & ((4-fullMonth) >> 4)) + // May
        (30 & ((5-fullMonth) >> 4)) + // June
        (31 & ((6-fullMonth) >> 4)) + // July
        (31 & ((7-fullMonth) >> 4)) + // August
        (30 & ((8-fullMonth) >> 4)) + // September
        (31 & ((9-fullMonth) >> 4)) + // October
        (30 & ((10-fullMonth) >> 4)) + // November
        // There are no months past December: the year rolls into the next.
        // Thus, fullMonth is 0-based, so it will never be 12 in Javascript

        (dateInput.getDate()|0) // get day of the month

    )&0xffff);
}
// Demonstration:
var date = new Date(2100, 0, 1)
for (var i=0; i<12; i=i+1|0, date.setMonth(date.getMonth()+1|0))
    console.log(date.getMonth()+":\tday "+daysIntoTheYear(date)+"\t"+date);
date = new Date(1900, 0, 1);
for (var i=0; i<12; i=i+1|0, date.setMonth(date.getMonth()+1|0))
    console.log(date.getMonth()+":\tday "+daysIntoTheYear(date)+"\t"+date);

// Performance Benchmark:
console.time("Speed of processing 65536 dates");
for (var i=0,month=date.getMonth()|0; i<65536; i=i+1|0)
    date.setMonth(month=month+1+(daysIntoTheYear(date)|0)|0);
console.timeEnd("Speed of processing 65536 dates");
})();

Розмір місяців року та спосіб роботи Leap Years ідеально підходять для того, щоб слідкувати за часом із сонцем. Чорт, це працює настільки досконало, що все, що ми коли-небудь робимо, - це просто налаштувати кілька секунд тут і там . Наша діюча система високосних років діє з 24 лютого 1582 року р. І, ймовірно, залишиться в силі в осяжному майбутньому.

DST, однак, може дуже змінитися. Можливо, через 20 років якась країна може компенсувати час на цілий день або якусь іншу крайність для DST. Цілий день DST майже напевно ніколи не відбудеться, але все ж DST все ще дуже високий і нерішучий. Таким чином, вищевказане рішення є доказом у майбутньому, крім того, що воно дуже швидко.

Вищенаведений фрагмент коду працює дуже швидко. Мій комп'ютер може обробити 65536 дат за ~ 52 мс у Chrome.

Це рішення, яке дозволяє уникнути проблемних проблем з об’єктом дати та часовим поясом, воно вимагає, щоб дата введення була у форматі "yyyy-dd-mm". Якщо ви хочете змінити формат, змініть функцію date_str_to_parts:

    function get_day_of_year(str_date){
    var date_parts = date_str_to_parts(str_date);
    var is_leap = (date_parts.year%4)==0;
    var acct_for_leap = (is_leap && date_parts.month>2);
    var day_of_year = 0;

    var ary_months = [
        0,
        31, //jan
        28, //feb(non leap)
        31, //march
        30, //april
        31, //may
        30, //june
        31, //july
        31, //aug
        30, //sep
        31, //oct
        30, //nov   
        31  //dec
        ];


    for(var i=1; i < date_parts.month; i++){
        day_of_year += ary_months[i];
    }

    day_of_year += date_parts.date;

    if( acct_for_leap ) day_of_year+=1;

    return day_of_year;

}

function date_str_to_parts(str_date){
    return {
        "year":parseInt(str_date.substr(0,4),10),
        "month":parseInt(str_date.substr(5,2),10),
        "date":parseInt(str_date.substr(8,2),10)
    }
}

Мене завжди турбує, коли змішується математика з функціями дати (так просто пропустити якусь іншу деталь у високосний рік). Скажіть, у вас є:

var d = new Date();

Я б запропонував використовувати наступне, дні будуть збережені в day:

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

Не бачу жодної причини, чому це не спрацювало б добре (і я б не переживав за кілька повторень, оскільки це не буде використовуватися так інтенсивно).

.

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");