वह सब कुछ जो आपको लिखना शुरू करने के लिए जानना चाहिए

गो आधुनिक प्रोग्रामिंग भाषाओं में से एक है, जो डेवलपर्स की पसंदीदा भाषा के रूप में कई सर्वेक्षणों पर कर्षण प्राप्त कर रही है। शीर्ष स्तरीय प्रदर्शन प्रदान करते हुए गो के पास उपयोग में आसान और सिंटैक्स को समझना है।

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

गो में वे अधिकांश विशेषताएं हैं जिनकी आप आधुनिक भाषा में अपेक्षा करते हैं: जेनरिक, संगामिति, प्रकार अनुमान, कचरा संग्रह, और बहुत कुछ।

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

आप अधिकांश ऑपरेटिंग सिस्टम पर गो चला सकते हैं। की ओर जाना स्थापना पृष्ठ और अपने ऑपरेटिंग सिस्टम के लिए पसंदीदा गो संस्करण डाउनलोड करें।

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

आप पाएंगे कि गो में अधिकांश सुविधाएं और अन्य प्रोग्रामिंग भाषाओं की अधिक कार्यक्षमता है। यदि आपके पास पिछले प्रोग्रामिंग का अनुभव है, तो आपको सीधा जाना चाहिए।

गो में चर

गो मौलिक स्तर पर काफी अभिव्यंजक है। आप दो तरीकों से गो में चर घोषित कर सकते हैं। आप उपयोग कर सकते हैं वर कीवर्ड विभिन्न डेटा प्रकारों के चर घोषित करने के लिए। पहचानकर्ता निर्दिष्ट करने के बाद, आपको चर का डेटा प्रकार सेट करना होगा।

वर ए डोरी
वर बी int यहाँ
वर सी कोई
वर आयु डोरी = "पांच साल पुराना"
वर उम्र = 5// var आयु int = 5 के बराबर
fmt. Println (उम्र)

आप उपयोग कर सकते हैं कोई डेटा प्रकार के रूप में यदि आप चर के डेटा प्रकार के बारे में अनिश्चित हैं।

आप के साथ स्थिरांक भी घोषित कर सकते हैं कॉन्स्ट चर घोषित करने के लिए समान रूप से कीवर्ड।

कॉन्स्ट आयु = "पांच वर्ष"

उनकी घोषणा के बाद स्थिरांक को संशोधित करना असंभव है।

गो कार्यों में चर घोषित करने का एक वैकल्पिक तरीका प्रदान करता है। बराबर चिह्न से पहले एक कोलन के उपयोग पर ध्यान दें:

समारोहमुख्य() {
 आयु: = "पांच वर्ष" // var आयु के बराबर = "पांच वर्ष पुराना"
}

गो में सशर्त

गो के पास कार्यक्रमों में निर्णय लेने की शर्तें भी हैं। आप उपयोग कर सकते हैं अगर और अन्य निर्णयों को संभालने के लिए आपके कोड में कथन।

यहाँ एक उदाहरण है अगर कथन जो समानता के लिए दो पूर्णांकों की तुलना करता है:

वर ए int यहाँ = 12
अगर एक == 12 {
 fmt. Println ("ए बारह के बराबर है")
}

यूज ही कर सकते हैं अन्य एक निर्दिष्ट करने के बाद बयान अगर कथन, और आपको निर्दिष्ट करना होगा अन्य बंद होने के बाद ब्लॉक करें अगर अवरोध पैदा करना:

वर ए int यहाँ = 12
अगर एक == 12 {
 fmt. Println ("ए बारह के बराबर है")
} अन्य {
 fmt. Println ("एक बारह के बराबर नहीं है")
}

अन्य ब्लॉक तभी चलता है जब अगर कथन असत्य का मूल्यांकन करता है। गो अन्य-यदि कथन प्रदान नहीं करता है, लेकिन आप इसका उपयोग कर सकते हैं बदलना जटिल सशर्त बयानों के लिए बयान।

यहाँ एक की शारीरिक रचना है बदलना गो में बयान।

उम्र := 7
बदलना आयु {
मामला1:
 fmt. प्रिंट्लन ("एक")
मामला2:
 fmt. प्रिंट्लन ("दो")
मामला3:
 fmt. प्रिंट्लन ("तीन")
गलती करना:
 fmt. प्रिंट्लन ("शून्य")
}

