Tid og dato er avgjørende komponenter i mye programvare, fra tidsstyringsverktøy til nettapplikasjoner. Som programmerer må du vite hvordan du manipulerer tid og dato på hvilket språk du enn bruker.
I Go, den tid pakken samler funksjonene for klokkeslett- og datomanipulering. Du kan få tilgang til disse funksjonene i en hvilken som helst kildefil ved å importere den pakken.
Så, hva betyr det å manipulere tid og dato, og hvordan kan du manipulere tid og dato i Go?
Hva er tids- og datomanipulering?
I henhold til programmets krav kan det være nødvendig å kontrollere, administrere eller justere atferden eller representasjonen av tider og datoer.
Ulike programmeringsspråk har sine egne funksjoner for tids- og datomanipulering. Go-språket har omfattende funksjoner, nyttig for dette formålet.
Tids- og datomanipulering kan omfatte:
- Innhenting av gjeldende tidspunkt for en plassering eller tidssone.
- Utføre aritmetiske operasjoner på tider og datoer.
- Endring av inn-/utdataformat for klokkeslett og datoer.
For å begynne å manipulere tid og dato i Go-applikasjonene dine, importer tid pakke sammen med de andre pakkene du bruker.
import (
"fmt"
"tid"
)Slik får du gjeldende tid og dato i farten
En vanlig brukssak for tidsmanipulasjon er å skaffe gjeldende lokale tid eller gjeldende tid for en bestemt tidssone eller sted.
For å få tid og dato i lokal tid eller i en bestemt tidssone eller sted, kan du bruke tid. Nå() og tid. LoadLocation() funksjoner:
func hoved-(){
// Få gjeldende tid og dato i lokal tid
min tid := ime. Nå()
fmt. Println("Gjeldende tid i ", min tid. Plassering(), " er: ", min tid)// En annen måte å få lokal tid på
plassering, _ := tid. Laststed("Lokalt") // eller tid. Laststed("")
fmt. Println("Gjeldende tid i ", plassering, " er: ", tid. Now().I (sted))// et annet sted
plassering, _ = tid. Laststed("Amerika/New_York")
fmt. Println("Gjeldende tid i ", plassering, " er: ", min tid. I (sted))
// få gjeldende tid i Mountain Time Zone (MST)
plassering, _ = tid. Laststed("MST")
fmt. Println("Gjeldende tid i ", plassering, " er: ", min tid. I (sted))
}
Kjører programmet ovenfor med kjør filnavn.go produserer følgende utgang i terminalen:
LoadLocation-metoden støtter ikke alle steds- og tidssoneforkortelser. Ifølge Gå dokumentasjon, støtter den bare steder i IANA.org database.
Hvordan få separate komponenter fra en gitt dato
Du kan få hver komponent i tidsstemplet separat som ligner på når jobber med tid og datoer i JavaScript.
Det er mange måter å oppnå dette ved å bruke Go's tid funksjoner. Denne delen illustrerer hver metode.
Du kan bruke Dato() funksjon for å få dagen, måneden og året, og Klokke() funksjon for å få time, minutt og sekunder. For eksempel:
funchoved-() {
min tid := tid. Nå();
år, måned, dag := minTid. Dato()
fmt. Println("År :", år)
fmt. Println("Måned :", måned)
fmt. Println("Dag :", dag)
time, min, sek := minTid. Klokke()
fmt. Println("Time :", time)
fmt. Println("Minutt :", min)
fmt. Println("Sekunder :", sek)
}
Utdataene illustrerer de forskjellige delene av tidsstemplet:
Du kan også få enheter av tidsstemplet individuelt med tid funksjoner for hver av dem:
funchoved-() {
min tid := tid. Nå()
// få hver enhet fra år til nanosekund
fmt. Println("År:", minTid. År())
fmt. Println("Måned :", minTid. Måned())
fmt. Println("Dag :", minTid. Dag())
fmt. Println("Time :", minTid. Time())
fmt. Println("Minutt :", minTid. Minutt())
fmt. Println("Seconds :", myTime. Sekund())
fmt. Println("Nanosekund :", myTime. Nanosekund())
}
Som utgangen illustrerer, gir dette deg også tilgang til nanosekunder:
Eksemplene frem til dette punktet har fokusert på å skaffe tidsstempelenheter fra gjeldende tid. Du kan utføre den samme typen handling på et tidsstempel som ikke er det tid. Nå().
Du kan trekke ut år, måned, dag, time, minutt og sekund for en gitt dato. For å gjøre det må du enten initialisere et nytt datoobjekt eller analysere datoen fra en streng:
funchoved-() {
// få individuelle komponenter av tiden fra år til nanosekund
// fra en bestemt dato
din tid := tid. Dato(2020, 07, 1, 06, 32, 10, 0, tid. UTC)
fmt. Println("År :", dinTid. År())
fmt. Println("Måned :", dinTid. Måned())
fmt. Println("Dag :", dinTid. Dag())
fmt. Println("Time :", dinTid. Time())
fmt. Println("Minutt :", dinTid. Minutt())
fmt. Println("Seconds :", yourTime. Sekund())
fmt. Println("Nanosekund :", dinTid. Nanosekund())
// ved å bruke Clock()-funksjonen for å få time, minutt og sekund
yourHour, yourMin, yourSec := yourTime. Klokke()
fmt. Println("Time :", din Time)
fmt. Println("Minutt :", dinMin)
fmt. Println("Seconds :", yourSec)
// få tid og dato fra streng
dateString := "2020-07-0106:32:10"
layout := "2006-01-0215:04:05" // ønsket utdataformat
dinTid, _ = tid. Parse (layout, datostreng)
fmt. Println("Din tid er: ", din tid)
fmt. Println("År :", dinTid. År())
fmt. Println("Måned :", dinTid. Måned())
fmt. Println("Dag :", dinTid. Dag())
fmt. Println("Time :", dinTid. Time())
fmt. Println("Minutt :", dinTid. Minutt())
fmt. Println("Seconds :", yourTime. Sekund())
}
Denne koden produserer følgende utgang:
Merk at Parse() bruker UTC som standard hvis du ikke angir en tidssone i datostrengen.
Hvordan utføre aritmetiske operasjoner med dato og klokkeslett
Aritmetiske operasjoner er en annen type manipulasjon du kan utføre på tid og dato i Go. Enkle operasjoner som addisjon, subtraksjon og tidsforskjell er alle mulige.
Go lar deg definere tid. Varighet verdier med alle tidsenheter fra tid. Time til tid. Nanosekund. Du kan bruke disse verdiene til å legge til eller trekke fra tid ved å bruke Legge til(). Det er også en AddDate() funksjon som tar inn 3 parametere: år, måneder og dager for å utføre addisjon eller subtraksjon.
Følgende kode viser bruken av disse funksjonene:
funchoved-() {
curTime := tid. Nå()
curTime = curTime. Legg til (tid. Time) // legger til en time
fmt. Println("Gjeldende tid er: ", CurTime)
i morgen := curTime. Legg til (tid. Time * 24)
fmt. Println("Denne tiden i morgen er: ", i morgen)
neste uke := curTime. Legg til (tid. Time * 24 * 7)
fmt. Println("Denne tiden neste uke er: ", neste uke)
// bruker AddDate (y, m, d)
neste morgen := curTime. AddDate(0, 0, 2)
fmt. Println("Denne gangen neste morgen er: ", neste morgen)
neste måned := curTime. AddDate(0, 1, 0)
fmt. Println("Denne tiden neste måned er: ", neste måned)
fiveYearsAndOneMonthAfter := curTime. AddDate(5, 1, 0)
fmt. Println("Denne gangen fem år og en måned etter er: ", fiveYearsAndOneMonthAfter)
}
Som gir følgende utgang:
Du kan også trekke fra tid med Legge til() og AddDate() ved å sende negative parametere. For eksempel:
funchoved-() {
curTime := tid. Nå()// trekk fra en dag med AddDate()
i går := curTime. AddDate(0, 0, -1)
fmt. Println("Denne gangen i går var: ", i går)
// trekk fra en måned med Add()
siste måned := curTime. Legg til (tid. Time * -24 * 30)
fmt. Println("Denne tiden forrige måned var: ", siste måned)
}
Produserer denne utgangen:
Selv om du kan bruke Legge til() og AddDate() for å finne forskjellen mellom datoer, har Go en Under() funksjon som fungerer litt annerledes:
funchoved-() {
curTime = tid. Nå()
forbi := tid. Dato(2022, tid. Desember, 25, 12, 0, 0, 0, tid. UTC)
diff := forbi. Sub (curTime)
fmt. Println("Forskjellen mellom nå og fortid er: ", diff)
// få forskjellen i ulike enheter
år := int(diff. Timer() / 24 / 365)
fmt. Println("År: ", år)
måneder := int(diff. Timer() / 24 / 30)
fmt. Println("Måneder: ", måneder)
dager := int(diff. Timer() / 24)
fmt. Println("Dager: ", dager)
timer := int(diff. Timer())
fmt. Println("Timer: ", timer)
// diff. Minutter(), diff. Sekunder(), diff. Millisekunder(), diff. Nanosekunder() returnerer også enhetene sine
}
Denne koden produserer følgende utgang:
Hvordan få tid og dato i forskjellige formater
Du kan også få klokkeslett og dato i flere formater ved å bruke Format() funksjon. Her er noen vanlige formateringsstiler:
funchoved-() {
curTime = tid. Nå()
// innebygde standard formateringsstiler
fmt. Println("Gjeldende tid er: ", CurTime)
fmt. Println("Gjeldende tid i RFC3339-format er: ", curTime. Format (tid. RFC3339))
fmt. Println("Gjeldende tid i RFC3339Nano-format er: ", curTime. Format (tid. RFC3339Nano))
fmt. Println("Gjeldende tid i RFC1123-format er: ", curTime. Format (tid. RFC1123))
fmt. Println("Gjeldende tid i RFC1123Z-format er: ", curTime. Format (tid. RFC1123Z))
fmt. Println("Gjeldende tid i RFC822-format er: ", CurTime. Format (tid. RFC822))
fmt. Println("Gjeldende tid i RFC822Z-format er: ", curTime. Format (tid. RFC822Z))
fmt. Println("Gjeldende tid i RFC850-format er: ", curTime. Format (tid. RFC850))
fmt. Println("Gjeldende tid i ANSIC-format er: ", curTime. Format (tid. ANSIC))
fmt. Println("Gjeldende tid i Unix-format er: ", curTime. Format (tid. UnixDate))
// egendefinerte formateringsstiler
// DD-MM-ÅÅÅÅ TT: MM: SS
fmt. Println("Gjeldende tid i tilpasset format er: ", curTime. Format("02-01-200615:04:05"))
// MM-DD-ÅÅÅÅ TT: MM: SS
fmt. Println("Gjeldende tid i tilpasset format er: ", curTime. Format("01-02-200615:04:05"))
// ÅÅÅÅ-MM-DD TT: MM: SS
fmt. Println("Gjeldende tid i tilpasset format er: ", curTime. Format("2006-01-0215:04:05"))
// DD.MM.ÅÅÅÅ
fmt. Println("Gjeldende tid i tilpasset format er: ", curTime. Format("02.01.2006"))
// DD/MM/ÅÅÅÅ
fmt. Println("Gjeldende tid i tilpasset format er: ", curTime. Format("02/01/2006"))
// 1. februar 2006
fmt. Println("Gjeldende tid i tilpasset format er: ", curTime. Format("02 Jan 2006"))
// 01. februar 2006 mandag
fmt. Println("Gjeldende tid i tilpasset format er: ", curTime. Format("02 februar 2006 Mandag"))
// 1. februar 2006 Man 15:04:05
fmt. Println("Gjeldende tid i tilpasset format er: ", curTime. Format("02 februar 2006 man 15:04:05"))
}
Disse forskjellige formateringstypene produserer følgende utdata:
Manipulere tid og dato i farten
Listen over manipulasjoner som du kan utføre på tider og datoer er nesten uendelig. Avhengig av omfanget av søknaden din, kan det hende du må utføre mange forskjellige dato-/klokkeslettoperasjoner.
For enhver brukssituasjon du måtte ha tid pakken er veldig funksjonell og har mange innebygde metoder.
Du kan bruke dato- og tidsmanipulasjon for å bygge en enkel daglig planlegger- eller oppgaveplanlegger-app.
