Jak sprawdzić, czy obowiązuje DST (czas letni), a jeśli tak, przesunięcie?

Utwórz dwie daty: jedną w czerwcu, jedną w styczniu. Porównaj ich wartości getTimezoneOffset ().

• Jeśli przesunięcie Styczniowe > przesunięcie czerwcowe, klient znajduje się na półkuli północnej
• Jeśli przesunięcie Styczniowe
• Jeśli nie ma różnicy, Strefa czasowa klienta nie przestrzega DST

Teraz sprawdź getTimezoneOffset () bieżącej daty.

• jeśli jest równa czerwcowi, półkuli północnej, to bieżąca Strefa czasowa wynosi DST (+1 godzina)
• Jeśli równa styczeń, półkula południowa, wtedy bieżąca Strefa czasowa to DST (+1 godzina)

Ta odpowiedź jest dość podobna do zaakceptowanej odpowiedzi, ale nie nadpisuje prototypu Date i używa tylko jednego wywołania funkcji, aby sprawdzić, czy czas letni jest aktywny, a nie dwóch.

Chodzi o to, że ponieważ żaden kraj nie obserwuje DST, który trwa 7 miesięcy^[1], w obszarze, który obserwuje czas letni, przesunięcie od czasu UTC w styczniu będzie inne niż w lipcu.

Podczas Gdy czas letni przesuwa Zegary do przodu , JavaScript zawsze zwraca większą wartość w czasie standardowym. Dlatego uzyskanie minimalnego przesunięcia między styczniem a lipcem spowoduje przesunięcie strefy czasowej w czasie DST.

Następnie sprawdzamy, czy Strefa czasowa dat jest równa tej minimalnej wartości. Jeśli tak, to jesteśmy w DST; w przeciwnym razie nie jesteśmy.

Poniższa funkcja wykorzystuje ten algorytm. Przyjmuje obiekt date, d i zwraca true Jeśli dla tej daty obowiązuje czas letni i false jeśli jest Nie:

function isDST(d) {
    let jan = new Date(d.getFullYear(), 0, 1).getTimezoneOffset();
    let jul = new Date(d.getFullYear(), 6, 1).getTimezoneOffset();
    return Math.max(jan, jul) != d.getTimezoneOffset(); 
}

Miałem dziś do czynienia z tym samym problemem, ale ponieważ nasz czas letni zaczyna się i zatrzymuje w różnych porach od USA( przynajmniej z mojego zrozumienia), skorzystałem z nieco innej trasy..

var arr = [];
for (var i = 0; i < 365; i++) {
 var d = new Date();
 d.setDate(i);
 newoffset = d.getTimezoneOffset();
 arr.push(newoffset);
}
DST = Math.min.apply(null, arr);
nonDST = Math.max.apply(null, arr);

Następnie po prostu porównujesz bieżące przesunięcie strefy czasowej z DST i nonDST, aby zobaczyć, który z nich pasuje.

Na podstawie komentarza Matta Johansona do rozwiązania podanego przez Sheldona Griffina stworzyłem następujący kod:

    Date.prototype.stdTimezoneOffset = function() {
        var fy=this.getFullYear();
        if (!Date.prototype.stdTimezoneOffset.cache.hasOwnProperty(fy)) {

            var maxOffset = new Date(fy, 0, 1).getTimezoneOffset();
            var monthsTestOrder=[6,7,5,8,4,9,3,10,2,11,1];

            for(var mi=0;mi<12;mi++) {
                var offset=new Date(fy, monthsTestOrder[mi], 1).getTimezoneOffset();
                if (offset!=maxOffset) { 
                    maxOffset=Math.max(maxOffset,offset);
                    break;
                }
            }
            Date.prototype.stdTimezoneOffset.cache[fy]=maxOffset;
        }
        return Date.prototype.stdTimezoneOffset.cache[fy];
    };

    Date.prototype.stdTimezoneOffset.cache={};

    Date.prototype.isDST = function() {
        return this.getTimezoneOffset() < this.stdTimezoneOffset(); 
    };

Stara się uzyskać to, co najlepsze ze wszystkich światów, biorąc pod uwagę wszystkie komentarze i wcześniej sugerowane odpowiedzi, a konkretnie to:

1) buforuje wynik dla rocznego stdTimezoneOffset, dzięki czemu nie trzeba go przeliczać podczas testowania wielu dat w tym samym roku.

