Go / golang time.Now (). UnixNano () in Millisekunden konvertieren?

Wie kann ich Unix-Zeit in Go in Millisekunden erhalten?

Ich habe folgende Funktion:

func makeTimestamp() int64 {
    return time.Now().UnixNano() % 1e6 / 1e3
}

Ich brauche weniger Präzision und möchte nur Millisekunden.

Teilen Sie es einfach:

func makeTimestamp() int64 {
    return time.Now().UnixNano() / int64(time.Millisecond)
}

Hier ist ein Beispiel, das Sie kompilieren und ausführen können, um die Ausgabe anzuzeigen

package main

import (
    "time"
    "fmt"
)

func main() {
    a := makeTimestamp()

    fmt.Printf("%d \n", a)
}

func makeTimestamp() int64 {
    return time.Now().UnixNano() / int64(time.Millisecond)
}

Wie @Jono in der Antwort von @ OneOfOne ausführt, sollte die richtige Antwort die Dauer einer Nanosekunde berücksichtigen. Z.B:

func makeTimestamp() int64 {
    return time.Now().UnixNano() / (int64(time.Millisecond)/int64(time.Nanosecond))
}

Die Antwort von OneOfOne funktioniert, weil time.Nanoseconddies der Fall 1ist und das Teilen durch 1 keine Auswirkung hat. Ich weiß nicht genug darüber, wie wahrscheinlich es ist, dass sich dies in Zukunft ändert, aber für die streng korrekte Antwort würde ich diese Funktion verwenden, nicht die Antwort von OneOfOne. Ich bezweifle, dass es einen Leistungsnachteil gibt, da der Compiler dies perfekt optimieren sollte.

Siehe https://en.wikipedia.org/wiki/Dimensional_analysis

Eine andere Sichtweise ist, dass beide time.Now().UnixNano()und time.Milliseconddieselben Einheiten (Nanosekunden) verwenden. Solange dies zutrifft, sollte die Antwort von OneOfOne einwandfrei funktionieren.

Halte es einfach.

func NowAsUnixMilli() int64 {
    return time.Now().UnixNano() / 1e6
}

Ich denke, es ist besser, die Zeit auf Millisekunden vor der Teilung zu runden.

func makeTimestamp() int64 {
    return time.Now().Round(time.Millisecond).UnixNano() / (int64(time.Millisecond)/int64(time.Nanosecond))
}

Hier ist ein Beispielprogramm:

package main

import (
        "fmt"
        "time"
)

func main() {
        fmt.Println(unixMilli(time.Unix(0, 123400000)))
        fmt.Println(unixMilli(time.Unix(0, 123500000)))
        m := makeTimestampMilli()
        fmt.Println(m)
        fmt.Println(time.Unix(m/1e3, (m%1e3)*int64(time.Millisecond)/int64(time.Nanosecond)))
}

func unixMilli(t time.Time) int64 {
        return t.Round(time.Millisecond).UnixNano() / (int64(time.Millisecond) / int64(time.Nanosecond))
}

func makeTimestampMilli() int64 {
        return unixMilli(time.Now())
}

Das obige Programm hat das folgende Ergebnis auf meinem Computer gedruckt:

123
124
1472313624305
2016-08-28 01:00:24.305 +0900 JST

Einfach zu lesende, aber präzise Lösung wäre:

func nowAsUnixMilliseconds(){
    return time.Now().Round(time.Millisecond).UnixNano() / 1e6
}

Diese Funktion:

1. Rundet den Wert korrekt auf die nächste Millisekunde (vergleiche mit der Ganzzahldivision: Es wird nur der Dezimalteil des resultierenden Werts verworfen).
2. Taucht nicht in Go-Besonderheiten der Zeit ein. Durationszwang - da eine numerische Konstante verwendet wird, die den absoluten Millisekunden / Nanosekunden-Teiler darstellt.

PS Ich habe Benchmarks mit konstanten und zusammengesetzten Teilern durchgeführt. Sie zeigten fast keinen Unterschied. Sie können also eine besser lesbare oder sprachlich strengere Lösung verwenden.