सवाल गोलांग में दिनांक / समय तुलना


गोलांग में डेट तुलना करने में कोई विकल्प है? मुझे तारीख और समय के आधार पर डेटा को सॉर्ट करना होगा - स्वतंत्र रूप से। इसलिए मैं ऐसी ऑब्जेक्ट की अनुमति दे सकता हूं जो तिथियों की एक श्रृंखला के भीतर तब तक हो जब तक कि यह कई बार के भीतर भी होता है। इस मॉडल में, मैं बस सबसे पुरानी तारीख, सबसे कम समय / नवीनतम तिथि, नवीनतम समय और यूनिक्स () सेकंड का चयन नहीं कर सकता था। मैं वास्तव में किसी भी सुझाव की सराहना करता हूं।

आखिरकार, मैंने एक समय पार्सिंग स्ट्रिंग मॉड्यूल मॉड्यूल लिखा है ताकि यह जांच सके कि कोई समय सीमा के भीतर है या नहीं। हालांकि, यह अच्छी तरह से नहीं बढ़ रहा है; मुझे कुछ अंतरंग मुद्दे हैं। मैं इसे सिर्फ मजेदार के लिए पोस्ट करूंगा, लेकिन मुझे आशा है कि समय की तुलना करने का एक बेहतर तरीका है।

package main

import (
    "strconv"
    "strings"
)

func tryIndex(arr []string, index int, def string) string {
    if index <= len(arr)-1 {
        return arr[index]
    }
    return def
}

/*
 * Takes two strings of format "hh:mm:ss" and compares them.
 * Takes a function to compare individual sections (split by ":").
 * Note: strings can actually be formatted like "h", "hh", "hh:m",
 * "hh:mm", etc. Any missing parts will be added lazily.
 */
func timeCompare(a, b string, compare func(int, int) (bool, bool)) bool {
    aArr := strings.Split(a, ":")
    bArr := strings.Split(b, ":")
    // Catches margins.
    if (b == a) {
        return true
    }
    for i := range aArr {
        aI, _ := strconv.Atoi(tryIndex(aArr, i, "00"))
        bI, _ := strconv.Atoi(tryIndex(bArr, i, "00"))
        res, flag := compare(aI, bI)
        if res {
            return true
        } else if flag { // Needed to catch case where a > b and a is the lower limit
            return false
        }
    }
    return false
}

func timeGreaterEqual(a, b int) (bool, bool) {return a > b, a < b}
func timeLesserEqual(a, b int) (bool, bool) {return a < b, a > b}

/*
 * Returns true for two strings formmated "hh:mm:ss".
 * Note: strings can actually be formatted like "h", "hh", "hh:m",
 * "hh:mm", etc. Any missing parts will be added lazily.
 */
func withinTime(timeRange, time string) bool {
    rArr := strings.Split(timeRange, "-")
    if timeCompare(rArr[0], rArr[1], timeLesserEqual) {
        afterStart := timeCompare(rArr[0], time, timeLesserEqual)
        beforeEnd := timeCompare(rArr[1], time, timeGreaterEqual)
        return afterStart && beforeEnd
    }
    // Catch things like `timeRange := "22:00:00-04:59:59"` which will happen
    // with UTC conversions from local time.
    // THIS IS THE BROKEN PART I BELIEVE
    afterStart := timeCompare(rArr[0], time, timeLesserEqual)
    beforeEnd := timeCompare(rArr[1], time, timeGreaterEqual)
    return afterStart || beforeEnd
}

तो टीएलडीआर, मैंने एक भीतर टाइमरेंज (रेंज, टाइम) फ़ंक्शन लिखा लेकिन यह पूरी तरह से सही ढंग से काम नहीं कर रहा है। (वास्तव में, ज्यादातर दूसरे मामले में, जहां समय सीमा पार हो जाती है, दिन टूट जाता है। मूल भाग काम करता है, मुझे अभी एहसास हुआ कि स्थानीय लोगों से यूटीसी में रूपांतरण करते समय मुझे इसके लिए खाते की आवश्यकता होगी।)

यदि कोई बेहतर (अधिमानतः निर्मित) तरीका है, तो मुझे इसके बारे में सुनना अच्छा लगेगा!

ध्यान दें: उदाहरण के तौर पर, मैंने इस समस्या के साथ जावास्क्रिप्ट में इस मुद्दे को हल किया:

function withinTime(start, end, time) {
    var s = Date.parse("01/01/2011 "+start);
    var e = Date.parse("01/0"+(end=="24:00:00"?"2":"1")+"/2011 "+(end=="24:00:00"?"00:00:00":end));
    var t = Date.parse("01/01/2011 "+time);
    return s <= t && e >= t;
}

हालांकि मैं वास्तव में यह फ़िल्टर सर्वर-पक्ष करना चाहता हूं।


51
2018-01-04 17:35


मूल


मुझे विश्वास नहीं है कि आप इतनी परेशानी से गुजर चुके हैं और एक बार ऐसा नहीं सोचा था कि ऐसा लगता है कि यह एसडीटीएलआईबी में होना चाहिए। - Kugel


