కోర్సు వెళ్ళండి

పునాదులు: ప్యాకేజీలు, వేరియబుల్స్, రకాలు, స్థిరాంకాలు, ఆపరేటర్లు మరియు fmt ప్యాకేజీతో ఇన్‌పుట్/అవుట్‌పుట్.

1. 1.1వేరియబుల్స్ మరియు రకాలుvar, సంక్షిప్త ప్రకటన `:=`, ప్రాథమిక రకాలు (int, float64, string, bool), మరియు స్టాటిక్ టైపింగ్ భావన.~10 min
2. 1.2సున్నా విలువ మరియు రకం మార్పిడులుప్రతి వేరియబుల్ డిఫాల్ట్ విలువను కలిగి ఉంటుంది; మార్పిడులు స్పష్టంగా ఉన్నాయి (`int(x)`, `string(b)`).~10 min
3. 1.3స్థిరాంకాలు మరియు అయోటా`const`, టైప్ చేయని స్థిరాంకాలు మరియు చదవగలిగే గణనలను రూపొందించడానికి `iota` నమూనా.~10 min
4. 1.4ఆపరేటర్లుఅంకగణితం, పోలిక, లాజికల్ మరియు బిట్‌వైస్; ఇతర భాషల నుండి ప్రాధాన్యత మరియు తేడాలు.~8 min
5. 1.5fmtతో ఇన్‌పుట్/అవుట్‌పుట్`fmt.Println`, `fmt.Printf`, ఫార్మాట్ క్రియలు (`%d`, `%s`, `%v`, `%T`) మరియు ఒకదానిపై మరొకటి ఎప్పుడు ప్రాధాన్యత ఇవ్వాలి.~10 min

నిర్ణయాలు మరియు పునరావృత్తులు: init స్టేట్‌మెంట్‌లతో ఉంటే, సింగిల్ `ఫర్`, ఇడియోమాటిక్ స్విచ్ మరియు స్పష్టమైన ఎర్రర్ హ్యాండ్లింగ్.

1. 2.1if, else, మరియు init స్టేట్‌మెంట్‌లుది `if v := f(); v > 0 { ... }` ఫారమ్ మరియు ఎందుకు గోకి టెర్నరీ ఆపరేటర్ లేదు.~10 min
2. 2.2కోసం: ఏకైక లూప్`ఫర్` యొక్క మూడు రూపాలు: మూడు-నిబంధన, ఒకే-షరతు (= అయితే) మరియు అనంతం; `బ్రేక్` మరియు `కొనసాగించు` ఉపయోగించి.~10 min
3. 2.3కోసం...పరిధిస్లైస్‌లు, మ్యాప్‌లు మరియు స్ట్రింగ్‌లపై మళ్లించండి; అందించిన విలువ ఒక కాపీ, ఎప్పుడు ఇండెక్స్ లేదా విలువను `_`తో విస్మరించాలో.~10 min
4. 2.4ఇడియోమాటిక్ స్విచ్అవ్యక్త ఫాల్‌త్రూ లేదు, సందర్భాలలో సంక్లిష్ట వ్యక్తీకరణలు, if యొక్క గొలుసుగా షరతు లేకుండా మారండి.~10 min
5. 2.5లోపాలు: `ఇఫ్ ఎర్రర్ != nil` నమూనాలోపాలు విలువలు; ప్రాథమిక నమూనా `ఇఫ్ ఎర్రర్ != నిల్ {రిటర్న్ ఎర్రర్ }` మరియు ఎందుకు గోకి మినహాయింపులు లేవు.~12 min

ఫస్ట్-క్లాస్ పౌరులుగా విధులు: సంతకాలు, బహుళ రిటర్న్‌లు, విభిన్న పారామితులు, మూసివేతలు మరియు `డిఫర్`.

1. 3.1సంతకం మరియు పారామితులు`ఫంక్ పేరు(పి రకం) రకం` సింటాక్స్, డిఫాల్ట్‌గా పాస్-బై-వాల్యూ, ఒకే రకమైన పారామితులు కలిసి సమూహం చేయబడ్డాయి.~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`డిఫర్`: హామీ క్లీనప్తిరిగి వచ్చే వరకు అమలును వాయిదా వేయండి; `డిఫర్ f.Close()` నమూనా, LIFO ఆర్డర్, లూప్‌ల లోపల గోచాస్.~12 min

శ్రేణులు, స్లైస్‌లు (అత్యంత ముఖ్యమైన నిర్మాణం), మ్యాప్‌లు, స్ట్రింగ్‌ల లోపల రూన్‌లు మరియు సార్టింగ్.

