¿Cómo puedo obtener la hora Unix en Go en milisegundos?
Tengo la siguiente función:
func makeTimestamp() int64 {
return time.Now().UnixNano() % 1e6 / 1e3
}
Necesito menos precisión y solo quiero milisegundos.
Respuestas:
Solo divídelo:
func makeTimestamp() int64 {
return time.Now().UnixNano() / int64(time.Millisecond)
}
Aquí hay un ejemplo que puede compilar y ejecutar para ver el resultado
package main
import (
"time"
"fmt"
)
func main() {
a := makeTimestamp()
fmt.Printf("%d \n", a)
}
func makeTimestamp() int64 {
return time.Now().UnixNano() / int64(time.Millisecond)
}
Como señala @Jono en la respuesta de @ OneOfOne, la respuesta correcta debe tener en cuenta la duración de un nanosegundo. P.ej:
func makeTimestamp() int64 {
return time.Now().UnixNano() / (int64(time.Millisecond)/int64(time.Nanosecond))
}
La respuesta de OneOfOne funciona porque time.Nanosecond
resulta ser 1
, y dividir por 1 no tiene ningún efecto. No sé lo suficiente sobre ir para saber qué probabilidades hay de que esto cambie en el futuro, pero para la respuesta estrictamente correcta, usaría esta función, no la respuesta de OneOfOne. Dudo que haya alguna desventaja en el rendimiento, ya que el compilador debería poder optimizar esto perfectamente.
Ver https://en.wikipedia.org/wiki/Dimensional_analysis
Otra forma de ver esto es que ambos time.Now().UnixNano()
y time.Millisecond
usan las mismas unidades (Nanosegundos). Siempre que eso sea cierto, la respuesta de OneOfOne debería funcionar perfectamente.
.UnixNano()
voluntad siempre sea el tiempo en nanosegundos, time.Millisecond
será siempre el valor de bien, lo has adivinado, una milésima de segundo, por lo que incluso si por cualquier razón estúpida la constante cambia de valor, dividiendo UnixNano por milisegundo será siempre devolver el valor en milisegundos.
(int64(time.Now().UnixNano() / int64(time.Nanosecond))/int64(time.Millisecond)
? ns/(ms/ns)
Vuelve el análisis dimensional ns^2/ms
. Tu respuesta también funciona porque time.Nanosecond=1
, pero las unidades están apagadas ...
Mantenlo simple.
func NowAsUnixMilli() int64 {
return time.Now().UnixNano() / 1e6
}
Creo que es mejor redondear el tiempo a milisegundos antes de la división.
func makeTimestamp() int64 {
return time.Now().Round(time.Millisecond).UnixNano() / (int64(time.Millisecond)/int64(time.Nanosecond))
}
Aquí hay un programa de ejemplo:
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())
}
El programa anterior imprimió el resultado a continuación en mi máquina:
123
124
1472313624305
2016-08-28 01:00:24.305 +0900 JST
La solución de lectura simple pero precisa sería:
func nowAsUnixMilliseconds(){
return time.Now().Round(time.Millisecond).UnixNano() / 1e6
}
Esta función:
PD: He ejecutado pruebas de rendimiento con divisores constantes y compuestos, casi no mostraron diferencias, así que siéntase libre de usar una solución más legible o más estricta en el lenguaje.
time.Now().UnixNano() * (time.Nanosecond / time.Millisecond)
. Sin embargo, es mejor cambiar el orden debido a la división de enteros:time.Nanosecond * time.Now().UnixNano() / time.Millisecond