कोर्स जाओ

आधार: पैकेज, चर, प्रकार, स्थिरांक, ऑपरेटर और एफएमटी पैकेज के साथ इनपुट/आउटपुट।

1. 1.1चर और प्रकारvar, संक्षिप्त घोषणा `:=`, मूल प्रकार (int, फ्लोट64, स्ट्रिंग, बूल), और स्थिर टाइपिंग की अवधारणा।~10 min
2. 1.2शून्य मान और प्रकार रूपांतरणप्रत्येक चर का एक डिफ़ॉल्ट मान होता है; रूपांतरण स्पष्ट हैं (`int(x)`, `string(b)`)।~10 min
3. 1.3स्थिरांक और iotaपठनीय गणनाएँ उत्पन्न करने के लिए `const`, अलिखित स्थिरांक, और `iota` पैटर्न।~10 min
4. 1.4संचालकअंकगणित, तुलना, तार्किक और बिटवाइज़; अन्य भाषाओं से प्राथमिकता और अंतर।~8 min
5. 1.5एफएमटी के साथ इनपुट/आउटपुट`fmt.Println`, `fmt.Printf`, क्रिया स्वरूप (`%d`, `%s`, `%v`, `%T`) और कब एक को दूसरे पर प्राथमिकता देनी है।~10 min

निर्णय और दोहराव: यदि init कथनों के साथ, एकल `for`, मुहावरेदार स्विच, और स्पष्ट त्रुटि प्रबंधन।

1. 2.1यदि, अन्यथा, और init कथन`if v := f(); v > 0 { ... }` फॉर्म और गो के पास कोई टर्नरी ऑपरेटर क्यों नहीं है।~10 min
2. 2.2के लिए: एकमात्र लूप'के लिए' के तीन रूप: तीन-खंड, एकल-स्थिति (= जबकि), और अनंत; `ब्रेक` और `जारी रखें` का उपयोग करना।~10 min
3. 2.3के लिए...रेंजस्लाइस, मानचित्र और स्ट्रिंग्स पर पुनरावृति करें; लौटाया गया मान एक प्रतिलिपि है, जब सूचकांक या `_` वाले मान को अनदेखा करना है।~10 min
4. 2.4मुहावरेदार स्विचकोई अंतर्निहित फ़ॉलथ्रू नहीं, मामलों में जटिल अभिव्यक्तियाँ, यदि की श्रृंखला के रूप में किसी शर्त के बिना स्विच।~10 min
5. 2.5त्रुटियाँ: `यदि ग़लती !=शून्य` पैटर्नत्रुटियाँ मान हैं; मौलिक पैटर्न `if err != nil { return err }` और Go के पास कोई अपवाद क्यों नहीं है।~12 min

प्रथम श्रेणी के नागरिकों के रूप में कार्य: हस्ताक्षर, एकाधिक रिटर्न, विविध पैरामीटर, समापन, और `स्थगित`।

1. 3.1हस्ताक्षर और पैरामीटर`func name(p type) type` सिंटैक्स, डिफ़ॉल्ट रूप से पास-बाय-वैल्यू, एक ही प्रकार के पैरामीटर एक साथ समूहीकृत।~10 min
2. 3.2एकाधिक रिटर्न और नामित रिटर्नएकाधिक मान लौटाना (`मान, त्रुटि`), नामित रिटर्न पैटर्न, और कब इसका उपयोग नहीं करना है।~12 min
3. 3.3विविध कार्य`func sum(nums...int) int`, `slice...` के साथ एक स्लाइस फैलाना, stdlib से उदाहरण।~10 min
4. 3.4क्लोजर और मूल्यों के रूप में कार्य करता हैअनाम फ़ंक्शन जो आसपास के संदर्भ से चर कैप्चर करते हैं; एडाप्टर और फ़ैक्टरी पैटर्न।~12 min
5. 3.5`स्थगित`: गारंटीकृत सफ़ाईवापसी तक निष्पादन स्थगित करें; `defer f.Close()` पैटर्न, LIFO ऑर्डर, लूप्स के अंदर गेटचास।~12 min

सारणी, स्लाइस (सबसे महत्वपूर्ण संरचना), मानचित्र, स्ट्रिंग के अंदर रन, और सॉर्टिंग।

