Wie man Millisekunden in time.Time in Golang konvertiert

In Go (Golang) ist der Umgang mit Zeit in Millisekunden eine häufige Anforderung, insbesondere bei der Interaktion mit Systemen oder Daten, die die Zeit als Millisekunden seit der Unix-Epoche (1. Januar 1970) darstellen. Dieser Artikel bietet eine umfassende Anleitung zur Konvertierung von Millisekunden in Go's time.Time-Typ und umgekehrt, um Präzision und Benutzerfreundlichkeit bei Ihren Zeitmanipulationen zu gewährleisten.

Konvertieren von Millisekunden in time.Time

Um Millisekunden seit der Unix-Epoche in ein time.Time-Objekt in Go zu konvertieren, können Sie die Funktion time.Unix verwenden. Diese Funktion akzeptiert zwei Parameter: Sekunden und Nanosekunden. Da 1 Millisekunde 1.000.000 Nanosekunden entspricht, können Sie die Sekunden und die verbleibenden Nanosekunden aus dem Millisekundenwert berechnen.

So können Sie die Konvertierung durchführen:

package main

import (
    "fmt"
    "time"
)

func main() {
    // Millisekunden seit der Unix-Epoche
    millis := int64(1610000000000)

    // Konvertieren von Millisekunden in time.Time
    t := time.Unix(0, millis*int64(time.Millisecond))

    fmt.Println("Konvertierte Zeit:", t)
}

Erklärung

• millis*int64(time.Millisecond) konvertiert Millisekunden in Nanosekunden.
• time.Unix(0, nanoseconds) erstellt ein time.Time-Objekt, das den gegebenen Nanosekunden seit der Unix-Epoche entspricht. Ab Go-Version 1.17 führte die Standardbibliothek die Funktion time.UnixMilli ein, die diese Konvertierung vereinfacht:

t := time.UnixMilli(millis)

Diese Funktion gibt direkt ein time.Time-Objekt zurück, das den bereitgestellten Millisekunden seit der Unix-Epoche entspricht.

Konvertieren von time.Time in Millisekunden

Wenn Sie ein time.Time-Objekt haben und die Millisekunden seit der Unix-Epoche erhalten müssen, können Sie die Methode UnixMilli verwenden:

package main

import (
    "fmt"
    "time"
)

func main() {
    // Aktuelle Zeit
    t := time.Now()

    // Konvertieren von time.Time in Millisekunden seit der Unix-Epoche
    millis := t.UnixMilli()

    fmt.Println("Millisekunden seit der Epoche:", millis)
}

Umgang mit JSON mit Millisekunden

Wenn Sie mit JSON-Daten arbeiten, die Zeitstempel in Millisekunden enthalten, können Sie Ihre Struktur definieren, um die Millisekunden in ein int64-Feld zu entpacken und sie dann in time.Time zu konvertieren.

package main

import (
    "encoding/json"
    "fmt"
    "time"
)

type Event struct {
    Name      string `json:"name"`
    Timestamp int64  `json:"timestamp"`
}

func (e *Event) Time() time.Time {
    return time.UnixMilli(e.Timestamp)
}

func main() {
    data := []byte(`{"name": "Sample Event", "timestamp": 1610000000000}`)

    var event Event
    if err := json.Unmarshal(data, &event); err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Println("Event Name:", event.Name)
    fmt.Println("Event Time:", event.Time())
}

Schlussfolgerung

Das Konvertieren zwischen Millisekunden und time.Time in Go ist unkompliziert, insbesondere mit den Verbesserungen, die in Go 1.17 eingeführt wurden. Durch die Verwendung von Funktionen wie time.UnixMilli und Methoden wie UnixMilli können Sie Zeitkonvertierungen effizient und genau verarbeiten.

Für detailliertere Informationen können Sie die Go-Dokumentation zum time-Paket einsehen.

Wir sind Leapcell, Ihre erste Wahl für das Hosting von Go-Projekten.

Leapcell ist die Serverless-Plattform der nächsten Generation für Webhosting, asynchrone Aufgaben und Redis:

Multi-Sprachen-Unterstützung

• Entwickeln Sie mit Node.js, Python, Go oder Rust.

Stellen Sie unbegrenzt viele Projekte kostenlos bereit

• Zahlen Sie nur für die Nutzung – keine Anfragen, keine Gebühren.

Unschlagbare Kosteneffizienz

• Pay-as-you-go ohne Leerlaufgebühren.
• Beispiel: 25 US-Dollar unterstützen 6,94 Millionen Anfragen bei einer durchschnittlichen Antwortzeit von 60 ms.

Optimierte Entwicklererfahrung

• Intuitive Benutzeroberfläche für mühelose Einrichtung.
• Vollautomatische CI/CD-Pipelines und GitOps-Integration.
• Echtzeitmetriken und -protokollierung für verwertbare Erkenntnisse.

Mühelose Skalierbarkeit und hohe Leistung

• Automatische Skalierung zur einfachen Bewältigung hoher Parallelität.
• Null Betriebsaufwand – konzentrieren Sie sich einfach auf das Bauen.

Erfahren Sie mehr in der Dokumentation!

Folgen Sie uns auf X: @LeapcellHQ