जाओ के साथ स्वरूपण संख्याएं और मुद्राएं

संख्याओं को सही ढंग से फ़ॉर्मेट करना एक मुश्किल काम हो सकता है। और मुद्राओं को स्वरूपित करने से स्थानीयकरण से जुड़ी अतिरिक्त चुनौतियाँ आती हैं। सौभाग्य से, गो में मदद करने के लिए सुविधाएँ हैं।

गो मानक पुस्तकालय संख्याओं को प्रारूपित करने के लिए विभिन्न उपकरण प्रदान करता है। strconv पैकेज में पार्सिंग और स्ट्रिंग्स से संख्याओं को परिवर्तित करने के लिए फ़ंक्शंस शामिल हैं।

strconv पैकेज

strconv पैकेज संख्या और तार के बीच रूपांतरण के लिए एक शक्तिशाली उपकरण है। आप इसका उपयोग विभिन्न स्वरूपों में संख्याओं के साथ काम करने के लिए कर सकते हैं।

strconv मानक पुस्तकालय का हिस्सा है, इसलिए यह कई के लिए प्रासंगिक है बुनियादी गो अवधारणाएँ जिनसे आपको परिचित होना चाहिए. यहां बताया गया है कि आप इसे कैसे आयात कर सकते हैं:

आयात"स्ट्रकोनव"

पैकेज विभिन्न स्वरूपों में संख्याओं को तार से और में परिवर्तित करने के लिए कार्य प्रदान करता है। इसमें पूर्णांक और फ़्लोटिंग-पॉइंट नंबरों के साथ काम करने के लिए फ़ंक्शन शामिल हैं।

strconv बाइनरी, ऑक्टल, और हेक्साडेसिमल स्वरूपों के साथ-साथ वैज्ञानिक संकेतन से रूपांतरण को भी संभाल सकता है।

गो में पूर्णांकों को स्वरूपित करना

strconv पैकेज इतोआ फ़ंक्शन पूर्णांक को स्ट्रिंग्स में परिवर्तित करने के लिए कार्यक्षमता प्रदान करता है। इतोआ फ़ंक्शन एक पूर्णांक लेता है और उस पूर्णांक का स्ट्रिंग प्रतिनिधित्व लौटाता है।

आयात (
"एफएमटी"
"स्ट्रकोनव"
)
समारोहमुख्य() {
 पूर्णांक := 3043
 स्ट्रिंग वर्जन: = strconv. इतोआ (पूर्णांक)
 fmt. Println (स्ट्रिंग संस्करण) // आउटपुट: "3043"
}

यह कोड एक पूर्णांक मान को एक स्ट्रिंग का उपयोग करके परिवर्तित करता है इतोआ. इसके बाद परिणामी स्ट्रिंग को कंसोल का उपयोग करके आउटपुट करता है fmt पैकेट।

निम्न के अलावा इतोआ समारोह, strconv प्रदान करता है:

• FormatInt किसी दिए गए आधार के साथ पूर्णांकों को तार के रूप में स्वरूपित करने के लिए
• परिशिष्ट बाइट्स के एक स्लाइस में स्ट्रिंग फॉर्म में पूर्णांक जोड़ने के लिए।

यहां बताया गया है कि आप कैसे उपयोग कर सकते हैं FormatInt एक पूर्णांक स्वरूपित करने के लिए कार्य करें:

आयात (
"एफएमटी"
"स्ट्रकोनव"
)
समारोहमुख्य() {
 पूर्णांक := 12345
 स्ट्रिंग्स := strconv. प्रारूप इंट (int64(पूर्णांक), 10)
 fmt. Println (स्ट्रिंग्स) // आउटपुट: "12345"
}

यह कोड उपयोग करता है int64 () मूल मान को 64-बिट पूर्णांक में बदलने के लिए। यह तब परिणाम को पास करता है FormatIntरूपांतरण के लिए आधार के साथ, इस मामले में 10. FormatInt एक स्ट्रिंग देता है जो Println फिर कंसोल पर आउटपुट करता है।

परिशिष्ट फ़ंक्शन एक बाइट स्लाइस लेता है, a int64 मूल्य, और एक आधार।

आयात (
"एफएमटी"
"स्ट्रकोनव"
)
समारोहमुख्य() {
 पूर्णांक := 12345
 बाइटस्लाइस := निर्माण([]बाइट, 0, 20)
 बाइटस्लाइस = strconv. परिशिष्ट (बाइटस्लाइस, int64(पूर्णांक), 10)
 fmt. प्रिंटलन(डोरी(बाइटस्लाइस)) // आउटपुट: "12345"
}

