Calculating Jday(Julian Day) in javascript

Question

I have requirement to calculate jday in javascript , for doing client side validation , Can any one help me how to calculate JDAY in javascript or script to change given JDAY to actual date or vice versa .

To know what is JDay ,I found the following site ,

http://www.pauahtun.org/Software/jday.1.html

Am also refering the below site for calculation which is mentioned in JAVA

http://www.rgagnon.com/javadetails/java-0506.html

Thank you in advance

Answer 1

Julian Day

The Julian Day is the number of elapsed days since the beginning of a cycle of 7980 years.

Invented in 1583 by Joseph Scaliger, the purpose of the system is to make it easy to compute an integer (whole number) difference between one calendar date and another calendar date.

The 7980 year cycle was derived by combining several traditional time cycles (solar, lunar, and a particular Roman tax cycle) for which 7980 was a common multiple.

The starting point for the first Julian cycle began on January 1, 4713 B.C. at noon GMT, and will end on January 22, 3268 at noon GMT, exactly 7980 whole days later.

As an example, the Julian day number for January 1, 2016 was 2,457,389, which is the number of days since January 1, 4713 B.C. at that day.

How to calculate it

As we know that Unix time is the number of seconds since 00:00:00 UTC, January 1, 1970, not counting leap seconds, and also called Epoch, we can use some math to calculate the Julian Day when we already have the Unix time.

GMT and UTC share the same current time in practice, so for this, there should be no difference.

To start with, we need to know the number of days from when the Julian cycle began, until Unix timestamps began.
In other words, the number of days from January 1, 4713 B.C. at 12:00:00 GMT, until January 1, 1970 at 00:00:00 UTC.

Having this set number of days, that never change, we can just add the number of days from January 1, 1970 until today, which is what Javascript returns anyway, to get the Julian Day.

Without adding up all those years, but simply by searching the web, it tells us that the difference in days between the year 4713 B.C. and 1970 A.D. is 2440588 days, and because the Julian Cycle began at noon, not at midnight, we have to subtract exactly half a day, making it 2440587.5 days.

So what we have now is 2440587.5 days + UNIX TIME in days === Julian Day

With some simple math we can figure out that a day is 86,400 seconds long, and the Unix timestamp is in milliseconds when using Javascript, so UNIX TIME / 86400000 would get us the number of days since Thursday, 1 January 1970, until today.

Now for just the day, we wanted the whole number of days, and not the fractional, and can just round it down to the closes whole day, doing something like

Math.floor((UNIX TIME / 86400000) + 2440587.5);

Julian Date

Sometimes in programming, a "Julian Date" has come to mean the number of days since the year started, for instance June 1, 2016 would be 152 days into that year etc.

The correct use of "Julian Date" is a Julian Day with a timestamp added as a fractional part of the day.

Taking the example at the top of this answer, where January 1, 2016 was the Julian Day 2,457,389 , we can add a time to that.
The Julian Day starts at noon, with no fractional time added, and so at midnight it would be 2457389.5 and at 18:00, or six hours after noon, it would be 2457389.25, adding "half a day", "quarter of a day" etc.

Calculating it, again

This means 0.1 Julian Date is the same as 24 hours divided by 10, or 24 / 10 === 2.4 hours, or in other words, Julian Day timestamps are fractional with decimals (one tenth of a day etc).

Lets look at some Javascript functions, firstly the Date constructor.

Javascript only has access to the local time on the computer it runs on, so when we do new Date() it does not neccessarely create an UTC date, even if UNIX time is in UTC, new Date gives you the number of seconds from epoch until whatever local time your computer has, and does not take your timezone into consideration.

Javascript does however have Date.UTC, which would return the date in UTC format, lets check the difference, and this will of course differ according to the timezone you've set the local system to.

var regular_date = new Date(2016, 1, 1, 0, 0, 0);
var UTC_date     = Date.UTC(2016, 1, 1, 0, 0, 0);
var difference   = UTC_date - regular_date;

