What are valid Date Time Strings in JavaScript?

Solution 1:

The Essentials

JavaScript officially supports a simplification of the ISO 8601 Extended Format. The format is as follows: YYYY-MM-DDTHH:mm:ss.sssZ. The letter T is the date/time separator and Z is the time zone offset specified as Z (for UTC) or either + or - followed by a time expression HH:mm. Some parts (e.g. the time) of that format can be omitted.

Note that years must have at least four digits, month/day/hours/minutes/seconds must have exactly two digits, and milliseconds must have exactly three digits. For example, 99-1-1 is not a valid date string.

These are some examples of valid date (time) strings:

• 2018-12-30
• 2018-12-30T20:59
• 2018-12-30T20:59:00
• 2018-12-30T20:59:00.000Z
• 2018-12-30T20:59:00.000+01:00
• 2018-12-30T20:59:00.000-01:00

When you omit the time zone offset, date-times are interpreted as user local time. When you omit the time altogether, dates are interpreted as UTC.

Important: All modern and reasonably old browsers and implementations support the full-length date time format according to the specification. However, there are differences in the handling of date (time) strings without a time zone (see "Missing Time Zone Offset" below for details). You should not use date time strings without a time zone (Status 2018). Instead pass a unix timestamp in milliseconds or separate arguments for different parts of the date to the Date constructor.

Most browser also support some other formats but they are not specified and thus don't work in all browsers the same way. If at all, you should only use the date time string formats explained above. Every other format might break in other browsers or even in other versions of the same browser.

If you run into Invalid Date instead of a date object, you most probably are using an invalid date time string.

And now with a little more detail.

Date Time String Format

ECMAScript (the specification that the JavaScript language implements) has been supporting date strings in new Date (specification) and Date.parse (specification) since its inception. However, the first versions did not actually specify a date time format. This changed in 2009 when ES5 was introduced with a specification of a date time format.

The Basics

ECMAScript specifies the Date Time String Format as a simplification of the ISO 8601 Extended Format. The format is as follows: YYYY-MM-DDTHH:mm:ss.sssZ.

• YYYY is the decimal digits of the year 0000 to 9999 in the proleptic Gregorian calendar.
• - (hyphen) appears literally twice in the string.
• MM is the month of the year from 01 (January) to 12 (December).
• DD is the day of the month from 01 to 31.
• T appears literally in the string, to indicate the beginning of the time element.
• HH is the number of complete hours that have passed since midnight as two decimal digits from 00 to 24.
• : (colon) appears literally twice in the string.
• mm is the number of complete minutes since the start of the hour as two decimal digits from 00 to 59.
• ss is the number of complete seconds since the start of the minute as two decimal digits from 00 to 59.
• . (dot) appears literally in the string.
• sss is the number of complete milliseconds since the start of the second as three decimal digits.
• Z is the time zone offset specified as "Z" (for UTC) or either "+" or "-" followed by a time expression HH:mm

The specification also mentions that if "the String does not conform to [the specified] format the function may fall back to any implementation-specific heuristics or implementation-specific date formats" which might result in different dates in different browsers.

ECMAScript does not take any user local date time formats into account which means that you can not use country or region-specific date time formats.

Short Date (and Time) Forms

The specification also includes shorter formats as follows.

This format includes date-only forms:

• YYYY
• YYYY-MM
• YYYY-MM-DD

It also includes “date-time” forms that consist of one of the above date-only forms immediately followed by one of the following time forms with an optional time zone offset appended:

• THH:mm
• THH:mm:ss
• THH:mm:ss.sss

Fallback Values

[...] If the MM or DD fields are absent "01" is used as the value. If the HH, mm, or ss fields are absent "00" is used as the value and the value of an absent sss field is "000". When the time zone offset is absent, date-only forms are interpreted as a UTC time and date-time forms are interpreted as a local time.

See "Missing Time Zone Offset" below for more information on the lacking browser support.

Out of Bound Values

Illegal values (out-of-bounds as well as syntax errors) in a format string means that the format string is not a valid instance of this format.

For example, new Date('2018-01-32') and new Date('2018-02-29') will result in a Invalid Date.

Extended Years

The date time format of ECMAScript also specifies extended years which are six digit year values. An example of such an extended year string format looks like +287396-10-12T08:59:00.992Z which denotes a date in the year 287396 A.D. Extended years can either be positive or negative.

Date API

ECMAScript specifies a wide range of date object properties. Given a valid date object, you can use Date.prototype.toISOString() to get a valid date time string. Note that the time zone is always UTC.

