Как я могу узнать время Unix в Go в миллисекундах?
У меня есть такая функция:
func makeTimestamp() int64 {
return time.Now().UnixNano() % 1e6 / 1e3
}
Мне нужно меньше точности и нужны только миллисекунды.
Ответы:
Просто разделите это:
func makeTimestamp() int64 {
return time.Now().UnixNano() / int64(time.Millisecond)
}
Вот пример, который вы можете скомпилировать и запустить, чтобы увидеть результат
package main
import (
"time"
"fmt"
)
func main() {
a := makeTimestamp()
fmt.Printf("%d \n", a)
}
func makeTimestamp() int64 {
return time.Now().UnixNano() / int64(time.Millisecond)
}
Как указывает @Jono в ответе @ OneOfOne, правильный ответ должен учитывать продолжительность наносекунды. Например:
func makeTimestamp() int64 {
return time.Now().UnixNano() / (int64(time.Millisecond)/int64(time.Nanosecond))
}
Ответ OneOfOne работает, потому time.Nanosecond
что он1
, и деление на 1 не имеет никакого эффекта. Я не знаю достаточно, чтобы узнать, насколько вероятно это изменится в будущем, но для строго правильного ответа я бы использовал эту функцию, а не ответ OneOfOne. Я сомневаюсь, что есть какие-либо недостатки в производительности, поскольку компилятор должен уметь оптимизировать это идеально.
См. Https://en.wikipedia.org/wiki/Dimensional_analysis.
Другой способ взглянуть на это - использовать одни time.Now().UnixNano()
и time.Millisecond
те же единицы измерения (наносекунды). Если это правда, ответ OneOfOne должен работать отлично.
.UnixNano()
воли всегда будет время в наносекундах, time.Millisecond
будет всегда иметь значение для хорошо, как вы уже догадались, миллисекунды, так что даже если по какой - то идиотской причине постоянного изменения значения, разделив UnixNano на миллисекунде будет всегда возвращать значение в миллисекундах.
(int64(time.Now().UnixNano() / int64(time.Nanosecond))/int64(time.Millisecond)
? Анализ размеров ns/(ms/ns)
возвращается ns^2/ms
. Ваш ответ также работает, потому что time.Nanosecond=1
, но агрегаты выключены ...
Будь проще.
func NowAsUnixMilli() int64 {
return time.Now().UnixNano() / 1e6
}
Думаю, перед делением лучше округлить время до миллисекунд.
func makeTimestamp() int64 {
return time.Now().Round(time.Millisecond).UnixNano() / (int64(time.Millisecond)/int64(time.Nanosecond))
}
Вот пример программы:
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())
}
Вышеупомянутая программа распечатала на моей машине результат ниже:
123
124
1472313624305
2016-08-28 01:00:24.305 +0900 JST
Простое, но точное решение:
func nowAsUnixMilliseconds(){
return time.Now().Round(time.Millisecond).UnixNano() / 1e6
}
Эта функция:
PS Я проводил тесты с постоянными и составными делителями, они почти не показали разницы, поэтому не стесняйтесь использовать более читаемое или более строгое языковое решение.
time.Now().UnixNano() * (time.Nanosecond / time.Millisecond)
. Однако лучше всего изменить порядок из-за целочисленного деления:time.Nanosecond * time.Now().UnixNano() / time.Millisecond