गो के साथ सीएलआई एप्लिकेशन लिखना

गो और सीएलआई अनुप्रयोगों का परिचय

गो, जिसे गोलांग के नाम से भी जाना जाता है , Google द्वारा डिज़ाइन की गई एक ओपन-सोर्स प्रोग्रामिंग भाषा है। यह सरलता, सुरक्षा और प्रदर्शन पर जोर देता है, जो इसे कमांड-लाइन इंटरफ़ेस (सीएलआई) अनुप्रयोगों के निर्माण के लिए एक उत्कृष्ट विकल्प बनाता है। सीएलआई एप्लिकेशन ऐसे उपकरण हैं जिनके साथ उपयोगकर्ता टेक्स्ट-आधारित इंटरफ़ेस के माध्यम से बातचीत कर सकते हैं, जो आमतौर पर सिस्टम प्रशासन, स्वचालन और स्क्रिप्टिंग कार्यों के लिए उपयोग किया जाता है। गो सीएलआई विकास के लिए उपयुक्त है क्योंकि यह प्रदान करता है:

1. सरलता: गो का सिंटैक्स समझना और लिखना आसान है, जिससे डेवलपर्स तेजी से सीएलआई एप्लिकेशन बना और बनाए रख सकते हैं।
2. प्रदर्शन: गो एक संकलित और स्थिर रूप से टाइप की गई भाषा है, जिसका अर्थ है कि यह अनुकूलित बाइनरी फ़ाइलें तैयार करती है, जिसके परिणामस्वरूप तेज़ और कुशल सीएलआई अनुप्रयोग होते हैं।
3. समवर्ती समर्थन: गो में गोरोइन्स और चैनल जैसे अंतर्निहित समवर्ती प्राइमेटिव्स हैं, जो निर्बाध समानांतर प्रसंस्करण और अंततः तेज़ और अधिक प्रतिक्रियाशील सीएलआई अनुप्रयोगों को सक्षम करते हैं।
4. स्टेटिक बाइनरी संकलन: गो अनुप्रयोगों को एक एकल, स्टैंडअलोन बाइनरी में संकलित करता है - बाहरी निर्भरता के बिना - आपके सीएलआई एप्लिकेशन के आसान वितरण और तैनाती की सुविधा प्रदान करता है।
5. शक्तिशाली मानक लाइब्रेरी: गो की मानक लाइब्रेरी कई अंतर्निहित पैकेज प्रदान करती है, जो सामान्य सीएलआई विकास कार्यों को सरल बनाती है, जैसे फाइलों के साथ काम करना, नेटवर्किंग और कमांड-लाइन तर्कों को संभालना।

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

आरंभ करना: गो इंस्टॉल करना और अपना वातावरण स्थापित करना

इससे पहले कि आप गो के साथ सीएलआई एप्लिकेशन लिखना शुरू कर सकें, आपको पहले अपने सिस्टम पर गो प्रोग्रामिंग भाषा इंस्टॉल करनी होगी।

1. आधिकारिक गो डाउनलोड पृष्ठ पर जाएँ, अपने प्लेटफ़ॉर्म (विंडोज़, मैकओएस, या लिनक्स) के लिए उपयुक्त बाइनरी पैकेज का चयन करें, और इंस्टॉलेशन निर्देशों का पालन करें।
2. एक बार इंस्टॉलेशन पूरा हो जाने पर, अपने टर्मिनल में go version चलाकर सत्यापित करें कि गो सही ढंग से इंस्टॉल है। इस आदेश को स्थापित गो संस्करण प्रदर्शित करना चाहिए।
3. गो के लिए आवश्यक पर्यावरण चर कॉन्फ़िगर करें, जिसमें GOPATH शामिल है, जो आपके गो कार्यक्षेत्र का स्थान निर्धारित करता है (जहां आपके गो प्रोजेक्ट और निर्भरताएं संग्रहीत की जाएंगी), और GOROOT , जो आपके गो इंस्टॉलेशन निर्देशिका को इंगित करता है।
4. सुनिश्चित करें कि go कमांड आपके सिस्टम के PATH वेरिएबल में है। यह आपको किसी भी निर्देशिका से गो कमांड निष्पादित करने की अनुमति देता है।

