עבור לקורס

היסודות: חבילות, משתנים, טיפוסים, קבועים, אופרטורים וקלט/פלט עם חבילת 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.5קלט/פלט עם fmt`fmt.Println`, `fmt.Printf`, פורמט פעלים (`%d`, `%s`, `%v`, `%T`) ומתי להעדיף אחד על פני השני.~10 min

החלטות וחזרות: אם עם הצהרות init, ה- `for` היחיד, מתג אידיומטי וטיפול בשגיאות מפורש.

1. 2.1if, else, והצהרות initה-`if v := f(); v > 0 { ... }` טופס ומדוע ל-Go אין אופרטור טרינרי.~10 min
2. 2.2עבור: הלולאה היחידהשלוש הצורות של `for`: שלוש פסוקיות, תנאי יחיד (= while), ואינסוף; באמצעות 'break' ו-'continue'.~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(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, gotchas בתוך לולאות.~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]`), `מחק`, איטרציה לא דטרמיניסטית.~12 min
4. 4.4מחרוזות, בתים ורוניםמחרוזות הן UTF-8 בתים; `טווח` מניב רונים; `len()` סופר בתים, לא תווים.~12 min
5. 4.5מיון עם חבילת המיון`sort.Ints`, `sort.Strings`, `sort.Slice` עם פונקציית השוואה, יציבות.~10 min

סוגי נתונים מורכבים: מבנים, שיטות על מקלטי ערך או מצביע, קומפוזיציה (ללא ירושה) ותגים.

1. 5.1הגדרה ושימוש במבנה`type Person struct { מחרוזת שם; Age int }`, אתחול מיקום לעומת אתחול בשם, מבנים אנונימיים.~12 min
2. 5.2שיטות: ערך מול מקלט מצביע`func (p Person) Hello()` לעומת `func (p *Person) Rename(n string)`; מתי להשתמש בזה או אחר.~14 min
3. 5.3קומפוזיציה (הטמעה)ל-Go אין ירושה: אתה מלחין על ידי הטמעת סוג אחד בתוך סוג אחר. קידום שיטה.~12 min
4. 5.4תגי שדה ו-JSON`json:"name,omitempty"`, רישום/ביטול רישום עם `קידוד/json`, טעויות נפוצות.~12 min
5. 5.5תבנית הקונסטרוקטור 'חדש...'ל-Go אין בנאים: הקונבנציה היא פונקציית `NewT(...) *T` שמאמתת ומחזירה שגיאות.~10 min

ממשקים מבניים (ללא יישומים מפורשים), הצהרות, מתגי סוג וממשקי ה-Stringer ו-'שגיאה' הסטנדרטיים.

1. 6.1ממשקים: הגדרת התנהגותממשק הוא סט של שיטות; מי שמיישם אותם מספק את זה אוטומטית (הקלדת ברווז סטטית).~12 min
2. 6.2סוג קביעה`v, ok := i.(*MyT)`, צורת הפסיק-OK כדי למנוע פאניקה, מתי להעדיף טענה על פני החלפת סוג.~10 min
3. 6.3סוג מתג`switch v := x.(type) { case int: ... }` כדי לשלוח על סוג זמן הריצה.~10 min
4. 6.4הממשק של Stringerיישום המחרוזת של `String() משנה את האופן שבו `fmt.Println` מייצג את הסוג שלך.~10 min
5. 6.5ממשק השגיאה`error` הוא רק `Error() string`; יצירת שגיאות מותאמות אישית, `errors.Is`, `errors.As`, `fmt.Errorf("%w", err)`.~14 min

מודל המקבילות של Go: גורוטינים קלים, ערוצים לתקשורת, `בחירה`, סנכרון והקשר.

1. 7.1Goroutines: מקביליות קלת משקל`go f()`, העלות של goroutine, מדוע יציאות ראשיות ללא המתנה וכיצד לסנכרן.~12 min
2. 7.2ערוצים: תקשורת מודפסת`ch := make(chan int)`, `ch <- v`, `v := <-ch`, ערוצים מאוחסנים לעומת ערוצים לא מאוחסנים, סוגרים.~15 min
3. 7.3'בחר': ריבוי ערוציםהמתן לערוץ המוכן הראשון, מקרה 'ברירת המחדל' כדי להימנע מחסימה, דפוס הזמן הקצוב עם 'זמן.אחרי'.~12 min
4. 7.4`sync.Mutex` ו-`sync.WaitGroup`כאשר הערוצים אינם מספיקים: הגן על מצב משותף עם Mutex, המתן ל-N גורוטיינים עם WaitGroup.~14 min
5. 7.5`context.Context`: ביטול ומועדיםהפצת ביטול על פני גורוטיינים, `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`strings` ו-`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()`, durations, ניתוח עם פריסת ההפניה `2006-01-02 15:04:05`, טיימרים וטיקרים.~12 min
5. 8.5'קידוד/json'`json.Marshal/Unmarshal`, תגיות struct, `json.Decoder/Encoder` עבור זרמים, שגיאות ניתוח.~14 min

הכלי 'Go test', מבחנים מונחי טבלה, בנצ'מרקים, ניהול תלות עם 'go mod' ותגיות בנייה.

1. 9.1חבילת ה'בדיקות'קבצי `*_test.go`, פונקציות `TestXxx(t *testing.T)`, `t.Error` לעומת `t.Fatal`, `go test ./...`.~12 min
2. 9.2מבחנים מונחי שולחןהתבנית האידיומטית: פרוסה של מבנים אנונימיים עם תשומות ויציאות צפויות, `t.Run(name, ...)` עבור תת-מבחנים.~14 min
3. 9.3מדדים ופרופיליםפונקציות `BenchmarkXxx(b *testing.B)`, ה- `for i := 0; i < b.N; i++` לולאה, `עבור לבדוק -bench=.`.~12 min
4. 9.4לך מודולים`go mod init`, `go get`, גירסאות ייבוא סמנטי, קובץ הנעילה `go.sum`, `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`), שגיאות מותאמות אישית עם `Unwrap`, גלישה עם `%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 עם דגליםחבילת ה'דגל', פקודות ותתי פקודות, קודי יציאה, 'log' לעומת 'fmt' לפלט.~18 min
5. 10.5מיני-פרויקט: שרת HTTP`net/http`, מטפל ונתב מינימלי, תוכנת ביניים כעיצובים, כיבוי חינני עם הקשר.~18 min