Go / golang time.Now (). UnixNano () convertir a milisegundos?

¿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.

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.Nanosecondresulta 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.Millisecondusan las mismas unidades (Nanosegundos). Siempre que eso sea cierto, la respuesta de OneOfOne debería funcionar perfectamente.

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:

1. Redondea correctamente el valor al milisegundo más cercano (compárese con la división de enteros: simplemente descarta la parte decimal del valor resultante);
2. No se sumerge en los aspectos específicos del tiempo Go. Coerción de duración: ya que utiliza una constante numérica que representa un divisor absoluto de milisegundos / nanosegundos.

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.