समय.समय पर यूनिक्स टाइमस्टैम्प को पार्स कैसे करें

Question

मैं एक यूनिक्स टाइमस्टैम्प पार्स करने की कोशिश कर रहा हूं, लेकिन मैं सीमा त्रुटि से बाहर निकलता हूं। यह वास्तव में मेरे लिए मायने नहीं रखता है, क्योंकि लेआउट सही है (जैसा कि गो डॉक्स में):

package main

import "fmt"
import "time"

func main() {
    tm, err := time.Parse("1136239445", "1405544146")
    if err != nil{
        panic(err)
    }

    fmt.Println(tm)
}

खेल का मैदान

Answer 1

time.Parseसमारोह यूनिक्स टाइमस्टैम्प नहीं करता है। इसके बजाय आप strconv.ParseIntस्ट्रिंग को पार्स करने int64और टाइमस्टैम्प को बनाने के लिए उपयोग कर सकते हैं time.Unix:

package main

import (
    "fmt"
    "time"
    "strconv"
)

func main() {
    i, err := strconv.ParseInt("1405544146", 10, 64)
    if err != nil {
        panic(err)
    }
    tm := time.Unix(i, 0)
    fmt.Println(tm)
}

आउटपुट:

2014-07-16 20:55:46 +0000 UTC

खेल का मैदान: http://play.golang.org/p/v_j6UIro7a

संपादित करें:

32 बिट सिस्टम पर int overflows से बचने के strconv.Atoiलिए परिवर्तित strconv.ParseInt।

Comments

किसी भी विचार क्यों डॉक्स में ऐसा कोई संदर्भ नहीं है? वे यूनिक्स टाइमस्टैप लेआउट को भी एक उदाहरण के रूप में देते हैं।

— अरे

मुझे लगता है कि यह एक यूनिक्स टाइमस्टैम्प को पार्सिंग की आवश्यकता नहीं है क्योंकि यह पाठ प्रतिनिधित्व नहीं है, बल्कि समय का पूर्णांक प्रतिनिधित्व है। आपने अभी पूर्णांक मान का एक स्ट्रिंग प्रतिनिधित्व किया है। और डॉक्स में 1136239445 का उल्लेख शायद यह स्पष्ट करने के लिए है कि संदर्भ समय के रूप में क्या सटीक टाइमस्टैम्प का उपयोग किया जाना है, न कि इसका उपयोग लेआउट के रूप में किया जाना है।

— एनिसस

strconv.ParseUintइसके बजाय इसका उपयोग करना बेहतर नहीं होगा क्योंकि नकारात्मक संख्याओं का वैसे भी कोई मतलब नहीं है?

— Atmocreations

@Atmocreations: मूल्यों func Unix(sec int64, nsec int64) Timeको प्राप्त करता int64है। इसके अलावा, सेकंड के लिए नकारात्मक संख्या सही अर्थ बनाती है - वे 1970 से पहले की तारीखों का वर्णन करते हैं! :) के रूप में nsec, नकारात्मक मूल्यों का मतलब है कि सेकंड से कई नैनोसेकंड हटा दें।

— एनिसस

मैं केवल दिनांक और समय "2014-07-16 20:55:46" के रूप में चाहता हूं कि इसे कैसे प्राप्त किया जा सकता है?

— कार्तिक

Answer 2

आप सीधे समय का उपयोग कर सकते हैं। समय का यूनिक्स फ़ंक्शन जो यूटीसी के लिए यूनिक्स समय की मुहर को परिवर्तित करता है

package main

import (
  "fmt"
  "time"
)


func main() {
    unixTimeUTC:=time.Unix(1405544146, 0) //gives unix time stamp in utc 

    unitTimeInRFC3339 :=unixTimeUTC.Format(time.RFC3339) // converts utc time to RFC3339 format

    fmt.Println("unix time stamp in UTC :--->",unixTimeUTC)
    fmt.Println("unix time stamp in unitTimeInRFC3339 format :->",unitTimeInRFC3339)
}

उत्पादन

