Using getTimezoneOffset()

You can get the time zone offset in minutes like this:

var offset = new Date().getTimezoneOffset();
console.log(offset);
// if offset equals -60 then the time zone offset is UTC+01

The time-zone offset is the difference, in minutes, between UTC and local time. Note that this means that the offset is positive if the local timezone is behind UTC and negative if it is ahead. For example, if your time zone is UTC+10 (Australian Eastern Standard Time), -600 will be returned. Daylight savings time prevents this value from being a constant even for a given locale

• Mozilla Date Object reference

Note that not all timezones are offset by whole hours: for example, Newfoundland is UTC minus 3h 30m (leaving Daylight Saving Time out of the equation).

Please also note that this only gives you the time zone offset (eg: UTC+01), it does not give you the time zone (eg: Europe/London).

A one-liner that gives both the offset and the time zone is to simply call toTimeString() on a new Date object. From MDN:

The toTimeString() method returns the time portion of a Date object in human readable form in American English.

The catch is that the timezone is not in the standard IANA format; it's somewhat more user-friendly, than the "continent/city" IANA format. Try it out:

console.log(new Date().toTimeString().slice(9));
console.log(Intl.DateTimeFormat().resolvedOptions().timeZone);
console.log(new Date().getTimezoneOffset() / -60);

In California right now, toTimeString() returns Pacific Daylight Time while the Intl API returns America/Los_Angeles. In Colombia, you'd get Colombia Standard Time, vs. America/Bogota.

Note that many other answers to this question attempt to obtain the same information by calling Date.toString(). That approach is not that reliable, as MDN explains:

Date instances refer to a specific point in time. Calling toString() will return the date formatted in a human readable form in American English. [...] Sometimes it is desirable to obtain a string of the time portion; such a thing can be accomplished with the toTimeString() method.

The toTimeString() method is especially useful because compliant engines implementing ECMA-262 may differ in the string obtained from toString() for Date objects, as the format is implementation-dependent; simple string slicing approaches may not produce consistent results across multiple engines.

try getTimezoneOffset() of the Date object:

var curdate = new Date()
var offset = curdate.getTimezoneOffset()

This method returns time zone offset in minutes which is the difference between GMT and local time in minutes.

This question already has 30+ answers, but I am sure there are people who will come here and really don't know what they are looking for.

Surprise! you are about to open a can of worms!

I strongly recommend reading this article that I wrote recently about the headaches of dealing with TimeZones in JS! https://medium.com/@EyeDin/time-and-time-zone-headaches-in-javascript-ae4d873a665d

What are you EXACTLY looking for?

Depending on your actually use case, you actually need different things.

1) A way to convert a fixed point-in-time (like November 13th of 2021 at 11:35:21pm in San Francisco) to the user's wall-clock time, who might be anywhere in the world.

Use .toLocaleString().