1. 4.1निश्चित-लंबाई सरणियाँ`[एन] टी` सिंटैक्स, गो में वास्तविक सरणियों का उपयोग शायद ही कभी क्यों किया जाता है, सरणी से स्लाइस में रूपांतरण।~8 min
2. 4.2स्लाइस: मुहावरेदार संरचना`बनाना`, `जोड़ना`, लेन/कैप, `s[a:b]` को काटना, अंतर्निहित सरणी को साझा करना, और कब कॉपी करना है।~15 min
3. 4.3मानचित्र: कुंजियाँ और मानघोषणा, अल्पविराम-ओके एक्सेस (`v, ok := m[k]`), `डिलीट`, गैर-नियतात्मक पुनरावृत्ति।~12 min
4. 4.4स्ट्रिंग्स, बाइट्स और रून्सस्ट्रिंग्स UTF-8 बाइट्स हैं; `रेंज` रन उत्पन्न करता है; `len()` बाइट्स गिनता है, अक्षर नहीं।~12 min
5. 4.5सॉर्ट पैकेज के साथ सॉर्टिंगतुलनात्मक फ़ंक्शन, स्थिरता के साथ `sort.Ints`, `sort.Strings`, `sort.Slice`।~10 min

समग्र डेटा प्रकार: संरचनाएं, मूल्य या सूचक रिसीवर पर विधियां, संरचना (कोई विरासत नहीं), और टैग।

1. 5.1किसी संरचना को परिभाषित करना और उसका उपयोग करना`प्रकार व्यक्ति संरचना {नाम स्ट्रिंग; आयु पूर्णांक }`, स्थितीय बनाम नामित आरंभीकरण, अनाम संरचनाएं।~12 min
2. 5.2तरीके: मूल्य बनाम सूचक रिसीवर`func (p व्यक्ति) Hello()` बनाम `func (p *व्यक्ति) नाम बदलें(n string)`; एक या दूसरे का उपयोग कब करना है।~14 min
3. 5.3रचना (एम्बेडिंग)गो की कोई विरासत नहीं है: आप एक प्रकार को दूसरे प्रकार के अंदर एम्बेड करके बनाते हैं। विधि प्रचार.~12 min
4. 5.4फ़ील्ड टैग और JSON`json:"name,omitempty"`, `encoding/json` के साथ मार्शलिंग/अनमर्शलिंग, सामान्य गलतियाँ।~12 min
5. 5.5`नया...` कंस्ट्रक्टर पैटर्नगो के पास कोई कंस्ट्रक्टर नहीं है: कन्वेंशन एक `NewT(...) *T` फ़ंक्शन है जो त्रुटियों को मान्य करता है और लौटाता है।~10 min

संरचनात्मक इंटरफ़ेस (कोई स्पष्ट कार्यान्वयन नहीं), अभिकथन, प्रकार स्विच, और मानक `स्ट्रिंगर` और `त्रुटि` इंटरफ़ेस।

1. 6.1इंटरफेस: एक व्यवहार को परिभाषित करनाएक इंटरफ़ेस विधियों का एक सेट है; जो कोई भी उन्हें लागू करता है वह स्वचालित रूप से इसे संतुष्ट करता है (स्टेटिक डक टाइपिंग)।~12 min
2. 6.2अभिकथन टाइप करें`v, ok := i.(*MyT)`, घबराहट से बचने के लिए अल्पविराम-ओके फॉर्म, एक प्रकार के स्विच पर एक अभिकथन को कब प्राथमिकता दी जाए।~10 min
3. 6.3स्विच टाइप करें`स्विच v := x.(type) { केस int: ... }` रनटाइम प्रकार पर भेजने के लिए।~10 min
4. 6.4स्ट्रिंगर इंटरफ़ेस`String() string` को लागू करने से `fmt.Println` आपके प्रकार को कैसे दर्शाता है, यह बदल जाता है।~10 min
5. 6.5त्रुटि इंटरफ़ेस`त्रुटि` सिर्फ `त्रुटि() स्ट्रिंग` है; कस्टम त्रुटियाँ बनाना, `errors.Is`, `errors.As`, `fmt.Errorf("%w", err)`।~14 min

गो का समवर्ती मॉडल: हल्का गोरोइन, संचार के लिए चैनल, `चयन`, सिंक और संदर्भ।

1. 7.1गोरोइन्स: हल्की समानता`go f()`, एक गोरोइन की लागत, प्रतीक्षा किए बिना मुख्य निकास क्यों, और सिंक्रनाइज़ कैसे करें।~12 min
2. 7.2चैनल: टाइप किया गया संचार`ch := make(chan int)`, `ch <- v`, `v := <-ch`, बफ़र्ड बनाम अनबफ़र्ड चैनल, समापन।~15 min
3. 7.3`चयन करें`: मल्टीप्लेक्सिंग चैनलपहले तैयार चैनल की प्रतीक्षा करें, अवरोध से बचने के लिए `डिफ़ॉल्ट` केस, `time.After` के साथ टाइमआउट पैटर्न।~12 min
4. 7.4`sync.Mutex` और `sync.WaitGroup`जब चैनल पर्याप्त न हों: म्यूटेक्स के साथ साझा स्थिति की रक्षा करें, वेटग्रुप के साथ एन गोरआउट्स की प्रतीक्षा करें।~14 min
5. 7.5`context.Context`: रद्दीकरण और समय सीमाgoroutines, `context.WithTimeout`, `ctx.Done()`, प्रथम-पैरामीटर पैटर्न में रद्दीकरण का प्रचार करें।~14 min