गो इंस्टॉल होने और आपका वातावरण कॉन्फ़िगर होने के साथ, आप अपना पहला सीएलआई एप्लिकेशन बनाना शुरू करने के लिए तैयार हैं।

आपके सीएलआई एप्लिकेशन की संरचना: पैकेज और मॉड्यूल

आपके सीएलआई एप्लिकेशन को उचित रूप से संरचित करना रखरखाव और स्केलेबिलिटी के लिए आवश्यक है, यह सुनिश्चित करना कि आपका कोड व्यवस्थित है और नेविगेट करने में आसान है। गो में, कोड संगठन पैकेज और मॉड्यूल के माध्यम से हासिल किया जाता है।

पैकेज: पैकेज कोड को व्यवस्थित करने और विभाजित करने का एक तरीका है। एक पैकेज में एक ही निर्देशिका में स्थित एक या अधिक स्रोत फ़ाइलें ( .go एक्सटेंशन के साथ) होती हैं। पैकेज में प्रत्येक फ़ाइल को अपना पैकेज नाम घोषित करना होगा, जो फ़ाइल की शुरुआत में package कीवर्ड के साथ निर्दिष्ट है। एक सामान्य गो सीएलआई एप्लिकेशन में कम से कम दो पैकेज होते हैं:

1. main : यह आपके एप्लिकेशन के प्रवेश बिंदु के लिए डिफ़ॉल्ट पैकेज है। यह वह जगह है जहां main() फ़ंक्शन रहता है और आपके सीएलआई एप्लिकेशन के लिए शुरुआती बिंदु के रूप में कार्य करता है। सभी सीएलआई-विशिष्ट तर्क और आदेश मुख्य पैकेज के अंदर रखे जाने चाहिए।
2. internal या pkg : इन पैकेजों में पुन: प्रयोज्य कोड होता है जो आपके सीएलआई तर्क से अलग होता है। आप उस कोड के लिए internal का उपयोग कर सकते हैं जिसे प्रोजेक्ट के भीतर केवल आपके अपने गो कोड द्वारा आयात किया जाना चाहिए, और उस कोड के लिए pkg उपयोग कर सकते हैं जिसे किसी भी गो प्रोजेक्ट द्वारा आयात किया जा सकता है।

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

Try AppMaster no-code today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

 go mod init your.module.name

यह कमांड रूट डायरेक्टरी में एक go.mod फ़ाइल बनाता है, जो आपके प्रोजेक्ट की निर्भरताओं को सूचीबद्ध करता है, और एक go.sum फ़ाइल बनाता है, जो प्रत्येक निर्भरता के चेकसम को रखता है। जब आप पैकेज आयात करते हैं या तृतीय-पक्ष लाइब्रेरी का उपयोग करते हैं, तो गो स्वचालित रूप से go.mod और go.sum फ़ाइलों में निर्भरता का ट्रैक रखेगा।

छवि स्रोत: द गो प्रोग्रामिंग लैंग्वेज

पैकेज और मॉड्यूल का प्रभावी ढंग से उपयोग करके, आप अपने गो सीएलआई एप्लिकेशन के लिए एक स्वच्छ और कुशल कोड संरचना बनाए रख सकते हैं, जिससे भविष्य में आपके प्रोजेक्ट को विकसित करना, डीबग करना और विस्तारित करना अधिक सरल हो जाएगा।

कमांड-लाइन तर्क और झंडे

कमांड-लाइन तर्क और झंडे सीएलआई अनुप्रयोगों के आवश्यक घटक हैं, जो उपयोगकर्ताओं को एप्लिकेशन के व्यवहार को नियंत्रित करने और आवश्यक इनपुट प्रदान करने की अनुमति देते हैं। गो में, आप मानक लाइब्रेरी के flag और os.Args पैकेज का उपयोग करके कमांड-लाइन तर्क और झंडे के साथ काम कर सकते हैं।

ओएस.आर्ग्स का उपयोग करना

os.Args पैकेज कमांड-लाइन तर्कों तक सीधी पहुंच प्रदान करता है। यह स्ट्रिंग्स का एक टुकड़ा है, जहां os.Args[0] चल रहे प्रोग्राम का नाम है, और बाकी प्रविष्टियाँ प्रोग्राम को दिए गए तर्कों का प्रतिनिधित्व करती हैं।

