கோ கோர்ஸ்

அடித்தளங்கள்: தொகுப்புகள், மாறிகள், வகைகள், மாறிலிகள், ஆபரேட்டர்கள் மற்றும் 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 அறிக்கைகளுடன் இருந்தால், ஒற்றை `for`, idiomatic switch மற்றும் வெளிப்படையான பிழை கையாளுதல்.

1. 2.1if, else, மற்றும் init அறிக்கைகள்`if v := f(); v > 0 { ... }` படிவம் மற்றும் ஏன் Go க்கு மும்முனை ஆபரேட்டர் இல்லை.~10 min
2. 2.2இதற்கு: ஒரே வளையம்`for` இன் மூன்று வடிவங்கள்: மூன்று-பிரிவு, ஒற்றை-நிலை (= while), மற்றும் எல்லையற்றது; `பிரேக்` மற்றும் `தொடரவும்` பயன்படுத்தி.~10 min
3. 2.3வரம்பிற்குதுண்டுகள், வரைபடங்கள் மற்றும் சரங்களை மீண்டும் செய்யவும்; திரும்பிய மதிப்பு ஒரு நகலாகும், குறியீட்டை அல்லது மதிப்பை `_` உடன் புறக்கணிக்கும்போது.~10 min
4. 2.4இடியோமேடிக் சுவிட்ச்மறைமுகமான சரிவு இல்லை, வழக்குகளில் சிக்கலான வெளிப்பாடுகள், if இன் சங்கிலியாக நிபந்தனை இல்லாமல் மாறவும்.~10 min
5. 2.5பிழைகள்: `if err != nil` முறைபிழைகள் மதிப்புகள்; அடிப்படை முறை `if err != nil { return err }` மற்றும் ஏன் Go விதிவிலக்கு இல்லை.~12 min

முதல் தர குடிமக்களாக செயல்பாடுகள்: கையொப்பங்கள், பல வருமானங்கள், மாறுபட்ட அளவுருக்கள், மூடல்கள் மற்றும் `ஒத்திவைத்தல்`.

1. 3.1கையொப்பம் மற்றும் அளவுருக்கள்`func name(p வகை) வகை` தொடரியல், முன்னிருப்பாக பாஸ்-பை-மதிப்பு, ஒரே வகையின் அளவுருக்கள் ஒன்றாக தொகுக்கப்பட்டுள்ளன.~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நிலையான நீள வரிசைகள்`[N]T` தொடரியல், ஏன் உண்மையான அணிவரிசைகள் Goவில் அரிதாகவே பயன்படுத்தப்படுகின்றன, அணிவரிசையிலிருந்து ஸ்லைஸாக மாற்றுதல்.~8 min
2. 4.2துண்டுகள்: இடியோமாடிக் அமைப்பு`make`, `append`, len/cap, slicing `s[a:b]`, அடிப்படை வரிசையைப் பகிர்தல் மற்றும் எப்போது நகலெடுக்க வேண்டும்.~15 min
3. 4.3வரைபடங்கள்: விசைகள் மற்றும் மதிப்புகள்பிரகடனம், கமா-சரி அணுகல் (`v, ok := m[k]`), `delete`, நிர்ணயம் செய்யாத மறு செய்கை.~12 min
4. 4.4சரங்கள், பைட்டுகள் மற்றும் ரூன்கள்சரங்கள் UTF-8 பைட்டுகள்; `வரம்பு` ரன்களை அளிக்கிறது; `len()` பைட்டுகளை எண்ணுகிறது, எழுத்துக்கள் அல்ல.~12 min
5. 4.5வரிசையாக்க தொகுப்புடன் வரிசைப்படுத்துதல்`sort.Ints`, `sort.Strings`, `sort.Slice` ஒரு ஒப்பீட்டு செயல்பாடு, நிலைத்தன்மை.~10 min

கூட்டு தரவு வகைகள்: கட்டமைப்புகள், மதிப்பு அல்லது சுட்டிக்காட்டி பெறுதல்கள், கலவை (பரம்பரை இல்லை) மற்றும் குறிச்சொற்கள்.