आप इसके साथ स्विच स्टेटमेंट बना सकते हैं बदलना कीवर्ड, जिसके बाद आप विभिन्न मामलों को निर्दिष्ट कर सकते हैं मामला कीवर्ड। आप a का उपयोग करके डिफ़ॉल्ट मामले को संभाल सकते हैं गलती करना कीवर्ड।

लूप्स इन गो के लिए

गो दोहराए जाने वाले कार्यों के लिए फॉर-लूप प्रदान करता है, और अधिकांश भाषाओं के विपरीत, गो में कोई समय या डू-लूप नहीं है।

आप लोकप्रिय सी-स्टाइल फॉर-लूप या का उपयोग कर सकते हैं श्रेणी for-loop कि कुछ डेटा संरचनाएं समर्थन करती हैं।

गो प्रोग्राम में लूप के लिए सी-स्टाइल का उपयोग करने का एक उदाहरण यहां दिया गया है:

समारोहमुद्रक() {
के लिए मैं := 0; मैं <= 3; मैं++ {
 fmt. प्रिंटलाइन (i)
 }
}

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

के लिए सूचकांक, मूल्य: = श्रेणी डेटा संरचना {
}

गो में एरे

Arrays गो में मिश्रित डेटा प्रकारों में से एक है। गो सरणियाँ सी-शैली सरणियों के समान हैं और घोषणा और तात्कालिकता पर एक निश्चित लंबाई होती है।

यहां बताया गया है कि आप गो में सरणियों की घोषणा कैसे कर सकते हैं:

वर गिरफ्तार [5]डोरी
आगमन := [7]int यहाँ{0, 1, 2, 3, 4, 5, 6}

आप ऐरे की स्थिति में तत्वों को एक्सेस करने, असाइन करने और अपडेट करने के लिए इंडेक्सिंग का उपयोग कर सकते हैं:

गिरफ्तार [3] = "तीन"

उपरोक्त कोड अद्यतन करता है या स्ट्रिंग को चौथी प्रविष्टि के रूप में सम्मिलित करता है आगमन सरणी चर।

गो में स्लाइस

गो अनिश्चित लंबाई के डेटा से निपटने के लिए सरणियों के विकल्प के रूप में स्लाइस प्रदान करता है। स्लाइस सरणियों के समान हैं, सिवाय इसके कि आप स्लाइस की लंबाई बदल सकते हैं।

आपको बिल्ट-इन का उपयोग करने की आवश्यकता होगी निर्माण एक टुकड़ा बनाने के लिए कार्य करें। स्लाइस के डेटा प्रकार और आरंभिक लंबाई को मेक फंक्शन में पास करें।

टुकड़ा := निर्माण([]डोरी, 9)
टुकड़ा[2] = "दो"

तत्वों को स्लाइस में सम्मिलित करने के लिए आप एपेंड फ़ंक्शन का उपयोग कर सकते हैं। डिफ़ॉल्ट रूप से, संलग्न फ़ंक्शन स्लाइस के अंत में तत्वों को सम्मिलित करता है।

टुकड़ा = संलग्न(टुकड़ा, "दस")

स्लाइस पर एपेंड ऑपरेशंस काम करना महंगा हो सकता है क्योंकि गो प्रत्येक एपेंड ऑपरेशन पर एक नया एरे बनाता है।

गो में मानचित्र

मैप्स गो में बिल्ट-इन एसोसिएटिव (की-वैल्यू पेयर) डेटा टाइप हैं। आप उपयोग कर सकते हैं निर्माण एक नक्शा या एक साधारण घोषणा बनाने के लिए कार्य करें जहाँ आपको मानचित्र को तुरंत चालू करना होगा।

नक्शे := निर्माण(नक्शा[डोरी]int यहाँ) // मेक फंक्शन का उपयोग करके
नक्शे := नक्शा[डोरी]int यहाँ{"एक": 1, "दो": 2, "तीन": 3} // मानचित्र घोषित करना और तत्काल करना

आप कुंजियों को निर्दिष्ट करके मानचित्र में मानों तक पहुँच सकते हैं। साथ ही, आप कुंजी-मूल्य युग्म निर्दिष्ट करके मानचित्र में मान सम्मिलित कर सकते हैं।

मानचित्र ["एक"] = 1// मानचित्र में सम्मिलित करना
एक: = नक्शे ["एक"] // मानचित्र से तत्व तक पहुँचना

