Čas a datum jsou zásadními součástmi mnoha softwaru, od nástrojů pro správu času až po webové aplikace. Jako programátor musíte vědět, jak manipulovat s časem a datem v jakémkoli jazyce, který používáte.
V Go, čas balíček obsahuje funkce pro manipulaci s časem a datem. K těmto funkcím můžete přistupovat v libovolném zdrojovém souboru importováním daného balíčku.
Co tedy znamená manipulovat s časem a datem a jak můžete manipulovat s časem a datem v Go?
Co je manipulace s časem a datem?
Podle požadavků vašeho programu může být nutné řídit, spravovat nebo upravovat chování nebo reprezentaci časů a dat.
Různé programovací jazyky mají své vlastní funkce pro manipulaci s časem a datem. Jazyk Go má rozsáhlé možnosti, užitečné pro tento účel.
Manipulace s časem a datem může zahrnovat:
- Získání aktuálního času místa nebo časového pásma.
- Provádění aritmetických operací v časech a datech.
- Změna vstupního/výstupního formátu časů a dat.
Chcete-li začít manipulovat s časem a datem v aplikacích Go, importujte soubor čas balíček spolu s ostatními balíčky, které používáte.
import (
"fmt"
"čas"
)Jak získat aktuální čas a datum v Go
Běžným případem použití pro manipulaci s časem je získání aktuálního místního času nebo aktuálního času konkrétního časového pásma nebo místa.
Chcete-li získat čas a datum ve vašem místním čase nebo v určitém časovém pásmu nebo místě, můžete použít čas. Nyní() a čas. LoadLocation() funkce:
func hlavní(){
// Získání aktuálního času a data v místním čase
myTime := ime. Nyní()
fmt. Println("Aktuální čas v ", můj čas. Umístění(), " je: ", můj čas)// Další způsob, jak získat místní čas
místo, _ := čas. LoadLocation("Místní") // nebo čas. LoadLocation("")
fmt. Println("Aktuální čas v ", umístění, " je: ", čas. Nyní().In (umístění))// jiné umístění
místo, _ = čas. LoadLocation("Amerika/New_York")
fmt. Println("Aktuální čas v ", umístění, " je: ", můj čas. V (umístění))
// získat aktuální čas v horském časovém pásmu (MST)
místo, _ = čas. LoadLocation("MST")
fmt. Println("Aktuální čas v ", umístění, " je: ", můj čas. V (umístění))
}
Spuštění výše uvedeného programu s go spustit filename.go vytváří v terminálu následující výstup:
Metoda LoadLocation nepodporuje všechny zkratky místa a časového pásma. Podle Přejít na dokumentaci, podporuje pouze umístění v databáze IANA.org.
Jak získat samostatné komponenty od daného data
Každou komponentu časového razítka můžete získat samostatně, což je podobné tomu, kdy práce s časem a daty v JavaScriptu.
Existuje mnoho způsobů, jak toho dosáhnout pomocí Go's čas funkcí. Tato část ilustruje každou metodu.
Můžete použít Datum() funkce pro získání dne, měsíce a roku a Hodiny() funkce pro získání hodin, minut a sekund. Například:
funchlavní() {
myTime := čas. Nyní();
rok, měsíc, den := myTime. Datum()
fmt. Println("Rok:", rok)
fmt. Println("Měsíc:", měsíc)
fmt. Println("Den:", den)
hodina, min, sekunda := můj čas. Hodiny()
fmt. Println("Hour:", hour)
fmt. Println("minuta:", min)
fmt. Println("sekundy:", sec)
}
Výstup ilustruje různé části časového razítka:
Jednotky časového razítka můžete také získat jednotlivě pomocí čas funkce pro každou z nich:
funchlavní() {
myTime := čas. Nyní()
// získat každou jednotku od roku do nanosekundy
fmt. Println("Rok:", můjČas. Rok())
fmt. Println("Měsíc:", můjČas. Měsíc())
fmt. Println("Den:", můjČas. Den())
fmt. Println("Hodina:", můjČas. Hodina())
fmt. Println("Minuta:", můjČas. Minuta())
fmt. Println("Seconds:", myTime. Druhý())
fmt. Println("Nanosekunda:", myTime. nanosekunda())
}
Jak ilustruje výstup, toto vám také poskytuje přístup k nanosekundám:
Příklady až do tohoto bodu se zaměřovaly na získávání jednotek časového razítka z aktuálního času. Stejné druhy akcí můžete provést s časovým razítkem, které tomu tak není čas. Nyní().
Můžete extrahovat rok, měsíc, den, hodinu, minutu a sekundu daného data. Chcete-li tak učinit, musíte buď inicializovat nový objekt data, nebo analyzovat datum z řetězce:
funchlavní() {
// získat jednotlivé složky času od roku do nanosekundy
// od určitého data
váš čas := čas. Datum(2020, 07, 1, 06, 32, 10, 0, čas. UTC)
fmt. Println("Rok:", vášČas. Rok())
fmt. Println("Měsíc:", vášČas. Měsíc())
fmt. Println("Den:", váš čas. Den())
fmt. Println("Hour:", yourTime. Hodina())
fmt. Println("minuta:", váš čas. Minuta())
fmt. Println("Seconds:", yourTime. Druhý())
fmt. Println("Nanosekunda:", vášČas. nanosekunda())
// pomocí funkce Clock() získáte hodinu, minutu a sekundu
yourHour, yourMin, yourSec := yourTime. Hodiny()
fmt. Println("Hour:", yourHour)
fmt. Println("Minute:", yourMin)
fmt. Println("Seconds:", yourSec)
// získat čas a datum z řetězce
dateString :="2020-07-0106:32:10"
rozložení :="2006-01-0215:04:05" // požadovaný výstupní formát
yourTime, _ = čas. Analyzovat (rozvržení, dateString)
fmt. Println("Váš čas je: ", váš čas)
fmt. Println("Rok:", vášČas. Rok())
fmt. Println("Měsíc:", vášČas. Měsíc())
fmt. Println("Den:", váš čas. Den())
fmt. Println("Hour:", yourTime. Hodina())
fmt. Println("minuta:", váš čas. Minuta())
fmt. Println("Seconds:", yourTime. Druhý())
}
Tento kód vytváří následující výstup:
Všimněte si, že Parse() používá UTC ve výchozím nastavení, pokud v řetězci data nezadáte časové pásmo.
Jak provádět aritmetické operace s datem a časem
Aritmetické operace jsou dalším typem manipulace, který můžete v Go provádět s časem a datem. Jednoduché operace jako sčítání, odčítání a časový rozdíl jsou všechny možné.
Go umožňuje definovat čas. Doba trvání hodnoty se všemi jednotkami času od čas. Hodina na čas. Nanosekunda. Tyto hodnoty můžete použít k přidání nebo odečtení času pomocí Přidat(). K dispozici je také AddDate() funkce, která zabírá 3 parametry: roky, měsíce a dny pro provádění sčítání nebo odčítání.
Následující kód ukazuje použití těchto funkcí:
funchlavní() {
curTime := čas. Nyní()
curTime = curTime. Přidat (čas. Hodina) // přidá jednu hodinu
fmt. Println("Aktuální čas je: ", curTime)
zítra := curTime. Přidat (čas. hodina * 24)
fmt. Println("Zítra tato doba je: ", zítra)
nextWeek := curTime. Přidat (čas. hodina * 24 * 7)
fmt. Println("Tento čas příští týden je: ", příští týden)
// pomocí AddDate (y, m, d)
nextTomorrow := curTime. AddDate(0, 0, 2)
fmt. Println("Tentokrát Příští zítra je: ", PříštíZítra)
nextMonth := curTime. AddDate(0, 1, 0)
fmt. Println("Tento čas příští měsíc je: ", nextMonth)
fiveYearsAndOneMonthAfter := curTime. AddDate(5, 1, 0)
fmt. Println("Tentokrát pět let a jeden měsíc poté je: ", fiveYearsAndOneMonthAfter)
}
Což vytváří následující výstup:
Můžete také odečíst čas pomocí Přidat() a AddDate() předáním negativních parametrů. Například:
funchlavní() {
curTime := čas. Nyní()// odečíst jeden den pomocí AddDate()
včera := curTime. AddDate(0, 0, -1)
fmt. Println("Včerejší čas byl: ", včera)
// odečíst jeden měsíc pomocí Add()
lastMonth := curTime. Přidat (čas. hodina * -24 * 30)
fmt. Println("Tento čas minulý měsíc byl: ", minulý měsíc)
}
Vytváří tento výstup:
I když můžete použít Přidat() a AddDate() k nalezení rozdílu mezi daty má Go a Sub() funkce, která funguje trochu jinak:
funchlavní() {
curTime = čas. Nyní()
minulost := čas. Datum(2022, čas. Prosinec, 25, 12, 0, 0, 0, čas. UTC)
diff := minulost. Sub (curTime)
fmt. Println("Rozdíl mezi současností a minulostí je: ", diff)
// získat rozdíl v různých jednotkách
let := int(rozdíl. Hodiny() / 24 / 365)
fmt. Println("Roky: ", roky)
měsíce := int(rozdíl. Hodiny() / 24 / 30)
fmt. Println("Měsíce: ", měsíce)
dny := int(rozdíl. Hodiny() / 24)
fmt. Println("Dny: ", dny)
hodiny := int(rozdíl. Hodiny())
fmt. Println("Hours: ", hours)
// rozdíl Minuty(), dif. Seconds(), diff. Milisekundy(), rozdíl. Nanosekundy() také vrátí své jednotky
}
Tento kód vytváří následující výstup:
Jak získat čas a datum v různých formátech
Můžete také získat výstupy času a data v několika formátech pomocí Formát() funkce. Zde jsou některé běžné styly formátování:
funchlavní() {
curTime = čas. Nyní()
// vestavěné standardní styly formátování
fmt. Println("Aktuální čas je: ", curTime)
fmt. Println("Aktuální čas ve formátu RFC3339 je: ", curTime. Formát (čas. RFC3339))
fmt. Println("Aktuální čas ve formátu RFC3339Nano je: ", curTime. Formát (čas. RFC3339Nano))
fmt. Println("Aktuální čas ve formátu RFC1123 je: ", curTime. Formát (čas. RFC1123))
fmt. Println("Aktuální čas ve formátu RFC1123Z je: ", curTime. Formát (čas. RFC1123Z))
fmt. Println("Aktuální čas ve formátu RFC822 je: ", curTime. Formát (čas. RFC822))
fmt. Println("Aktuální čas ve formátu RFC822Z je: ", curTime. Formát (čas. RFC822Z))
fmt. Println("Aktuální čas ve formátu RFC850 je: ", curTime. Formát (čas. RFC850))
fmt. Println("Aktuální čas ve formátu ANSIC je: ", curTime. Formát (čas. ANSIC))
fmt. Println("Aktuální čas ve formátu Unix je: ", curTime. Formát (čas. UnixDate))
// vlastní styly formátování
// DD-MM-RRRR HH: MM: SS
fmt. Println("Aktuální čas ve vlastním formátu je: ", curTime. Formát("02-01-200615:04:05"))
// MM-DD-YYYY HH: MM: SS
fmt. Println("Aktuální čas ve vlastním formátu je: ", curTime. Formát("01-02-200615:04:05"))
// YYYY-MM-DD HH: MM: SS
fmt. Println("Aktuální čas ve vlastním formátu je: ", curTime. Formát("2006-01-0215:04:05"))
// DD.MM.RRRR
fmt. Println("Aktuální čas ve vlastním formátu je: ", curTime. Formát("02.01.2006"))
// DD/MM/RRRR
fmt. Println("Aktuální čas ve vlastním formátu je: ", curTime. Formát("02/01/2006"))
// 1. února 2006
fmt. Println("Aktuální čas ve vlastním formátu je: ", curTime. Formát("02 Jan 2006"))
// 1. února 2006 pondělí
fmt. Println("Aktuální čas ve vlastním formátu je: ", curTime. Formát("02 Únor 2006 Pondělí"))
// 01. února 2006 Po 15:04:05
fmt. Println("Aktuální čas ve vlastním formátu je: ", curTime. Formát("02 Únor 2006 Po 15:04:05"))
}
Tyto různé typy formátování vytvářejí následující výstup:
Manipulace s časem a datem v režimu Go
Seznam manipulací, které můžete provádět v časech a datech, je téměř nekonečný. V závislosti na rozsahu vaší aplikace možná budete muset provést mnoho různých operací s datem a časem.
Pro jakýkoli případ použití, který můžete mít, čas balíček je velmi funkční a má mnoho vestavěných metod.
Pomocí manipulace s datem a časem můžete vytvořit jednoduchý denní plánovač nebo plánovač úloh.
