Go Cheat Sheet: דף עזר ל-Golang
עודכן לאחרונה
Hello World ומבנה התוכנית
כל תוכנית Go נמצאת בתוך package; נקודת הכניסה היא func main ב-package main.
| פעולה | תחביר |
|---|---|
| הצהרת package | package main |
| ייבוא package | import "fmt" |
| ייבוא כמה packages | import (\n "fmt"\n "os"\n) |
| נקודת כניסה | func main() { ... } |
| הדפסת שורה | fmt.Println("Hello, World!") |
| הדפסה מעוצבת | fmt.Printf("%d items\n", n) |
| הרצת קובץ | go run main.go |
| בניית קובץ הרצה | go build |
משתנים וטיפוסים
Go היא שפה עם טיפוסים סטטיים, אבל יודעת להסיק טיפוסים עם :=.
| פעולה | תחביר |
|---|---|
| הצהרה עם טיפוס | var age int = 30 |
| הצהרה עם הסקת טיפוס | var name = "Ada" |
| הצהרה מקוצרת | count := 0 |
| כמה בבת אחת | x, y := 1, 2 |
| קבוע | const Pi = 3.14 |
| ערכי אפס | 0, "", false, nil |
| טיפוסים בסיסיים | int, float64, string, bool, byte, rune |
| המרת טיפוסים | f := float64(i) |
בקרת זרימה
ל-Go יש מילת מפתח אחת ללולאות, for, ואין סוגריים סביב תנאים.
| פעולה | תחביר |
|---|---|
| If / else | if x > 0 { ... } else { ... } |
| If עם משפט אתחול | if v, ok := m[k]; ok { ... } |
| לולאת for (בסגנון C) | for i := 0; i < 10; i++ { ... } |
| לולאה בסגנון while | for x < 100 { ... } |
| לולאה אינסופית | for { ... } |
| מעבר על slice עם range | for i, v := range items { ... } |
| Switch | switch day { case 1: ...; default: ... } |
| Switch בלי ביטוי | switch { case x > 0: ... } |
| Break / continue | break, continue |
פונקציות
פונקציות הן ערכים מדרגה ראשונה ויכולות להחזיר כמה תוצאות.
| פעולה | תחביר |
|---|---|
| פונקציה בסיסית | func add(a int, b int) int { return a + b } |
| טיפוס משותף לפרמטרים | func add(a, b int) int { ... } |
| כמה ערכי החזרה | func divmod(a, b int) (int, int) { return a / b, a % b } |
| ערכי החזרה עם שם | func split(sum int) (x, y int) { x = sum / 2; return } |
| פונקציה עם מספר משתנה של ארגומנטים | func sum(nums ...int) int { ... } |
| פונקציה אנונימית | f := func() { ... } |
| Closure | func counter() func() int { ... } |
| Defer (רץ ביציאה מהפונקציה) | defer file.Close() |
Slices ומערכים
למערכים יש גודל קבוע; slices הם תצוגות דינמיות על מערכים.
| פעולה | תחביר |
|---|---|
| מערך בגודל קבוע | var a [3]int |
| ליטרל של slice | nums := []int{1, 2, 3} |
| יצירת slice | s := make([]int, 0, 10) |
| הוספה | s = append(s, 4) |
| אורך / קיבולת | len(s), cap(s) |
| חיתוך slice | s[1:3] |
| העתקה | copy(dst, src) |
| מעבר על האיברים | for i, v := range s { ... } |
Maps
Maps הן טבלאות הגיבוב המובנות של Go.
| פעולה | תחביר |
|---|---|
| יצירת map | m := make(map[string]int) |
| ליטרל של map | m := map[string]int{"a": 1, "b": 2} |
| הגדרת ערך | m["c"] = 3 |
| קבלת ערך | v := m["a"] |
| בדיקת קיום | v, ok := m["x"] |
| מחיקת מפתח | delete(m, "a") |
| אורך | len(m) |
| מעבר על האיברים | for k, v := range m { ... } |
Structs ומתודות
Structs מקבצים שדות; מתודות מוסיפות התנהגות דרך receiver.
| פעולה | תחביר |
|---|---|
| הגדרת struct | type Point struct { X, Y int } |
| יצירת מופע | p := Point{X: 1, Y: 2} |
| גישה לשדה | p.X |
| מצביע ל-struct | p := &Point{1, 2} |
| מתודה עם value receiver | func (p Point) Dist() float64 { ... } |
| מתודה עם pointer receiver | func (p *Point) Move(dx int) { p.X += dx } |
| Struct משובץ | type Circle struct { Point; R int } |
| Struct tags | Name string עם תגית json:"name" בתוך backticks |
ממשקים (Interfaces)
ממשקים מתממשים באופן מרומז: כל טיפוס עם המתודות הנכונות מתאים.
| פעולה | תחביר |
|---|---|
| הגדרת ממשק | type Shape interface { Area() float64 } |
| מימוש (מרומז) | func (c Circle) Area() float64 { ... } |
| ממשק ריק (any) | var x interface{} או var x any |
| Type assertion | s, ok := x.(string) |
| Type switch | switch v := x.(type) { case int: ... } |
| ממשק Stringer | func (p Point) String() string { ... } |
Goroutines ו-channels
Goroutines הן threads קלים; channels מעבירים ערכים ביניהן.
| פעולה | תחביר |
|---|---|
| הפעלת goroutine | go doWork() |
| יצירת channel | ch := make(chan int) |
| Channel עם buffer | ch := make(chan int, 5) |
| שליחה ל-channel | ch <- 42 |
| קבלה מ-channel | v := <-ch |
| סגירת channel | close(ch) |
| מעבר על channel עם range | for v := range ch { ... } |
| Select על channels | select { case v := <-ch: ...; default: ... } |
| WaitGroup (המתנה לכמה goroutines) | var wg sync.WaitGroup; wg.Add(1); wg.Wait() |
| Mutex | var mu sync.Mutex; mu.Lock(); mu.Unlock() |
טיפול בשגיאות
Go מחזירה שגיאות כערכים: אין בה exceptions.
| פעולה | תחביר |
|---|---|
| החזרת שגיאה | func read() (string, error) { return "", err } |
| בדיקת שגיאה | if err != nil { return err } |
| יצירת שגיאה | errors.New("not found") |
| שגיאה מעוצבת | fmt.Errorf("bad id %d", id) |
| עטיפת שגיאה | fmt.Errorf("load: %w", err) |
| פתיחת עטיפה / התאמה | errors.Is(err, os.ErrNotExist) |
| התאמה לפי טיפוס | errors.As(err, &target) |
| Panic / recover | defer func() { recover() }() |
התחביר של Go שהכי שימושי, בעמוד אחד. ה-Go cheat sheet הזה הוא דף עזר מהיר לליבת השפה: משתנים וטיפוסים, slices ו-maps, structs וממשקים, וגם ה-goroutines וה-channels שבזכותם Golang מצטיינת במקביליות.
כל מה שכאן הוא Go סטנדרטי ומתקמפל עם ה-toolchain הרשמי. העתיקו את מה שצריך, או נסו כל קטע קוד בזמן אמת בעורך האונליין של Go, בלי צורך בהתקנה. לומדים Go? קורס Go האינטראקטיבי והחינמי של Coddy מלמד slices, structs, ממשקים ו-goroutines צעד אחר צעד.
שאלות נפוצות על ה-Go cheat sheet
האם ה-Go cheat sheet הזה בחינם?
כן. ה-Go cheat sheet הזה חינמי לגמרי, בלי צורך בהרשמה. שמרו אותו במועדפים וחזרו אליו בכל פעם שצריך לבדוק פעולה על slice, דפוס של channel או מתודה של struct.
מה ההבדל בין := ל-var ב-Go?
var x = 0 מצהיר על משתנה ועובד בכל מקום, כולל ברמת ה-package. x := 0 הוא הצהרת משתנה מקוצרת: הוא גם מצהיר וגם מבצע השמה, מסיק את הטיפוס, ואפשר להשתמש בו רק בתוך פונקציה. השתמשו ב-var כשצריך טיפוס מפורש או משתנה ברמת ה-package, וב-:= להצהרות מקומיות תמציתיות.מה הם goroutines ו-channels?
Goroutine היא thread קל שמנוהל על ידי ה-runtime של Go: מפעילים אחת על ידי כתיבת
go someFunc(). Channels הם צינורות עם טיפוס שמאפשרים ל-goroutines לתקשר בבטחה: goroutine אחת שולחת עם ch <- v ואחרת מקבלת עם <-ch. יחד הם מודל המקביליות המרכזי של Go, שמתומצת באמרה "share memory by communicating" (לשתף זיכרון באמצעות תקשורת).אפשר לתרגל Go אונליין?
כן. פתחו את עורך האונליין של Go כדי להריץ כל קטע קוד מדף העזר הזה בדפדפן, בלי להתקין את ה-toolchain של Go. כשתרצו מסגרת מסודרת, קורס Go האינטראקטיבי והחינמי של Coddy לוקח אתכם צעד אחר צעד ממשתנים ו-slices ועד goroutines ו-channels.
האם דף העזר הזה מתאים למתחילים?
כן. הוא מסודר מהנושאים הנפוצים ביותר (משתנים, בקרת זרימה, פונקציות) ועד המתקדמים (goroutines, channels, טיפול בשגיאות), כך שאפשר להשתמש בחלקים העליונים כבר מהיום הראשון ולהתקדם לשאר בהמשך.
משאבים קשורים
עוד דפי עזר
