Alternative to casting UTC Date in Javascript?

Question

I wish to create a new Date in JS, but have it be cast as UTC time. For example, suppose castAsUTC() produces the following desired effect:

var x = new Date('2019-01-01T00:00:00') // In local time (PST)
castAsUTC(x).toISOString(); // => '2019-01-01T00:00:00Z'
// x.toISOString() gives us '2019-01-01T08:00:00Z', which is undesired

Currently, my function looks like this:

function castAsUTC(date) {
  return new Date(x.toLocaleString() + '+00:00');
}

Is there a cleaner/nicer way of producing the same effect? Thanks in advance!

EDIT: To be more specific, I'm interested in transforming the date's timezone, without changing its actual value with as little arithmetic as possible. So calling .toISOString() will produce the same date as it is in local time.

I am currently using the moment-timezone library, but I can't seem to get the desired effect using that, either. I would definitely accept an answer that uses Moment.js

Answer 1

tl;dr;

You formatted the date wrong. Add the letter "Z" to the end of your date string and it will be treated as UTC.

var x = new Date('2019-01-01T00:00:00Z')    // Jan 1, 2019 12 AM UTC

These formatting issues are easier to manage with a library like momentjs (utc and format functions) as described in other answers. If you want to use vanilla javascript, you'll need to subtract out the timezone offset before calling toISOString (see warnings in the longer answer below).

Details

Date in javascript deals with timezones in a somewhat counter intuitive way. Internally, the date is stored as the number of milliseconds since the Unix epoch (Jan 1, 1970). That's the number you get when you call getTime() and it's the number that's used for math and comparisons.

However - when you use the standard string formatting functions (toString, toTimeString, toDateString, etc) javascript automatically applies the timezone offset for the local computers timezone before formatting. In a browser, that means it will apply the offset for the end users computer, not the server. The toISOString and toUTCString functions will not apply the offset - they print the actual UTC value stored in the Date. This will probably still look "wrong" to you because it won't match the value you see in the console or when calling toString.

Here's where things really get interesting. You can create Date's in javascript by specifying the number of milliseconds since the Unix epoch using new Date(milliseconds) or by using a parser with either new Date(dateString). With the milliseconds method, there's no timezone to worry about - it's defined as UTC. The question is, with the parse method, how does javascript determine which timezone you intended? Before ES5 (released 2009) the answer was different depending on the browser! Post ES5, the answer depends on how you format the string! If you use a simplified version of ISO 8601 (with only the date, no time), javascript considers the date to be UTC. Otherwise, if you specify the time in ISO 8601 format, or you use a "human readable" format, it considers the date to be local timezone. Check out MDN for more.

Some examples. I've indicated for each if javascript treats it as a UTC or a local date. In UTC, the value would be Jan 1, 1970 at midnight. In local it depends on the timezone. For OP in pacfic time (UTC-8), the UTC value would be Jan 1, 1970 at 8 AM.

new Date(0)                    // UTC (milliseconds is always UTC)
new Date("1/1/1970");          // Local - (human readable string)
new Date("1970-1-1");          // Local (invalid ISO 8601 - missing leading zeros on the month and day)
new Date("1970-01-01");        // UTC (valid simplified ISO 8601)
new Date("1970-01-01T00:00");  // Local (valid ISO 8601 with time and no timezone)
new Date("1970-01-01T00:00Z"); // UTC (valid ISO 8601 with UTC specified)

You cannot change this behavior - but you can be pedantic about the formats you use to parse dates. In your case, the problem was you provided an ISO-8601 string with the time component but no timezone. Adding the letter "Z" to the end of your string, or removing the time would both work for you.

Or, always use a library like momentjs to avoid these complexities.

Vanilla JS Workaround

As discussed, the real issue here is knowing whether a date will be treated as local or UTC. You can't "cast" from local to UTC because all Date's are UTC already - it's just formatting. However, if you're sure a date was parsed as local and it should really be UTC, you can work around it by manually adjusting the timezone offset. This is referred to as "epoch shifting" (thanks @MattJohnson for the term!) and it's dangerous. You actually create a brand new Date that refers to a different point in time! If you use it in other parts of your code, you can end up with incorrect values!

Here's a sample epoch shift method (renamed from castAsUtc for clarity). First get the timezone offset from the object, then subtract it and create a new date with the new value. If you combine this with toISOString you'll get a date formatted as you wanted.

function epochShiftToUtc(date) {
    var timezoneOffsetMinutes = date.getTimezoneOffset();
    var timezoneOffsetMill = timezoneOffsetMinutes * 1000 * 60;
    var buffer = new Date(date.getTime() - timezoneOffsetMill);

    return buffer;
}

epochShiftToUtc(date).toUTCString();

Answer 2

If indeed the string you have is like the one shown, then the easiest thing to do would be to append a Z to indicate UTC.

var input = '2019-01-01T00:00:00';
var date = new Date(input + 'Z');
var output = date.toISOString();

Or, if you would like to use Moment.js, then do this:

var input = '2019-01-01T00:00:00';
var m = moment.utc(input);
var output = m.format();

You do not need moment-timezone for this.

Answer 3

You can switch a Moment instance to UTC using the utc function. Then just use format to get whatever the specific output you want from it.