गो / गोलंग समय ।अब ()। यूनिक्सनानो () मिलीसेकंड में परिवर्तित हो जाते हैं?

Question

मुझे मिलीसेकंड में गो में यूनिक्स समय कैसे मिल सकता है?

मेरा निम्नलिखित कार्य है:

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

मुझे कम सटीकता की आवश्यकता है और केवल मिलीसेकंड चाहिए।

Answer 1

बस इसे विभाजित करें:

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

Comments

उपरोक्त गणना वास्तव में कोई मतलब नहीं है। आप मिलिसेकंड द्वारा नैनोसेकंड को विभाजित नहीं करते हैं। ऐसा होता है कि गोलैंग नैनोसेकंड के नीचे के समय का प्रतिनिधित्व करने के लिए धोखा देता है और निरंतर 'मिलिसकॉन्ड' 1,000,000 है। गणितीय रूप से, गणना होनी चाहिए time.Now().UnixNano() * (time.Nanosecond / time.Millisecond):। हालांकि पूर्णांक विभाजन के कारण ऑर्डर को बदलना सबसे अच्छा है:time.Nanosecond * time.Now().UnixNano() / time.Millisecond

— जोनो नोव

उसके लिए धन्यवाद। आप उस गारंटी पर भरोसा करने के लिए स्वागत करते हैं, लेकिन यह एक Y2K बग के प्रभाव में है। यह भविष्य में किसी बिंदु पर टूट सकता है। गलत गणितीय प्रतिनिधित्व क्यों चुनें?

— जोनो

वे मनमाना स्थिरांक हैं। वे भविष्य में बदल सकते हैं। समय पैकेज वर्तमान में नैनोसेकंड सटीक में "काम करता है", लेकिन यह एक मनमाना विकल्प है जो सेटिंग समय के लिए अग्रणी है। मीलिसेकंड = 1,000,000। ध्यान दें कि आपके द्वारा संदर्भित उसी फ़ाइल में भी, time.ilisecond 1000 * Microsecond पर सेट है, क्योंकि गणितीय रूप से यह कहा जा रहा है कि इसे क्या प्रतिनिधित्व करना चाहिए। मैं ऑफ़लाइन जा रहा हूँ - आशा है कि मेरी व्याख्या से मदद मिलती है

— जोनो

-1 यह सिर्फ गलत है। आपकी इकाइयां नहीं जुड़ती हैं। भौतिकी से आयामी विश्लेषण देखें। आपका परिणाम समय का प्रतिनिधित्व नहीं करता है।

— कुगेल

व्यस्त लोगों के लिए त्वरित उत्तर। को देखो https://gobyexample.com/epoch

— honzajde

Answer 2

जैसा कि @Jono @ OneOfOne के उत्तर में बताता है, सही उत्तर को नैनोसेकंड की अवधि को ध्यान में रखना चाहिए। जैसे:

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

OneOfOne का जवाब काम करता है क्योंकि time.Nanosecondऐसा होता है 1, और 1 से विभाजित होने का कोई प्रभाव नहीं पड़ता है। मैं यह जानने के लिए पर्याप्त नहीं हूं कि यह भविष्य में बदलने की कितनी संभावना है, लेकिन सख्ती से सही जवाब के लिए मैं इस फ़ंक्शन का उपयोग करूंगा, न कि वनऑफऑन के जवाब का। मुझे संदेह है कि कोई प्रदर्शन नुकसान है क्योंकि कंपाइलर को इसे पूरी तरह से अच्छी तरह से अनुकूलित करने में सक्षम होना चाहिए।

Https://en.wikipedia.org/wiki/Dimunning_analysis देखें

इस को देखने का एक और तरीका है कि दोनों है time.Now().UnixNano()और time.Millisecondएक ही इकाइयों (नैनोसेकंड) का उपयोग करें। जब तक यह सच है, OneOfOne का जवाब पूरी तरह से अच्छी तरह से काम करना चाहिए।

Comments

