Zeit und Datum sind entscheidende Komponenten vieler Software, von Zeitmanagement-Dienstprogrammen bis hin zu Webanwendungen. Als Programmierer müssen Sie wissen, wie man Zeit und Datum in der von Ihnen verwendeten Sprache manipuliert.
In Go, die Zeit Paket bündelt die Funktionen zur Zeit- und Datumsmanipulation. Sie können auf diese Funktionen in jeder Quelldatei zugreifen, indem Sie dieses Paket importieren.
Was bedeutet es also, Zeit und Datum zu manipulieren, und wie können Sie Zeit und Datum in Go manipulieren?
Was ist Zeit- und Datumsmanipulation?
Entsprechend den Anforderungen Ihres Programms muss es möglicherweise das Verhalten oder die Darstellung von Zeiten und Daten steuern, verwalten oder anpassen.
Verschiedene Programmiersprachen verfügen über eigene Funktionen zur Zeit- und Datumsmanipulation. Die Go-Sprache hat umfangreiche Fähigkeiten, die für diesen Zweck nützlich sind.
Die Manipulation von Uhrzeit und Datum kann Folgendes umfassen:
- Abrufen der aktuellen Uhrzeit eines Standorts oder einer Zeitzone.
- Durchführen von arithmetischen Operationen mit Zeiten und Daten.
- Ändern des Ein-/Ausgabeformats von Uhrzeiten und Datumsangaben.
Um mit der Manipulation von Uhrzeit und Datum in Ihren Go-Anwendungen zu beginnen, importieren Sie die Zeit Paket zusammen mit den anderen Paketen, die Sie verwenden.
importieren (
"fmt"
"Zeit"
)So erhalten Sie die aktuelle Uhrzeit und das Datum in Go
Ein häufiger Anwendungsfall für die Zeitmanipulation ist das Abrufen der aktuellen Ortszeit oder der aktuellen Zeit einer bestimmten Zeitzone oder eines bestimmten Standorts.
Um die Uhrzeit und das Datum in Ihrer Ortszeit oder in einer bestimmten Zeitzone oder an einem bestimmten Ort abzurufen, können Sie die verwenden Zeit. Jetzt() und Zeit. LoadLocation() Funktionen:
Funk hauptsächlich(){
// Abrufen der aktuellen Uhrzeit und des Datums in Ortszeit
meineZeit := Zeit. Jetzt()
fmt. Println("Aktuelle Zeit in ", meine Zeit. Ort(), " ist: ", meine Zeit)// Eine andere Möglichkeit, die Ortszeit zu erhalten
Ort, _ := Zeit. Ladeort("Lokal") // oder Zeit. Ladeort("")
fmt. Println("Aktuelle Zeit in ", Lage, " ist: ", Zeit. Now().In (Ort))// ein anderer Ort
Ort, _ = Zeit. Ladeort("Amerika/New_York")
fmt. Println("Aktuelle Zeit in ", Lage, " ist: ", meine Zeit. In (Ort))
// die aktuelle Uhrzeit in der Mountain Time Zone (MST) abrufen
Ort, _ = Zeit. Ladeort("MST")
fmt. Println("Aktuelle Zeit in ", Lage, " ist: ", meine Zeit. In (Ort))
}
Führen Sie das obige Programm mit aus gehen Sie Dateiname.go ausführen erzeugt im Terminal folgende Ausgabe:
Die LoadLocation-Methode unterstützt nicht alle Abkürzungen für Standorte und Zeitzonen. Laut dem Gehen Sie Dokumentation, es werden nur Standorte in unterstützt IANA.org-Datenbank.
So erhalten Sie separate Komponenten ab einem bestimmten Datum
Sie können jede Komponente des Zeitstempels separat abrufen, was dem Wann ähnelt Arbeiten mit Zeit und Datum in JavaScript.
Es gibt zahlreiche Möglichkeiten, dies mit Gos zu erreichen Zeit Funktionen. Dieser Abschnitt veranschaulicht jede Methode.
Du kannst den... benutzen Datum() Funktion zum Abrufen von Tag, Monat und Jahr und der Uhr() Funktion, um die Stunde, Minute und Sekunden zu erhalten. Zum Beispiel:
Funkhauptsächlich() {
meineZeit := Zeit. Jetzt();
Jahr, Monat, Tag := myTime. Datum()
fmt. Println("Jahr :", Jahr)
fmt. Println("Monat :", Monat)
fmt. Println("Tag :", Tag)
Stunde, Minute, Sekunde := myTime. Uhr()
fmt. Println("Stunde :", Stunde)
fmt. Println("Minute :", min)
fmt. Println("Sekunden :", sec)
}
Die Ausgabe veranschaulicht die verschiedenen Teile des Zeitstempels:
Sie können Einheiten des Zeitstempels auch einzeln mit dem abrufen Zeit Funktionen für jeden von ihnen:
Funkhauptsächlich() {
meineZeit := Zeit. Jetzt()
// erhält jede Einheit von Jahr bis Nanosekunde
fmt. Println("Jahr :", meineZeit. Jahr())
fmt. Println("Monat :", meineZeit. Monat())
fmt. Println("Tag :", meineZeit. Tag())
fmt. Println("Stunde :", meineZeit. Stunde())
fmt. Println("Minute :", meineZeit. Minute())
fmt. Println("Sekunden :", meineZeit. Zweite())
fmt. Println("Nanosekunde :", myTime. Nanosekunde())
}
Wie die Ausgabe zeigt, erhalten Sie damit auch Zugriff auf Nanosekunden:
Die bisherigen Beispiele haben sich darauf konzentriert, Zeitstempeleinheiten aus der aktuellen Zeit zu erhalten. Sie können die gleichen Aktionen mit einem Zeitstempel ausführen, der keiner ist Zeit. Jetzt().
Sie können Jahr, Monat, Tag, Stunde, Minute und Sekunde eines bestimmten Datums extrahieren. Dazu müssen Sie entweder ein neues Datumsobjekt initialisieren oder das Datum aus einer Zeichenfolge analysieren:
Funkhauptsächlich() {
// einzelne Komponenten der Zeit von Jahr bis Nanosekunde erhalten
// ab einem bestimmten Datum
yourTime := Zeit. Datum(2020, 07, 1, 06, 32, 10, 0, Zeit. KOORDINIERTE WELTZEIT)
fmt. Println("Jahr :", yourTime. Jahr())
fmt. Println("Monat :", yourTime. Monat())
fmt. Println("Tag :", yourTime. Tag())
fmt. Println("Stunde :", yourTime. Stunde())
fmt. Println("Minute :", yourTime. Minute())
fmt. Println("Sekunden :", yourTime. Zweite())
fmt. Println("Nanosekunde :", yourTime. Nanosekunde())
// Verwendung der Clock()-Funktion, um Stunde, Minute und Sekunde zu erhalten
yourHour, yourMin, yourSec := yourTime. Uhr()
fmt. Println("Stunde :", deineStunde)
fmt. Println("Minute :", yourMin)
fmt. Println("Sekunden :", yourSec)
// Uhrzeit und Datum aus String abrufen
dateString := "2020-07-0106:32:10"
Anordnung := "2006-01-0215:04:05" // Ihr gewünschtes Ausgabeformat
yourTime, _ = Zeit. Parsen (Layout, dateString)
fmt. Println("Deine Zeit ist: ", deineZeit)
fmt. Println("Jahr :", yourTime. Jahr())
fmt. Println("Monat :", yourTime. Monat())
fmt. Println("Tag :", yourTime. Tag())
fmt. Println("Stunde :", yourTime. Stunde())
fmt. Println("Minute :", yourTime. Minute())
fmt. Println("Sekunden :", yourTime. Zweite())
}
Dieser Code erzeugt die folgende Ausgabe:
Beachten Sie, dass Parse() verwendet koordinierte Weltzeit standardmäßig, wenn Sie keine Zeitzone in der Datumszeichenfolge angeben.
So führen Sie arithmetische Operationen mit Datum und Uhrzeit durch
Arithmetische Operationen sind eine weitere Art der Manipulation, die Sie an Uhrzeit und Datum in Go vornehmen können. Einfache Operationen wie Addition, Subtraktion und Zeitdifferenz sind alle möglich.
Mit Go können Sie definieren Zeit. Dauer Werte mit allen Zeiteinheiten von Zeit. Stunde zu Zeit. Nanosekunde. Mit diesen Werten können Sie Zeit addieren oder subtrahieren Hinzufügen(). Es gibt auch eine Datum hinzufügen() Funktion, die 3 Parameter aufnimmt: Jahre, Monate und Tage zur Durchführung von Additionen oder Subtraktionen.
Der folgende Code demonstriert die Verwendung dieser Funktionen:
Funkhauptsächlich() {
aktuelle Zeit := Zeit. Jetzt()
aktuelleZeit = aktuelleZeit. Zeit hinzufügen. Stunde) // fügt eine Stunde hinzu
fmt. Println("Aktuelle Zeit ist: ", aktuelleZeit)
morgen := aktuelleZeit. Zeit hinzufügen. Stunde * 24)
fmt. Println("Morgen um diese Zeit ist: ", morgen)
nächsteWoche := aktuelleZeit. Zeit hinzufügen. Stunde * 24 * 7)
fmt. Println("Nächste Woche um diese Uhrzeit ist: ", nextWeek)
// mit AddDate (y, m, d)
nextTomorrow := aktuelleZeit. Datum hinzufügen(0, 0, 2)
fmt. Println("Diese Zeit Nächster Morgen ist: ", nextTomorrow)
nextMonth := aktuelleZeit. Datum hinzufügen(0, 1, 0)
fmt. Println("Nächster Monat um diese Zeit ist: ", nextMonth)
fiveYearsAndOneMonthAfter := aktuelleZeit. Datum hinzufügen(5, 1, 0)
fmt. Println("Diese Zeit fünf Jahre und einen Monat später ist: ", fiveYearsAndOneMonthAfter)
}
Was die folgende Ausgabe erzeugt:
Sie können die Zeit auch mit subtrahieren Hinzufügen() und Datum hinzufügen() durch Übergabe negativer Parameter. Zum Beispiel:
Funkhauptsächlich() {
aktuelle Zeit := Zeit. Jetzt()// subtrahiere einen Tag mit AddDate()
gestern := aktuelleZeit. Datum hinzufügen(0, 0, -1)
fmt. Println("Gestern um diese Zeit war: ", gestern)
// Subtrahiere einen Monat mit Add()
letzterMonat := aktuelleZeit. Zeit hinzufügen. Stunde * -24 * 30)
fmt. Println("Diese Zeit im letzten Monat war: ", lastMonth)
}
Erzeugt diese Ausgabe:
Obwohl Sie verwenden können Hinzufügen() und Datum hinzufügen() Um die Unterscheidung zwischen Datumsangaben zu finden, hat Go a Teil() Funktion, die etwas anders funktioniert:
Funkhauptsächlich() {
aktuelleZeit = Zeit. Jetzt()
Vergangenheit := Zeit. Datum(2022, Zeit. Dezember, 25, 12, 0, 0, 0, Zeit. KOORDINIERTE WELTZEIT)
diff := Vergangenheit. Sub (aktuelle Zeit)
fmt. Println("Unterschied zwischen jetzt und der Vergangenheit ist: ", diff)
// den Unterschied in verschiedenen Einheiten erhalten
Jahre := int(verschieden. Std() / 24 / 365)
fmt. Println("Jahre: ", Jahre)
Monate := int(verschieden. Std() / 24 / 30)
fmt. Println("Monate: ", Monate)
Tage := int(verschieden. Std() / 24)
fmt. Println("Tage: ", Tage)
Stunden := int(verschieden. Std())
fmt. Println("Stunden: ", Stunden)
// diff. Minuten(), diff. Sekunden(), diff. Millisekunden(), diff. Nanoseconds() geben auch ihre Einheiten zurück
}
Dieser Code erzeugt die folgende Ausgabe:
So erhalten Sie Uhrzeit und Datum in verschiedenen Formaten
Sie können auch Zeit- und Datumsausgaben in mehreren Formaten erhalten, indem Sie die verwenden Format() Funktion. Hier sind einige gängige Formatierungsstile:
Funkhauptsächlich() {
aktuelleZeit = Zeit. Jetzt()
// eingebaute Standardformatierungsstile
fmt. Println("Aktuelle Zeit ist: ", aktuelleZeit)
fmt. Println("Aktuelle Zeit im RFC3339-Format ist: ", curTime. Format (Zeit. RFC3339))
fmt. Println("Aktuelle Zeit im RFC3339Nano-Format ist: ", curTime. Format (Zeit. RFC3339Nano))
fmt. Println("Aktuelle Zeit im RFC1123-Format ist: ", curTime. Format (Zeit. RFC1123))
fmt. Println("Aktuelle Zeit im RFC1123Z-Format ist: ", curTime. Format (Zeit. RFC1123Z))
fmt. Println("Aktuelle Zeit im RFC822-Format ist: ", curTime. Format (Zeit. RFC822))
fmt. Println("Aktuelle Zeit im RFC822Z-Format ist: ", curTime. Format (Zeit. RFC822Z))
fmt. Println("Aktuelle Zeit im RFC850-Format ist: ", curTime. Format (Zeit. RFC850))
fmt. Println("Aktuelle Zeit im ANSIC-Format ist: ", curTime. Format (Zeit. ANSIC))
fmt. Println("Aktuelle Zeit im Unix-Format ist: ", curTime. Format (Zeit. UnixDatum))
// benutzerdefinierte Formatierungsstile
// TT-MM-JJJJ HH: MM: SS
fmt. Println("Aktuelle Zeit im benutzerdefinierten Format ist: ", curTime. Format("02-01-200615:04:05"))
// MM-TT-JJJJ HH: MM: SS
fmt. Println("Aktuelle Zeit im benutzerdefinierten Format ist: ", curTime. Format("01-02-200615:04:05"))
// JJJJ-MM-TT HH: MM: SS
fmt. Println("Aktuelle Zeit im benutzerdefinierten Format ist: ", curTime. Format("2006-01-0215:04:05"))
// DD / MM / JJJJ
fmt. Println("Aktuelle Zeit im benutzerdefinierten Format ist: ", curTime. Format("02.01.2006"))
// DD / MM / JJJJ
fmt. Println("Aktuelle Zeit im benutzerdefinierten Format ist: ", curTime. Format("02/01/2006"))
// 01.02.2006
fmt. Println("Aktuelle Zeit im benutzerdefinierten Format ist: ", curTime. Format("02 Jan 2006"))
// 1. Februar 2006 Montag
fmt. Println("Aktuelle Zeit im benutzerdefinierten Format ist: ", curTime. Format("02 Februar 2006 Montag"))
// 01. Februar 2006 Mo 15:04:05
fmt. Println("Aktuelle Zeit im benutzerdefinierten Format ist: ", curTime. Format("02 Februar 2006 Mo 15:04:05"))
}
Diese unterschiedlichen Formatierungsarten erzeugen die folgende Ausgabe:
Manipulieren von Uhrzeit und Datum in Go
Die Liste der Manipulationen, die Sie an Zeiten und Daten vornehmen können, ist nahezu endlos. Abhängig vom Umfang Ihrer Anwendung müssen Sie möglicherweise viele verschiedene Datums-/Uhrzeitoperationen ausführen.
Für jeden Anwendungsfall, den Sie möglicherweise haben, die Zeit Paket ist sehr funktional und hat viele eingebaute Methoden.
Sie können die Manipulation von Datum und Uhrzeit verwenden, um eine einfache Tagesplaner- oder Aufgabenplaner-App zu erstellen.