वे पैकेज जो आप हर दिन उपयोग करेंगे: एफएमटी, स्ट्रिंग्स, स्ट्रोनव, आईओ, ओएस, टाइम, एन्कोडिंग/जेसन।

1. 8.1उन्नत `एफएमटी``स्प्रिंटफ`, `एफप्रिंटफ`, `%+v` और `%#v` क्रियाएं, चौड़ाई और सटीक स्वरूपण, `-` और `0` झंडे।~10 min
2. 8.2`स्ट्रिंग्स` और `strconv``strings.Contains/Split/Join/TrimSpace`, `strconv.Itoa/Atoi/ParseInt/FormatFloat`।~12 min
3. 8.3`io` और `os`: फ़ाइलें और स्ट्रीम`os.Open/Create/ReadFile/WriteFile`, `io.Reader/Writer` इंटरफेस, `defer f.Close()` पैटर्न।~14 min
4. 8.4'समय' पैकेज`time.Now()`, अवधि, संदर्भ लेआउट के साथ पार्सिंग `2006-01-02 15:04:05`, टाइमर और टिकर।~12 min
5. 8.5`एन्कोडिंग/जेसन``json.Marshal/Unmarshal`, स्ट्रक्चर टैग, स्ट्रीम के लिए `json.Decoder/Encoder`, पार्सिंग त्रुटियाँ।~14 min

`गो टेस्ट` टूल, टेबल-संचालित परीक्षण, बेंचमार्क, `गो मॉड` के साथ निर्भरता प्रबंधन, और टैग बनाएं।

1. 9.1'परीक्षण' पैकेज`*_test.go` फ़ाइलें, `TestXxx(t *testing.T)` फ़ंक्शंस, `t.Error` बनाम `t.Fatal`, `go test ./...`।~12 min
2. 9.2टेबल-संचालित परीक्षणमुहावरेदार पैटर्न: इनपुट और अपेक्षित आउटपुट के साथ अज्ञात संरचनाओं का एक टुकड़ा, उप-परीक्षणों के लिए `t.Run(नाम, ...)`।~14 min
3. 9.3बेंचमार्क और प्रोफाइल`BenchmarkXxx(b *testing.B)` फ़ंक्शंस, `for i := 0; मैं <बीएन; i++` लूप, `गो टेस्ट -बेंच=.`।~12 min
4. 9.4जाओ मॉड्यूल`गो मॉड इनिट`, `गो गेट`, सिमेंटिक इंपोर्ट वर्जनिंग, `गो.सम` लॉकफाइल, `गो मॉड साफ`।~12 min
5. 9.5बाधाएं और टैग बनाएंक्रॉस-प्लेटफ़ॉर्म बिल्ड के लिए `//go:build ...` निर्देश, परीक्षण/एकीकरण कोड, वास्तविक दुनिया के उदाहरणों को अलग करता है।~10 min

नामकरण, उन्नत त्रुटि प्रबंधन, जेनेरिक (गो 1.18+), और दो मिनी-प्रोजेक्ट: एक सीएलआई और एक HTTP सर्वर।

1. 10.1नामकरण परंपराएं और शैलीनिर्यात के लिए पास्कलकेस, स्थानीय लोगों के लिए कैमलकेस, छोटे दायरे में संक्षिप्त नाम, `gofmt` गैर-परक्राम्य है।~10 min
2. 10.2मुहावरेदार त्रुटि प्रबंधनसेंटिनल त्रुटियाँ (`io.EOF`), `अनरैप` के साथ कस्टम त्रुटियाँ, `%w` के साथ रैपिंग, `पैनिक` का उपयोग कब करें।~14 min
3. 10.3जेनेरिक (गो 1.18+)पैरामीटर टाइप करें `func मैप[T, U कोई भी](s []T, f func(T) U) []U`, बाधाएं (`तुलनीय`, कस्टम), ट्रेड-ऑफ़।~15 min
4. 10.4मिनी-प्रोजेक्ट: झंडों के साथ एक सीएलआई`फ़्लैग` पैकेज, आदेश और उप-आदेश, निकास कोड, आउटपुट के लिए `लॉग` बनाम `एफएमटी`।~18 min
5. 10.5मिनी-प्रोजेक्ट: एक HTTP सर्वर`नेट/http`, न्यूनतम हैंडलर और राउटर, डेकोरेटर के रूप में मिडलवेयर, संदर्भ के साथ सुंदर शटडाउन।~18 min