Wie man Zeit nutzt.Funktionieren Sie nun in Golang - Beispiele

Go-Programmiersprache bietet mehrere integrierte Funktionen, um die Zeit zu bewältigen, und zu diesen Funktionen, die Zeit.Jetzt() ist der weit verbreitete verwendete. Sie können die aktuelle lokale Zeit in Ihrer Systemzeitzone abrufen. Die Funktion gibt a zurück Zeit Struktur, der das aktuelle Datum und die aktuelle Uhrzeit umfasst. Danach können Sie mehrere Vorgänge auf der Struktur ausführen, um Ihre gewünschte Ausgabe zu erhalten.

Folgen Sie diesem Tutorial, um die Verwendung von zu lernen Zeit.Jetzt() Funktionen Sie mit einigen grundlegenden Beispielen für ein besseres Verständnis.

Wie man Zeit nutzt.Jetzt () Funktion in Golang - Beispiele

Bevor Sie sich zur Verwendung der benutzen Zeit.Jetzt() Funktion in der Go -Programmierung müssen Sie die grundlegende Syntax für diese Funktion lernen, die unten angegeben ist:

func jetzt () Zeit

Der Zeit.Jetzt() Funktion nimmt keine Argumente und gibt die aktuelle lokale Zeit als Zeit Wert. Sie können diesen Wert verwenden, um eine Vielzahl von zeitbezogenen Operationen in Ihrem Code auszuführen, z. B. die Formatierung der Zeit oder die Berechnung der Zeit zwischen zwei Ereignissen.

Notiz: Der Zeit.Jetzt() Vergewöhnt sich auf die Systemuhr des Computers, das Ihren Code ausführt, sodass Sie sicherstellen müssen, dass die Systemuhr korrekt eingestellt ist, um genaue Zeitmessungen zu erhalten.

Schritt -für -Schritt -Implementierung der Zeit.Jetzt () Funktion in Golang

Hier finden Sie eine Schritt-für-Schritt-Implementierung Zeit.Jetzt() Funktion in Go:

Schritt 1: Importieren Sie zuerst das Zeitpaket, bevor Sie die Hauptfunktion starten.

Schritt 2: Dann ruf die Zeit.Jetzt() Funktion innerhalb der Hauptfunktion und speichert den aktuellen Zeitwert in einer Variablen.

Schritt 3: Drucken Sie dann den variablen Wert aus, um die gewünschte Zeit zu erhalten.

Der unten geschriebene Beispielcode zeigt die Arbeit von Zeit.Jetzt() Funktion in Go:

Paket Main
importieren "fmt"
"Zeit" importieren "
func main ()
Zeit: = Zeit.Jetzt()
fmt.Printf ("Die aktuelle Zeit ist: %s", Zeit)

Im obigen Code haben wir die verwendet Zeit.Jetzt() Funktionieren Sie das aktuelle Datum und die aktuelle Uhrzeit und speichern Sie ihn dann in der Zeitvariablen. Als nächstes haben wir die benutzt fmt.Printf () Funktionieren Sie, um die Zeitvariable in die Konsole zu drucken.

Ausgang

Der Zeit.Jetzt() Gibt den Wert der Zeit in der lokalen Zeitzone zurück; Hier gibt es die Zeit in UTC zurück, da die aktuelle Zeitzone meines Servers UTC ist. In der obigen Ausgabe sehen Sie auch den M = -Wert, der eine monotonische Uhr ist, mit der die Unterschiede in der Zeit gemessen werden können, um Änderungen in Datum und Uhrzeit des Geräts zu überprüfen.

Sie können der aktuellen Zeit in Go auch eine Dauer hinzufügen Zeit.Jetzt() Funktion und der Code für ein solches Szenario sind unten angegeben:

Paket Main
importieren "fmt"
"Zeit" importieren "
func main ()
Jetzt: = Zeit.Jetzt()
Zukunft: = jetzt.Add (24 * Zeit.Stunde)
fmt.Println ("zukünftige Zeit:", Zukunft)

Der obige Code ruft die aktuelle Zeit mit dem ab Zeit.Jetzt() Funktion und fügt ihm dann 24 Stunden mit dem hinzu Add () Methode des Zeit Typ. Danach druckt es die endgültige Ausgabe in die Konsole über die fmt.Println () Funktion.

Ausgang

Sie können auch die verwenden Zeit.Jetzt() Funktionieren Sie, um das laufende Jahr, Monat, Tag, Stunden, Minuten und Sekunden separat zu identifizieren.

Der folgende Code wird für das vorherige Szenario verwendet.

Paket Main
importieren (
"fmt"
"Zeit"
)
func main ()
Zeit: = Zeit.Jetzt()
fmt.Println ("Aktuelle Zeit ist:", Zeit)
fmt.Println ("Jahr ist:", Zeit.Jahr())
fmt.Println ("Monat ist:", Zeit.Monat())
fmt.Println ("Tag ist:", Zeit.Tag())
fmt.Println ("Stunde ist:", Zeit.Stunde())
fmt.Println ("Minute ist:", Zeit.Stunde())
fmt.Println ("Sekunde ist:", Zeit.Zweite())

Das obige Programm extrahiert und druckt das laufende Jahr, Monat, Tag, Stunde, Minute und zweite, indem Sie die relevanten Funktionen für das von zurückgegebene Zeitobjekt aufrufen Zeit.Jetzt() Funktion.

Ausgang

Endeffekt

Die zeitbezogenen Operationen sind in den meisten Programmiersprachen von wesentlicher Bedeutung, und Golang ist keine Ausnahme. Der Zeit.Jetzt() Funktion ist eine leistungsstarke integrierte Funktion, mit der die aktuelle lokale Zeit abgerufen und eine Vielzahl von zeitbezogenen Operationen in GO durchgeführt werden kann. Durch die Schritt-für-Schritt-Implementierung, die in diesem Handbuch bereitgestellt wird, können Sie diese Funktion problemlos verwenden, um die aktuelle Zeit abzurufen oder die Dauer der Dauer hinzuzufügen oder bestimmte Zeitkomponenten zu extrahieren.