new Date().toISOString() // "2018-08-05T20:19:50.905Z"

It is also possible to detect whether a date object valid or an Invalid Date using the following function.

function isValidDate(d) {
  return d instanceof Date && !isNaN(d);
}

Source and more information can be found in Detecting an “invalid date” Date instance in JavaScript.

Examples

Valid Date Time Formats

The following date time formats are all valid according to the specification and should work in every browser, Node.js or other implementation that supports ES2016 or higher.

2018
2018-01
2018-01-01
2018-01-01T00:00
2018-01-01T00:00:00
2018-01-01T00:00:00.000
2018-01-01T00:00:00.000Z
2018-01-01T00:00:00.000+01:00
2018-01-01T00:00:00.000-01:00
+002018-01-01T00:00:00.000+01:00

Invalid Date Time Formats

Note that the following examples are invalid as per the specification. However, that does not mean that no browser or other implementation interprets them to a date. Please do not use any of the date time formats below as they are non-standard and might fail in some browsers or browser versions.

2018-1-1 // month and date must be two digits
2018-01-01T0:0:0.0 // hour/minute/second must be two digits, millisecond must be three digits
2018-01-01 00:00 // whitespace must be "T" instead
2018-01-01T00 // shortest time part must have format HH:mm
2018-01-01T00:00:00.000+01 // time zone must have format HH:mm

Browser Support

Today, every modern and reasonably old browser supports the date time format that was introduced with the ES5 specification in 2009. However, even today (Status 2018) there are different implementations for date time strings without a time zone (see "Missing Time Zone Offset" below). If you need to support older browsers or use strings without a time zone, you should not use date time strings. Instead, pass a number of milliseconds since January 1, 1970, 00:00:00 UTC or two or more arguments representing the different date parts to the Date constructor.

Missing Time Zone Offset

ES5.1 incorrectly states that the value of an absent time zone offset is “Z” which contradicts with ISO 8601. This mistake was fixed in ES6 (ES2015) and extended on in ES2016 (see "Changes to the ECMAScript Specifications" below). As of ES2016, date time strings without a time zone are parsed as local time while date only strings are parsed as UTC.

According to this answer, some implementations never implemented the behaviour specified in ES5.1. One of them seems to be Mozilla Firefox. Other browsers that seem to be compliant with the specification of ES2016 (and higher) are Google Chrome 65+, Microsoft Internet Explorer 11, and Microsoft Edge. The current version of Apple Safari (11.1.2) is not compliant as it erroneously parses date time strings without a time zone (e.g. 2018-01-01T00:00) as UTC instead of local time.

Legacy Date Time Formats

ES5 introduced a specification for date time strings in 2009. Before that, there were no specified formats that were supported by all browsers. As a result, each browser vendor added support for different formats which often did not work accross different browsers (and versions). For a small example of ancient history, see date-formats.

Most browsers still support those legacy formats in order to not break the backward compatibility of older websites. But it is not safe to rely on those non-standard formats as they might be inconsistent or get removed at any time.

Date.prototype.toString() and Date.prototype.toUTCString()

ES2018 for the first time specified the date format that is returned by Date.prototype.toString() and Date.prototype.toUTCString(). Already before that, the ECMA Specification required the Date constructor and Date.parse to correctly parse the formats returned by those methods (even though it did not specify a format before 2018).

An example return value of Date.prototype.toString() may look like this:

Sun Feb 03 2019 14:27:49 GMT+0100 (Central European Standard Time)

Note that the timezone name within brackets is optional and the exact name is "implementation-dependent".

Date.prototype.toUTCString() returns a date in a similar format as Date.prototype.toString() but with a zero timezone offset. An example format may look like this:

Sun, 03 Feb 2019 13:27:49 GMT

Note that there is a comma , after the weekday and day month are reversed compared to Date.prototype.toUTCString().

As those formats have only been specified in 2018, you should not rely on them working equally in different implementations (especially older browsers).

Node.js

Node.js is running on the V8 JavaScript engine which is also used in Google Chrome. So the same specification regarding the date time string format applies. As the code runs in the backend though, the user local time does not influence the time zones but only the settings on the server do. Most platform as a service (PaaS) provider that host Node.js applications use UTC as their default time zone.

Date Time Libraries

Moment.js

Moment.js is a very popular library to help with the handling of dates in JavaScript and it also supports more formats than ECMAScript specifies. In addition, Moment.js also supports creating date objects based on a string and a arbitrary format.