2) nie zakłada, że DST (jeśli w ogóle istnieje) jest koniecznie w Lipiec, i będzie działać, nawet jeśli w pewnym momencie i w pewnym miejscu będzie w dowolnym miesiącu. Jednak pod względem wydajności będzie działać szybciej, jeśli rzeczywiście Lipiec (lub najbliższe miesiące) rzeczywiście będą DST.

3) w gorszym przypadku porównuje getTimezoneOffset pierwszego z każdego miesiąca. [i robić to raz na rok].

Założenie to nadal sprawia, że jeśli istnieje okres DST jest większy niż jeden miesiąc.

Jeśli ktoś chce usunąć to założenie może zmienić pętlę w coś bardziej podobnego do tego, co w solutinie dostarczonym przez Aarona Cole ' a - ale i tak skoczyłbym pół roku do przodu i wyrwał się z pętli, gdy znaleziono dwa różne offsety]

Moment.biblioteka js dostarcza .isDst() metoda na obiektach czasowych.

Moment # isDST sprawdza, czy bieżący moment jest w czasie letnim.

moment([2011, 2, 12]).isDST(); // false, March 12 2011 is not DST
moment([2011, 2, 14]).isDST(); // true, March 14 2011 is DST

Metoda getTimezoneOffset() w JavaScript, w przeglądarce, Zwraca liczbę minut przesuniętych od strefy czasowej 00: 00. Na przykład Strefa czasowa America / New_York w Daylight Savings (DST) Zwraca liczbę 300. 300 minut to 5 godzin różnicy od zera. 300 minut podzielone przez 60 minut to 5 godzin. Każda strefa czasowa jest porównywana ze strefą czasową zerową, +00: 00/Etc / GMT / Greenwich time.

MDN Web Docs

Następną rzeczą, którą musisz wiedzieć, jest to, że offset ma przeciwny znak rzeczywistej strefy czasowej.

Informacje o strefach czasowych są utrzymywane przez Internet Assigned Numbers Authority (Iana)

Strefy czasowe Iana

Ładnie sformatowana tabela stref czasowych jest dostarczana przez joda.org

Joda-strefy czasowe

+00: 00 or Etc / GMT is Greenwich time

Wszystkie strefy czasowe są przesunięte od +00:00 / "etc/GMT" / Greenwich time

Czas letni jest zawsze wcześniejszy niż "regularny" czas w lecie. Ustawiasz zegary z powrotem w sezonie jesiennym. W tym samym roku, w 2010 roku, w Polsce i na świecie, w 2011 roku, w Polsce i na świecie.]}

Tak, Ameryka/New_York czas w letni (zimowy) jest godzina przed czasem regularnym. Tak więc, na przykład, co zwykle było o 17: 00 w godzinach popołudniowych w Nowym Jorku w lecie, jest teraz o 16: 00 czasu America/New_York w czasie letnim. Nazwa "America / New_York" jest nazwą strefy czasowej" Long Format". Wschodnie wybrzeże USA zwykle nazywa swój czas Strefa czasu wschodniego (EST)

Jeśli chcesz porównać dzisiejsze przesunięcie strefy czasowej z przesunięciem strefy czasowej innej daty, musisz wiedzieć, że znak matematyczny (+/- "dodatni / ujemny") przesunięcia strefy czasowej jest przeciwieństwem strefy czasowej.

Spójrz na tabelę stref czasowych w joda.org i znajdź strefę czasową dla "America / New_York" będzie miał znak ujemny przed standardowym offsetem.

Możesz to przetestować, tworząc datę, która jest w lipcu, a następnie uzyskując offset.

var July_Date = new Date(2017, 6, 1);
var july_Timezone_OffSet = July_Date.getTimezoneOffset();

console.log('july_Timezone_OffSet: ' + july_Timezone_OffSet)

Co zostanie wydrukowane w dzienniku konsoli narzędzi programistycznych przeglądarki?

Odpowiedź to: 240

Więc teraz możesz utworzyć datę w styczniu i zobaczyć, co twoja przeglądarka zwraca dla przesunięcia strefy czasowej na zimę sezon.

var Jan_Date = new Date(2017, 0, 1);//Month is zero indexed - Jan is zero
var jan_Timezone_OffSet = Jan_Date.getTimezoneOffset();

console.log('jan_Timezone_OffSet: ' + jan_Timezone_OffSet)

Odpowiedź brzmi: 300