It has more customization parameters for formatting than you can think of, via its two parameters of locale and options listed at DateTimeFormat. It even supports different calendars, languages, ways of formatting year, month, day, etc. (no passed parameter will use the user's default settings, which might be the ideal.)

As a developer, just pass that point-in-time value (e.g. opening time of a Sales event, or a competition) as UNIX timestamp number (that's the number of seconds from 1/1/1970 in UTC, timezone-agnostic and DST0agnostic) to the client, and then do new Date(timestamp).toLocaleString(). e.g. for that point-of-time above, the value is 1636875321000 (in milliseconds), via +dateWithTimeZone("America/Los_Angeles",2021,10,13,23,35,21) using the function from this answer.

2) Be able to send the user a notification/email at 9am of their local time, 3 months from now

This is a totally different requirement! Like, very very different!

Isn't GMT-8:00 enough?

No!

That's just the time zone the user is at, at one point of time, like "right now, today".

• How would you know if the user has Daylight Saving or not? (Arizona in the US doesn't, and so many other countries and states, and even counties!)
• How would you know if the user is in the DST or out of it? Is it winter in San Francisco (GMT-8) or summer in Alaska (again, GMT-8). See this giant list to freak out: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones

Isn't "PDT" enough for that?

No!

First of all, PDT isn't even a year-round thing. It's November now and timeanddate.com says "No locations currently on PDT. Would you like to see PST?" (read my Medium article above for more details.)

Unless you are going for the cosmetic from-client-to-client UI string, this PDT/CEST/etc. doesn't worth anything!

Why? Because Tijuana in Mexico and San Francisco in the US are both in PDT during June, but they have different DST (Daylight Saving) days that they switch to PST. And you need to know that!

US's DST days in 2022 are Mar 13, 2022 to Nov 6, 2022. Mexico's DST days in 2022 are April 3, 2022 to Oct 30, 2022. So, while Tijuana and San Francisco are sharing that "PDT/PST" thing in almost 93% of the days, in 7% of the days (e.g. Mar 14 till April 3, and Oct 31 till Nov 6 in 2022) they don't match.

So, even if you know it's November and you know the user is in PDT, you cannot tell when (which timestamp number) would be 9am of April 1st of 2022 in the user's device.

PS. Worse if you are trying to get that PDT from new Date().toString(). FYI, if you change the locale of your machine to es-MX (Spanish, that's the language of 13% of the US population), this is what you get:

> new Date().toString()
'Sun Nov 14 2021 00:47:25 GMT-0800 (hora estándar del Pacífico)'

Good Luck with hedP!

Then, what should I do?

The ONLY CORRECT WAY is to use IANA (read "standard") Time Zone values. That's the second column of this Wikipedia page. It comes from:

const timeZoneIANA = Intl.DateTimeFormat().resolvedOptions().timeZone;

It returns the IANA value, which is America/Los_Angeles for San Francisco. This is the value you should store in your DB for the user, if anything. You can get all sorts of information about it at from timezones.json package, and convert a time from/to that timezone, plus the day (which matters) like this answer.

What about IE11?

IE11 doesn't support that Intl.... thing. Most polyfills are just guessing it and are inaccurate. So, try to drop support for IE11, or use a library and prepare yourself for some inaccuracy.

3) I just want to find out their time zone offset at the moment (e.g. -8:00)

You probably shouldn't. I cannot think of any real reason that you need this. Again, knowing this value for today, doesn't tell you what would this value be even tomorrow.

Anyhow, you can always get that value by

new Date().getTimezoneOffset() / 60

in client side.

NOTE: .getTimezoneOffset() is NOT the timezone offset of the date object, you are calling it on. Please read the documentation.

To be accurate, it takes the passed Date object (which has a timestamp, which refer to a single point-of-time in the history), and then tells what's the difference between the UTC time and local time at the point-of-time.

Again, it depends on the date. See:

console.log(new Date("6/13/2021").getTimezoneOffset() / 60); // It's 7 on a machine that runs in San Francisco
console.log(new Date("11/13/2021").getTimezoneOffset() / 60); // It's 8 on a machine that runs in in San Francisco

Any libraries?

Here is a list of libraries that support time zone exchanges.

But, remember, you have to solve the design problem first, and then look for the code. Things around time zone can easily get complicated and you have to know "PDT" and "GMT-8" are NOT year-round informative/valuable time zone values to store in the DB for the user. :)

Try this :

new Date().toLocaleString("en-US",Intl.DateTimeFormat().resolvedOptions().timeZone)

This will look for timeZone on your client's browser.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/DateTimeFormat

The Intl.DateTimeFormat() constructor creates Intl.DateTimeFormat objects that enable language-sensitive date and time formatting.

Intl.DateTimeFormat().resolvedOptions().timeZone // Asia/Kolkata

function getLocalTimeZone() {
    var dd = new Date();
    var ddStr = dd.toString();
    var ddArr = ddStr.split(' ');
    var tmznSTr = ddArr[5];
    tmznSTr = tmznSTr.substring(3, tmznSTr.length);
    return tmznSTr;
}

Example : Thu Jun 21 2018 18:12:50 GMT+0530 (India Standard Time)

O/P : +0530

Try this,

new Date().toString().split("GMT")[1].split(" (")[0]

On the new Date() you can get the offset, to get the timezone name you may do:

new Date().toString().replace(/(.*\((.*)\).*)/, '$2');

you get the value between () in the end of the date, that is the name of the timezone.

This would be my solution:

    // For time zone:
    const timeZone = /\((.*)\)/.exec(new Date().toString())[1];
    
    // Offset hours:
    const offsetHours = new Date().getTimezoneOffset() / 60;
    
    console.log(`${timeZone}, ${offsetHours}hrs`);

This might not be the most elegant solution but it is the most versatile.

This uses the timeZoneName property of Intl.DateTimeFormat

function getTimeZone(zoneName = "long") {
    // set up formatter
    let formatter = new Intl.DateTimeFormat(undefined, {
        timeZoneName: zoneName
    });
    // run formatter on current date
    return formatter.formatToParts(Date.now())
        // extract the actual value from the formatter, only reliable way i can find to do this
        .find(formatted => formatted.type === "timeZoneName")['value'];
}
// console.log every type
for (const zoneName of ['short', 'long', 'shortOffset', 'longOffset', 'shortGeneric', 'longGeneric']) {
    console.log(`${zoneName}: ${getTimeZone(zoneName)}`)
}
/*
short: CDT
long: Central Daylight Time
shortOffset: GMT-5
longOffset: GMT-05:00
shortGeneric: CT
longGeneric: Central Time
*/

This not only gets the formatted GMT offset time (i.e. GMT-5), but also the colloquial name of the timezone (i.e. Central Daylight Time)

The only thing this method doesn't do is get the IANA timezone. I recommend the top answer for that.

As far as I'm aware, DateTimeFormat doesn't have a way to do custom formatting, hence the use of formatToParts, which seems to be the only reliable way to get just the timezone.

something important to note that only short and long are officially defined in the current ECMAscript specs, the other 4 options are part of a proposal that is only somewhat standard, notably missing on safari as of writing this, though it is in progress

Once I had this "simple" task and I used (new Date()).getTimezoneOffset() - the approach that is widely suggested here. But it turned out that the solution wasn't quite right. For some undocumented reasons in my case new Date() was returning GMT+0200 when new Date(0) was returning GMT+0300 which was right. Since then I always use

(new Date(0)).getTimezoneOffset() to get a correct timeshift.

Why not just use:

function timezoneOffset(date: Date) {
  return 6000 * ((date.getUTCHours() - date.getHours()) * 60 + ((date.getUTCMinutes() - date.getMinutes())))
}

Here is the solution for finding the remote countries TimezoneOffset by just passing the timezone to the function. In this example 'Asia/Calcutta' is the timezone

function getTimezoneOffset(timezone) {
    LocalDate = new Date();
    LocalDate.setMilliseconds(0);

    const LocalOffset = LocalDate.getTimezoneOffset();
    RemoteLocaleStr = LocalDate.toLocaleString('en-US', {timeZone: timezone});
    RemoteDate = new Date(RemoteLocaleStr);
    diff = (LocalDate.getTime()-RemoteDate.getTime()) / 1000 / 60 ;

    RemoteOffset = LocalOffset + diff;
    return RemoteOffset;
}
console.log(getTimezoneOffset('Asia/Calcutta'));