Luxon

Luxon supports parsing of ISO 8601, HTTP, RFC2822, SQL, and arbitrary formats. But only using different functions for different date time formats.

Changes to the ECMAScript Specifications

A list of notable changes in the ECMAScript specifications regarding date time string formats.

Changes in ES2018

Introduces a specification for the date formats returned by Date.prototype.toString() and Date.prototype.toUTCString().

Changes in ES2017

No notable changes.

Changes in ES2016

If the time zone offset is absent, the date-time is interpreted as a local time.

When the time zone offset is absent, date-only forms are interpreted as a UTC time and date-time forms are interpreted as a local time.

Changes in ES6 (ES2015)

The value of an absent time zone offset is “Z”.

If the time zone offset is absent, the date-time is interpreted as a local time.

_{From Corrections and Clarifications in ECMAScript 2015 with Possible Compatibility Impact:}

If a time zone offset is not present, the local time zone is used. Edition 5.1 incorrectly stated that a missing time zone should be interpreted as "z".

_{See Date Time String Format: default time zone difference from ES5 not web-compatible for more details on that change.}

Changes in ES5.1

If the MM or DD fields are absent “01” is used as the value. If the HH, mm, or ss fields are absent “00” is used as the value and the value of an absent sss field is “000”. The value of an absent time zone offset is “Z”.

Changes in ES5

First introduction of a date time string format to the ECMAScript specification.

ECMAScript defines a string interchange format for date-times based upon a simplification of the ISO 8601 Extended Format. The format is as follows: YYYY-MM-DDTHH:mm:ss.sssZ

Also introduces Date.prototype.toISOString() which returns a date time string in that specified format.

Changes in ES3

Deprecates Date.prototype.toGMTString() and replaces it with Date.parse(x.toUTCString()) in the section mentioning that the format returned by these methods must be correctly parseable by implmentations of Date.parse. Note that the format returned by Date.parse(x.toUTCString()) is "implementation-dependent".

Changes in ES2

No notable changes.

Initial Specification: ES1

ES1 introduced date time strings to be used in new Date(value) and Date.parse(value). However, it did not specify an actual date (time) format, it even states that

[...] the value produced by Date.parse is implementation dependent [...]

The specification also mentions that

If x is any Date object [...], then all of the following expressions should produce the same numeric value in that implementation [...]:

• [...]
• Date.parse(x.toString())
• Date.parse(x.toGMTString())

However, the returned value of both Date.prototype.toString() and Date.prototype.toGMTString() were specified as "implementation dependent".

Solution 2:

So which date time formats should I use?

The general recommendation is to not use the built-in parser at all as it's unreliable, so the answer to "should" is "none". See Why does Date.parse give incorrect results?

However, as str says, you can likely use the format specified in ECMA-262 with a timezone: YYYY-MM-DDTHH:mm:ss.sssZ or YYYY-MM-DDTHH:mm:ss.sss±HH:mm, don't trust any other format.

Do all browser support the same formats?

No.

How do Mozilla Firefox, Google Chrome, Microsoft Internet Explorer, Microsoft Edge, and Apple Safari handle date time strings?

Differently. Anything other than the format in ECMA-262 is implementation dependent, and there are bugs in parsing the the ECMA-262 format.

What about Node.js?

Likely different again, see above.

Does it take the local date format into consideration? E.g. if I live in Switzerland and the date format is 30.07.2018, can I use new Date('30.07.2018')?

Maybe. Since it's not the standard format, parsing is implementation dependent, so maybe, maybe not.

Does it take the local time zone into consideration?

It uses the host timezone offset where the string is parsed as local and to generate the string displayed using local times. Otherwise it uses UTC (and the internal time value is UTC).

How can I get a date time string from a date object?

Date.parse.toString, or see Where can I find documentation on formatting a date in JavaScript?

How can I detect invalid date time strings?

One of the first 3 answers here should answer that.

How do date libraries like Moment.js handle date strings?

They parse them based on either a default or provided format. Read the source (e.g. fecha.js is a simple parser and formatter with well written, easy to follow code).

A parser isn't hard to write, but trying to guess the input format (as built-in parsers tend to do) is fraught, unreliable and inconsistent across implementations. So the parser should require the format to be provided unless the input string is in the parser's default format.

PS

There are changes to the formats of strings that implementations must support for parsing and formatting in ECMAScript 2019 (currently in draft), but I think the general advice to avoid the built–in parser will stand for some time yet.