यहां os.Args का उपयोग करने का एक उदाहरण दिया गया है:

 पैकेज मुख्य

आयात (
	"एफएमटी"
	"ओएस"
)

func मुख्य() {
	argCount := len(os.Args)
	fmt.Printf('तर्कों की संख्या: %d\n', argCount)
	fmt.Println("तर्क:", os.Args)
}

प्रोग्राम चलाने पर, आपको दिए गए तर्कों की संख्या और सूची दिखाई देगी।

ध्वज पैकेज का उपयोग करना

flag पैकेज कमांड-लाइन फ़्लैग के साथ काम करने का एक अधिक परिष्कृत और लचीला तरीका है। यह आपको विभिन्न डेटा प्रकारों के साथ झंडे को परिभाषित करने और इनपुट को आसानी से पार्स करने में सक्षम बनाता है।

flag पैकेज का उपयोग करने का एक उदाहरण नीचे दिया गया है:

 पैकेज मुख्य

आयात (
	"झंडा"
	"एफएमटी"
)

func मुख्य() {
	वर (
		नाम स्ट्रिंग
		उम्र इंट
		ऊंचाई फ्लोट64
	)

	ध्वज.स्ट्रिंगवार(&नाम, "नाम", "जॉन डो", "आपका नाम")
	flag.IntVar(&उम्र, "उम्र", 21, "आपकी उम्र")
	फ़्लैग.फ़्लोट64Var(&ऊंचाई, "ऊंचाई", 180.0, "आपकी ऊंचाई (सेमी में)")

	झंडा.पार्स()

	fmt.Printf('नाम: %s\n', नाम)
	fmt.Printf('आयु: %d\n', आयु)
	fmt.Printf('ऊंचाई: %.1f\n', ऊंचाई)
}

एक बार जब आप झंडे को परिभाषित कर लेते हैं, तो आप दिए गए कमांड-लाइन इनपुट को पार्स करने और परिभाषित चर को पॉप्युलेट करने के लिए flag.Parse() को लागू करेंगे। फिर आप अपने संपूर्ण एप्लिकेशन में इन वेरिएबल्स का उपयोग कर सकते हैं।

कमांड और सबकमांड बनाना

जटिल सीएलआई अनुप्रयोगों के लिए, आप अपनी कार्यक्षमताओं और विकल्पों को बेहतर ढंग से व्यवस्थित करने के लिए कमांड और उपकमांड बनाना चाह सकते हैं। गो में कमांड और उपकमांड के साथ काम करने के लिए एक लोकप्रिय तृतीय-पक्ष पैकेज github.com/spf13/cobra है।

कोबरा के साथ शुरुआत करना

आरंभ करने के लिए, आपको कोबरा पैकेज स्थापित करना होगा:

 -u github.com/spf13/cobra/cobra पर जाएं

एक बार इंस्टॉल हो जाने पर, आप कोबरा के साथ एक नया सीएलआई एप्लिकेशन बना सकते हैं:

 कोबरा init my-cli --pkg-name=my-cli

यह कमांड कोबरा-आधारित सीएलआई एप्लिकेशन के लिए आवश्यक संरचना और फ़ाइलों के साथ my-cli नामक एक नई निर्देशिका बनाता है।

कमांड को परिभाषित करना

कोबरा-आधारित एप्लिकेशन में, आप cobra.Command के उदाहरणों को परिभाषित करके कमांड बनाते हैं। प्रत्येक कमांड में एक Use फ़ील्ड होता है (यह दर्शाता है कि कमांड का उपयोग कैसे किया जाता है), एक Short फ़ील्ड (संक्षिप्त विवरण प्रदान करता है), और एक Long फ़ील्ड (अधिक विस्तृत विवरण प्रदान करता है)।

इसके अलावा, प्रत्येक कमांड में एक Run फ़ील्ड होना चाहिए, जिसमें एक फ़ंक्शन शामिल हो जो कमांड के तर्क को निष्पादित करता हो। आप अक्सर इस फ़ंक्शन को कमांड के फ़्लैग और तर्कों को कैप्चर करने के लिए क्लोजर के रूप में परिभाषित करेंगे।