ध्यान दें कि AppendInt को संलग्न करने के लिए एक बाइट स्लाइस प्राप्त होता है, और परिणामी बाइट स्लाइस लौटाता है। इस स्थिति में, प्रारंभिक बाइट स्लाइस खाली है, लेकिन पूर्णांक के परिणामी स्ट्रिंग प्रतिनिधित्व को संग्रहीत करने के लिए 20 की क्षमता है।

स्ट्रिंग्स को पूर्णांक के रूप में पार्स करना

अटोई फ़ंक्शन स्ट्रिंग्स को पूर्णांकों में परिवर्तित करता है। यह एक स्ट्रिंग को इनपुट के रूप में लेता है और एक त्रुटि प्रकार के साथ उस स्ट्रिंग का एक पूर्णांक प्रतिनिधित्व देता है।

यहां बताया गया है कि आप कैसे उपयोग कर सकते हैं अटोई स्ट्रिंग-टू-इंटीजर रूपांतरण के लिए कार्य:

आयात (
"एफएमटी"
"स्ट्रकोनव"
)
समारोहमुख्य() {
 तार: = "123"
 पूर्णांक, त्रुटि: = strconv. अटोई (स्ट्रिंग्स)
अगर गलती! = शून्य {
 fmt. प्रिंट्लन (इरेट)
 }
 fmt. Println (पूर्णांक) 
}

कार्यक्रम कंसोल के पूर्णांक मान को आउटपुट करता है:

आप भी इस्तेमाल कर सकते हैं ParseUint अहस्ताक्षरित पूर्णांकों के स्ट्रिंग प्रतिनिधित्व को पार्स करने के लिए कार्य करें।

पैकेट मुख्य
आयात (
"एफएमटी"
"स्ट्रकोनव"
)
समारोहमुख्य() {
// पार्स स्ट्रिंग को आधार 10 और 0-बिट अहस्ताक्षरित पूर्णांक के रूप में
 वैल, त्रुटि: = strconv. पारसेइंट("12345", 10, 0)
अगर गलती! = शून्य {
 fmt. प्रिंट्लन (इरेट)
 } अन्य {
 fmt. प्रिंटलाइन (वैल्यू) // आउटपुट: 12345
 }
}

ParseUint फ़ंक्शन 12345 स्ट्रिंग को आधार दस, अहस्ताक्षरित पूर्णांक के रूप में पार्स करता है। 0-बिट आकार सुनिश्चित करता है कि यह एक मानक इंट प्रकार देता है। यह पार्स किए गए मान और एक त्रुटि देता है।

आप उपयोग कर सकते हैं ParseFloat फ़्लोटिंग पॉइंट नंबर के स्ट्रिंग प्रतिनिधित्व को पार्स करने के लिए फ़ंक्शन।

आयात (
"एफएमटी"
"स्ट्रकोनव"
)
समारोहमुख्य() {
// पार्स स्ट्रिंग को 64-बिट फ़्लोटिंग-पॉइंट नंबर के रूप में
 वैल, त्रुटि: = strconv. पारसेफ्लोट("3.14", 64)
अगर गलती! = शून्य {
 fmt. प्रिंट्लन (इरेट)
 } अन्य {
 fmt. प्रिंटलाइन (वैल्यू) // आउटपुट: 3.14
 }
}

ParseFloat फ़ंक्शन स्ट्रिंग को 64-बिट फ़्लोटिंग पॉइंट नंबर के रूप में पार्स करता है और स्ट्रिंग और एक त्रुटि प्रकार देता है।

गो में मुद्राओं का प्रारूपण

मुद्राओं के साथ इंटरैक्ट करने वाले एप्लिकेशन का निर्माण करने के लिए संख्या स्वरूपण और पार्सिंग की आवश्यकता होती है। विभिन्न मुद्राओं के साथ कार्य करना एक चुनौती हो सकती है, लेकिन strconv और लेखांकन संकुल उन्हें स्वरूपित करने में आपकी सहायता कर सकते हैं।

यहां बताया गया है कि मुद्रा पर संचालन के लिए आप मुद्रा स्ट्रिंग को फ़्लोट में कैसे पार्स कर सकते हैं:

आयात (
"एफएमटी"
"स्ट्रकोनव"
)
समारोहमुख्य() {
// मुद्रा स्ट्रिंग पार्स करने के लिए
 करेंसीएसटीआर:= "$1,234.56"
// करेंसी सिंबल को हटाएं और फ्लोट में बदलें
 फ्लोटवैल, इरेट: = strconv. परसेफ्लोट (मुद्राएसटीआर [1:], 64)
अगर गलती! = शून्य {
 fmt. प्रिंट्लन (इरेट)
वापस करना
 }
// पार्स किए गए फ्लोट वैल्यू को प्रिंट करें
 fmt. Println (फ्लोटवैल) // आउटपुट: 1234.56
}

मुद्रा एसटी चर प्रतीक के रूप में एक डॉलर चिह्न के साथ मुद्रा मूल्य का एक स्ट्रिंग प्रतिनिधित्व है। कार्यक्रम का उपयोग करता है ParseFloat दूसरे तत्व (मुद्रा प्रतीक के बाद) से शुरू होने वाली मुद्रा स्ट्रिंग को पार्स करने के लिए कार्य करें।

परंपरागत रूप से, मुद्राओं के लिए फ़्लोट्स का उपयोग करने से बचना सबसे अच्छा है क्योंकि वे उत्पादन में गलतियाँ और बग पैदा कर सकते हैं।

वैकल्पिक रूप से, आप तृतीय-पक्ष पैकेज का उपयोग कर सकते हैं जैसे लेखांकन जिसमें मुद्राओं को स्वरूपित और पार्स करने की कार्यक्षमता है।

लेखा पैकेज स्थापित करने के लिए अपनी प्रोजेक्ट निर्देशिका में इस टर्मिनल कमांड को चलाएँ:

github.com/leekchan/accounting पर जाएं

का एक उदाहरण बनाकर प्रारंभ करें लेखांकन संरचना। याद रखें कि structs इनमें से एक हैं गो की मुख्य वस्तु-उन्मुख विशेषताएं, अन्य भाषाओं की कक्षाओं के समान। आप अन्य विकल्पों के बीच एक मुद्रा प्रतीक और एक सटीक मान के साथ एक लेखा उदाहरण को प्रारंभ कर सकते हैं।

आप उपयोग कर सकते हैं FormatMoney संख्याओं को मुद्राओं में प्रारूपित करने के लिए लेखांकन पैकेज का कार्य।

पैकेट मुख्य
आयात (
"एफएमटी"
"गणित/बड़ा"
"github.com/leekchan/accounting"
)
समारोहमुख्य() {
 एसी := लेखा। लेखा {प्रतीक: "$", शुद्धता: 2}
 fmt. प्रिंट्लन (अ. फॉर्मेटमनी(123456789.213123))
 fmt. प्रिंट्लन (अ. फॉर्मेटमनी(12345678))
 fmt. प्रिंट्लन (अ. फॉर्मेटमनी (बड़ा। न्यूरैट(77777777, 3)))
 fmt. प्रिंट्लन (अ. फॉर्मेटमनी (बड़ा। न्यूरैट(-77777777, 3)))
 fmt. प्रिंट्लन (अ. फॉर्मेटमनीबिगफ्लोट (बड़ा। न्यूफ्लोट(123456789.213123)))
}

एसी चर लेखा उदाहरण है। यह प्रोग्राम मौद्रिक मूल्यों का उपयोग करके स्वरूपित और प्रिंट करता है FormatMoney और फॉर्मेटमनीबिगफ्लोट लेखांकन उदाहरण के तरीके। न्यूरैट समारोह से बड़ा पैकेज अंश और भाजक दिए जाने पर एक परिमेय संख्या बनाता है। न्यूफ्लोट फ़ंक्शन बड़े फ़्लोटिंग पॉइंट नंबरों का प्रतिनिधित्व करने में मदद करता है।

गो आपको अन्य प्रकारों को भी प्रारूपित करने में मदद कर सकता है

संख्याओं और मुद्राओं को सरल तरीके से परिवर्तित करने के लिए गो बहुत सारे कार्य प्रदान करता है।

भाषा एक शक्तिशाली स्ट्रिंग स्वरूपण प्रणाली भी प्रदान करती है। fmt पैकेज का C-प्रेरित स्प्रिंटफ फ़ंक्शन आपको एक विशेष प्लेसहोल्डर सिंटैक्स का उपयोग करके स्वरूपित स्ट्रिंग्स बनाने देता है। आप Sprintf का उपयोग स्ट्रिंग बनाने के लिए कर सकते हैं जिसमें संख्याएँ और मुद्रा मान शामिल हैं, जिससे मानव-पठनीय आउटपुट बनाना आसान हो जाता है।