जवाब:


उपयोग पहर जाओ में समय की जानकारी के साथ काम करने के लिए पैकेज।

प्ले उदाहरण:

package main

import (
    "fmt"
    "time"
)

func inTimeSpan(start, end, check time.Time) bool {
    return check.After(start) && check.Before(end)
}

func main() {
    start, _ := time.Parse(time.RFC822, "01 Jan 15 10:00 UTC")
    end, _ := time.Parse(time.RFC822, "01 Jan 16 10:00 UTC")

    in, _ := time.Parse(time.RFC822, "01 Jan 15 20:00 UTC")
    out, _ := time.Parse(time.RFC822, "01 Jan 17 10:00 UTC")

    if inTimeSpan(start, end, in) {
        fmt.Println(in, "is between", start, "and", end, ".")
    }

    if !inTimeSpan(start, end, out) {
        fmt.Println(out, "is not between", start, "and", end, ".")
    }
}

56
2018-01-04 17:52



शायद मैं पढ़ नहीं सकता, लेकिन मुझे समय तुलना के बारे में कुछ भी नहीं मिला। यदि यह वहां है, तो क्या आप मुझे एक सटीक लेख पर इंगित कर सकते हैं? - eatonphil
प्रयत्न godoc.org/time#Time.Equal या godoc.org/time#Time.After सरल तुलना के लिए, या godoc.org/time#Time.Sub दो बार के बीच अंतर जानने के लिए। - andybalholm
हाँ, यह काम करता है। मैं पूरी तरह से गलत पढ़ता हूं। धन्यवाद! - eatonphil


के लिये दो बार के बीच तुलना उपयोग time.Sub ()

// utc life
loc, _ := time.LoadLocation("UTC")

// setup a start and end time
createdAt := time.Now().In(loc).Add(1 * time.Hour)
expiresAt := time.Now().In(loc).Add(4 * time.Hour)

// get the diff
diff := expiresAt.Sub(createdAt)
fmt.Printf("Lifespan is %+v", diff)

कार्यक्रम आउटपुट:

Lifespan is 3h0m0s

http://play.golang.org/p/bbxeTtd4L6


15
2017-12-05 02:25





यदि आपके अंतराल के अंत में इसकी तारीखें बिना किसी घंटे के हैं "2017-01-01 से 2017-01-16 के पूरे दिन" अंतराल को 23 घंटे 59 मिनट और 59 सेकंड में समायोजित करना बेहतर है:

end = end.Add(time.Duration(23*time.Hour) + time.Duration(59*time.Minute) + time.Duration(59*time.Second)) 

if now.After(start) && now.Before(end) {
    ...
}

5
2018-01-16 04:30





हालिया प्रोटोकॉल प्रति आरएफसी 3339 का उपयोग पसंद करते हैं गोलांग समय पैकेज दस्तावेज

सामान्य रूप से RFC1123Z का उपयोग उन सर्वरों के लिए आरएफसी 1123 के बजाय किया जाना चाहिए जो उस प्रारूप पर जोर देते हैं, और आरएफसी 3339 को नए प्रोटोकॉल के लिए प्राथमिकता दी जानी चाहिए। आरएफसी 822, आरएफसी 822Z, आरएफसी 1123, और आरएफसी1123Z स्वरूपण के लिए उपयोगी हैं; जब समय के साथ उपयोग किया जाता है। पर्स वे आरएफसी द्वारा अनुमत सभी समय प्रारूपों को स्वीकार नहीं करते हैं।

cutOffTime, _ := time.Parse(time.RFC3339, "2017-08-30T13:35:00Z")
// POSTDATE is a date time field in DB (datastore)
query := datastore.NewQuery("db").Filter("POSTDATE >=", cutOffTime).

0
2017-08-30 08:18





निम्नलिखित ने स्ट्रिंग को आज तक परिवर्तित करने की मेरी समस्या का हल किया

पैकेज मुख्य

import (
    "fmt"
    "time"
)

func main() {
    value  := "Thu, 05/19/11, 10:47PM"
    // Writing down the way the standard time would look like formatted our way
    layout := "Mon, 01/02/06, 03:04PM"
    t, _ := time.Parse(layout, value)
    fmt.Println(t)
}

// => "Thu May 19 22:47:00 +0000 2011"

पॉल अदम स्मिथ के लिए धन्यवाद


-1
2018-05-07 09:10



यह सब अच्छा है लेकिन सवाल के साथ बहुत कुछ नहीं है, क्या यह है? - matthias krull
आप सही @matthiaskrull हैं। यह तिथियों की तुलना करने के सवाल का जवाब नहीं देता है, लेकिन आसानी से पार्सिंग तिथियों में आंशिक रूप से मदद करता है। - suryakrupa
ऐसा इस और कुछ अन्य। मैं बस इतना कह रहा हूं कि टिप्पणियों में कुछ जोड़ने से बेहतर फिट होगा जो यादृच्छिक उपयोगी बिट्स के साथ जवाब दे। - matthias krull