1. 5.1ஒரு கட்டமைப்பை வரையறுத்தல் மற்றும் பயன்படுத்துதல்`வகை நபர் struct {பெயர் சரம்; வயது எண் }`, பொசிஷனல் vs பெயரிடப்பட்ட துவக்கம், அநாமதேய கட்டமைப்புகள்.~12 min
2. 5.2முறைகள்: மதிப்பு vs சுட்டிக்காட்டி பெறுதல்`func (p Person) Hello()` vs `func (p *Person) Rename(n string)`; ஒன்று அல்லது மற்றொன்றை எப்போது பயன்படுத்த வேண்டும்.~14 min
3. 5.3கலவை (உட்பொதித்தல்)கோவிற்கு மரபுரிமை இல்லை: ஒரு வகையை மற்றொரு வகைக்குள் உட்பொதித்து நீங்கள் இசையமைக்கிறீர்கள். முறை ஊக்குவிப்பு.~12 min
4. 5.4புல குறிச்சொற்கள் மற்றும் JSON`json:"name,omitempty"`, `குறியீடு/json` உடன் மார்ஷலிங்/அன்மார்ஷலிங், பொதுவான தவறுகள்.~12 min
5. 5.5`புதிய...` கன்ஸ்ட்ரக்டர் பேட்டர்ன்Goவில் கன்ஸ்ட்ரக்டர்கள் இல்லை: கன்வென்ஷன் என்பது `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பிழை இடைமுகம்`எரர்` என்பது `பிழை() சரம்` மட்டுமே; தனிப்பயன் பிழைகளை உருவாக்குதல், `errors.Is`, `errors.As`, `fmt.Errorf("%w", err)`.~14 min

Go's concurrency model: இலகுரக goroutines, தகவல்தொடர்புக்கான சேனல்கள், `select`, sync மற்றும் சூழல்.

1. 7.1Goroutines: இலகுரக பேரலலிசம்`go f()`, ஒரு goroutine விலை, ஏன் காத்திருக்காமல் முக்கிய வெளியேறுகிறது, மற்றும் எப்படி ஒத்திசைக்க வேண்டும்.~12 min
2. 7.2சேனல்கள்: தட்டச்சு செய்யப்பட்ட தொடர்பு`ch := make(chan int)`, `ch <- v`, `v := <-ch`, buffered vs unbuffered channels, closing.~15 min
3. 7.3`செலக்ட்`: மல்டிபிளெக்சிங் சேனல்கள்முதலில் தயாராக இருக்கும் சேனலுக்காக காத்திருங்கள், தடுப்பதைத் தவிர்க்க `இயல்புநிலை` கேஸ், `time.After` உடன் காலாவதி முறை.~12 min
4. 7.4`sync.Mutex` மற்றும் `sync.WaitGroup`சேனல்கள் போதுமானதாக இல்லாதபோது: Mutex மூலம் பகிரப்பட்ட நிலையைப் பாதுகாக்கவும், WaitGroup மூலம் N goroutines க்காக காத்திருக்கவும்.~14 min
5. 7.5`context.Context`: ரத்துசெய்தல் மற்றும் காலக்கெடுgoroutines, `context.WithTimeout`, `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` இடைமுகங்கள், `defer 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

`go test` கருவி, அட்டவணையால் இயக்கப்படும் சோதனைகள், வரையறைகள், `go mod` உடன் சார்பு மேலாண்மை மற்றும் குறிச்சொற்களை உருவாக்குதல்.

1. 9.1`சோதனை` தொகுப்பு`*_test.go` கோப்புகள், `TestXxx(t *testing.T)` செயல்பாடுகள், `t.Error` vs `t.Fatal`, `go test ./...`.~12 min
2. 9.2அட்டவணை சார்ந்த சோதனைகள்இடியோமேடிக் பேட்டர்ன்: உள்ளீடுகள் மற்றும் எதிர்பார்க்கப்படும் வெளியீடுகளுடன் அநாமதேய அமைப்புகளின் ஒரு துண்டு, துணை சோதனைகளுக்கு `t.Run(name, ...)`.~14 min
3. 9.3வரையறைகள் மற்றும் சுயவிவரங்கள்`BenchmarkXxx(b *testing.B)` செயல்பாடுகள், `i := 0; i < b.N; i++` loop, `go test -bench=.`.~12 min
4. 9.4செல் தொகுதிகள்`go mod init`, `go get`, semantic import versioning, the `go.sum` lockfile, `go mod tidy`.~12 min
5. 9.5கட்டுப்பாடுகள் மற்றும் குறிச்சொற்களை உருவாக்கவும்கிராஸ்-பிளாட்ஃபார்ம் உருவாக்கங்களுக்கான `//go:build ...` கட்டளை, சோதனை/ஒருங்கிணைப்புக் குறியீட்டைப் பிரித்தல், நிஜ உலக எடுத்துக்காட்டுகள்.~10 min

பெயரிடுதல், மேம்பட்ட பிழை கையாளுதல், ஜெனரிக்ஸ் (Go 1.18+), மற்றும் இரண்டு சிறிய திட்டங்கள்: ஒரு CLI மற்றும் ஒரு HTTP சர்வர்.

1. 10.1பெயரிடும் மரபுகள் மற்றும் பாணிஏற்றுமதிக்கான PascalCase, உள்ளூர்வாசிகளுக்கான CamelCase, குறுகிய நோக்கங்களில் குறுகிய பெயர்கள், `gofmt` என்பது பேச்சுவார்த்தைக்குட்பட்டது அல்ல.~10 min
2. 10.2மொழியியல் பிழை கையாளுதல்சென்டினல் பிழைகள் (`io.EOF`), `அன்ராப்` உடன் தனிப்பயன் பிழைகள், `%w` உடன் ரேப்பிங், `பேனிக்` எப்போது பயன்படுத்த வேண்டும்.~14 min
3. 10.3ஜெனரிக்ஸ் (Go 1.18+)வகை அளவுருக்கள் `func Map[T, U any](s []T, f func(T) U) []U`, கட்டுப்பாடுகள் (`comparable`, custom), trade-offs.~15 min
4. 10.4சிறு திட்டம்: கொடிகள் கொண்ட ஒரு CLI`flag` தொகுப்பு, கட்டளைகள் மற்றும் துணைக் கட்டளைகள், வெளியேறும் குறியீடுகள், வெளியீட்டிற்கான `log` vs `fmt`.~18 min
5. 10.5சிறு திட்டம்: ஒரு HTTP சர்வர்`net/http`, குறைந்தபட்ச ஹேண்ட்லர் மற்றும் ரூட்டர், அலங்கரிப்பாளர்களாக மிடில்வேர், சூழலுடன் அழகான பணிநிறுத்தம்.~18 min