ఆపరేటర్లు

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)

ఇంక్రిమెంట్ మరియు తగ్గింపు ప్రకటనలు, వ్యక్తీకరణలు కాదు

x++ మరియు x-- విలువను ఉత్పత్తి చేయవు: అవి "చర్యలు" మరియు ఏమీ లేవు మరింత. C లో లాగా y := x++ లేదు.

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

పోలిక

== != < <= > >= తిరిగి bool. అవి సంఖ్యలు మరియు తీగలకు వర్తిస్తాయి; కోసం అన్ని ఫీల్డ్‌లు తప్పనిసరిగా పోల్చదగినవిగా ఉండాలి (లోపల ముక్కలు/మ్యాప్‌లు లేవు).

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

షార్ట్-సర్క్యూట్‌తో లాజికల్

&&, ||, !. అవి ఎడమ నుండి కుడికి షార్ట్ సర్క్యూట్: మొదటిది అయితే ఫలితాన్ని నిర్ణయించడానికి operand సరిపోతుంది, రెండవది కూడా కాదు మూల్యాంకనం చేయబడింది.

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

బిట్వైస్

& మరియు, | లేదా, ^ XOR, << ఎడమ షిఫ్ట్, >> కుడి షిఫ్ట్, __AGYTOK_ANDLINE_20 కాదు (బిట్ క్లియర్). అవి ఫ్లాగ్‌లు, బైనరీ పార్సింగ్ మరియు కోసం ఉపయోగపడతాయి ఆప్టిమైజేషన్లు:

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 గో కంపైల్స్లో, రెండూ టైప్ చేయని అక్షరాలు కాబట్టి. కానీ 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; &&/|| షార్ట్-సర్క్యూట్.
• ఫ్లాగ్‌లు మరియు బైనరీ పార్సింగ్ కోసం బిట్‌వైస్ & | ^ << >> &^.
• వివిధ రకాల మధ్య అవ్యక్త మార్పిడులు లేవు: type(x)ని ఉపయోగించండి.