यहां एक सरल "अभिवादन" कमांड बनाने का एक उदाहरण दिया गया है:

 नमस्कारCmd := &cobra.Command{
	उपयोग: "अभिवादन",
	संक्षिप्त: "किसी को नमस्कार करें",
	लंबा: "यह आदेश अनुकूलन योग्य संदेश के साथ किसी का स्वागत करता है।",
	चलाएँ: func(cmd *cobra.Command, args []string) {
		// नमस्कार आदेश के लिए तर्क
	},
}

एक उपकमांड बनाने के लिए, आप एक अन्य cobra.Command उदाहरण को परिभाषित कर सकते हैं और इसे AddCommand विधि का उपयोग करके मूल कमांड के चाइल्ड के रूप में जोड़ सकते हैं। उदाहरण के लिए, आप "अभिवादन" कमांड के अंतर्गत एक "अलविदा" उपकमांड बना सकते हैं:

Try AppMaster no-code today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

 अलविदाCmd := &cobra.Command{
	उपयोग: "अलविदा",
	लघु: "किसी को अलविदा कहो",
	लांग: "यह उपकमांड किसी विशिष्ट भाषा में किसी को अलविदा कहता है।"
	चलाएँ: func(cmd *cobra.Command, args []string) {
		// अलविदा उपकमांड के लिए तर्क
	},
}
नमस्कारCmd.AddCommand(अलविदाCmd)

इंटरएक्टिव संकेत और उपयोगकर्ता इनपुट

इंटरएक्टिव संकेत उपयोगकर्ताओं को प्रश्नों की एक श्रृंखला के माध्यम से मार्गदर्शन करके और उनकी प्रतिक्रियाओं के आधार पर इनपुट एकत्र करके आपके सीएलआई एप्लिकेशन के उपयोगकर्ता अनुभव को बेहतर बना सकते हैं। गो में इंटरैक्टिव संकेतों के साथ काम करने के लिए एक लोकप्रिय तृतीय-पक्ष पैकेज github.com/AlecAivazis/survey/v2 है।

सर्वेक्षण के साथ शुरुआत करना

सबसे पहले, आपको सर्वेक्षण पैकेज स्थापित करना होगा:

 जाओ -u github.com/AlecAivazis/survey/v2 प्राप्त करें

इंटरएक्टिव संकेतों के लिए सर्वेक्षण का उपयोग करना

सर्वेक्षण पूर्वनिर्धारित संकेत प्रकारों का एक सेट प्रदान करता है, जिसमें Input , Select , MultiSelect , Confirm और बहुत कुछ शामिल है। प्रॉम्प्ट बनाने के लिए, आप वांछित प्रॉम्प्ट प्रकार को इंस्टेंटियेट करते हैं और survey.Ask फ़ंक्शन को कॉल करते हैं।

 पैकेज मुख्य

आयात (
	"एफएमटी"
	"github.com/AlecAivazis/survey/v2"
)

func मुख्य() {
	var नाम स्ट्रिंग
	namePrompt := &survey.Input{
		संदेश: "आपका नाम क्या है?",
	}
	त्रुटि := सर्वेक्षण.पूछें([]*सर्वेक्षण.प्रश्न{{
		नाम नाम",
		संकेत: नामप्रॉम्प्ट,
		मान्य करें: सर्वेक्षण.आवश्यक,
	}}, &नाम)
	यदि त्रुटि !=शून्य {
		fmt.Println('त्रुटि:', त्रुटि)
		वापस करना
	}
	fmt.Printf('हैलो, %s!\n', नाम)
}

यह कोड स्निपेट एक नाम इकट्ठा करने और एक शुभकामना संदेश प्रदर्शित करने के लिए सर्वेक्षण के Input प्रॉम्प्ट के उपयोग को दर्शाता है। उपयोगकर्ता इनपुट के लिए कस्टम सत्यापन तर्क लागू करने के लिए Validate फ़ील्ड सेट किया जा सकता है।

बाहरी पुस्तकालयों के साथ कार्य करना