का मूल्य .UnixNano()इच्छा हमेशा नैनोसेकंड में समय हो, time.Millisecondहोगा हमेशा , मान हो के लिए अच्छी तरह से, आप इसे, एक millisecond अनुमान लगाया तो भी जो कुछ मूर्खतापूर्ण कारण निरंतर मूल्य बदलता है, मिलीसेकंड से UnixNano विभाजित होगा के लिए करता है, तो हमेशा मिलीसेकंड में मान।

— वनऑफऑन

यूनिक्स की इकाइयां। नैनो सवाल में नहीं है; न ही समय का मान है। क्या है प्रश्न में time.Millisecond की इकाई है। यह नैनोसेकंड में परिभाषित होने के लिए होता है, यही कारण है कि आपका उत्तर काम करता है। यदि समय.मिलिसकॉन्ड को अन्य इकाइयों (जैसे, माइक्रोसेकंड) में मापा गया था, तो आपके द्वारा दिया गया उत्तर काम नहीं करेगा।

— ब्योर्न रोश

@BjornRoche मुझे इस पार्टी में थोड़ी देर हो गई है, लेकिन सही जवाब नहीं होगा (int64(time.Now().UnixNano() / int64(time.Nanosecond))/int64(time.Millisecond)? आयामी विश्लेषण ns/(ms/ns)रिटर्न ns^2/ms। आपका उत्तर इसलिए भी काम करता है time.Nanosecond=1, लेकिन इकाइयाँ बंद हैं ...

— Puma

@thepuma कुछ समय हो गया है, इसलिए मैं आपको इस गलत या गलतफहमी में देख रहा हूं, लेकिन ns / (ms / ns) ns ^ 2 / ms के बराबर है, इसलिए दोनों उत्तर काम करने चाहिए।

— ब्योर्न रोश

यह उत्तर सही है क्योंकि इसे चलाने पर ऑनलाइन कन्वर्टर Unitconverters.net/prefixes/nano-to-milli.htm

— user666

Answer 3

इसे सरल रखें।

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

Answer 4

मुझे लगता है कि विभाजन से पहले मिलीसेकंड के समय को गोल करना बेहतर है।

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

Comments

आप यह उल्लेख करना भूल गए कि आपको लगता है कि मिलीसेकंड के समय को गोल करना बेहतर है।

— गुरपताप सिंह

Answer 5

सरल-सरल लेकिन सटीक समाधान होगा:

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

यह समारोह:

1. सही ढंग से निकटतम मिलीसेकंड के लिए मूल्य को गोल करता है (पूर्णांक विभाजन के साथ तुलना करें: यह केवल परिणामी मूल्य के दशमलव भाग को त्यागता है);
2. यह समय की गो-बारीकियों में गोता नहीं लगाता है। अवधि बल - यह एक संख्यात्मक स्थिरांक का उपयोग करता है जो पूर्ण मिलीसेकंड / नैनोसेकंड विभक्त का प्रतिनिधित्व करता है।

PS मैंने लगातार और समग्र डिवाइडर के साथ बेंचमार्क चलाया है, उन्होंने लगभग कोई अंतर नहीं दिखाया, इसलिए अधिक पठनीय या अधिक भाषा-सख्त समाधान का उपयोग करने के लिए स्वतंत्र महसूस करें।

Comments

यदि आप मिलीसेकंड (एपिक के बाद मिलीसेकंड) में सही यूनिक्स समय जानना चाहते हैं, तो आपको राउंड () का उपयोग नहीं करना चाहिए, क्योंकि यह आधे समय तक चलेगा, और आपके परिणाम में एक मिलीसेकंड शामिल होगा जो अभी तक पूरी तरह से समाप्त नहीं हुआ है।

— Torbenl

एक नोट के लिए धन्यवाद, @torbenl - यह अधिकांश प्रणालियों के लिए महत्वपूर्ण हो सकता है (मेरा एक बहिष्करण है, यह समय लाइव के लिए संग्रहीत है)।

— Liubov