Go / golang time.Now (). UnixNano () chuyển đổi sang mili giây?

Tôi làm cách nào để có được thời gian Unix trong Go tính bằng mili giây?

Tôi có chức năng sau:

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

Tôi cần ít độ chính xác hơn và chỉ muốn mili giây.

Chỉ cần chia nó:

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

Đây là một ví dụ mà bạn có thể biên dịch và chạy để xem đầu ra

package main

import (
    "time"
    "fmt"
)

func main() {
    a := makeTimestamp()

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

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

Như @Jono đã chỉ ra trong câu trả lời của @ OneOfOne, câu trả lời đúng phải tính đến thời lượng một nano giây. Ví dụ:

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

Câu trả lời của OneOfOne hoạt động vì time.Nanosecondxảy ra 1và chia cho 1 không có hiệu lực. Tôi không biết đủ về go để biết khả năng điều này sẽ thay đổi như thế nào trong tương lai, nhưng để có câu trả lời chính xác, tôi sẽ sử dụng chức năng này, không phải câu trả lời của OneOfOne. Tôi nghi ngờ có bất kỳ nhược điểm nào về hiệu suất vì trình biên dịch sẽ có thể tối ưu hóa điều này một cách hoàn hảo.

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

Một cách khác để xem xét điều này là cả hai time.Now().UnixNano()và time.Millisecondsử dụng cùng một đơn vị (Nanoseconds). Miễn là điều đó đúng, câu trả lời của OneOfOne sẽ hoạt động hoàn toàn tốt.

Giữ nó đơn giản.

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

Tôi nghĩ tốt hơn nên làm tròn thời gian đến mili giây trước khi phân chia.

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

Đây là một chương trình ví dụ:

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())
}

Chương trình trên đã in kết quả dưới đây trên máy của tôi:

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

Giải pháp đọc đơn giản nhưng chính xác sẽ là:

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

Chức năng này:

1. Làm tròn chính xác giá trị đến mili giây gần nhất (so sánh với phép chia số nguyên: nó chỉ loại bỏ phần thập phân của giá trị kết quả);
2. Không đi sâu vào các chi tiết cụ thể của Go về thời gian. Cưỡng chế bão hòa - vì nó sử dụng một hằng số đại diện cho bộ chia mili giây / nano giây tuyệt đối.

PS Tôi đã chạy các điểm chuẩn với các bộ chia liên tục và tổng hợp, chúng hầu như không có sự khác biệt, vì vậy hãy thoải mái sử dụng giải pháp dễ đọc hơn hoặc nghiêm ngặt hơn về ngôn ngữ.