गो भाषा में समय और तिथि के संचालन का अन्वेषण

1. समय और तिथि पैकेज का परिचय

Go भाषा में time पैकेज समय और तिथि का व्यवस्थापन करने के लिए एक शक्तिशाली लाइब्रेरी है। यह समय और तिथि से जुड़ी समस्याओं को हैंडल करने के लिए विशेषता से बनाया गया है। यह पैकेज समय प्राप्त करने, समय और तिथि को संशोधित करने, समय की तुलना करने, समय को पार्स और प्रारूपित करने, और अन्य कार्यों के लिए बहुत सुविधाजनक है।

2. समय प्रकार का विस्तृत विवरण

Go में, Time प्रकार एक क्षण, एक समय का बिंदु, को प्रस्तुत करता है। आप time.Now() फ़ंक्शन का उपयोग करके वर्तमान समय प्राप्त कर सकते हैं। यहां एक सरल उदाहरण है जो दिखाता है कि Time प्रकार के एक चर में घोषणा और प्रारंभ कैसे करें:

package main

import (
    "fmt"
    "time"
)

func main() {
    currentTime := time.Now()   // वर्तमान समय प्राप्त करें
    fmt.Printf("वर्तमान समय: %v\n", currentTime)
    
    // कस्टम समय
    customTime := time.Date(2022, time.December, 31, 23, 59, 59, 0, time.UTC)
    fmt.Printf("कस्टम समय: %v\n", customTime)
}

उपरोक्त कोड में, time.Now() का उपयोग वर्तमान समय प्राप्त करने के लिए किया गया है, और time.Date() फ़ंक्शन का उपयोग विशिष्ट समय की प्रारंभिककरण करने के लिए किया गया है। इसमें वर्ष, महीना, दिन, घंटा, मिनट, सेकंड, और नैनोसेकंड को पैरामीटर के रूप में लेता है, साथ ही समय क्षेत्र भी।

3. स्वरूपण और पार्सिंग

3.1. समय और तारीख का स्वरूपण

समय और तारीख का स्वरूपण समय प्रकार Time को मानव-पठनीय स्ट्रिंग के रूप में प्रस्तुत करना होता है। Go में, आप Time प्रकार का Format मेथड का उपयोग समय के स्वरूपण के लिए कर सकते हैं। Go के उपयोग करते हुए समय को स्वरूपित करने के लिए एक विशेष लेआउट संदर्भ (2006-01-02 15:04:05) का उपयोग करता है। नीचे एक उदाहरण है:

package main

import (
    "fmt"
    "time"
)

func main() {
    currentTime := time.Now()

    // समय को "YYYY-MM-DD" के रूप में स्वरूपित करें
    fmt.Println("स्वरूपित तिथि:", currentTime.Format("2006-01-02"))
    
    // समय को "YYYY-MM-DD hh:mm:ss" के रूप में स्वरूपित करें
    fmt.Println("स्वरूपित तिथि और समय:", currentTime.Format("2006-01-02 15:04:05"))
    
    // समय को "MM/DD/YY hh:mm:ss PM" के विभिन्न लेआउट के रूप में स्वरूपित करें
    fmt.Println("विभिन्न लेआउट के साथ स्वरूपित:", currentTime.Format("01/02/06 03:04:05 PM"))
}

ध्यान दें कि स्वरूपण को गो की जन्म समय संदर्भ (जनवरी 2, 2006, 15:04:05 UTC) के रूप में संदर्भित करना होता है।

3.2. समय और तारीख स्ट्रिंग का पार्सिंग

स्ट्रिंग पार्सिंग एक प्रक्रिया है जिसमें वाणिज्यिक समय और तारीख स्ट्रिंग को Time प्रकार में बदला जाता है। Go में, आप स्ट्रिंग को पार्स करने के लिए time.Parse मेथड का उपयोग कर सकते हैं। यहां एक सरल उदाहरण है:

package main

import (
    "fmt"
    "time"
)

func main() {
    timeString := "2022-12-31 23:59:59"

    // मिलती-जुलती समय स्ट्रिंग को पार्स करें
    parsedTime, err := time.Parse("2006-01-02 15:04:05", timeString)
    if err != nil {
        fmt.Println("समय को पार्स करते समय त्रुटि:", err)
    } else {
        fmt.Printf("पार्स किया गया समय: %v\n", parsedTime)
    }
}