Oczywiście 300 jest większe niż 240. Co to oznacza? Czy należy napisać kod, który sprawdza, czy offset Zimowy jest większy niż offset letni? Czy przesunięcie letnie mniejsze niż przesunięcie zimowe? Jeśli istnieje różnica między przesunięciami strefy czasowej letniej i zimowej, można założyć, że DST jest używany dla tej strefy czasowej. Ale to nie mówi ci, czy dzisiaj używa DST dla strefy czasowej przeglądarek. Więc musisz uzyskać przesunięcie strefy czasowej na dzisiaj.

var today = new Date();
var todaysTimeZone = today.getTimezoneOffset();

console.log('todaysTimeZone : ' + todaysTimeZone)

Odpowiedź brzmi: ? - Zależy od pory roku

Jeśli dzisiejsze przesunięcie strefy czasowej i przesunięcie strefy czasowej letniej są takie same, i przesunięcie strefy czasowej letniej i zimowej jest różne, to logicznie dedukcyjnie, dzisiaj nie może być w DST.

Czy możesz pominąć porównywanie przesunięć strefy czasowej latem i zimą, (aby wiedzieć, czy DST jest używany dla tej strefy czasowej) i po prostu porównać dzisiejsze przesunięcie strefy czasowej z lato TZ offset, i zawsze uzyskać poprawną odpowiedź?

today's TZ Offset !== Summer TZ Offset

