var c = new Date("2015-03-01"); c.toString(); > Sun Mar 01 2015 01:00:00 GMT+0100
.toJSON() returns the same result as to
c.toJSON(); > 2015-03-01T00:00:00.000Z
What we have got here is UTC-normalized date and time value. The time zone offset of actual time value used with time zone information allow us to normalize the date when sending it to a server. The most important thing here is that the values stored in Date object are expressed in local time zone i.e. the browser’s one. This implies some strange consequences like the one of being in UTC-xx:xx time zones. Let’s try the same example after setting time zone to UTC-01:00.
var c = new Date("2015-03-01"); c.toString(); > Sat Feb 28 2015 23:00:00 GMT-0100
The problem here is that we have actually ended up with parsed values which are different from their original textual representation i.e. March 1st versus February 28th. But it is still OK providing that our date processing logic relies on normalized values:
c.toJSON(); > 2015-03-01T00:00:00.000Z
However, it can be misleading when we try to get individual date components. Here we try to get day component.
c.getDate() > 28
But in general the object still can serve the purpose if we rely on normalized values and call appropriate methods.
The problem is that not all Date constructors behave in the same way. Let’s try this one:
var b = new Date('03/01/2015'); b.toString(); > Sun Mar 01 2015 00:00:00 GMT+0100
Now the parsed date although it still contains time zone information derived from the operating system, but it does not contain time value modified by the corresponding offset. In the first example we have 1am time which corresponds to GMT+01:00, here we have just 00:00 time and, of course, we still do have GMT+01:00 time zone information. This time zone information without correctly shifted time value is actually catastrophic. Look what happens when
.toJSON() is called:
b.toJSON() > 2015-02-28T23:00:00.000Z
The result is wrong date sent to a server. This is not the end of the observation. The same phenomenon can also happen in the other way round, i.e. when we are transferring date values from a server to a client. Now let’s assume the server sent the following date and we are parsing it. Please keep in mind that the actual process of parsing may happen implicitly in some framework’s code, for instance when specifying data source for Kendo grid. So the one who parses it for us can be a framework’s code.
var d = new Date("2015-03-01T00:00:00.000Z"); d.toString(); > Sun Mar 01 2015 01:00:00 GMT+0100
As we see, this constructor results in shifted time value just like the Date(“2015-03-01”) one. But when considering displaying these retrieved values we inevitably have to answer the question, whether we aim at showing local time or the server time. We have to remember that in case when the client’s browser is in GMT-xx:xx time zone and we try to show the parsed value (like in
c.getDate() example), not the normalized one, this may result in wrong date displayed in front of the user. I say `may`, because this can really be a desired behaviour depending on the requirements. For example, in Angularwe can enforce displaying normalized value by providing optional time zone parameter to
var c = new Date("2015-03-01"); $filter('date')(c, "yyyy-MM-dd", "+0000"); > 2015-03-01
Here we do not worry about internal, actual component values of object c whose prototype is Date. It internally may store February 28th but it does not matter.
$filter is told to output values for UTC time. It is also worth mentioning that the Date constructor also assumes that its argument in specified in UTC time. So we populate the Date object with UTC value and return also UTC value not worrying about internal representation which is local. This approach results in the output date and time being equal to the intended input one.
As a conclusion I should write some recommendations on how to use Date object and what to avoid. But honestly I cannot say I gained enough knowledge in this area to make any kind of guidelines. I can only afford making some general statements. Just pay attention to what your library components like, for instance, a date picker control operates on. Is their output a Date object or string representation of the date? What do you do with this output? Is their input a Date object or a string representation and they do the parsing on their own? Just examine carefully and do not blindly trust your framework. I personally do not accept situation when something works and I do now know why it does. I tend to dig into details and try to find the nitty gritty. I have always believed deep research (even one which takes much time) and understanding of underlying technology is worthwhile and I often recall the post by Scott Hanselman who also appears to follow this principle.