कई सीएलआई अनुप्रयोगों में, कार्यक्षमता बढ़ाने और विकास प्रक्रिया को सुव्यवस्थित करने के लिए बाहरी पुस्तकालयों पर भरोसा करना आम बात है। गो निर्भरता प्रबंधन के लिए एक आधुनिक और कुशल दृष्टिकोण प्रदान करता है जो डेवलपर्स को बाहरी पुस्तकालयों के साथ निर्बाध रूप से काम करने में सक्षम बनाता है। गो 1.11 में प्रस्तुत, गो मॉड्यूल आपको अपने प्रोजेक्ट के भीतर पैकेज निर्भरता की घोषणा करने और आवश्यक पैकेजों को डाउनलोड करने, बनाने और स्थापित करने की प्रक्रिया को स्वचालित करने देता है। अपने सीएलआई एप्लिकेशन में बाहरी लाइब्रेरी प्रबंधित करने के लिए, इन चरणों का पालन करें:

1. एक गो मॉड्यूल प्रारंभ करें: अपने सीएलआई एप्लिकेशन की रूट निर्देशिका में, '<मॉड्यूल-नाम>' को अपने इच्छित मॉड्यूल नाम से प्रतिस्थापित करते हुए कमांड go mod init <module-name> मॉड्यूल-नाम> चलाएं। यह कमांड आपके प्रोजेक्ट डायरेक्टरी में go.mod नामक एक नई फ़ाइल बनाएगा।
2. बाहरी लाइब्रेरी जोड़ें: जब भी आप किसी बाहरी लाइब्रेरी को आयात करना चाहते हैं, तो अपने स्रोत कोड में आवश्यक आयात विवरण जोड़ें। जब आप पहली बार अपना प्रोजेक्ट बनाते या चलाते हैं, तो गो स्वचालित रूप से उन लाइब्रेरी के आवश्यक संस्करणों को डाउनलोड और इंस्टॉल करेगा, और go.mod और go.sum फ़ाइलों को अपडेट करेगा।
3. लाइब्रेरी अपडेट करें: किसी बाहरी लाइब्रेरी को अपडेट करने के लिए, आप पैकेज नाम के बाद कमांड go get -u उपयोग कर सकते हैं। यह पैकेज को नवीनतम संस्करण में अपडेट करता है, जो आपकी go.mod फ़ाइल में परिवर्तनों को दर्शाता है।
4. अप्रयुक्त लाइब्रेरीज़ को हटाएँ: अपनी go.mod फ़ाइल से अप्रयुक्त लाइब्रेरीज़ को साफ़ करने के लिए, कमांड go mod tidy चलाएँ। यह उन सभी पुस्तकालयों को हटा देता है जिनकी अब आवश्यकता नहीं है या विकास के दौरान अप्रचलित हो गए हैं।

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

त्रुटियों को संभालना और लॉगिंग करना

आपके सीएलआई एप्लिकेशन की मजबूती सुनिश्चित करने के लिए उचित त्रुटि प्रबंधन और लॉगिंग महत्वपूर्ण हैं। गो त्रुटियों और लॉग के साथ काम करने के लिए अत्यधिक व्यावहारिक और एर्गोनोमिक दृष्टिकोण प्रदान करता है। गो में त्रुटियों को संभालने के लिए, आप मानक errors पैकेज का उपयोग कर सकते हैं। आपके सीएलआई अनुप्रयोगों में त्रुटियों के साथ काम करते समय यहां कुछ सर्वोत्तम अभ्यास दिए गए हैं:

• घबराने के बजाय त्रुटियाँ लौटाएँ: अपने एप्लिकेशन को घबराने और क्रैश करने की बजाय, फ़ंक्शंस से त्रुटियाँ लौटाएँ और उन्हें उचित रूप से संभालें। यह आपके सीएलआई एप्लिकेशन में बेहतर नियंत्रण प्रवाह और पुनर्प्राप्ति तंत्र की अनुमति देता है।
• कस्टम त्रुटि प्रकारों का उपयोग करें: errors.New उपयोग करके या error इंटरफ़ेस लागू करके अपने स्वयं के त्रुटि प्रकार बनाएं। कस्टम त्रुटि प्रकार आपको त्रुटि होने पर क्या गलत हुआ, इसके बारे में अधिक विशिष्ट जानकारी देने में सक्षम बनाते हैं।
• त्रुटियों को स्रोत के करीब संभालें: जब भी संभव हो, त्रुटियों को उनके मूल के जितना करीब हो सके संभालें। यह आपके कोड की सरलता बनाए रखने में मदद करता है और जटिल परिस्थितियों में त्रुटि प्रबंधन के बारे में तर्क करना आसान बनाता है।

