Go में Duration को Integer से गुणा करना: 2025 के रहस्य

Go में Duration को Integer से कैसे गुणा करें? उदाहरणों के साथ समझें

नमस्ते, सहकर्मी! यदि आपने कभी Go में टाइमर, अंतराल या केवल विलंब के साथ काम करने वाला कोड लिखा है, तो आप निश्चित रूप से इस प्रश्न का सामना कर चुके होंगे। आप time.Duration लेते हैं, इसे एक पूर्णांक से गुणा करना चाहते हैं — और आपको कंपाइलेशन एरर मिलती है। परिचित लगता है? चिंता न करें, यह Stack Overflow पर हज़ारों व्यूज़ वाले सबसे लोकप्रिय प्रश्नों में से एक है। इस लेख में, हम समझेंगे कि ऐसा क्यों होता है और 2025 में इस समस्या को सही तरीके से कैसे हल किया जाए। चलिए शुरू करते हैं!

time.Duration * int काम क्यों नहीं करता?

चलिए सीधे मुद्दे पर आते हैं। Go में time.Duration केवल एक संख्या नहीं है, बल्कि int64 (नैनोसेकंड) पर आधारित एक अलग प्रकार है। जब आप लिखते हैं:

package main\n\nimport (\n    "fmt"\n    "time"\n)\n\nfunc main() {\n    d := 2 * time.Second\n    multiplier := 3\n    result := d * multiplier // कंपाइलेशन एरर!\n    fmt.Println(result)\n}\n

कंपाइलर कुछ इस तरह आउटपुट देगा: invalid operation: d * multiplier (mismatched types time.Duration and int)। Go में सख्त टाइपिंग है, और विभिन्न प्रकारों को सीधे गुणा नहीं किया जा सकता। यह मूर्खतापूर्ण गलतियों से बचाता है, लेकिन कभी-कभी परेशान करता है। 2025 में यह नियम कहीं नहीं गया है, और इसे सही तरीके से संभालना होगा।

सर्वोत्तम प्रथाएँ: Duration को Integer से कैसे गुणा करें

कई तरीके हैं, और हम प्रत्येक पर विचार करेंगे। वह चुनें जो आपके कार्य के लिए सबसे उपयुक्त हो।

1. int को time.Duration में बदलना

सबसे स्पष्ट और सुरक्षित तरीका गुणक को time.Duration प्रकार में बदलना है। चूंकि time.Duration एक int64 है, रूपांतरण सीधे काम करता है:

package main\n\nimport (\n    "fmt"\n    "time"\n)\n\nfunc main() {\n    d := 2 * time.Second\n    multiplier := 3\n    result := d * time.Duration(multiplier)\n    fmt.Println(result) // आउटपुट: 6s\n}\n

यह तरीका तब आदर्श है जब गुणक एक छोटी धनात्मक संख्या हो। लेकिन सावधान रहें: यदि multiplier ऋणात्मक या बहुत बड़ा है, तो परिणाम अप्रत्याशित हो सकता है (ओवरफ़्लो)। 2025 में यह अभी भी प्रासंगिक है, इसलिए सीमा मानों की जाँच करें।

2. गणना के लिए time.Duration का उपयोग करना

कभी-कभी time.Duration स्थिरांकों के साथ सीधे काम करना अधिक सुविधाजनक होता है। उदाहरण के लिए, यदि आपको अंतराल को कई गुना बढ़ाना है:

package main\n\nimport (\n    "fmt"\n    "time"\n)\n\nfunc main() {\n    base := 500 * time.Millisecond\n    multiplier := time.Duration(4)\n    result := base * multiplier\n    fmt.Println(result) // आउटपुट: 2s\n}\n

यह दृष्टिकोण पढ़ने में आसान है, खासकर यदि गुणक एक स्थिरांक है। लेकिन याद रखें कि time.Duration नैनोसेकंड है, इसलिए time.Duration(4) का मतलब 4 नैनोसेकंड है, न कि समय की 4 इकाइयाँ। "4 गुना" से गुणा करने के लिए यह काम करता है, लेकिन अन्य उद्देश्यों के लिए नहीं।

3. सुविधा के लिए रैपर फ़ंक्शन

यदि कोड में duration को int से गुणा करना बार-बार होता है, तो एक छोटा फ़ंक्शन बनाएँ। इससे पठनीयता बढ़ेगी और दोहराव से बचा जा सकेगा:

package main\n\nimport (\n    "fmt"\n    "time"\n)\n\nfunc multiplyDuration(d time.Duration, factor int) time.Duration {\n    return d * time.Duration(factor)\n}\n\nfunc main() {\n    d := 3 * time.Minute\n    result := multiplyDuration(d, 2)\n    fmt.Println(result) // आउटपुट: 6m0s\n}\n

2025 में, जब प्रोजेक्ट जटिल हो जाते हैं, ऐसे सहायक फ़ंक्शन आवश्यक हैं। वे त्रुटियों से बचाते हैं और कोड को स्व-दस्तावेज़ीकृत बनाते हैं।

4. फ़्लोटिंग पॉइंट से गुणा (उन्नत स्तर)

कभी-कभी duration को भिन्नात्मक संख्या (जैसे, 1.5) से गुणा करने की आवश्यकता होती है। Go time.Duration को float64 से गुणा करने की अनुमति नहीं देता, लेकिन एक तरकीब है:

package main\n\nimport (\n    "fmt"\n    "time"\n)\n\nfunc main() {\n    d := 100 * time.Millisecond\n    factor := 1.5\n    result :=