Az idő és a dátum számos szoftver kulcsfontosságú összetevője, az időkezelő segédprogramoktól a webes alkalmazásokig. Programozóként tudnod kell, hogyan kell manipulálni az időt és a dátumot bármely nyelven.
A Go-ban a idő csomag az idő és a dátum kezeléséhez szükséges funkciókat köti össze. Ezeket a funkciókat bármely forrásfájlban elérheti a csomag importálásával.
Tehát mit jelent az idő és a dátum manipulálása, és hogyan manipulálhatja az időt és a dátumot a Go alkalmazásban?
Mi az idő- és dátummanipuláció?
A program követelményei szerint szükség lehet arra, hogy szabályozza, kezelje vagy módosítsa az idők és dátumok viselkedését vagy megjelenítését.
Különböző programozási nyelvek saját funkciójuk van az idő- és dátumkezeléshez. A Go nyelv széleskörű képességekkel rendelkezik, amelyek hasznosak erre a célra.
Az idő- és dátummanipuláció a következőket foglalhatja magában:
- Egy hely vagy időzóna aktuális idejének lekérése.
- Számtani műveletek végrehajtása időpontokkal és dátumokkal.
- Az idők és dátumok beviteli/kimeneti formátumának módosítása.
Az idő és a dátum kezelésének megkezdéséhez a Go-alkalmazásokban importálja a idő csomagot a többi használt csomag mellé.
import (
"fmt"
"idő"
)Az aktuális idő és dátum lekérése a Go alkalmazásban
Az időmanipuláció általános felhasználási esete az aktuális helyi idő vagy egy adott időzóna vagy hely aktuális idejének lekérése.
Ha az időt és a dátumot a helyi idő szerint vagy egy adott időzónában vagy helyen szeretné lekérni, használja a idő. Most() és idő. Betöltési hely() funkciók:
func fő-(){
// Az aktuális idő és dátum lekérése helyi idő szerint
myTime := ime. Most()
fmt. Println("Jelenlegi idő be ", az időm. Elhelyezkedés(), " ez: ", az időm)// Egy másik módja a helyi idő lekérésének
hely, _ := idő. LoadLocation("Helyi") // vagy időt. LoadLocation("")
fmt. Println("Jelenlegi idő be ", hely, " ez: ", idő. Most().In (hely))// másik helyen
hely, _ = idő. LoadLocation("Amerika/New_York")
fmt. Println("Jelenlegi idő be ", hely, " ez: ", az időm. Itt (helyszín))
// az aktuális idő lekérése a Mountain Time Zone-ban (MST)
hely, _ = idő. LoadLocation("MST")
fmt. Println("Jelenlegi idő be ", hely, " ez: ", az időm. Itt (helyszín))
}
A fenti program futtatása a futtassa a filename.go fájlt a következő kimenetet állítja elő a terminálon:
A LoadLocation módszer nem támogatja az összes hely- és időzóna-rövidítést. Szerint a Menj a dokumentációhoz, csak a helyeket támogatja a IANA.org adatbázis.
Hogyan szerezhet be külön alkatrészeket egy adott időpontból
Az időbélyegző minden egyes összetevőjét külön kaphatja meg, ami hasonló a mikorhoz munkaidővel és dátumokkal JavaScriptben.
Számos módja van ennek megvalósítására a Go's segítségével idő funkciókat. Ez a rész bemutatja az egyes módszereket.
Használhatja a Dátum() függvény a nap, hónap és év, valamint a Óra() függvény az óra, perc és másodperc lekérdezéséhez. Például:
funcfő-() {
myTime := idő. Most();
év, hónap, nap := myTime. Dátum()
fmt. Println("Év :", év)
fmt. Println("Hónap :", hónap)
fmt. Println("nap:", nap)
óra, perc, másodperc := myTime. Óra()
fmt. Println("Óra :", óra)
fmt. Println("Perc :", min)
fmt. Println("Másodperc :", mp)
}
A kimenet az időbélyeg különböző részeit mutatja be:
Az időbélyeg egységeit külön-külön is beszerezheti a idő funkciók mindegyikéhez:
funcfő-() {
myTime := idő. Most()
// minden egység lekérése évről nanoszekundumra
fmt. Println("Év :", myTime. Év())
fmt. Println("Hónap:", myTime. Hónap())
fmt. Println("Nap:", myTime. Nap())
fmt. Println("Óra:", myTime. Óra())
fmt. Println("Perc:", myTime. Perc())
fmt. Println("Seconds :", myTime. Második())
fmt. Println("Nanoszekundum :", myTime. Nanoszekundum()
}
Ahogy a kimenet is mutatja, ez hozzáférést biztosít a nanoszekundumokhoz is:
Az eddigi példák a pillanatnyi időbélyeg-egységek beszerzésére összpontosítottak. Ugyanilyen típusú műveleteket hajthat végre olyan időbélyeggel, amely nem idő. Most().
Kivonhatja egy adott dátum évét, hónapját, napját, óráját, percét és másodpercét. Ehhez vagy inicializálnia kell egy új dátumobjektumot, vagy elemeznie kell a dátumot egy karakterláncból:
funcfő-() {
// az idő egyes összetevőinek lekérése évtől nanoszekundumig
// egy adott dátumtól
yourTime := idő. Dátum(2020, 07, 1, 06, 32, 10, 0, idő. UTC)
fmt. Println("Év:", az Ön ideje. Év())
fmt. Println("Hónap:", az Ön ideje. Hónap())
fmt. Println("Nap:", az Ön ideje. Nap())
fmt. Println("Óra:", az Ön ideje. Óra())
fmt. Println("Perc :", te időd. Perc())
fmt. Println("Seconds :", yourTime. Második())
fmt. Println("Nanoszekundum :", az Ön ideje. Nanoszekundum()
// a Clock() függvény használatával óra, perc és másodperc lekérdezéséhez
yourHour, yourMin, yourSec := yourTime. Óra()
fmt. Println("Óra :", az Ön órája)
fmt. Println("Perc :", te Min.)
fmt. Println("Seconds :", yourSec)
// idő és dátum lekérése karakterláncból
dateString := "2020-07-0106:32:10"
elrendezés := "2006-01-0215:04:05" // a kívánt kimeneti formátumot
yourTime, _ = idő. Elemzés (elrendezés, dátumkarakterlánc)
fmt. Println("Az Ön idője: ", a te időd)
fmt. Println("Év:", az Ön ideje. Év())
fmt. Println("Hónap:", az Ön ideje. Hónap())
fmt. Println("Nap:", az Ön ideje. Nap())
fmt. Println("Óra:", az Ön ideje. Óra())
fmt. Println("Perc :", te időd. Perc())
fmt. Println("Seconds :", yourTime. Második())
}
Ez a kód a következő kimenetet hozza létre:
Vegye figyelembe, hogy a Parse() használja UTC alapértelmezés szerint, ha nem ad meg időzónát a dátum karakterláncban.
Aritmetikai műveletek végrehajtása dátummal és idővel
Az aritmetikai műveletek egy másik típusú manipuláció, amelyet időben és dátummal hajthat végre a Go alkalmazásban. Az olyan egyszerű műveletek, mint az összeadás, kivonás és időeltolódás, mind lehetségesek.
A Go segítségével meghatározhatja idő. Időtartam értékek az összes időegységgel idő. Óra nak nek idő. Nanoszekundum. Ezeket az értékeket használhatja az idő hozzáadására vagy kivonására Add(). Van még egy AddDate() függvény, amely 3 paramétert vesz fel: éveket, hónapokat és napokat az összeadás vagy kivonás végrehajtásához.
A következő kód ezeknek a függvényeknek a használatát mutatja be:
funcfő-() {
curTime := idő. Most()
curTime = curTime. Hozzáadás (idő. Óra) // hozzáad egy órát
fmt. Println("A jelenlegi idő: ", curTime)
holnap := curTime. Hozzáadás (idő. óra* 24)
fmt. Println("Ez az idő holnap: ", holnap)
nextWeek := curTime. Hozzáadás (idő. óra* 24 * 7)
fmt. Println("Ez az idő a jövő héten: ", nextWeek)
// az AddDate (y, m, d) használatával
nextTomorrow := curTime. AddDate(0, 0, 2)
fmt. Println("Ezúttal a következő holnap: ", nextTomorrow)
nextMonth := curTime. AddDate(0, 1, 0)
fmt. Println("Ez az idő a következő hónapban: ", next Month)
fiveYearsAndOneMonthAfter := curTime. AddDate(5, 1, 0)
fmt. Println("Ezúttal öt év és egy hónap után ez: ", FiveYearsAndOneMonthAfter)
}
Ami a következő kimenetet adja:
Ezzel az időt is kivonhatja Add() és AddDate() negatív paraméterek átadásával. Például:
funcfő-() {
curTime := idő. Most()// vonjunk ki egy napot az AddDate() segítségével
tegnap := curTime. AddDate(0, 0, -1)
fmt. Println("Ez az idő tegnap volt: ", tegnap)
// vonjon ki egy hónapot az Add() segítségével
lastMonth := curTime. Hozzáadás (idő. óra* -24 * 30)
fmt. Println("A múlt hónapban ez volt: ", utolsó hónap)
}
Ezt a kimenetet állítja elő:
Bár használhatod Add() és AddDate() a dátumok közötti különbség megtalálásához a Go rendelkezik a Alatti() funkció, amely egy kicsit másképp működik:
funcfő-() {
curTime = idő. Most()
múlt := idő. Dátum(2022, idő. December, 25, 12, 0, 0, 0, idő. UTC)
diff := múlt. Al (curTime)
fmt. Println("A különbség a jelen és a múlt között: ", diff)
// megkapja a különbséget különböző mértékegységekben
év := int(különb. Órák() / 24 / 365)
fmt. Println("Évek: ", év)
hónap := int(különb. Órák() / 24 / 30)
fmt. Println("Hónapok: ", hónapok)
nap := int(különb. Órák() / 24)
fmt. Println("Napok: ", napok)
óra := int(különb. Órák())
fmt. Println("Óra: ", óra)
// diff. Perc(), diff. Seconds(), diff. Milliszekundum(), diff. A nanoszekundum() is visszaadja egységeit
}
Ez a kód a következő kimenetet hozza létre:
Hogyan szerezhet be időt és dátumot különböző formátumokban
Az idő- és dátumkimeneteket többféle formátumban is megkaphatja a Formátum() funkció. Íme néhány általános formázási stílus:
funcfő-() {
curTime = idő. Most()
// beépített szabványos formázási stílusok
fmt. Println("A jelenlegi idő: ", curTime)
fmt. Println("A jelenlegi idő RFC3339 formátumban: ", curTime. Formátum (idő. RFC3339))
fmt. Println("A jelenlegi idő RFC3339Nano formátumban: ", curTime. Formátum (idő. RFC3339Nano))
fmt. Println("A jelenlegi idő RFC1123 formátumban: ", curTime. Formátum (idő. RFC1123))
fmt. Println("A jelenlegi idő RFC1123Z formátumban: ", curTime. Formátum (idő. RFC1123Z))
fmt. Println("A jelenlegi idő RFC822 formátumban: ", curTime. Formátum (idő. RFC822))
fmt. Println("A jelenlegi idő RFC822Z formátumban: ", curTime. Formátum (idő. RFC822Z))
fmt. Println("A jelenlegi idő RFC850 formátumban: ", curTime. Formátum (idő. RFC850))
fmt. Println("A jelenlegi idő ANSIC formátumban: ", curTime. Formátum (idő. ANSIC))
fmt. Println("A jelenlegi idő Unix formátumban: ", curTime. Formátum (idő. UnixDate))
// egyéni formázási stílusok
// NN-HH-ÉÉÉÉ ÓÓ: MM: SS
fmt. Println("A jelenlegi idő egyéni formátumban: ", curTime. Formátum("02-01-200615:04:05"))
// HH-NN-ÉÉÉÉ ÓÓ: MM: SS
fmt. Println("A jelenlegi idő egyéni formátumban: ", curTime. Formátum("01-02-200615:04:05"))
// ÉÉÉÉ-HH-NN ÓÓ: MM: SS
fmt. Println("A jelenlegi idő egyéni formátumban: ", curTime. Formátum("2006-01-0215:04:05"))
// NN.MM.YYYY
fmt. Println("A jelenlegi idő egyéni formátumban: ", curTime. Formátum("02.01.2006"))
// NN/HH/ÉÉÉÉ
fmt. Println("A jelenlegi idő egyéni formátumban: ", curTime. Formátum("02/01/2006"))
// 2006. február 1
fmt. Println("A jelenlegi idő egyéni formátumban: ", curTime. Formátum("02 jan 2006"))
// 2006. február 1., hétfő
fmt. Println("A jelenlegi idő egyéni formátumban: ", curTime. Formátum("02 február 2006 Hétfő"))
// 2006. február 1. H 15:04:05
fmt. Println("A jelenlegi idő egyéni formátumban: ", curTime. Formátum("02 február 2006 Hétfő 15:04:05"))
}
Ezek a különböző típusú formázások a következő kimenetet eredményezik:
Az idő és a dátum manipulálása a Go-ban
Az időpontokban és időpontokban végrehajtható manipulációk listája szinte végtelen. Az alkalmazás hatókörétől függően előfordulhat, hogy sok különböző dátum/idő műveletet kell végrehajtania.
Bármilyen felhasználási esetre, a idő csomag nagyon funkcionális és számos beépített módszerrel rendelkezik.
A dátum- és időkezeléssel egyszerű napitervező vagy feladatütemező alkalmazást hozhat létre.