Try AppMaster no-code today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

लॉगिंग के लिए, गो मानक लाइब्रेरी log पैकेज प्रदान करती है, जो एक सरल और लचीला लॉगिंग इंटरफ़ेस प्रदान करती है। आप विभिन्न गंभीरता स्तरों के साथ संदेशों को लॉग करने और आउटपुट लक्ष्य को अनुकूलित करने के लिए पैकेज का उपयोग कर सकते हैं। अधिक उन्नत लॉगिंग क्षमताओं के लिए, लोकप्रिय github.com/sirupsen/logrus पैकेज के साथ संरचित लॉगिंग का उपयोग करने पर विचार करें। आपके सीएलआई एप्लिकेशन में प्रभावी लॉगिंग के लिए यहां कुछ सुझाव दिए गए हैं:

• सही लॉगिंग स्तर चुनें: गंभीर त्रुटियों, चेतावनियों और नियमित सूचनात्मक संदेशों के बीच अंतर करने के लिए लॉगिंग स्तरों का उपयोग करें। यह लॉग को अधिक कार्रवाई योग्य बनाता है और मुद्दों को अधिक कुशलता से पहचानने में मदद करता है।
• लॉग संदेशों में संदर्भ शामिल करें: लॉगिंग करते समय प्रासंगिक संदर्भ प्रदान करें, जैसे चर मान और फ़ंक्शन नाम। इससे समस्या निवारण के समय समस्याओं का पता लगाना आसान हो जाता है।
• संरचित लॉगिंग पर विचार करें: JSON जैसे मशीन-पठनीय प्रारूप में लॉग संदेशों को भेजने के लिए संरचित लॉगिंग का उपयोग करें। यह केंद्रीकृत लॉगिंग सिस्टम, लॉग एकत्रीकरण और विश्लेषण टूल के लिए विशेष रूप से उपयोगी है।

सीएलआई अनुप्रयोगों का परीक्षण और बेंचमार्किंग

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

• परीक्षण फ़ंक्शन बनाएं: अपने सीएलआई एप्लिकेशन घटकों के लिए परीक्षण फ़ंक्शन लिखें और उन्हें TestMyFunction जैसे Test के साथ उपसर्ग करें। इन फ़ंक्शंस को परीक्षण की जा रही स्रोत फ़ाइल के साथ एक अलग _test.go फ़ाइल में रखें।
• परीक्षण तालिकाओं का उपयोग करें: एकल परीक्षण फ़ंक्शन का उपयोग करके एकाधिक इनपुट-आउटपुट संयोजनों का परीक्षण करने के लिए परीक्षण तालिकाओं (जिन्हें टेबल-संचालित परीक्षण के रूप में भी जाना जाता है) को नियोजित करें। यह दृष्टिकोण आपके परीक्षण कोड को सरल बनाता है और इसे अधिक रखरखाव योग्य बनाता है।
• समानांतर में परीक्षण चलाएं: परीक्षणों को समवर्ती रूप से चलाने के लिए अपने परीक्षण कार्यों के भीतर t.Parallel() फ़ंक्शन का लाभ उठाएं। यह आपके परीक्षण सूट के निष्पादन को गति दे सकता है, खासकर जब संसाधन-गहन परीक्षणों से निपट रहा हो।
• परीक्षण कवरेज रिपोर्ट तैयार करें: कोड कवरेज रिपोर्ट तैयार करने के लिए go test -cover कमांड का उपयोग करें। इससे आपको अपने कोड के उन क्षेत्रों की पहचान करने में मदद मिलती है जिनके लिए अधिक गहन परीक्षण की आवश्यकता होती है और उच्च स्तर की परीक्षण कवरेज सुनिश्चित होती है।