if ( it_is_winter && ( todays_TZ_Offset !== summer_TZ_Offset) {
  var are_We_In_DST = true;
}

Ale problem w tym, że nie wiesz, czy dzisiejsza data jest zimą czy latem. Każda strefa czasowa może mieć własne zasady, kiedy zaczyna się i zatrzymuje czas letni. Musisz śledzić Zasady każdej strefy czasowej dla każdej strefy czasowej na świecie. Więc, jeśli jest lepszy i łatwiejszy sposób, to równie dobrze możesz to zrobić lepszy i łatwiejszy sposób.

To, co nam pozostało, to to, że musisz wiedzieć, czy ta strefa czasowa używa czasu DST, a następnie porównać dzisiejsze przesunięcie strefy czasowej z przesunięciem strefy czasowej letniej. To zawsze da ci wiarygodną odpowiedź.

Końcowa logika to:

if ( DST_Is_Used_In_This_Time_Zone && ( todays_TZ_Offset !== summer_TZ_Offset) {
  var are_We_In_DST = true;
}

Funkcja określająca, czy Strefa czasowa w przeglądarce używa DST:

function is_DST_Used_In_This_TimeZone() {
  var Jan_Date, jan_Timezone_OffSet, July_Date, july_Timezone_OffSet 
      offsetsNotEqual, thisYear, today;

  today = new Date();//Create a date object that is now
  thisYear = today.getFullYear();//Get the year as a number

  Jan_Date = new Date(thisYear, 0, 1);//Month is zero indexed - Jan is zero
  jan_Timezone_OffSet = Jan_Date.getTimezoneOffset();

  console.log('jan_Timezone_OffSet: ' + jan_Timezone_OffSet)

  July_Date = new Date(thisYear, 6, 1);
  july_Timezone_OffSet = July_Date.getTimezoneOffset();

  console.log('july_Timezone_OffSet: ' + july_Timezone_OffSet)

  offsetsNotEqual = july_Timezone_OffSet !== jan_Timezone_OffSet;//True if not equal

  console.log('offsetsNotEqual: ' + offsetsNotEqual);

  return offsetsNotEqual;//If the offsets are not equal for summer and
       //winter then the only possible reason is that DST is used for
       //this time zone
}

Jesteś blisko, ale trochę daleko. Nigdy nie musisz obliczać własnego czasu, ponieważ jest to wynik własnego zegara. Może wykryć, czy używasz czasu letniego w swojej lokalizacji, ale nie dla zdalnej lokalizacji wytwarzanej przez offset:

newDateWithOffset = new Date(utc + (3600000*(offset)));

Odkryłem to używając chwili.biblioteka js z niektórymi opisywanymi tu pojęciami (porównując Styczeń do czerwca) działa bardzo dobrze.

Ta prosta funkcja zwróci, czy Strefa czasowa, w której znajduje się użytkownik, przestrzega czasu letniego:

function HasDST() {
    return moment([2017, 1, 1]).isDST() != moment([2017, 6, 1]).isDST();
}

Prostym sposobem sprawdzenia, czy to działa (w systemie Windows) jest zmiana strefy czasowej na strefę non DST, na przykład Arizona zwróci false, podczas gdy EST lub PST zwróci true.

Użyj Chwili.js ( https://momentjs.com/)

moment().isDST(); da ci, jeśli obserwuje się oszczędności światła dziennego.

Posiada również funkcję pomocniczą do obliczania względnego czasu dla Ciebie. Nie musisz wykonywać ręcznych obliczeń e. g moment("20200105", "YYYYMMDD").fromNow();

Ostatnio musiałem utworzyć ciąg daty Z UTC i DST, i na podstawie odpowiedzi Sheldona złożyłem to razem:

Date.prototype.getTimezone = function(showDST) {
    var jan = new Date(this.getFullYear(), 0, 1);
    var jul = new Date(this.getFullYear(), 6, 1);

    var utcOffset = new Date().getTimezoneOffset() / 60 * -1;
    var dstOffset = (jan.getTimezoneOffset() - jul.getTimezoneOffset()) / 60;

    var utc = "UTC" + utcOffset.getSign() + (utcOffset * 100).preFixed(1000);
    var dst = "DST" + dstOffset.getSign() + (dstOffset * 100).preFixed(1000);

    if (showDST) {
        return utc + " (" + dst + ")";
    }

    return utc;
}
Number.prototype.preFixed = function (preCeiling) {
    var num = parseInt(this, 10);
    if (preCeiling && num < preCeiling) {
        num = Math.abs(num);
        var numLength		 = num.toString().length;
        var preCeilingLength = preCeiling.toString().length;
        var preOffset		 = preCeilingLength - numLength;
        for (var i = 0; i < preOffset; i++) {
            num = "0" + num;
        }
    }
    return num;
}
Number.prototype.getSign = function () {
    var num	 = parseInt(this, 10);
    var sign = "+";
    if (num < 0) {
        sign = "-";
    }
    return sign;
}

document.body.innerHTML += new Date().getTimezone() + "<br>";
document.body.innerHTML += new Date().getTimezone(true);

<p>Output for Turkey (UTC+0200) and currently in DST: &nbsp; UTC+0300 (DST+0100)</p>
<hr>

Przyszłościowe Rozwiązanie, Które Działa We Wszystkich Strefach Czasowych]}

1. Niech x będzie oczekiwaną liczbą milisekund w roku oprocentowania bez uwzględniania oszczędności czasu letniego.
2. Niech y będzie liczbą milisekund od epoki Od początku roku, w którym przypada Data zainteresowania.
3. Niech z będzie liczbą milisekund od epoki pełnej daty i godziny zainteresowania
4. Niech t będzie odejmowaniem obu x i y od z: z - y - x. Daje to przesunięcie z powodu DST.
5. Jeśli t jest równe zeru, to DST nie obowiązuje. Jeśli t nie jest zerem, to DST jest w mocy.

(function(){"use strict";
function dstOffsetAtDate(dateInput) {
    var fullYear = dateInput.getFullYear()|0;
	// "Leap Years are any year that can be exactly divided by 4 (2012, 2016, etc)
 	//   except if it can be exactly divided by 100, then it isn't (2100,2200,etc)
 	//	  except if it can be exactly divided by 400, then it is (2000, 2400)"
	// (https://www.mathsisfun.com/leap-years.html).
    var isLeapYear = ((fullYear & 3) | (fullYear/100 & 3)) === 0 ? 1 : 0;
	// (fullYear & 3) = (fullYear % 4), but faster
    //Alternative:var isLeapYear=(new Date(currentYear,1,29,12)).getDate()===29?1:0
    var fullMonth = dateInput.getMonth()|0;
    return (
        // 1. We know what the time since the Epoch really is
        (+dateInput) // same as the dateInput.getTime() method
        // 2. We know what the time since the Epoch at the start of the year is
        - (+new Date(fullYear, 0, 0)) // day defaults to 1 if not explicitly zeroed
        // 3. Now, subtract what we would expect the time to be if daylight savings
        //      did not exist. This yields the time-offset due to daylight savings.
        - ((
            ((
                // Calculate the day of the year in the Gregorian calendar
                // The code below works based upon the facts of signed right shifts
                //    • (x) >> n: shifts n and fills in the n highest bits with 0s 
                //    • (-x) >> n: shifts n and fills in the n highest bits with 1s
                // (This assumes that x is a positive integer)
                (31 & ((-fullMonth) >> 4)) + // January // (-11)>>4 = -1
                ((28 + isLeapYear) & ((1-fullMonth) >> 4)) + // February
                (31 & ((2-fullMonth) >> 4)) + // March
                (30 & ((3-fullMonth) >> 4)) + // April
                (31 & ((4-fullMonth) >> 4)) + // May
                (30 & ((5-fullMonth) >> 4)) + // June
                (31 & ((6-fullMonth) >> 4)) + // July
                (31 & ((7-fullMonth) >> 4)) + // August
                (30 & ((8-fullMonth) >> 4)) + // September
                (31 & ((9-fullMonth) >> 4)) + // October
                (30 & ((10-fullMonth) >> 4)) + // November
                // There are no months past December: the year rolls into the next.
                // Thus, fullMonth is 0-based, so it will never be 12 in Javascript
                
                (dateInput.getDate()|0) // get day of the month
				
            )&0xffff) * 24 * 60 // 24 hours in a day, 60 minutes in an hour
            + (dateInput.getHours()&0xff) * 60 // 60 minutes in an hour
            + (dateInput.getMinutes()&0xff)
        )|0) * 60 * 1000 // 60 seconds in a minute * 1000 milliseconds in a second
        - (dateInput.getSeconds()&0xff) * 1000 // 1000 milliseconds in a second
        - dateInput.getMilliseconds()
    );
}

// Demonstration:
var date = new Date(2100, 0, 1)
for (var i=0; i<12; i=i+1|0, date.setMonth(date.getMonth()+1|0))
    console.log(date.getMonth()+":\t"+dstOffsetAtDate(date)/60/60/1000+"h\t"+date);
date = new Date(1900, 0, 1);
for (var i=0; i<12; i=i+1|0, date.setMonth(date.getMonth()+1|0))
    console.log(date.getMonth()+":\t"+dstOffsetAtDate(date)/60/60/1000+"h\t"+date);

// Performance Benchmark:
console.time("Speed of processing 16384 dates");
for (var i=0,month=date.getMonth()|0; i<16384; i=i+1|0)
    date.setMonth(month=month+1+(dstOffsetAtDate(date)|0)|0);
console.timeEnd("Speed of processing 16384 dates");
})();

Uważam, że powyższy fragment kodu jest lepszy od wszystkich innych odpowiedzi zamieszczonych tutaj z wielu powodów.

• Ta odpowiedź działa we wszystkich strefach czasowych, nawet Antarktyda / Casey.
[[15]}Czas letni może ulec zmianie. Może być tak, że 20 lat od teraz niektóre kraje mogą mieć 3 okresy DST zamiast normalnych 2. Ten kod obsługuje tę sprawę zwracając przesunięcie DST w milisekundach, a nie tylko to, czy DST jest w mocy, czy nie.
• wielkość miesięcy w roku i sposób, w jaki działają lata przestępne, doskonale wpisują się w utrzymywanie naszego czasu na torze ze słońcem. Heck, to działa tak doskonale, że wszystko, co robimy, to tylko dostosować zaledwie kilka sekund tu i tam. Nasz obecny system lat przestępnych obowiązuje od 24 lutego 1582 roku i prawdopodobnie pozostanie w mocy przez dającą się przewidzieć przyszłość.
• ten kod działa w strefach czasowych, które nie używają DST.
• kod ten działa w czasach historycznych przed implementacją DST (np. w 1900 roku).
• ten kod jest maksymalnie zoptymalizowany pod względem liczby całkowitej i nie powinien sprawiać problemów, jeśli zostanie wywołany w ciasnej pętli. Po uruchomieniu powyższego fragmentu kodu przewiń w dół do dołu wyjścia, aby zobaczyć test wydajności. Mój komputer jest w stanie przetworzyć 16384 daty w ~97ms na Chrome.

Jednakże, jeśli nie przygotowujesz się na więcej niż 2 okresy DST, poniższy kod może być użyty do określenia, czy DST działa jako boolean.

function isDaylightSavingsInEffect(dateInput) {
    // To satisfy the original question
    return dstOffsetAtDate(dateInput) !== 0;
}

Czy jest problem z użyciem Date.toString().indexOf('Daylight Time') > -1

"" + new Date()

Sat Jan 01 100050 00: 00: 00 GMT-0500 (Eastern Standard Time)

"" + new Date(...)

Sun May 01 100033 00:00:00 GMT-0400 (Eastern Daylight Time)

To wydaje się kompatybilne ze wszystkimi przeglądarkami.

Styl ES6

Math.min(...[0, 6].map(v => new Date(95, v, 1).getTimezoneOffset() * -1));