מפעילים

ל-Go יש את המפעילים הקלאסיים שהייתם מצפים להם, עם מעט הפתעות: אריתמטיקה, השוואה, לוגית, סיבית. אין מפעיל שליש (a ? b : c), ללא עומס יתר, ללא המרות מרומזות בין סוגים. פשטות היא תכונה.

חֶשְׁבּוֹן

a, b := 10, 3
fmt.Println(a + b)  // 13
fmt.Println(a - b)  // 7
fmt.Println(a * b)  // 30
fmt.Println(a / b)  // 3   ← divisione INTERA tra interi
fmt.Println(a % b)  // 1   ← resto (modulo)

תוספת והפחתה הן STATEMENTS, לא ביטויים

x++ ו-x-- לא מייצרים ערך: הם "פעולות" ולא כלום יותר. אין y := x++ כמו ב-C.

x := 5
x++          // ok: incrementa x
// y := x++  // ERRORE di compilazione
fmt.Println(x) // 6

השוואה

== != < <= > >= החזר bool. הם חלים על מספרים ומיתרים; עבור structs כל השדות חייבים להיות ברי השוואה (ללא פרוסות/מפות בפנים).

"abc" == "abc"  // true
"abc" < "abd"   // true (ordine lessicografico)
3 != 4           // true

הגיוני עם קצר חשמלי

&&, ||, !. הם מקצרים משמאל לימין: אם הראשון מספיק אופרנד כדי לקבוע את התוצאה, השני לא זוגי מוערך.

adult := age >= 18
seniorAdult := age >= 18 && age < 65

חלקית

& AND, | OR, ^ XOR, << המרת שמאל, >> המרת ימין, &^ ו לא (קצת ברור). הם שימושיים עבור דגלים, ניתוח בינארי ו אופטימיזציות:

flags := uint8(0b0000_0011)
flags |= 0b0000_0100   // imposta un bit:    0000_0111
flags &^= 0b0000_0010  // cancella un bit:   0000_0101
hasFlag := flags & 0b0000_0100 != 0  // true

אין המרות מרומזות

1 + 1.5 ב-Go קומפילציות, מכיוון ששניהם מילוליים לא מודפסים. אבל var i int = 1; i + 1.5 כן לא: אתה צריך float64(i) + 1.5.

i := 1
f := 1.5
// i + f          // ERRORE
float64(i) + f    // 2.5

התור שלך

a, b := 7, 2
fmt.Println(a/b, a%b)

לְסַכֵּם

• חשבון קלאסי; / בין ints היא חלוקת מספרים שלמים (קטוע).
• ++ ו-- הם הצהרות, לא ביטויים: אין y := x++.
• השוואה ואופרטורים לוגיים מייצרים bool; &&/|| קצר חשמלי.
• Bitwise & | ^ << >> &^ עבור דגלים וניתוח בינארי.
• אין המרות מרומזות בין סוגים שונים: השתמש ב-type(x).