Godzina i data to kluczowe elementy wielu programów, od narzędzi do zarządzania czasem po aplikacje internetowe. Jako programista musisz wiedzieć, jak manipulować czasem i datą w dowolnym języku, którego używasz.
W Go, czas pakiet zawiera funkcje do manipulacji czasem i datą. Możesz uzyskać dostęp do tych funkcji w dowolnym pliku źródłowym, importując ten pakiet.
Co to znaczy manipulować czasem i datą oraz jak manipulować czasem i datą w Go?
Czym jest manipulacja czasem i datą?
Zgodnie z wymaganiami programu może być konieczne kontrolowanie, zarządzanie lub dostosowywanie zachowania lub reprezentacji godzin i dat.
Różne języki programowania mają własne funkcje do manipulacji czasem i datą. Język Go posiada rozbudowane możliwości, przydatne do tego celu.
Manipulacja godziną i datą może obejmować:
- Uzyskanie aktualnego czasu lokalizacji lub strefy czasowej.
- Wykonywanie operacji arytmetycznych na godzinach i datach.
- Zmiana formatu wejścia/wyjścia godzin i dat.
Aby rozpocząć manipulowanie godziną i datą w aplikacjach Go, zaimportuj czas pakiet obok innych pakietów, których używasz.
import (
"fmt"
"czas"
)Jak uzyskać aktualny czas i datę w Go
Typowym przypadkiem użycia do manipulacji czasem jest uzyskanie aktualnego czasu lokalnego lub aktualnego czasu określonej strefy czasowej lub lokalizacji.
Aby uzyskać godzinę i datę w swoim czasie lokalnym lub w określonej strefie czasowej lub lokalizacji, możesz użyć przycisku czas. Ale już() oraz czas. Wczytaj lokalizację() Funkcje:
funkcjonować Główny(){
// Pobierz aktualny czas i datę w czasie lokalnym
mójCzas := ja. Ale już()
fmt. Drukujln("Aktualny czas w ", mój czas. Lokalizacja(), " jest: ", mój czas)// Kolejny sposób na uzyskanie czasu lokalnego
lokalizacja, _ := czas. Wczytaj lokalizację("Lokalny") // lub czas. Wczytaj lokalizację("")
fmt. Drukujln("Aktualny czas w ", Lokalizacja, " jest: ", czas. Now().W (lokalizacja))// inna lokalizacja
lokalizacja, _ = czas. Wczytaj lokalizację("Ameryka/Nowy_Jork")
fmt. Drukujln("Aktualny czas w ", Lokalizacja, " jest: ", mój czas. W (lokalizacja))
// pobierz aktualny czas w Mountain Time Zone (MST)
lokalizacja, _ = czas. Wczytaj lokalizację("MST")
fmt. Drukujln("Aktualny czas w ", Lokalizacja, " jest: ", mój czas. W (lokalizacja))
}
Uruchamianie powyższego programu za pomocą idź, uruchom nazwapliku.go generuje w terminalu następujące dane wyjściowe:
Metoda LoadLocation nie obsługuje każdego skrótu lokalizacji i strefy czasowej. Według Przejdź do dokumentacji, obsługuje tylko lokalizacje w Baza danych IANA.org.
Jak uzyskać oddzielne składniki z podanej daty?
Możesz uzyskać każdy składnik znacznika czasu osobno, co jest podobne do sytuacji, gdy praca z czasem i datami w JavaScript.
Istnieje wiele sposobów na osiągnięcie tego za pomocą Go's czas Funkcje. W tej sekcji przedstawiono każdą metodę.
Możesz użyć Data() funkcja, aby uzyskać dzień, miesiąc i rok, a Zegar() funkcja, aby uzyskać godzinę, minutę i sekundy. Na przykład:
funkcjonowaćGłówny() {
mójCzas := czas. Ale już();
rok, miesiąc, dzień := myTime. Data()
fmt. Println("Rok :", rok)
fmt. Println("Miesiąc :", miesiąc)
fmt. Println("Dzień :", dzień)
godzina, min, sek := mójCzas. Zegar()
fmt. Println("Godzina :", godzina)
fmt. Println("Minuta :", min)
fmt. Println("Sekundy :", sek)
}
Dane wyjściowe ilustrują różne części znacznika czasu:
Możesz również uzyskać jednostki sygnatury czasowej indywidualnie za pomocą czas funkcje dla każdego z nich:
funkcjonowaćGłówny() {
mójCzas := czas. Ale już()
// zdobądź każdą jednostkę od roku do nanosekundy
fmt. Println("Rok :", mójCzas. Rok())
fmt. Println("Miesiąc :", mójCzas. Miesiąc())
fmt. Println("Dzień :", mójCzas. Dzień())
fmt. Println("Godzina :", mójCzas. Godzina())
fmt. Println("Minuta:", mójCzas. Minuta())
fmt. Println("Sekundy :", mójCzas. Drugi())
fmt. Println("Nanosekunda :", mójCzas. Nanosekunda())
}
Jak pokazują wyniki, daje to również dostęp do nanosekund:
Dotychczasowe przykłady koncentrowały się na uzyskiwaniu jednostek znacznika czasu z aktualnego czasu. Możesz wykonać te same czynności na znaczniku czasu, który nie jest czas. Ale już().
Możesz wyodrębnić rok, miesiąc, dzień, godzinę, minutę i sekundę z podanej daty. Aby to zrobić, musisz zainicjować nowy obiekt daty lub przeanalizować datę z ciągu:
funkcjonowaćGłówny() {
// uzyskaj poszczególne składowe czasu od roku do nanosekund
// od określonej daty
twójCzas := czas. Data(2020, 07, 1, 06, 32, 10, 0, czas. UTC)
fmt. Println("Rok :", twójCzas. Rok())
fmt. Println("Miesiąc :", twójCzas. Miesiąc())
fmt. Println("Dzień :", twójCzas. Dzień())
fmt. Println("Godzina:", twójCzas. Godzina())
fmt. Println("Minuta:", twójCzas. Minuta())
fmt. Println("Sekundy :", yourTime. Drugi())
fmt. Println("Nanosekunda :", twójCzas. Nanosekunda())
// użycie funkcji Clock() do pobrania godziny, minuty i sekundy
TwojaGodzina, TwojeMin, TwojeSek := TwójCzas. Zegar()
fmt. Println("Godzina :", TwojaGodzina)
fmt. Println("Minuta :", twojaMin)
fmt. Println("Sekundy :", twojaSek)
// pobierz czas i datę z napisu
Ciąg daty := "2020-07-0106:32:10"
układ := "2006-01-0215:04:05" // żądany format wyjściowy
twójCzas, _ = czas. Parse (layout, dateString)
fmt. Println("Twój czas to: ", twójCzas)
fmt. Println("Rok :", twójCzas. Rok())
fmt. Println("Miesiąc :", twójCzas. Miesiąc())
fmt. Println("Dzień :", twójCzas. Dzień())
fmt. Println("Godzina:", twójCzas. Godzina())
fmt. Println("Minuta:", twójCzas. Minuta())
fmt. Println("Sekundy :", yourTime. Drugi())
}
Ten kod generuje następujące dane wyjściowe:
Zauważ, że Parse() używa UTC domyślnie, jeśli nie określisz strefy czasowej w ciągu daty.
Jak wykonywać operacje arytmetyczne z datą i godziną
Operacje arytmetyczne to kolejny rodzaj manipulacji, które możesz wykonać na godzinie i dacie w Go. Możliwe są proste operacje, takie jak dodawanie, odejmowanie i różnica czasu.
Idź pozwala zdefiniować czas. Czas trwania wartości ze wszystkimi jednostkami czasu od czas. Godzina do czas. Nanosekunda. Możesz użyć tych wartości, aby dodać lub odjąć czas za pomocą Dodać(). Istnieje również Data dodania() funkcja, która przyjmuje 3 parametry: lata, miesiące i dni do wykonania dodawania lub odejmowania.
Poniższy kod demonstruje użycie tych funkcji:
funkcjonowaćGłówny() {
curTime := czas. Ale już()
curTime = curTime. Dodaj czas. Godzina) // dodaje godzinę
fmt. Println("Obecny czas to: ", curTime)
jutro := curTime. Dodaj czas. Godzina * 24)
fmt. Println("Jutro o tej porze: ", jutro)
następny tydzień := curTime. Dodaj czas. Godzina * 24 * 7)
fmt. Println("Tym razem w przyszłym tygodniu jest: ", nextWeek)
// używając AddDate (y, m, d)
nextTomorrow := curTime. Data dodania(0, 0, 2)
fmt. Println("Tym razem Następne jutro to: ", nextTomorrow)
następny miesiąc := curTime. Data dodania(0, 1, 0)
fmt. Println("Tym razem w następnym miesiącu jest: ", nextMonth)
fiveYearsAndOneMonthAfter := curTime. Data dodania(5, 1, 0)
fmt. Println("Tym razem pięć lat i miesiąc później jest: ", fiveYearsAndOneMonthAfter)
}
Co daje następujące dane wyjściowe:
Możesz także odjąć czas za pomocą Dodać() oraz Data dodania() przekazując parametry ujemne. Na przykład:
funkcjonowaćGłówny() {
curTime := czas. Ale już()// odejmij jeden dzień za pomocą AddDate()
wczoraj := curTime. Data dodania(0, 0, -1)
fmt. Println("Tym razem wczoraj było: ", wczoraj)
// odejmij jeden miesiąc za pomocą Add()
ostatni miesiąc := curTime. Dodaj czas. Godzina * -24 * 30)
fmt. Println("Tym razem w zeszłym miesiącu było: ", lastMonth)
}
Daje to wyjście:
Chociaż możesz użyć Dodać() oraz Data dodania() aby znaleźć rozróżnienie między datami, Go ma Pod() funkcja, która działa nieco inaczej:
funkcjonowaćGłówny() {
curTime = czas. Ale już()
przeszłość := czas. Data(2022, czas. Grudzień, 25, 12, 0, 0, 0, czas. UTC)
diff := przeszłość. Sub (Czas bieżący)
fmt. Println("Różnica między teraźniejszością a przeszłością to: ", diff)
// uzyskaj różnicę w różnych jednostkach
lat := int(różn. Godziny() / 24 / 365)
fmt. Println("Lata: ", lata)
miesiące := int(różn. Godziny() / 24 / 30)
fmt. Println("Miesiące: ", miesiące)
dni := int(różn. Godziny() / 24)
fmt. Println("Dni: ", dni)
godziny := int(różn. Godziny())
fmt. Println("Godziny: ", godziny)
// różn. Minuty(), różnica. Sekundy(), różnica. Milisekundy(), różnica. Nanosekundy() również zwracają swoje jednostki
}
Ten kod generuje następujące dane wyjściowe:
Jak uzyskać czas i datę w różnych formatach?
Możesz także uzyskać informacje o czasie i dacie w wielu formatach, używając Format() funkcjonować. Oto kilka typowych stylów formatowania:
funkcjonowaćGłówny() {
curTime = czas. Ale już()
// wbudowane standardowe style formatowania
fmt. Println("Obecny czas to: ", curTime)
fmt. Println("Aktualny czas w formacie RFC3339 to: ", curTime. Format (czas. RFC3339))
fmt. Println("Aktualny czas w formacie RFC3339Nano to: ", curTime. Format (czas. RFC3339Nano))
fmt. Println("Aktualny czas w formacie RFC1123 to: ", curTime. Format (czas. RFC1123))
fmt. Println("Aktualny czas w formacie RFC1123Z to: ", curTime. Format (czas. RFC1123Z))
fmt. Println("Aktualny czas w formacie RFC822 to: ", curTime. Format (czas. RFC822))
fmt. Println("Aktualny czas w formacie RFC822Z to: ", curTime. Format (czas. RFC822Z))
fmt. Println("Aktualny czas w formacie RFC850 to: ", curTime. Format (czas. RFC850))
fmt. Println("Aktualny czas w formacie ANSIC to: ", curTime. Format (czas. ANSIC))
fmt. Println("Aktualny czas w formacie Unix to: ", curTime. Format (czas. UnixDate))
// niestandardowe style formatowania
// DD-MM-RRRR GG: MM: SS
fmt. Println("Aktualny czas w formacie niestandardowym to: ", curTime. Format("02-01-200615:04:05"))
// MM-DD-RRRR GG: MM: SS
fmt. Println("Aktualny czas w formacie niestandardowym to: ", curTime. Format("01-02-200615:04:05"))
// RRRR-MM-DD GG: MM: SS
fmt. Println("Aktualny czas w formacie niestandardowym to: ", curTime. Format("2006-01-0215:04:05"))
// DD / MM / RRRR
fmt. Println("Aktualny czas w formacie niestandardowym to: ", curTime. Format("02.01.2006"))
// DD / MM / RRRR
fmt. Println("Aktualny czas w formacie niestandardowym to: ", curTime. Format("02/01/2006"))
// 01 lut 2006
fmt. Println("Aktualny czas w formacie niestandardowym to: ", curTime. Format("02 Jan 2006"))
// 01 luty 2006 poniedziałek
fmt. Println("Aktualny czas w formacie niestandardowym to: ", curTime. Format("02 Luty 2006 Poniedziałek"))
// 01 luty 2006 pon 15:04:05
fmt. Println("Aktualny czas w formacie niestandardowym to: ", curTime. Format("02 Luty 2006 pon 15:04:05"))
}
Te różne typy formatowania dają następujące dane wyjściowe:
Manipulowanie czasem i datą w Go
Lista manipulacji, które możesz przeprowadzić w godzinach i datach, jest prawie nieskończona. W zależności od zakresu aplikacji może być konieczne wykonanie wielu różnych operacji daty/czasu.
W każdym przypadku użycia, który możesz mieć, czas pakiet jest bardzo funkcjonalny i posiada wiele wbudowanych metod.
Możesz użyć manipulacji datą i godziną, aby zbudować prostą aplikację do planowania dziennego lub harmonogramu zadań.