Čas a dátum sú kľúčovými súčasťami množstva softvéru, od nástrojov na správu času až po webové aplikácie. Ako programátor musíte vedieť, ako manipulovať s časom a dátumom v akomkoľvek jazyku, ktorý používate.
V Go, čas balík obsahuje funkcie na manipuláciu s časom a dátumom. K týmto funkciám môžete pristupovať v ľubovoľnom zdrojovom súbore importovaním daného balíka.
Čo teda znamená manipulovať s časom a dátumom a ako môžete manipulovať s časom a dátumom v Go?
Čo je to manipulácia s časom a dátumom?
Podľa požiadaviek vášho programu môže byť potrebné kontrolovať, spravovať alebo upravovať správanie alebo reprezentáciu časov a dátumov.
Rôzne programovacie jazyky majú svoje vlastné funkcie na manipuláciu s časom a dátumom. Jazyk Go má rozsiahle možnosti, ktoré sú na tento účel užitočné.
Manipulácia s časom a dátumom môže zahŕňať:
- Získanie aktuálneho času miesta alebo časového pásma.
- Vykonávanie aritmetických operácií v časoch a dátumoch.
- Zmena vstupného/výstupného formátu časov a dátumov.
Ak chcete začať manipulovať s časom a dátumom v aplikáciách Go, importujte súbor
čas balík spolu s ostatnými balíkmi, ktoré používate.importovať (
"fmt"
"čas"
)Ako získať aktuálny čas a dátum v aplikácii Go
Bežným prípadom použitia na manipuláciu s časom je získanie aktuálneho miestneho času alebo aktuálneho času konkrétneho časového pásma alebo miesta.
Ak chcete získať čas a dátum vo vašom miestnom čase alebo v konkrétnom časovom pásme alebo lokalite, môžete použiť čas. teraz() a čas. LoadLocation() funkcie:
func hlavné(){
// Získanie aktuálneho času a dátumu v miestnom čase
myTime := ime. teraz()
fmt. Println("Aktuálny čas v ", môj čas. Miesto(), " je: ", môj čas)// Ďalší spôsob, ako získať miestny čas
miesto, _ := čas. LoadLocation("Miestne") // alebo čas. LoadLocation("")
fmt. Println("Aktuálny čas v ", umiestnenie, " je: ", čas. Teraz().V (umiestnenie))// iné miesto
miesto, _ = čas. LoadLocation("Amerika/New_York")
fmt. Println("Aktuálny čas v ", umiestnenie, " je: ", môj čas. V (umiestnenie))
// získať aktuálny čas v horskom časovom pásme (MST)
miesto, _ = čas. LoadLocation("MST")
fmt. Println("Aktuálny čas v ", umiestnenie, " je: ", môj čas. V (umiestnenie))
}
Spustenie vyššie uvedeného programu s choď spustiť filename.go vytvára nasledujúci výstup v termináli:
Metóda LoadLocation nepodporuje každú skratku miesta a časového pásma. Podľa Prejdite na dokumentáciu, podporuje iba umiestnenia v Databáza IANA.org.
Ako získať samostatné komponenty od daného dátumu
Každý komponent časovej pečiatky môžete získať samostatne, čo je podobné ako kedy práca s časom a dátumami v JavaScripte.
Existuje mnoho spôsobov, ako to dosiahnuť pomocou Go's čas funkcie. Táto časť ilustruje každú metódu.
Môžete použiť Dátum() funkcia na získanie dňa, mesiaca a roku a hodiny() funkcia na získanie hodín, minút a sekúnd. Napríklad:
funchlavné() {
myTime := čas. Teraz();
rok, mesiac, deň := môj čas. Dátum()
fmt. Println("Rok:", rok)
fmt. Println("Mesiac:", mesiac)
fmt. Println("Deň:", deň)
hodina, min, sek := môj čas. hodiny()
fmt. Println("Hour:", hour)
fmt. Println("minúta:", min)
fmt. Println("Sekundy:", sek.)
}
Výstup ilustruje rôzne časti časovej pečiatky:
Jednotky časovej pečiatky môžete získať aj jednotlivo pomocou čas funkcie pre každú z nich:
funchlavné() {
myTime := čas. teraz()
// získa každú jednotku od roku po nanosekundu
fmt. Println("Rok:", myTime. rok ())
fmt. Println("Mesiac:", môjČas. mesiac())
fmt. Println("Deň:", môj čas. deň())
fmt. Println("Hodina:", môj čas. hodina())
fmt. Println("Minúta:", môjČas. minúta())
fmt. Println("Sekundy:", myTime. Druhý())
fmt. Println("Nanosekunda:", myTime. Nanosekunda())
}
Ako ilustruje výstup, toto vám tiež poskytuje prístup k nanosekundám:
Príklady až do tohto bodu sa zamerali na získanie jednotiek časovej pečiatky z aktuálneho času. Rovnaký druh akcie môžete vykonať na časovej pečiatke, ktorá nie je čas. teraz().
Môžete extrahovať rok, mesiac, deň, hodinu, minútu a sekundu daného dátumu. Ak to chcete urobiť, musíte buď inicializovať nový objekt dátumu, alebo analyzovať dátum z reťazca:
funchlavné() {
// získa jednotlivé zložky času od roku po nanosekundu
// od konkrétneho dátumu
tvoj čas := čas. Dátum(2020, 07, 1, 06, 32, 10, 0, čas. UTC)
fmt. Println("Rok:", vášČas. rok ())
fmt. Println("Mesiac:", vášČas. mesiac())
fmt. Println("Deň:", vášČas. deň())
fmt. Println("Hodina:", vášČas. hodina())
fmt. Println("Minúta:", vášČas. minúta())
fmt. Println("Sekundy:", váš čas. Druhý())
fmt. Println("Nanosekunda:", vášČas. Nanosekunda())
// pomocou funkcie Clock() získate hodinu, minútu a sekundu
tvoja hodina, tvoja min, tvoja sekunda := tvoj čas. hodiny()
fmt. Println("Hour:", yourHour)
fmt. Println("Minúta:", vašaMin)
fmt. Println("Sekundy:", yourSec)
// získať čas a dátum z reťazca
dateString :="2020-07-0106:32:10"
rozloženie :="2006-01-0215:04:05" // požadovaný výstupný formát
váš čas, _ = čas. Analýza (rozloženie, dátumový reťazec)
fmt. Println("Váš čas je: ", váš čas)
fmt. Println("Rok:", vášČas. rok ())
fmt. Println("Mesiac:", vášČas. mesiac())
fmt. Println("Deň:", vášČas. deň())
fmt. Println("Hodina:", vášČas. hodina())
fmt. Println("Minúta:", vášČas. minúta())
fmt. Println("Sekundy:", váš čas. Druhý())
}
Tento kód vytvára nasledujúci výstup:
Všimnite si, že Parse() používa UTC predvolene, ak v reťazci dátumu nešpecifikujete časové pásmo.
Ako vykonávať aritmetické operácie s dátumom a časom
Aritmetické operácie sú ďalším typom manipulácie, ktorý môžete v aplikácii Go vykonávať v čase a dátume. Jednoduché operácie ako sčítanie, odčítanie a časový rozdiel sú všetky možné.
Go umožňuje definovať čas. Trvanie hodnoty so všetkými jednotkami času od čas. hodina do čas. Nanosekunda. Tieto hodnoty môžete použiť na pridanie alebo odčítanie času pomocou Pridať (). K dispozícii je tiež AddDate() funkcia, ktorá zaberá 3 parametre: roky, mesiace a dni na vykonávanie sčítania alebo odčítania.
Nasledujúci kód demonštruje použitie týchto funkcií:
funchlavné() {
curTime := čas. teraz()
curTime = curTime. Pridajte (čas. hodina) // pridá jednu hodinu
fmt. Println("Aktuálny čas je: ", curTime)
zajtra := curTime. Pridajte (čas. hodina * 24)
fmt. Println("Zajtra je tento čas: ", zajtra)
nextWeek := curTime. Pridajte (čas. hodina * 24 * 7)
fmt. Println("Tento čas budúci týždeň je: ", budúci týždeň)
// pomocou AddDate (y, m, d)
nextTomorrow := curTime. AddDate(0, 0, 2)
fmt. Println("Tento čas Budúci zajtra je: ", ďalšíZajtra)
nextMonth := curTime. AddDate(0, 1, 0)
fmt. Println("Tento čas budúci mesiac je: ", budúci mesiac)
fiveYearsAndOneMonthAfter := curTime. AddDate(5, 1, 0)
fmt. Println("Tentokrát o päť rokov a jeden mesiac potom je: ", päť rokov a jeden mesiac po)
}
Čo produkuje nasledujúci výstup:
Môžete tiež odpočítať čas pomocou Pridať () a AddDate() odovzdaním negatívnych parametrov. Napríklad:
funchlavné() {
curTime := čas. teraz()// odpočítajte jeden deň pomocou AddDate()
včera := curTime. AddDate(0, 0, -1)
fmt. Println("Včera tento čas bol: ", včera)
// odpočítajte jeden mesiac pomocou Add()
minulý mesiac := curTime. Pridajte (čas. hodina * -24 * 30)
fmt. Println("Tento čas minulý mesiac bol: ", minulý mesiac)
}
Produkuje tento výstup:
Aj keď môžete použiť Pridať () a AddDate() na nájdenie rozdielu medzi dátumami má Go a Sub() funkcia, ktorá funguje trochu inak:
funchlavné() {
curTime = čas. teraz()
minulosť := čas. Dátum(2022, čas. December, 25, 12, 0, 0, 0, čas. UTC)
diff := minulosť. Sub (curTime)
fmt. Println("Rozdiel medzi súčasnosťou a minulosťou je: ", diff)
// získajte rozdiel v rôznych jednotkách
roky := int(rozdiel Hodiny() / 24 / 365)
fmt. Println("Roky: ", roky)
mesiace := int(rozdiel Hodiny() / 24 / 30)
fmt. Println("Mesiace: ", mesiace)
dni := int(rozdiel Hodiny() / 24)
fmt. Println("Dni: ", dni)
hodiny := int(rozdiel Hodiny())
fmt. Println("Hodiny: ", hodiny)
// rozdiel Minúty(), rozdiel. Sekundy(), rozdiel. Milisekúnd(), rozdiel. Nanosekundy() tiež vrátia svoje jednotky
}
Tento kód vytvára nasledujúci výstup:
Ako získať čas a dátum v rôznych formátoch
Môžete tiež získať výstupy času a dátumu vo viacerých formátoch pomocou Format() funkciu. Tu sú niektoré bežné štýly formátovania:
funchlavné() {
curTime = čas. teraz()
// vstavané štandardné štýly formátovania
fmt. Println("Aktuálny čas je: ", curTime)
fmt. Println("Aktuálny čas vo formáte RFC3339 je: ", curTime. Formát (čas. RFC3339))
fmt. Println("Aktuálny čas vo formáte RFC3339Nano je: ", curTime. Formát (čas. RFC3339Nano))
fmt. Println("Aktuálny čas vo formáte RFC1123 je: ", curTime. Formát (čas. RFC1123))
fmt. Println("Aktuálny čas vo formáte RFC1123Z je: ", curTime. Formát (čas. RFC1123Z))
fmt. Println("Aktuálny čas vo formáte RFC822 je: ", curTime. Formát (čas. RFC822))
fmt. Println("Aktuálny čas vo formáte RFC822Z je: ", curTime. Formát (čas. RFC822Z))
fmt. Println("Aktuálny čas vo formáte RFC850 je: ", curTime. Formát (čas. RFC850))
fmt. Println("Aktuálny čas vo formáte ANSIC je: ", curTime. Formát (čas. ANSIC))
fmt. Println("Aktuálny čas vo formáte Unix je: ", curTime. Formát (čas. UnixDate))
// vlastné štýly formátovania
// DD-MM-RRRR HH: MM: SS
fmt. Println("Aktuálny čas vo vlastnom formáte je: ", curTime. Formát("02-01-200615:04:05"))
// MM-DD-YYYY HH: MM: SS
fmt. Println("Aktuálny čas vo vlastnom formáte je: ", curTime. Formát("01-02-200615:04:05"))
// RRRR-MM-DD HH: MM: SS
fmt. Println("Aktuálny čas vo vlastnom formáte je: ", curTime. Formát("2006-01-0215:04:05"))
// DD.MM.RRRR
fmt. Println("Aktuálny čas vo vlastnom formáte je: ", curTime. Formát("02.01.2006"))
// DD/MM/RRRR
fmt. Println("Aktuálny čas vo vlastnom formáte je: ", curTime. Formát("02/01/2006"))
// 1. februára 2006
fmt. Println("Aktuálny čas vo vlastnom formáte je: ", curTime. Formát("02 Jan 2006"))
// 1. februára 2006 pondelok
fmt. Println("Aktuálny čas vo vlastnom formáte je: ", curTime. Formát("02 februára 2006 pondelok))
// 01. február 2006 Po 15:04:05
fmt. Println("Aktuálny čas vo vlastnom formáte je: ", curTime. Formát("02 februára 2006 Po 15:04:05"))
}
Tieto rôzne typy formátovania vytvárajú nasledujúci výstup:
Manipulácia s časom a dátumom v režime Go
Zoznam manipulácií, ktoré môžete vykonať v časoch a dátumoch, je takmer nekonečný. V závislosti od rozsahu vašej aplikácie možno budete musieť vykonať mnoho rôznych operácií s dátumom a časom.
Pre akýkoľvek prípad použitia, ktorý môžete mať, čas balík je veľmi funkčný a má veľa vstavaných metód.
Manipuláciu s dátumom a časom môžete použiť na vytvorenie jednoduchého denného plánovača alebo aplikácie plánovača úloh.