आपके सीएलआई एप्लिकेशन घटकों के प्रदर्शन को मापने के लिए, गो उसी testing पैकेज के माध्यम से बेंचमार्किंग के लिए समर्थन प्रदान करता है। बेंचमार्क का उपयोग इस प्रकार करें:

• बेंचमार्क फ़ंक्शंस बनाएं: बेंचमार्क फ़ंक्शंस लिखें और उन्हें Benchmark के साथ बेंचमार्क करें, जैसे BenchmarkMyFunction । इन फ़ंक्शंस को उसी _test.go फ़ाइल में रखें जिसमें प्रासंगिक परीक्षण फ़ंक्शंस हों।
• testing.B पैरामीटर का उपयोग करें: उस कोड को चलाएं जिसे आप testing.B पैरामीटर द्वारा नियंत्रित लूप के भीतर बेंचमार्क करना चाहते हैं (उदाहरण for i := 0; i < bN; i++ { ... } सांख्यिकीय रूप से महत्वपूर्ण माप प्राप्त करने के लिए testing.B पैरामीटर स्वचालित रूप से testing पैकेज द्वारा समायोजित किया जाता है।
• बेंचमार्क परिणामों का विश्लेषण करें: अपने बेंचमार्क चलाने और परिणामों का विश्लेषण करने के लिए go test -bench कमांड का उपयोग करें। यह आपके सीएलआई एप्लिकेशन के उन क्षेत्रों को निर्धारित करने में आपकी सहायता कर सकता है जिन्हें अनुकूलन की आवश्यकता है और प्रदर्शन सुधारों के प्रभाव का आकलन करने में मदद मिल सकती है।

निष्कर्ष में, विश्वसनीय और कुशल सीएलआई एप्लिकेशन बनाने के लिए बाहरी पुस्तकालयों का उचित प्रबंधन, त्रुटि प्रबंधन, लॉगिंग, परीक्षण और बेंचमार्किंग महत्वपूर्ण हैं। इस आलेख में उल्लिखित विभिन्न उपकरणों, तकनीकों और सर्वोत्तम प्रथाओं का लाभ उठाकर, आप यह सुनिश्चित कर सकते हैं कि आपका गो-आधारित सीएलआई एप्लिकेशन उच्च स्तर की गुणवत्ता और उत्कृष्टता प्राप्त करता है। इसके अलावा, गो की शक्ति को ऐपमास्टर जैसे बहुमुखी प्लेटफार्मों के साथ संयोजित करने से सॉफ्टवेयर विकास प्रक्रियाओं में काफी तेजी आ सकती है, जिससे उत्कृष्ट परिणाम प्राप्त हो सकते हैं।

Try AppMaster no-code today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

आपके सीएलआई एप्लिकेशन का परिनियोजन और वितरण

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

निष्पादन योग्य का निर्माण

अपना गो सीएलआई एप्लिकेशन बनाने के लिए, लक्ष्य पैकेज या फ़ाइल के बाद go build कमांड का उपयोग करें:

 go build ./path/to/your/package

या:

 go build main.go

यह कमांड आपके वर्तमान प्लेटफ़ॉर्म (उदाहरण के लिए, विंडोज़, मैकओएस, लिनक्स) के लिए एक निष्पादन योग्य बाइनरी फ़ाइल बनाएगा और इसे वर्तमान कार्यशील निर्देशिका में रखेगा। डिफ़ॉल्ट रूप से, बाइनरी फ़ाइल का नाम एक्सटेंशन के बिना पैकेज के नाम या स्रोत फ़ाइल के नाम से मेल खाता है (उदाहरण के लिए, main )।

हालाँकि, आप आउटपुट बाइनरी फ़ाइल नाम निर्दिष्ट कर सकते हैं और -o ध्वज और पर्यावरण चर का उपयोग करके विभिन्न प्लेटफार्मों को लक्षित कर सकते हैं:

 GOOS=linux GOARCH=amd64 go build -o custom-name ./path/to/your/package

उपरोक्त उदाहरण में, हमने AMD64 आर्किटेक्चर के साथ लिनक्स को लक्षित करने के लिए गो बिल्ड प्रक्रिया को निर्देश देने के लिए GOOS और GOARCH पर्यावरण चर सेट किए हैं, और हम आउटपुट बाइनरी फ़ाइल नाम को custom-name पर सेट करते हैं।

विभिन्न प्लेटफार्मों के लिए क्रॉस-कंपाइलिंग

गो क्रॉस-संकलन को सरल बनाता है, और आप जटिल बिल्ड कॉन्फ़िगरेशन के बिना विभिन्न प्लेटफार्मों के लिए त्वरित रूप से निष्पादन योग्य बना सकते हैं। कई प्लेटफार्मों के लिए अपने गो सीएलआई एप्लिकेशन को क्रॉस-कंपाइल करने के लिए, तदनुसार GOOS और GOARCH पर्यावरण चर सेट करें। निम्नलिखित उदाहरण दर्शाता है कि विंडोज़, मैकओएस और लिनक्स के लिए गो सीएलआई एप्लिकेशन को क्रॉस-कंपाइल कैसे किया जाए:

 # For Windows 64-bit GOOS=windows GOARCH=amd64 go build -o mycli-windows.exe ./path/to/package # For macOS 64-bit GOOS=darwin GOARCH=amd64 go build -o mycli-macos ./path/to/package # For Linux 64-bit GOOS=linux GOARCH=amd64 go build -o mycli-linux ./path/to/package

आपका सीएलआई आवेदन वितरित करना

आप अपने प्रोजेक्ट की वेबसाइट पर या रीडमी दस्तावेज़ीकरण के भीतर सीधे डाउनलोड विकल्प प्रदान करके अपनी गो सीएलआई निष्पादन योग्य बाइनरी फ़ाइलों को वितरित कर सकते हैं। वैकल्पिक रूप से, पैकेजिंग सिस्टम, रिपॉजिटरी या पैकेज मैनेजर का उपयोग करके प्लेटफ़ॉर्म-विशिष्ट पैकेज के रूप में वितरित करें। कुछ लोकप्रिय पैकेज प्रबंधन प्रणालियों में शामिल हैं:

• Homebrew - पैकेजों को स्थापित करने और प्रबंधित करने के लिए उपयोगकर्ता के अनुकूल सिंटैक्स के साथ macOS और Linux के लिए एक पैकेज मैनेजर।
• एपीटी (डेबियन-आधारित सिस्टम) - उबंटू जैसे डेबियन-आधारित लिनक्स वितरण के लिए एक पैकेज प्रबंधक।
• आरपीएम (रेड हैट-आधारित सिस्टम) - फेडोरा जैसे रेड हैट-आधारित लिनक्स वितरण के लिए एक पैकेज प्रबंधक।

अंतिम विचार और संसाधन

गो के साथ शक्तिशाली सीएलआई एप्लिकेशन बनाना एक आनंददायक और फायदेमंद प्रक्रिया है। सादगी, प्रदर्शन और बाइनरी वितरण लाभ गो को इस उद्देश्य के लिए एक आदर्श प्रोग्रामिंग भाषा विकल्प बनाते हैं। जैसे-जैसे आप अपने गो सीएलआई अनुप्रयोगों को विकसित करना जारी रखते हैं, अपने ज्ञान का विस्तार करने और अपने कौशल में सुधार करने के लिए अतिरिक्त संसाधनों की खोज पर विचार करें:

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

इसके अलावा, AppMaster.io जैसे no-code प्लेटफ़ॉर्म की खोज करने पर विचार करें जो गो (गोलंग) को अपनी बैकएंड प्रोग्रामिंग भाषा के रूप में उपयोग करते हैं। AppMaster.io एक सहज ड्रैग-एंड-ड्रॉप इंटरफ़ेस प्रदान करता है जो आपको कोड की एक भी पंक्ति लिखे बिना वेब, मोबाइल और बैकएंड एप्लिकेशन विकसित करने की अनुमति देता है। गो और AppMaster.io जैसे no-code प्लेटफ़ॉर्म दोनों को समझकर, आप भविष्य में और भी अधिक परिष्कृत सॉफ़्टवेयर समाधान विकसित करने के लिए अच्छी तरह से सुसज्जित होंगे।