time.Parse फ़ंक्शन में, पहला पैरामीटर लेआउट स्ट्रिंग है, जिसमें इनपुट समय स्ट्रिंग का प्रारूपण दिया गया है, और दूसरा पैरामीटर समय स्ट्रिंग है जिसे आप पार्स करना चाहते हैं।

4. समय कार्रवाई

प्रोग्रामिंग में, समय कार्रवाई करना एक सामान्य आवश्यकता है, चाहे वह लॉग रिकॉर्डिंग में हो, घटना निर्धारण में हो, या उपयोगकर्ता इंटरफ़ेस में समय प्रदर्शित करने में हो, समय को जोड़ने और घटाने को संभावना हो सकती है।

4.1. समय जोड़ना और घटाना

Go भाषा के time पैकेज में, Time प्रकार समय जोड़ने और घटाने के लिए Add और Sub विधियाँ प्रदान करता है।

• समय जोड़ने के लिए Add विधि का उपयोग करें:

package main

import (
	"fmt"
	"time"
)

func main() {
	// वर्तमान समय
	now := time.Now()

	// 2 घंटे जोड़ें
	twoHoursLater := now.Add(2 * time.Hour)

	fmt.Println("वर्तमान समय:", now)
	fmt.Println("दो घंटे बाद:", twoHoursLater)
}

उपरोक्त कोड में, time.Hour स्थायी का उपयोग दो घंटों को संदर्भित करने के लिए किया गया है, और Add विधि का उपयोग करके उसे now चर को जोड़ा गया है।

• समय अंतर की गणना करने के लिए Sub विधि का उपयोग करें:

// वर्तमान समय
now := time.Now()

// दो घंटे पहले का समय
twoHoursBefore := now.Add(-2 * time.Hour)

fmt.Println("वर्तमान समय:", now)
fmt.Println("दो घंटे पहले:", twoHoursBefore)

// Sub विधि का उपयोग करके समय अंतर की गणना करें
duration := now.Sub(twoHoursBefore)

fmt.Println("दो समयों का अंतर है:", duration)

उपरोक्त कोड उदाहरण में, -2 * time.Hour का उपयोग वर्तमान समय से दो घंटे पहले का समय संदर्भित करने के लिए किया गया है, और Sub विधि का उपयोग दो Time इंस्टेंस के बीच समय अंतर की गणना करने के लिए किया गया है, जिससे एक time.Duration प्रकार प्राप्त होता है।

4.2. समय अंतर गणना

दो समय बिंदुओं के बीच अंतर की गणना एक और सामान्य कार्य है, जैसे कि दो घटनाओं के बीच समय अंतर की गणना। Go भाषा में, इसको Sub विधि का उपयोग करके आसानी से किया जा सकता है।

package main

import (
	"fmt"
	"time"
)

func main() {
	startTime := time.Date(2023, 1, 1, 10, 0, 0, 0, time.UTC)
	endTime := time.Date(2023, 1, 1, 12, 30, 0, 0, time.UTC)

// समय अंतर की गणना
duration := endTime.Sub(startTime)

fmt.Printf("घटना %v चली।\n", duration)
}

इस कोड टुकड़े में, हमने दो समय बिंदु startTime और endTime बनाए और उनके बीच समय अंतर duration प्राप्त करने के लिए Sub विधि का उपयोग किया।

5. टाइमस्टैम्प को समय प्रकार में और उल्टा करना

एक टाइमस्टैम्प एक निश्चित समय से के बाद का समय माप है (सामान्यत: Unix युग से सेकंड की संख्या), जो एक और तरीका है एक समय को प्रतिनिधित करने के लिए।

• टाइमस्टैम्प को Time प्रकार में बदलना:

package main

import (
	"fmt"
	"time"
)

func main() {
// वर्तमान टाइमस्टैम्प प्राप्त करें
timestamp := time.Now().Unix()

// टाइमस्टैम्प को समय प्रकार में बदलें
tm := time.Unix(timestamp, 0)

fmt.Println("वर्तमान टाइमस्टैम्प:", timestamp)
fmt.Println("संबंधित समय प्रकार:", tm)
}

Unix फ़ंक्शन एक पैरामीटर जो सेकंड को प्रतिनिधित करता है और एक और नैनोसेकंड को प्रतिनिधित करता है, और Unix टाइमस्टैम्प को time.Time प्रकार में बदलने के लिए उपयोग किया जा सकता है।