आप उपयोग कर सकते हैं मिटाना नक्शे से कुंजी-मूल्य जोड़े को हटाने का कार्य। मिटाना फ़ंक्शन मानचित्र के पहचानकर्ता और उस जोड़ी की कुंजी लेता है जिसे आप हटाना चाहते हैं:

मिटाना(नक्शे, "एक")

गो में कार्य करता है

गो में कोड पुन: प्रयोज्य के लिए कार्य उपकरण हैं। आप के साथ कार्यों की घोषणा कर सकते हैं समारोह फ़ंक्शन के पहचानकर्ता के बाद कीवर्ड:

समारोहमुख्य() {
}

कार्य तर्कों को स्वीकार कर सकते हैं और मान वापस कर सकते हैं। आपको तर्कों के लिए पहचानकर्ता के साथ तर्क प्रकार निर्दिष्ट करना होगा।

समारोहजोड़ना(एक्स डोरी, वाई int यहाँ)int यहाँ {
वापस करना एक्स + वाई
}

आप फ़ंक्शन के कोड ब्लॉक से पहले वापसी प्रकार निर्दिष्ट करेंगे और मान लौटाने वाले फ़ंक्शन के लिए निर्दिष्ट प्रकार का मान लौटाएंगे।

गो में संरचनाएं

जाओ एक नहीं है वस्तु उन्मुख भाषा डिजाइन द्वारा, लेकिन आप गो में ऑब्जेक्ट-ओरिएंटेड सुविधाओं को लागू कर सकते हैं स्ट्रक्चर्स का उपयोग करना।

अन्य डेटा प्रकारों को एक इकाई में समूहित करने के लिए स्ट्रक्चर्स उपयोगकर्ता-परिभाषित प्रकार हैं। गो स्ट्रक्चर्स किसी भी गो-समर्थित प्रकार के मान रख सकते हैं, और फ़ंक्शंस स्ट्रक्चर्स को लागू कर सकते हैं।

यहां बताया गया है कि आप गो में संरचना कैसे घोषित कर सकते हैं:

प्रकार खेल struct {
 नाम डोरी
 वर्ष int यहाँ
 विश्राम फ्लोट64
 खिलाड़ी कोई
 देशों नक्शा[डोरी]डोरी
}

खेल संरचना में मानचित्र, स्ट्रिंग, पूर्णांक और फ़्लोटिंग पॉइंट के प्रकार वाले फ़ील्ड हैं। आप डिफॉल्ट वैल्यू के साथ स्ट्रक्चर को इंस्टेंट कर सकते हैं या उन्हें वैल्यू असाइन कर सकते हैं।

वर एमको गेम // डिफ़ॉल्ट मान इन्स्टेन्शियशन
// मूल्यों के साथ तत्काल
एमको := खेल{
 नाम: "मूल्य",
 वर्ष: 1231,
 खेलने का समय: 1345412,
 खिलाड़ियों: [2]डोरी{"9", "सामग्री"},
 आंकड़े: नक्शा[डोरी]int यहाँ{"एक": 1, "दो": 2, "तीन": 2},
}

कार्य संरचना प्रकारों को कार्यान्वित और एक्सेस कर सकते हैं। फ़ंक्शन के पहचानकर्ता से पहले आपको संरचना पैरामीटर निर्दिष्ट करना होगा।

समारोह(जी खेल)खेल ढूंढें(नाम डोरी) {
 अ := जी। वर्ष // संरचना क्षेत्रों तक पहुँचना
वर बी = जी। देशों // संरचना क्षेत्रों तक पहुँचना
}

जब आप किसी फ़ंक्शन को स्ट्रक्चर पास करते हैं, तो फ़ंक्शन के पास स्ट्रक्चर के फ़ील्ड तक पहुंच होती है, और फ़ंक्शन एक स्ट्रक्चर विधि बन जाता है।

गो के कई उपयोग मामले हैं

आपने गो प्रोग्राम लिखना शुरू करने के लिए गो प्रोग्रामिंग भाषा और सिंटैक्स की मूल बातें सीख ली हैं।

ऐसे कई क्षेत्र और एप्लिकेशन हैं जहां आप गो का उपयोग कर सकते हैं। गो लोकप्रिय रूप से सर्वर-साइड भाषा के रूप में उपयोग किया जाता है, और आप हमेशा इसके साथ वेब-आधारित एप्लिकेशन बनाने का भी पता लगा सकते हैं।