Tijd en datum zijn cruciale componenten van veel software, van hulpprogramma's voor tijdbeheer tot webapplicaties. Als programmeur moet je weten hoe je tijd en datum kunt manipuleren in welke taal je ook gebruikt.
In Go, de tijd pakket bundelt de functies voor tijd- en datummanipulatie. U hebt toegang tot deze functies in elk bronbestand door dat pakket te importeren.
Dus, wat betekent het om tijd en datum te manipuleren, en hoe kun je tijd en datum manipuleren in Go?
Wat is tijd- en datummanipulatie?
Afhankelijk van de vereisten van uw programma, moet het mogelijk het gedrag of de weergave van tijden en datums controleren, beheren of aanpassen.
Verschillende programmeertalen hebben hun eigen functies voor tijd- en datummanipulatie. De Go-taal heeft uitgebreide mogelijkheden, handig voor dit doel.
Tijd- en datummanipulatie kan het volgende omvatten:
- Het verkrijgen van de huidige tijd van een locatie of tijdzone.
- Het uitvoeren van rekenkundige bewerkingen op tijden en datums.
- Het invoer-/uitvoerformaat van tijden en datums wijzigen.
Om te beginnen met het manipuleren van tijd en datum in uw Go-applicaties, importeert u de tijd pakket naast de andere pakketten die u gebruikt.
importeren (
"fmt"
"tijd"
)Hoe u de huidige tijd en datum in Go kunt krijgen
Een veelvoorkomend gebruik voor tijdmanipulatie is het verkrijgen van de huidige lokale tijd of de huidige tijd van een specifieke tijdzone of locatie.
Om de tijd en datum in uw lokale tijd of in een specifieke tijdzone of locatie te krijgen, kunt u de tijd. Nutsvoorzieningen() en tijd. LaadLocatie() functies:
func hoofd(){
// Krijg de huidige tijd en datum in Lokale tijd
mijnTijd := tijd. Nutsvoorzieningen()
fmt. Println("Lokale tijd in ", mijn tijd. Plaats(), " is: ", mijn tijd)// Een andere manier om lokale tijd te krijgen
locatie, _ := tijd. LaadLocatie("lokaal") // of tijd. LaadLocatie("")
fmt. Println("Lokale tijd in ", plaats, " is: ", tijd. Nu().In (locatie))// een andere locatie
locatie, _ = tijd. LaadLocatie("Amerika/New_York")
fmt. Println("Lokale tijd in ", plaats, " is: ", mijn tijd. In (locatie))
// krijg de huidige tijd in Mountain Time Zone (MST)
locatie, _ = tijd. LaadLocatie("MST")
fmt. Println("Lokale tijd in ", plaats, " is: ", mijn tijd. In (locatie))
}
Bovenstaand programma uitvoeren met ga bestandsnaam.go uitvoeren produceert de volgende uitvoer in de terminal:
De LoadLocation-methode ondersteunt niet elke afkorting voor locaties en tijdzones. Volgens de Ga documentatie, het ondersteunt alleen locaties in de IANA.org-database.
Afzonderlijke componenten verkrijgen vanaf een bepaalde datum
U kunt elk onderdeel van de tijdstempel afzonderlijk krijgen, wat vergelijkbaar is met wanneer werken met tijd en datums in JavaScript.
Er zijn talloze manieren om dit te bereiken met Go's tijd functies. Deze sectie illustreert elke methode.
U kunt de Datum() functie om de dag, maand en jaar te krijgen, en de Klok() functie om het uur, de minuut en de seconden te krijgen. Bijvoorbeeld:
funchoofd() {
mijnTijd := tijd. Nutsvoorzieningen();
jaar, maand, dag := myTime. Datum()
fmt. Println("Jaar :", jaar)
fmt. Println("Maand :", maand)
fmt. Println("Dag :", dag)
uur, min, sec := myTime. Klok()
fmt. Println("Uur :", uur)
fmt. Println("Minuut :", min)
fmt. Println("Seconden :", sec)
}
De uitvoer illustreert de verschillende delen van de tijdstempel:
U kunt ook afzonderlijke eenheden van de tijdstempel krijgen met de tijd functies voor elk van hen:
funchoofd() {
mijnTijd := tijd. Nutsvoorzieningen()
// haal elke eenheid van jaar tot nanoseconde
fmt. Println("Jaar:", myTime. Jaar())
fmt. Println("Maand :", myTime. Maand())
fmt. Println("Dag :", myTime. Dag())
fmt. Println("Uur :", myTime. Uur())
fmt. Println("Minuut :", myTime. Minuut())
fmt. Println("Seconden:", myTime. Seconde())
fmt. Println("Nanoseconde :", myTime. Nanoseconde())
}
Zoals de uitvoer illustreert, geeft dit u ook toegang tot nanoseconden:
De voorbeelden tot nu toe waren gericht op het verkrijgen van tijdstempeleenheden uit de huidige tijd. U kunt dezelfde soort acties uitvoeren op een tijdstempel die dat niet is tijd. Nutsvoorzieningen().
U kunt het jaar, de maand, de dag, het uur, de minuut en de seconde van een bepaalde datum extraheren. Om dit te doen, moet u een nieuw datumobject initialiseren of de datum ontleden uit een tekenreeks:
funchoofd() {
// ontvang individuele componenten van de tijd van jaar tot nanoseconde
// vanaf een specifieke datum
jouw tijd := tijd. Datum(2020, 07, 1, 06, 32, 10, 0, tijd. UTC)
fmt. Println("Jaar:", yourTime. Jaar())
fmt. Println("Maand :", yourTime. Maand())
fmt. Println("Dag :", yourTime. Dag())
fmt. Println("Hour :", yourTime. Uur())
fmt. Println("Minuut :", yourTime. Minuut())
fmt. Println("Seconden:", yourTime. Seconde())
fmt. Println("Nanoseconde :", yourTime. Nanoseconde())
// de functie Clock() gebruiken om uur, minuut en seconde te krijgen
jouwHour, jouwMin, jouwSec := jouwTijd. Klok()
fmt. Println("Uur :", uwUur)
fmt. Println("Minuut :", jouwMin)
fmt. Println("Seconden:", jouwSec)
// haal tijd en datum uit string
datumString := "2020-07-0106:32:10"
indeling := "2006-01-0215:04:05" // uw gewenste uitvoerformaat
jouwTijd, _ = tijd. Ontleden (lay-out, dateString)
fmt. Println("Uw tijd is: ", uw tijd)
fmt. Println("Jaar:", yourTime. Jaar())
fmt. Println("Maand :", yourTime. Maand())
fmt. Println("Dag :", yourTime. Dag())
fmt. Println("Hour :", yourTime. Uur())
fmt. Println("Minuut :", yourTime. Minuut())
fmt. Println("Seconden:", yourTime. Seconde())
}
Deze code produceert de volgende uitvoer:
Merk op dat Parse() gebruikt UTC standaard als u geen tijdzone opgeeft in de datumreeks.
Rekenkundige bewerkingen uitvoeren met datum en tijd
Rekenkundige bewerkingen zijn een ander soort manipulatie die u in Go op tijd en datum kunt uitvoeren. Eenvoudige bewerkingen zoals optellen, aftrekken en tijdsverschil zijn allemaal mogelijk.
Met Go kunt u definiëren tijd. Looptijd waarden met alle tijdseenheden van tijd. Uur tot tijd. Nanoseconde. U kunt deze waarden gebruiken om tijd op te tellen of af te trekken met Toevoegen(). Er is ook een Datum toevoegen() functie die 3 parameters inneemt: jaren, maanden en dagen voor het uitvoeren van optellen of aftrekken.
De volgende code demonstreert het gebruik van deze functies:
funchoofd() {
curTime := tijd. Nutsvoorzieningen()
curTijd = curTijd. Voeg tijd toe. Uur) // voegt een uur toe
fmt. Println("Huidige tijd is: ", curTime)
morgen := curTime. Voeg tijd toe. Uur * 24)
fmt. Println("Morgen is deze tijd: ", morgen)
volgende week := curTime. Voeg tijd toe. Uur * 24 * 7)
fmt. Println("Volgende week deze tijd is: ", volgende week)
// met AddDate (y, m, d)
volgendeMorgen := curTime. Datum toevoegen(0, 0, 2)
fmt. Println("Deze keer Volgende morgen is: ", volgendeMorgen)
nextMonth := curTime. Datum toevoegen(0, 1, 0)
fmt. Println("Deze tijd volgende maand is: ", nextMonth)
fiveYearsAndOneMonthAfter := curTime. Datum toevoegen(5, 1, 0)
fmt. Println("Deze keer vijf jaar en een maand later is: ", fiveYearsAndOneMonthAfter)
}
Wat de volgende output oplevert:
U kunt de tijd ook aftrekken met Toevoegen() en Datum toevoegen() door negatieve parameters door te geven. Bijvoorbeeld:
funchoofd() {
curTime := tijd. Nutsvoorzieningen()// trek één dag af met AddDate()
gisteren := curTime. Datum toevoegen(0, 0, -1)
fmt. Println("Dit keer was gisteren: ", gisteren)
// trek één maand af met Add()
lastMonth := curTime. Voeg tijd toe. Uur * -24 * 30)
fmt. Println("Vorige maand deze tijd was: ", lastMonth)
}
Produceert deze uitvoer:
Hoewel je kunt gebruiken Toevoegen() en Datum toevoegen() om het onderscheid tussen datums te vinden, heeft Go een Sub() functie die iets anders werkt:
funchoofd() {
curTime = tijd. Nutsvoorzieningen()
verleden := tijd. Datum(2022, tijd. December, 25, 12, 0, 0, 0, tijd. UTC)
verschil := verleden. Sub (curTime)
fmt. Println("Verschil tussen nu en verleden is: ", diff)
// krijg het verschil in verschillende eenheden
jaar := int(verschil. Uren() / 24 / 365)
fmt. Println("Jaren:", jaren)
maanden := int(verschil. Uren() / 24 / 30)
fmt. Println("Maanden:", maanden)
dagen := int(verschil. Uren() / 24)
fmt. Println("Dagen:", dagen)
uur := int(verschil. Uren())
fmt. Println("Uren:", uren)
// verschil. Minuten(), verschil. Seconden(), verschil. Milliseconden(), verschil. Nanoseconden() retourneren ook hun eenheden
}
Deze code produceert de volgende uitvoer:
Hoe u tijd en datum in verschillende indelingen kunt krijgen
U kunt ook tijd- en datum-uitvoer krijgen in meerdere formaten met behulp van de Formaat() functie. Hier volgen enkele veelvoorkomende opmaakstijlen:
funchoofd() {
curTime = tijd. Nutsvoorzieningen()
// ingebouwde standaard opmaakstijlen
fmt. Println("Huidige tijd is: ", curTime)
fmt. Println("Huidige tijd in RFC3339-formaat is: ", curTime. Formaat (tijd. RFC3339))
fmt. Println("Huidige tijd in RFC3339Nano-formaat is: ", curTime. Formaat (tijd. RFC3339Nano))
fmt. Println("Huidige tijd in RFC1123-formaat is: ", curTime. Formaat (tijd. RFC1123))
fmt. Println("Huidige tijd in RFC1123Z-formaat is: ", curTime. Formaat (tijd. RFC1123Z))
fmt. Println("Huidige tijd in RFC822-formaat is: ", curTime. Formaat (tijd. RFC822))
fmt. Println("Huidige tijd in RFC822Z-formaat is: ", curTime. Formaat (tijd. RFC822Z))
fmt. Println("Huidige tijd in RFC850-formaat is: ", curTime. Formaat (tijd. RFC850))
fmt. Println("Huidige tijd in ANSIC-formaat is: ", curTime. Formaat (tijd. ANSIC))
fmt. Println("Huidige tijd in Unix-formaat is: ", curTime. Formaat (tijd. UnixDatum))
// aangepaste opmaakstijlen
// DD-MM-JJJJ UU: MM: SS
fmt. Println("Huidige tijd in aangepast formaat is: ", curTime. Formaat("02-01-200615:04:05"))
// MM-DD-JJJJ UU: MM: SS
fmt. Println("Huidige tijd in aangepast formaat is: ", curTime. Formaat("01-02-200615:04:05"))
// JJJJ-MM-DD UU: MM: SS
fmt. Println("Huidige tijd in aangepast formaat is: ", curTime. Formaat("2006-01-0215:04:05"))
// DD.MM.JJJJ
fmt. Println("Huidige tijd in aangepast formaat is: ", curTime. Formaat("02.01.2006"))
// DD/MM/JJJJ
fmt. Println("Huidige tijd in aangepast formaat is: ", curTime. Formaat("02/01/2006"))
// 01 februari 2006
fmt. Println("Huidige tijd in aangepast formaat is: ", curTime. Formaat("02 Jan 2006"))
// 01 februari 2006 maandag
fmt. Println("Huidige tijd in aangepast formaat is: ", curTime. Formaat("02 Februari 2006 Maandag"))
// 01 februari 2006 ma 15:04:05
fmt. Println("Huidige tijd in aangepast formaat is: ", curTime. Formaat("02 Februari 2006 maandag 15:04:05"))
}
Deze verschillende soorten opmaak produceren de volgende uitvoer:
Tijd en datum manipuleren in Go
De lijst met manipulaties die u op tijden en datums kunt uitvoeren, is bijna oneindig. Afhankelijk van de reikwijdte van uw toepassing, moet u mogelijk veel verschillende datum-/tijdbewerkingen uitvoeren.
Voor elk gebruik dat u heeft, de tijd pakket is zeer functioneel en heeft veel ingebouwde methoden.
U kunt datum- en tijdmanipulatie gebruiken om een eenvoudige dagelijkse planner of taakplanner-app te bouwen.