• Time प्रकार से टाइमस्टैम्प प्राप्त करें:

// वर्तमान समय प्राप्त करें
now := time.Now()

// समय प्रकार को टाइमस्टैम्प में बदलें
timestamp := now.Unix()

fmt.Println("वर्तमान समय:", now)
fmt.Println("संबंधित टाइमस्टैम्प:", timestamp)

इस कोड में, Unix विधि का उपयोग Time प्रकार के संबंधित Unix टाइमस्टैम्प प्राप्त करने के लिए किया गया है, जो समय सूचना को संग्रहीत या प्रसारित करने के लिए बहुत उपयोगी होता है।

6. समय क्षेत्र संभालना

समय क्षेत्र संभालना विभिन्न भौगोलिक क्षेत्रों से बचने वाले प्रणालियों के लिए अत्यंत महत्वपूर्ण है। Go में time पैकेज आपको विभिन्न समय क्षेत्रों के साथ काम करने की अनुमति देता है।

• विशिष्ट समय क्षेत्र के लिए समय बनाना:

package main

import (
	"fmt"
	"time"
)

func main() {
	// समय क्षेत्र लोड करें
	loc, _ := time.LoadLocation("Europe/Paris")

	// विशिष्ट समय क्षेत्र का उपयोग करके समय बनाएं
	now := time.Now().In(loc)

	fmt.Println("पेरिस का समय:", now)
}

ऊपर का कोड "Europe/Paris" समय क्षेत्र को LoadLocation फ़ंक्शन का उपयोग करके लोड करता है और फिर In विधि का उपयोग करके पेरिस में वर्तमान समय बनाता है।

• समय क्षेत्र परिवर्तन:

// UTC में समय बनाएं
utcTime := time.Date(2023, 1, 1, 12, 0, 0, 0, time.UTC)

// लक्षित समय क्षेत्र लोड करें
nyLoc, _ := time.LoadLocation("America/New_York")

// UTC समय को न्यू यॉर्क समय में परिवर्तित करें
nyTime := utcTime.In(nyLoc)

fmt.Println("UTC समय:", utcTime)
fmt.Println("न्यू यॉर्क समय:", nyTime)

ऊपर का कोड दिखाता है कि UTC समय को न्यू यॉर्क समय में कैसे परिवर्तित किया जाता है।

7. टाइमर्स और टिक्कर्स

time पैकेज टाइमर्स और टिक्कर्स प्रदान करता है, जो नियमित निष्पादन की आवश्यकता रखने वाले कार्यों के लिए उपयोग किया जा सकता है।

• टाइमर का उपयोग:

package main

import (
	"fmt"
	"time
)

func main() {
	// 2 सेकंड के बाद ट्रिगर होने के लिए एक टाइमर बनाएं
	timer := time.NewTimer(2 * time.Second)

	// जब टाइमर ट्रिगर होता है, वह वर्तमान समय को timer.C को भेजता है
	<-timer.C

	fmt.Println("टाइमर ट्रिगर हुआ")
}

इस कोड में, 2 सेकंड के बाद ट्रिगर होने के लिए एक टाइमर बनाया जाता है, और <-timer.C का उपयोग उसकी ट्रिगर का इंतजार करने के लिए किया जाता है।

• पुनरावृत्ति के लिए टिक्कर का उपयोग:

// हर 1 सेकंड में ट्रिगर होने के लिए एक टिक्कर बनाएं
ticker := time.NewTicker(1 * time.Second)

for i := 0; i < 5; i++ {
	// चैनल के माध्यम से मान प्राप्त करें
	<-ticker.C
	fmt.Println("टिक्कर ट्रिगर हुआ", i+1, "बार")
}

// टिक्कर को बंद करें
ticker.Stop()

ऊपर का कोड दिखाता है कि कैसे हर 1 सेकंड में ट्रिगर होने वाला टिक्कर बनाया जाता है, और फिर इसे 5 बार ट्रिगर होने के बाद बंद किया जाता है।

टाइमर्स और टिक्कर्स समय संबंधी कार्यों के लिए शक्तिशाली उपकरण हैं, जो आपको सटीक समय नियंत्रण तर्क बनाने में मदद करते हैं।