1. 4.1స్థిర-పొడవు శ్రేణులు`[N]T` సింటాక్స్, గోలో నిజమైన శ్రేణులు ఎందుకు అరుదుగా ఉపయోగించబడుతున్నాయి, శ్రేణి నుండి స్లైస్‌కి మార్చడం.~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నిర్మాణాన్ని నిర్వచించడం మరియు ఉపయోగించడం`టైప్ పర్సన్ స్ట్రక్ట్ {నేమ్ స్ట్రింగ్; వయస్సు పూర్ణం }`, పొజిషనల్ vs పేరు పెట్టబడిన ప్రారంభీకరణ, అనామక నిర్మాణాలు.~12 min
2. 5.2పద్ధతులు: విలువ vs పాయింటర్ రిసీవర్`func (p Person) Hello()` vs `func (p *Person) పేరుమార్చు(n స్ట్రింగ్)`; ఒకటి లేదా మరొకటి ఎప్పుడు ఉపయోగించాలి.~14 min
3. 5.3కూర్పు (పొందుపరచడం)గోకి ఎటువంటి వారసత్వం లేదు: మీరు ఒక రకాన్ని మరొకదానిలో పొందుపరచడం ద్వారా కంపోజ్ చేస్తారు. పద్ధతి ప్రమోషన్.~12 min
4. 5.4ఫీల్డ్ ట్యాగ్‌లు మరియు JSON`json:"name,omitempty"`, `ఎన్‌కోడింగ్/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స్విచ్ టైప్ చేయండి`switch v := x.(type) { case int: ... }` రన్‌టైమ్ రకంపై పంపడానికి.~10 min
4. 6.4స్ట్రింగర్ ఇంటర్‌ఫేస్`స్ట్రింగ్() స్ట్రింగ్`ని అమలు చేయడం వల్ల `fmt.Println` మీ రకాన్ని ఎలా సూచిస్తుందో మారుతుంది.~10 min
5. 6.5లోపం ఇంటర్ఫేస్`ఎర్రర్` కేవలం `ఎర్రర్() స్ట్రింగ్`; కస్టమ్ లోపాలను సృష్టించడం, `ఎర్రర్స్.ఇస్`, `ఎర్రర్స్.అస్`, `fmt.Errorf("%w", ఎర్రర్)`.~14 min

గో యొక్క కాన్కరెన్సీ మోడల్: తేలికైన గోరౌటిన్‌లు, కమ్యూనికేషన్ కోసం ఛానెల్‌లు, `సెలెక్ట్`, సింక్ మరియు సందర్భం.

1. 7.1గోరౌటీన్స్: తేలికైన సమాంతరత`go f()`, గోరౌటిన్ యొక్క ధర, వేచి ఉండకుండా ప్రధాన నిష్క్రమణ ఎందుకు మరియు ఎలా సమకాలీకరించాలి.~12 min
2. 7.2ఛానెల్‌లు: టైప్ చేసిన కమ్యూనికేషన్`ch := make(chan int)`, `ch <- v`, `v := <-ch`, బఫర్ vs బఫర్ చేయని ఛానెల్‌లు, మూసివేయడం.~15 min
3. 7.3`సెలెక్ట్`: మల్టీప్లెక్సింగ్ ఛానెల్‌లుమొదటి సిద్ధంగా ఉన్న ఛానెల్ కోసం వేచి ఉండండి, నిరోధించడాన్ని నివారించడానికి `డిఫాల్ట్` కేస్, `సమయం. తర్వాత`తో గడువు ముగింపు నమూనా.~12 min
4. 7.4`sync.Mutex` మరియు `sync.WaitGroup`ఛానెల్‌లు సరిపోనప్పుడు: Mutexతో భాగస్వామ్య స్థితిని రక్షించండి, WaitGroupతో N గోరౌటిన్‌ల కోసం వేచి ఉండండి.~14 min
5. 7.5`context.Context`: రద్దు మరియు గడువులుగోరౌటీన్‌ల అంతటా రద్దును ప్రచారం చేయండి, `సందర్భం.సమయంతో`, `ctx.Done()`, మొదటి-పరామితి నమూనా.~14 min

మీరు ప్రతిరోజూ ఉపయోగించే ప్యాకేజీలు: fmt, strings, strconv, io, os, time, encoding/json.

1. 8.1అధునాతన `fmt``Sprintf`, `Fprintf`, `%+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` ఇంటర్‌ఫేస్‌లు, `డిఫర్ f.Close()` నమూనా.~14 min
4. 8.4`సమయం` ప్యాకేజీ`time.Now()`, వ్యవధులు, సూచన లేఅవుట్ `2006-01-02 15:04:05`, టైమర్‌లు మరియు టిక్కర్‌లతో అన్వయించడం.~12 min
5. 8.5`ఎన్‌కోడింగ్/json``json.Marshal/Unmarshal`, స్ట్రక్ట్ ట్యాగ్‌లు, స్ట్రీమ్‌ల కోసం `json.Decoder/Encoder`, పార్సింగ్ లోపాలు.~14 min

`గో టెస్ట్` టూల్, టేబుల్ ఆధారిత పరీక్షలు, బెంచ్‌మార్క్‌లు, `గో మోడ్`తో డిపెండెన్సీ మేనేజ్‌మెంట్ మరియు బిల్డ్ ట్యాగ్‌లు.

1. 9.1`టెస్టింగ్` ప్యాకేజీ`*_test.go` ఫైల్‌లు, `TestXxx(t *testing.T)` ఫంక్షన్‌లు, `t.Error` vs `t.Fatal`, `గో టెస్ట్ ./...`.~12 min
2. 9.2టేబుల్ ఆధారిత పరీక్షలుఇడియోమాటిక్ ప్యాటర్న్: ఇన్‌పుట్‌లు మరియు ఊహించిన అవుట్‌పుట్‌లతో అనామక నిర్మాణాల స్లైస్, ఉప-పరీక్షల కోసం `t.Run(name, ...)`.~14 min
3. 9.3బెంచ్‌మార్క్‌లు మరియు ప్రొఫైల్‌లు`BenchmarkXxx(b *testing.B)` ఫంక్షన్‌లు, `i := 0; i < b.N; i++` లూప్, `గో టెస్ట్ -బెంచ్=.`.~12 min
4. 9.4గో మాడ్యూల్స్`గో మోడ్ ఇనిట్`, `గో గెట్`, సెమాంటిక్ ఇంపోర్ట్ వెర్షన్, `go.sum` లాక్‌ఫైల్, `గో మోడ్ టైడీ`.~12 min
5. 9.5అడ్డంకులు మరియు ట్యాగ్‌లను రూపొందించండిక్రాస్-ప్లాట్‌ఫారమ్ బిల్డ్‌ల కోసం `//go:build ...` డైరెక్టివ్, టెస్ట్/ఇంటిగ్రేషన్ కోడ్‌ను వేరు చేయడం, వాస్తవ-ప్రపంచ ఉదాహరణలు.~10 min

