How to assume local time zone when parsing ISO 8601 date string?

Question

I have a ISO date string as below

 var startTimeISOString = "2013-03-10T02:00:00Z";

when I convert it to date object in javascript using below code, it returns

var startTimeDate = new Date(startTimeISOString);

output is

Date {Sun Mar 10 2013 07:30:00 GMT+0530 (India Standard Time)}

It sure converts the ISOString to date but it converts to local time since new Date() is client dependent. How to just convert iso date time string to date and time but not to local date-time..?

Thanks

Answer 1

According to MDN:

Differences in assumed time zone

Given a date string of "March 7, 2014", parse() assumes a local time zone, but given an ISO format such as "2014-03-07" it will assume a time zone of UTC. Therefore Date objects produced using those strings will represent different moments in time unless the system is set with a local time zone of UTC. This means that two date strings that appear equivalent may result in two different values depending on the format of the string that is being converted (this behavior is changed in ECMAScript ed 6 so that both will be treated as local).

I have done like this and am now getting the exact time which is inside the ISO date string instead of the local time

 var startTimeISOString = "2013-03-10T02:00:00Z";

 var startTime = new Date(startTimeISOString );
 startTime =   new Date( startTime.getTime() + ( startTime.getTimezoneOffset() * 60000 ) );

This will give the same date time inside iso date string , the output here is

o/p

Date {Sun Mar 10 2013 02:00:00 GMT+0530 (India Standard Time)}

Answer 2

To sum up the conversation from tracevipin's post:

All Date objects are based on a time value that is milliseconds since 1970-01-01T00:00:00Z so they are UTC at their core. This is different to UNIX, which uses a value that is represents seconds since the same epoch.

The Date.prototype.toString method returns an implementation dependent string that represents the time based on the system settings and timezone offset of the client (aka local time).

If a UTC ISO8601 time string is required, the Date.prototype.toISOString method can be used. It's quite easy to write a "shim" for this methods if required.

Lastly, do not trust Date.parse to parse a string. Support for an ISO8601 format UTC string is specified in ES5, however it's not consistently implemented across browsers in use. It is much better to parse the string manually (it's not hard, there are examples on SO of how to do it) if wide browser support is required (e.g. typical web application).

Simple ISO8601 UTC time stamp parser:

function dateObjectFromUTC(s) {
  s = s.split(/\D/);
  return new Date(Date.UTC(+s[0], --s[1], +s[2], +s[3], +s[4], +s[5], 0));
}

and here's a shim for toISOString:

if (typeof Date.prototype.toISOString != 'function') {

  Date.prototype.toISOString = (function() {
  
    function z(n){return (n<10? '0' : '') + n;}
    function p(n){
      n = n < 10? z(n) : n;
      return n < 100? z(n) : n;
    }
    
    return function() {
      return this.getUTCFullYear() + '-' +
             z(this.getUTCMonth() + 1) + '-' +
             z(this.getUTCDate()) + 'T' +
             z(this.getUTCHours()) + ':' +
             z(this.getUTCMinutes()) + ':' +
             z(this.getUTCSeconds()) + '.' +
             p(this.getUTCMilliseconds()) + 'Z';
    } 
  }());
}

Answer 3

This happens because date is printed using toString method which by default returns the date and time in local timezone. The method toUTCString will give you the string you need.

Date actually keeps the date as unix time in milliseconds and provides methods to manipulate it.

Answer 4

In vanilla javascript there isn't a way to create a date that assumes the local time of the ISO formatted string you give it. Here's what happens when you pass an ISO 8601 formatted string to javascript. I'm going to use a non UTC time as it illustrates the problem better than using an ISO formatted string:

1. var startTime = new Date("2013-03-10T02:00:00+06:00"). Note this could also be 2013-03-10T02:00:00Z or any other ISO-formatted string.
2. read the time, apply the offset and calculate milliseconds since 1970-01-01T00:00:00Z
3. You now have only milliseconds - you have lost all timezone info. In this case 1362859200000

All functions, apart from the ones that give you a UTC representation of that number, will use the timezone of the computer running the code to interpret that number as a time.

To do what the original poster wants, you need to.

1. parse the ISO string, interpret the offset ('Z' or '+06:00') as the timezone offset
2. store the timezone offset
3. calculate and store the ms since epoch, using the offset timezone offset
4. hold that offset
5. whenever attempting to make a calculation or print the date, apply the timezone offset.

This isn't trivial, and requires a complete interpretation of the 8601 spec. Way too much code to put here.

This is exactly what moment.js is designed to do. I strongly recommend using it. Using moment.js:

moment("2013-03-10T02:00:00Z").format()
"2013-03-10T02:00:00Z"

this will result in printing the ISO time of the original string, preserving the offset.

Answer 5

you can try moment js library https://momentjs.com

For my case, I had 2022-10-17T01:00:00 on my database. SO I need to format it to the 01:00:00 AM.

So here was my solution.

var date = "2022-10-17T01:00:00"
var timeFormat = moment(date ).format('HH:mm A');

output: 01:00:00 AM

Answer 6

it will return ISOdate

var getDate = () => {
    var dt = new Date();
    var off = dt.getTimezoneOffset() * 60000
    var newdt = new Date(dt - off).toISOString()
    return newdt.slice(0, 19)
}

Output