ஆபரேட்டர்கள்

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_20 INLINE_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

மறைமுகமான மாற்றங்கள் இல்லை

Go compiles இல் 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)

மறுபரிசீலனை

• கிளாசிக் எண்கணிதம்; / எண்ணுக்கு இடையே உள்ள முழு எண் வகுத்தல் (துண்டிக்கப்பட்டது).
• ++ மற்றும் -- ஆகியவை அறிக்கைகள், வெளிப்பாடுகள் அல்ல: இல்லை y := x++.
• ஒப்பீடு மற்றும் தருக்க ஆபரேட்டர்கள் bool; &&/|| ஷார்ட் சர்க்யூட்.
• கொடிகள் மற்றும் பைனரி பாகுபடுத்தலுக்கு பிட்வைஸ் & | ^ << >> &^.
• வெவ்வேறு வகைகளுக்கு இடையே மறைமுகமான மாற்றங்கள் இல்லை: type(x) ஐப் பயன்படுத்தவும்.