పేరు పెట్టడం, అధునాతన ఎర్రర్ హ్యాండ్లింగ్, జెనరిక్స్ (గో 1.18+), మరియు రెండు చిన్న-ప్రాజెక్ట్‌లు: ఒక CLI మరియు ఒక HTTP సర్వర్.

1. 10.1నామకరణ సంప్రదాయాలు మరియు శైలిఎగుమతుల కోసం పాస్కల్‌కేస్, స్థానికుల కోసం ఒంటెకేస్, షార్ట్ స్కోప్‌లలో షార్ట్ నేమ్‌లు, `gofmt` అనేది చర్చించబడదు.~10 min
2. 10.2ఇడియోమాటిక్ ఎర్రర్ హ్యాండ్లింగ్సెంటినల్ ఎర్రర్‌లు (`io.EOF`), `అన్‌ర్యాప్`తో అనుకూల లోపాలు, `%w`తో చుట్టడం, `పానిక్` ఎప్పుడు ఉపయోగించాలి.~14 min
3. 10.3జెనరిక్స్ (గో 1.18+)టైప్ పారామితులు `func Map[T, U ఏదైనా](s []T, f func(T) U) []U`, పరిమితులు (`comparable`, custom), trade-offs.~15 min
4. 10.4మినీ-ప్రాజెక్ట్: ఫ్లాగ్‌లతో కూడిన CLIఅవుట్‌పుట్ కోసం `ఫ్లాగ్` ప్యాకేజీ, ఆదేశాలు మరియు ఉప-కమాండ్‌లు, నిష్క్రమణ కోడ్‌లు, `లాగ్` vs `fmt`.~18 min
5. 10.5మినీ-ప్రాజెక్ట్: ఒక HTTP సర్వర్`net/http`, కనిష్ట హ్యాండ్లర్ మరియు రూటర్, డెకరేటర్‌లుగా మిడిల్‌వేర్, సందర్భానుసారంగా ఆకర్షణీయమైన షట్‌డౌన్.~18 min