Tid og dato er afgørende komponenter i en masse software, fra tidsstyringsværktøjer til webapplikationer. Som programmør skal du vide, hvordan du manipulerer tid og dato på det sprog, du bruger.
I Go, den tid pakken samler funktionerne til tids- og datomanipulation. Du kan få adgang til disse funktioner i enhver kildefil ved at importere den pakke.
Så hvad betyder det at manipulere tid og dato, og hvordan kan du manipulere tid og dato i Go?
Hvad er tids- og datomanipulation?
I henhold til dit programs krav skal det muligvis kontrollere, administrere eller justere adfærden eller repræsentationen af tidspunkter og datoer.
Forskellige programmeringssprog har deres egne funktioner til tids- og datomanipulation. Go-sproget har omfattende muligheder, som er nyttige til dette formål.
Tids- og datomanipulation kan omfatte:
- Indhentning af det aktuelle tidspunkt for en placering eller tidszone.
- Udførelse af aritmetiske operationer på tidspunkter og datoer.
- Ændring af input/output format for tidspunkter og datoer.
For at begynde at manipulere tid og dato i dine Go-applikationer skal du importere tid pakke sammen med de andre pakker, du bruger.
importere (
"fmt"
"tid"
)Sådan får du den aktuelle tid og dato i farten
Et almindeligt eksempel på tidsmanipulation er at få det aktuelle lokale klokkeslæt eller det aktuelle klokkeslæt for en specifik tidszone eller placering.
For at få klokkeslæt og dato i din lokale tid eller i en specifik tidszone eller placering, kan du bruge tid. Nu() og tid. LoadLocation() funktioner:
func vigtigste(){
// Få det aktuelle klokkeslæt og dato i lokal tid
min Tid := ime. Nu()
fmt. Println("Aktuel tid i ", min tid. Beliggenhed(), " er: ", min tid)// En anden måde at få lokal tid på
sted, _ := tid. LoadLocation("Lokal") // eller tid. LoadLocation("")
fmt. Println("Aktuel tid i ", Beliggenhed, " er: ", tid. Now().I (placering))// et andet sted
placering, _ = tid. LoadLocation("Amerika/New_York")
fmt. Println("Aktuel tid i ", Beliggenhed, " er: ", min tid. I (sted))
// få den aktuelle tid i Mountain Time Zone (MST)
placering, _ = tid. LoadLocation("MST")
fmt. Println("Aktuel tid i ", Beliggenhed, " er: ", min tid. I (sted))
}
Kører programmet ovenfor med kør filnavn.go producerer følgende output i terminalen:
LoadLocation-metoden understøtter ikke alle placeringer og tidszoneforkortelser. Ifølge Gå til dokumentation, den understøtter kun placeringer i IANA.org database.
Sådan får du separate komponenter fra en given dato
Du kan få hver komponent af tidsstemplet separat, hvilket svarer til hvornår arbejder med tid og datoer i JavaScript.
Der er adskillige måder at opnå dette ved at bruge Go's tid funktioner. Dette afsnit illustrerer hver metode.
Du kan bruge Dato() funktion til at få dagen, måneden og året og Ur() funktion for at få time, minut og sekunder. For eksempel:
funcvigtigste() {
min Tid := tid. Nu();
år, måned, dag := minTid. Dato()
fmt. Println("År :", år)
fmt. Println("Måned :", måned)
fmt. Println("Dag :", dag)
time, min, sek := minTid. Ur()
fmt. Println("Time :", time)
fmt. Println("Minut :", min)
fmt. Println("Sekunder :", sek.)
}
Outputtet illustrerer de forskellige dele af tidsstemplet:
Du kan også få enheder af tidsstemplet individuelt med tid funktioner for hver af dem:
funcvigtigste() {
min Tid := tid. Nu()
// få hver enhed 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("Minute :", minTid. Minut())
fmt. Println("Seconds :", minTid. Sekund())
fmt. Println("Nanosekund :", minTid. Nanosekund())
}
Som outputtet illustrerer, giver dette dig også adgang til nanosekunder:
Eksemplerne indtil dette punkt har fokuseret på at opnå tidsstemplingsenheder fra det aktuelle tidspunkt. Du kan udføre den samme slags handling på et tidsstempel, der ikke er det tid. Nu().
Du kan udtrække år, måned, dag, time, minut og sekund for en given dato. For at gøre det skal du enten initialisere et nyt datoobjekt eller parse datoen fra en streng:
funcvigtigste() {
// få individuelle komponenter af 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("Minute :", dinTid. Minut())
fmt. Println("Sekunder :", dinTid. Sekund())
fmt. Println("Nanosekund :", dinTid. Nanosekund())
// ved at bruge funktionen Clock() til at få time, minut og sekund
yourHour, yourMin, yourSec := yourTime. Ur()
fmt. Println("Time :", din Time)
fmt. Println("Minute :", dinMin)
fmt. Println("Seconds :", dinSec)
// få tid og dato fra streng
datostreng := "2020-07-0106:32:10"
layout := "2006-01-0215:04:05" // dit ønskede outputformat
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("Minute :", dinTid. Minut())
fmt. Println("Sekunder :", dinTid. Sekund())
}
Denne kode producerer følgende output:
Bemærk at Parse() bruger UTC som standard, hvis du ikke angiver en tidszone i datostrengen.
Sådan udføres aritmetiske operationer med dato og tid
Aritmetiske operationer er en anden type manipulation, du kan udføre på tid og dato i Go. Simple operationer som addition, subtraktion og tidsforskel er alle mulige.
Go giver dig mulighed for at definere tid. Varighed værdier med alle tidsenheder fra tid. Time til tid. Nanosekund. Du kan bruge disse værdier til at tilføje eller trække tid ved hjælp af Tilføje(). Der er også en AddDate() funktion som tager i 3 parametre: år, måneder og dage for at udføre addition eller subtraktion.
Følgende kode viser brugen af disse funktioner:
funcvigtigste() {
curTime := tid. Nu()
curTime = curTime. Tilføj (tid. Time) // tilføjer en time
fmt. Println("Aktuel tid er: ", CurTime)
i morgen := CurTime. Tilføj (tid. Time * 24)
fmt. Println("Denne tid i morgen er: ", i morgen)
næste uge := curTime. Tilføj (tid. Time * 24 * 7)
fmt. Println("Denne tid i næste uge er: ", næste uge)
// ved hjælp af AddDate (å, m, d)
næste morgen := curTime. Tilføj dato(0, 0, 2)
fmt. Println("Denne gang Næste i morgen er: ", næste i morgen)
næste Måned := CurTime. Tilføj dato(0, 1, 0)
fmt. Println("Denne tid næste måned er: ", næste måned)
fiveYearsAndOneMonthAfter := curTime. Tilføj dato(5, 1, 0)
fmt. Println("Denne gang fem år og en måned efter er: ", fem år og en måned efter)
}
Hvilket giver følgende output:
Du kan også trække tiden fra med Tilføje() og AddDate() ved at videregive negative parametre. For eksempel:
funcvigtigste() {
curTime := tid. Nu()// trække en dag fra ved hjælp af AddDate()
i går := CurTime. Tilføj dato(0, 0, -1)
fmt. Println("Denne gang i går var: ", i går)
// trække en måned fra ved hjælp af Add()
sidste Måned := CurTime. Tilføj (tid. Time * -24 * 30)
fmt. Println("Denne tid sidste måned var: ", sidste måned)
}
Producerer dette output:
Selvom du kan bruge Tilføje() og AddDate() for at finde skelnen mellem datoer, har Go en Sub() funktion som virker lidt anderledes:
funcvigtigste() {
curTime = tid. Nu()
forbi := tid. Dato(2022, tid. December, 25, 12, 0, 0, 0, tid. UTC)
diff := forbi. Sub (curTime)
fmt. Println("Forskellen mellem nu og fortid er: ", diff)
// få forskellen i forskellige enheder
år := int(forskel. Timer() / 24 / 365)
fmt. Println("År: ", år)
måneder := int(forskel. Timer() / 24 / 30)
fmt. Println("Måneder: ", måneder)
dage := int(forskel. Timer() / 24)
fmt. Println("Dage: ", dage)
timer := int(forskel. Timer())
fmt. Println("Timer: ", timer)
// forsk. Minutter(), diff. Sekunder(), diff. Millisekunder(), diff. Nanosekunder() returnerer også deres enheder
}
Denne kode producerer følgende output:
Sådan får du tid og dato i forskellige formater
Du kan også få tids- og datooutput i flere formater ved hjælp af Format() fungere. Her er nogle almindelige formateringsstile:
funcvigtigste() {
curTime = tid. Nu()
// indbyggede standardformateringsstile
fmt. Println("Aktuel tid er: ", CurTime)
fmt. Println("Aktuel tid i RFC3339-format er: ", curTime. Format (tid. RFC3339))
fmt. Println("Aktuel tid i RFC3339Nano-format er: ", curTime. Format (tid. RFC3339Nano))
fmt. Println("Aktuel tid i RFC1123-format er: ", curTime. Format (tid. RFC1123))
fmt. Println("Aktuel tid i RFC1123Z-format er: ", curTime. Format (tid. RFC1123Z))
fmt. Println("Aktuel tid i RFC822-format er: ", curTime. Format (tid. RFC822))
fmt. Println("Aktuel tid i RFC822Z-format er: ", curTime. Format (tid. RFC822Z))
fmt. Println("Aktuel tid i RFC850-format er: ", curTime. Format (tid. RFC850))
fmt. Println("Aktuel tid i ANSIC-format er: ", curTime. Format (tid. ANSIC))
fmt. Println("Aktuel tid i Unix-format er: ", curTime. Format (tid. UnixDate))
// brugerdefinerede formateringsstile
// DD-MM-ÅÅÅÅ TT: MM: SS
fmt. Println("Aktuel tid i brugerdefineret format er: ", curTime. Format("02-01-200615:04:05"))
// MM-DD-ÅÅÅÅ TT: MM: SS
fmt. Println("Aktuel tid i brugerdefineret format er: ", curTime. Format("01-02-200615:04:05"))
// ÅÅÅÅ-MM-DD TT: MM: SS
fmt. Println("Aktuel tid i brugerdefineret format er: ", curTime. Format("2006-01-0215:04:05"))
// DD.MM.ÅÅÅÅ
fmt. Println("Aktuel tid i brugerdefineret format er: ", curTime. Format("02.01.2006"))
// DD/MM/ÅÅÅÅ
fmt. Println("Aktuel tid i brugerdefineret format er: ", curTime. Format("02/01/2006"))
// 1. februar 2006
fmt. Println("Aktuel tid i brugerdefineret format er: ", curTime. Format("02 Jan 2006"))
// 01. februar 2006 mandag
fmt. Println("Aktuel tid i brugerdefineret format er: ", curTime. Format("02 februar 2006 Mandag"))
// 1. februar 2006 man 15:04:05
fmt. Println("Aktuel tid i brugerdefineret format er: ", curTime. Format("02 februar 2006 man 15:04:05"))
}
Disse forskellige typer formatering producerer følgende output:
Manipulering af tid og dato i farten
Listen over manipulationer, som du kan udføre på tidspunkter og datoer, er næsten uendelig. Afhængigt af omfanget af din applikation skal du muligvis udføre mange forskellige dato/klokkeslæt operationer.
For enhver brugssag, du måtte have tid pakken er meget funktionel og har mange indbyggede metoder.
Du kan bruge dato- og tidsmanipulation til at bygge en simpel daglig planlægnings- eller opgaveplanlægningsapp.