document.body.innerHTML = 'The difference between your local time and UTC is ' +(difference/1000)+ ' seconds';

Remember the part at the begin of this chapter, about 0.1 Julian Date being the same as 24 hours divided by 10, or 24 / 10 === 2.4 hours, well, 2.4 hours is 144 minutes, and now lets look quickly at Javascripts getTimezoneOffset() method, the docs say

The getTimezoneOffset() method returns the time-zone offset from UTC, in minutes, for the current locale.

So, it returns the offset for the systems timezone in minutes, that's interesting as most javascript methods that deal with dates returns milliseconds.

We know that a 1/10 of a day is 144 minutes, so 10/10, or a whole day, would be 1440 minutes, so we could use some math to counteract the local systems timezone, given in minutes, and divide it by the number of minutes in a day, to get the correct fractional value

So now we have

2440587.5 days + UNIX TIME in days === Julian Day

and we know Javascripts Date constructor doesn't really use UTC for the current date, but the system time, so we have to have

TIMEZONEOFFSET / 1440

joining them together we would get

(JAVASCRIPT TIME / 86400000) - (TIMEZONEOFFSET / 1440) + 2440587.5
//  ^^ days since epoch ^^      ^^ subtract offset ^^    ^^days from 4713 B.C. to 1970 A.D.

Translating that to javascript would be

var date = new Date();     // a new date
var time = date.getTime(); // the timestamp, not neccessarely using UTC as current time

var julian_day = (time / 86400000) - (date.getTimezoneOffset()/1440) + 2440587.5);

Now this is what we should use to get the Julian Day as well, taking measures to remove the timezone offset, and of course without the fractional time part of the Julian Date.
We would do this by simpy rounding it down to the closest whole integer

var julian_date = Math.floor((time / 86400000) - (date.getTimezoneOffset()/1440) + 2440587.5));

And it's time for my original answer to this question, before I made this extremely long edit to explain why this is the correct approach, after complaints in the comment field.

Date.prototype.getJulian = function() {
  return Math.floor((this / 86400000) - (this.getTimezoneOffset() / 1440) + 2440587.5);
}

var today = new Date(); //set any date
var julian = today.getJulian(); //get Julian counterpart

console.log(julian)

.as-console-wrapper {top:0}

And the same with the fracional part

Date.prototype.getJulian = function() {
  return (this / 86400000) - (this.getTimezoneOffset() / 1440) + 2440587.5;
}

var today = new Date(); //set any date
var julian = today.getJulian(); //get Julian counterpart

console.log(julian)

.as-console-wrapper { top: 0 }

And to finish of, an example showing why

new Date().getTime()/86400000 + 2440587.5

doesn't work, at least not if your system time is set to a timezone with an offset, i.e. anything other than GMT

// the correct approach
Date.prototype.getJulian = function() {
    return (this / 86400000) - (this.getTimezoneOffset() / 1440) + 2440587.5;
}

// the simple approach, that does not take the timezone into consideration
Date.prototype.notReallyJulian = function() {
  return this.getTime()/86400000 + 2440587.5;
}
// --------------

// remember how 18:00 should return a fractional 0.25 etc
var date = new Date(2016, 0,    1,   18,   0,   0,    0); 
//                   ^    ^     ^     ^    ^    ^     ^
//                 year  month date  hour min  sec  milli
                   
var julian = date.getJulian();       //get Julian date
var maybe  = date.notReallyJulian(); // not so much

console.log(julian); // always returns 2457389.25
console.log(maybe);  // returns different fractions, depending on timezone offset

.as-console-wrapper { top: 0 }

Answer 2

new Date().getTime()/86400000 + 2440587.5 will get the unix time stamp, convert it to days and add the JD of 1970-01-01, which is the epoch of the unix time stamp.

This is what astronomers call julian date. It is well defined. Since neither Unix time stamp nor JD take leap seconds into account that does not reduce the accuracy. Note that JD need not be in timezone UTC (but usually is). This answer gives you the JD in timezone UTC.