unix time stamp in UTC :---> 2014-07-16 20:55:46 +0000 UTC
unix time stamp in unitTimeInRFC3339 format :----> 2014-07-16T20:55:46Z

गो प्लेग्राउंड में चेक करें: https://play.golang.org/p/5FtRdnkxAd

Answer 3

कुछ कार्य जो मैंने तिथियों के लिए किए हैं, उन्हें साझा करना:

कृपया ध्यान दें कि मैं एक विशेष स्थान (केवल यूटीसी समय नहीं) के लिए समय निकालना चाहता था। यदि आप UTC समय चाहते हैं, तो बस लोक चर और .In (लोकल) फंक्शन कॉल को हटा दें।

func GetTimeStamp() string {
     loc, _ := time.LoadLocation("America/Los_Angeles")
     t := time.Now().In(loc)
     return t.Format("20060102150405")
}
func GetTodaysDate() string {
    loc, _ := time.LoadLocation("America/Los_Angeles")
    current_time := time.Now().In(loc)
    return current_time.Format("2006-01-02")
}

func GetTodaysDateTime() string {
    loc, _ := time.LoadLocation("America/Los_Angeles")
    current_time := time.Now().In(loc)
    return current_time.Format("2006-01-02 15:04:05")
}

func GetTodaysDateTimeFormatted() string {
    loc, _ := time.LoadLocation("America/Los_Angeles")
    current_time := time.Now().In(loc)
    return current_time.Format("Jan 2, 2006 at 3:04 PM")
}

func GetTimeStampFromDate(dtformat string) string {
    form := "Jan 2, 2006 at 3:04 PM"
    t2, _ := time.Parse(form, dtformat)
    return t2.Format("20060102150405")
}

Comments

निकालने .In(loc)से मुझे समय मिला -0400 EDT। इसे बदलकर .In(time.UTC)मुझे यूटीसी में समय दिया।

— नाटोबोरम

Answer 4

गो डॉक्यूमेंट के अनुसार , यूनिक्स एक स्थानीय समय लौटाता है।

यूनिक्स दिए गए यूनिक्स समय के अनुसार स्थानीय समय देता है

इसका मतलब यह है कि आउटपुट आपके कोड पर चलने वाली मशीन पर निर्भर करेगा, जो कि, सबसे अधिक बार वही होता है, जिसकी आपको आवश्यकता होती है, लेकिन कभी-कभी, आप UTC में मान रखना चाह सकते हैं।

ऐसा करने के लिए, मैंने स्निपेट को यूटीसी में एक बार वापस करने के लिए अनुकूलित किया :

i, err := strconv.ParseInt("1405544146", 10, 64)
if err != nil {
    panic(err)
}
tm := time.Unix(i, 0)
fmt.Println(tm.UTC())

यह मेरी मशीन पर प्रिंट करता है (CEST में)

2014-07-16 20:55:46 +0000 UTC

Answer 5

मैं बहुत से लॉगिंग करता हूं, जहां टाइमस्टैम्प फ़्लैट 64 हैं और टाइमस्टैम्प को स्ट्रिंग के रूप में प्राप्त करने के लिए इस फ़ंक्शन का उपयोग करते हैं:

func dateFormat(layout string, d float64) string{
    intTime := int64(d)
    t := time.Unix(intTime, 0)
    if layout == "" {
        layout = "2006-01-02 15:04:05"
    }
    return t.Format(layout)
}

Answer 6

बस समय का उपयोग करें

उदाहरण:

package main

import (
    "fmt"
    "time"
)

func main() {
    fromString := "Wed, 6 Sep 2017 10:43:01 +0300"
    t, e := time.Parse("Mon, _2 Jan 2006 15:04:05 -0700", fromString)
    if e != nil {
        fmt.Printf("err: %s\n", e)
    }
    fmt.Printf("UTC time: %v\n", t.UTC())
}

काम का उदाहरण play.golang.org पर ।

Comments

प्रश्न यूनिक्स टाइमस्टैम्प को निर्दिष्ट करता है। यह उत्तर उस पहलू को संबोधित नहीं करता है।

— t3h2mas