Tid och datum är avgörande komponenter i många program, från tidshanteringsverktyg till webbapplikationer. Som programmerare behöver du veta hur du manipulerar tid och datum på vilket språk du än använder.
I Go, den tid paketet paketerar funktionerna för tids- och datummanipulation. Du kan komma åt dessa funktioner i vilken källfil som helst genom att importera det paketet.
Så, vad betyder det att manipulera tid och datum, och hur kan du manipulera tid och datum i Go?
Vad är tids- och datummanipulation?
Enligt ditt programs krav kan det behöva kontrollera, hantera eller justera beteendet eller representationen av tider och datum.
Olika programmeringsspråk har sina egna funktioner för tids- och datummanipulation. Go-språket har omfattande möjligheter, användbart för detta ändamål.
Tids- och datummanipulation kan inkludera:
- Hämta aktuell tid för en plats eller tidszon.
- Utföra aritmetiska operationer på tider och datum.
- Ändra in-/utmatningsformat för tider och datum.
För att börja manipulera tid och datum i dina Go-applikationer, importera
tid paket tillsammans med de andra paketen du använder.importera (
"fmt"
"tid"
)Hur man får aktuell tid och datum i Go
Ett vanligt användningsfall för tidsmanipulation är att erhålla den aktuella lokala tiden eller den aktuella tiden för en specifik tidszon eller plats.
För att få tid och datum i din lokala tid eller i en specifik tidszon eller plats kan du använda tid. Nu() och tid. LoadLocation() funktioner:
func huvud(){
// Få aktuell tid och datum i lokal tid
myTime := ime. Nu()
fmt. Println("Aktuell tid i ", min tid. Plats(), " är: ", min tid)// Ett annat sätt att få lokal tid
plats, _ := tid. LoadLocation("Lokal") // eller tid. LoadLocation("")
fmt. Println("Aktuell tid i ", plats, " är: ", tid. Now().I (plats))// annan plats
plats, _ = tid. LoadLocation("Amerika/New_York")
fmt. Println("Aktuell tid i ", plats, " är: ", min tid. I (plats))
// få aktuell tid i Mountain Time Zone (MST)
plats, _ = tid. LoadLocation("MST")
fmt. Println("Aktuell tid i ", plats, " är: ", min tid. I (plats))
}
Kör programmet ovan med kör filnamn.go producerar följande utsignal i terminalen:
Metoden LoadLocation stöder inte alla plats- och tidszonförkortningar. Enligt Gå dokumentation, stöder den bara platser i IANA.org databas.
Hur man får separata komponenter från ett givet datum
Du kan få varje komponent i tidsstämpeln separat, vilket liknar när arbetar med tid och datum i JavaScript.
Det finns många sätt att åstadkomma detta med hjälp av Go's tid funktioner. Det här avsnittet illustrerar varje metod.
Du kan använda Datum() funktion för att få dag, månad och år, och Klocka() funktion för att få timme, minut och sekunder. Till exempel:
funchuvud() {
myTime := tid. Nu();
år, månad, dag := myTime. Datum()
fmt. Println("År :", år)
fmt. Println("Månad :", månad)
fmt. Println("Dag :", dag)
timme, min, sek := min tid. Klocka()
fmt. Println("Timme :", timme)
fmt. Println("Minute :", min)
fmt. Println("Sekunder :", sek)
}
Utdata illustrerar de olika delarna av tidsstämpeln:
Du kan också få enheter av tidsstämpeln individuellt med tid funktioner för var och en av dem:
funchuvud() {
myTime := tid. Nu()
// få varje enhet från år till nanosekund
fmt. Println("År :", minTid. År())
fmt. Println("Månad :", minTid. Månad())
fmt. Println("Dag :", myTime. Dag())
fmt. Println("Timme :", minTid. Timme())
fmt. Println("Minute :", minTid. Minut())
fmt. Println("Seconds :", myTime. Andra())
fmt. Println("Nanosekund :", myTime. Nanosekund())
}
Som utgången illustrerar ger detta dig också tillgång till nanosekunder:
Exemplen fram till denna punkt har fokuserat på att erhålla tidsstämpelenheter från den aktuella tiden. Du kan utföra samma typ av åtgärder på en tidsstämpel som inte är det tid. Nu().
Du kan extrahera år, månad, dag, timme, minut och sekund för ett visst datum. För att göra det måste du antingen initiera ett nytt datumobjekt eller analysera datumet från en sträng:
funchuvud() {
// få individuella komponenter av tiden från år till nanosekund
// från ett specifikt datum
din tid := tid. Datum(2020, 07, 1, 06, 32, 10, 0, tid. UTC)
fmt. Println("År :", din tid. År())
fmt. Println("Månad :", din tid. Månad())
fmt. Println("Dag :", din tid. Dag())
fmt. Println("Timme :", din tid. Timme())
fmt. Println("Minute :", din tid. Minut())
fmt. Println("Seconds :", yourTime. Andra())
fmt. Println("Nanosekund :", din tid. Nanosekund())
// med funktionen Clock() för att få timme, minut och sekund
yourHour, yourMin, yourSec := yourTime. Klocka()
fmt. Println("Timme :", dinTimme)
fmt. Println("Minute :", dinMin)
fmt. Println("Seconds :", dinSec)
// få tid och datum från sträng
dateString := "2020-07-0106:32:10"
layout := "2006-01-0215:04:05" // ditt önskade utdataformat
din tid, _ = tid. Parse (layout, dateString)
fmt. Println("Din tid är: ", din tid)
fmt. Println("År :", din tid. År())
fmt. Println("Månad :", din tid. Månad())
fmt. Println("Dag :", din tid. Dag())
fmt. Println("Timme :", din tid. Timme())
fmt. Println("Minute :", din tid. Minut())
fmt. Println("Seconds :", yourTime. Andra())
}
Denna kod producerar följande utdata:
Observera att Parse() använder UTC som standard om du inte anger en tidszon i datumsträngen.
Hur man utför aritmetiska operationer med datum och tid
Aritmetiska operationer är en annan typ av manipulation du kan utföra på tid och datum i Go. Enkla operationer som addition, subtraktion och tidsskillnad är alla möjliga.
Go låter dig definiera tid. Varaktighet värden med alla tidsenheter från tid. Timme till tid. Nanosekund. Du kan använda dessa värden för att addera eller subtrahera tid med hjälp av Lägg till(). Det finns också en AddDate() funktion som tar in 3 parametrar: år, månader och dagar för att utföra addition eller subtraktion.
Följande kod visar användningen av dessa funktioner:
funchuvud() {
curTime := tid. Nu()
curTime = curTime. Lägg till (tid. Timme) // lägger till en timme
fmt. Println("Aktuell tid är: ", CurTime)
imorgon := curTime. Lägg till (tid. timme * 24)
fmt. Println("Denna tid imorgon är: ", imorgon)
nästa vecka := curTime. Lägg till (tid. timme * 24 * 7)
fmt. Println("Denna tid nästa vecka är: ", nästa vecka)
// med AddDate (y, m, d)
nästa imorgon := curTime. AddDate(0, 0, 2)
fmt. Println("Den här gången Nästa morgon är: ", nästamorgon)
nästa månad := CurTime. AddDate(0, 1, 0)
fmt. Println("Denna tid nästa månad är: ", nästa månad)
fiveYearsAndOneMonthAfter := curTime. AddDate(5, 1, 0)
fmt. Println("Denna tid fem år och en månad efter är: ", fiveYearsAndOneMonthAfter)
}
Vilket ger följande utdata:
Du kan också dra av tid med Lägg till() och AddDate() genom att skicka negativa parametrar. Till exempel:
funchuvud() {
curTime := tid. Nu()// subtrahera en dag med AddDate()
igår := curTime. AddDate(0, 0, -1)
fmt. Println("Denna tid igår var: ", igår)
// subtrahera en månad med Add()
sista månaden := CurTime. Lägg till (tid. timme * -24 * 30)
fmt. Println("Denna tid förra månaden var: ", förra månaden)
}
Ger denna utdata:
Även om du kan använda Lägg till() och AddDate() för att hitta skillnaden mellan datum har Go en Sub() funktion som fungerar lite annorlunda:
funchuvud() {
curTime = tid. Nu()
förflutna := tid. Datum(2022, tid. december, 25, 12, 0, 0, 0, tid. UTC)
diff := förflutna. Sub (curTime)
fmt. Println("Skillnaden mellan nu och det förflutna är: ", diff)
// få skillnaden i olika enheter
år := int(diff. Timmar() / 24 / 365)
fmt. Println("År: ", år)
månader := int(diff. Timmar() / 24 / 30)
fmt. Println("Månader: ", månader)
dagar := int(diff. Timmar() / 24)
fmt. Println("Dagar:", dagar)
timmar := int(diff. Timmar())
fmt. Println("Timmar:", timmar)
// diff. Minuter(), diff. Sekunder(), diff. Millisekunder(), diff. Nanosekunder() returnerar också sina enheter
}
Denna kod producerar följande utdata:
Hur man får tid och datum i olika format
Du kan också få tid och datum i flera format med hjälp av Formatera() fungera. Här är några vanliga formateringsstilar:
funchuvud() {
curTime = tid. Nu()
// inbyggda standardformateringsstilar
fmt. Println("Aktuell tid är: ", CurTime)
fmt. Println("Aktuell tid i RFC3339-format är: ", curTime. Format (tid. RFC3339))
fmt. Println("Aktuell tid i RFC3339Nano-format är: ", curTime. Format (tid. RFC3339Nano))
fmt. Println("Aktuell tid i RFC1123-format är: ", curTime. Format (tid. RFC1123))
fmt. Println("Aktuell tid i RFC1123Z-format är: ", curTime. Format (tid. RFC1123Z))
fmt. Println("Aktuell tid i RFC822-format är: ", curTime. Format (tid. RFC822))
fmt. Println("Aktuell tid i RFC822Z-format är: ", curTime. Format (tid. RFC822Z))
fmt. Println("Aktuell tid i RFC850-format är: ", curTime. Format (tid. RFC850))
fmt. Println("Aktuell tid i ANSIC-format är: ", curTime. Format (tid. ANSIC))
fmt. Println("Aktuell tid i Unix-format är: ", curTime. Format (tid. UnixDate))
// anpassade formateringsstilar
// DD-MM-ÅÅÅÅ TT: MM: SS
fmt. Println("Aktuell tid i anpassat format är: ", curTime. Formatera("02-01-200615:04:05"))
// MM-DD-ÅÅÅÅ HH: MM: SS
fmt. Println("Aktuell tid i anpassat format är: ", curTime. Formatera("01-02-200615:04:05"))
// ÅÅÅÅ-MM-DD HH: MM: SS
fmt. Println("Aktuell tid i anpassat format är: ", curTime. Formatera("2006-01-0215:04:05"))
// DD.MM.ÅÅÅÅ
fmt. Println("Aktuell tid i anpassat format är: ", curTime. Formatera("02.01.2006"))
// DD/MM/ÅÅÅÅ
fmt. Println("Aktuell tid i anpassat format är: ", curTime. Formatera("02/01/2006"))
// 1 februari 2006
fmt. Println("Aktuell tid i anpassat format är: ", curTime. Formatera("02 Jan 2006"))
// 1 februari 2006 måndag
fmt. Println("Aktuell tid i anpassat format är: ", curTime. Formatera("02 februari 2006 måndag"))
// 1 februari 2006 mån 15:04:05
fmt. Println("Aktuell tid i anpassat format är: ", curTime. Formatera("02 februari 2006 mån 15:04:05"))
}
Dessa olika typer av formatering ger följande utdata:
Manipulera tid och datum i farten
Listan över manipulationer som du kan utföra på tider och datum är nästan oändlig. Beroende på omfattningen av din applikation kan du behöva utföra många olika datum/tid-operationer.
För alla användningsfall du kan ha tid paketet är mycket funktionellt och har många inbyggda metoder.
Du kan använda datum- och tidsmanipulation för att bygga en enkel dagsplanerare eller uppgiftsschemaläggare.