Goda operatorlar

Operator — qiymatlar ustida amal bajaradigan belgi yoki belgilar birikmasi. Masalan, + ikki sonni qo'shadi, == qiymatlarni taqqoslaydi, && esa mantiqiy shartlarni birlashtiradi.

Operator ishlaydigan qiymat operand deyiladi. a + b ifodasida + — operator, a va b esa operandlar.

Arifmetik operatorlar

Operator	Amal	Misol	Natija
+	qo'shish	10 + 3	13
-	ayirish	10 - 3	7
*	ko'paytirish	10 * 3	30
/	bo'lish	10 / 3	3
%	qoldiqli bo'lish	10 % 3	1

package main

import "fmt"

func main() {
    a := 10
    b := 3

    fmt.Println("Qo'shish:", a+b)
    fmt.Println("Ayirish:", a-b)
    fmt.Println("Ko'paytirish:", a*b)
    fmt.Println("Bo'lish:", a/b)
    fmt.Println("Qoldiq:", a%b)
}

Natija:

Qo'shish: 13
Ayirish: 7
Ko'paytirish: 30
Bo'lish: 3
Qoldiq: 1

Butun va kasrli sonlarni bo'lish

Ikkala operand ham butun son bo'lsa, natija ham butun son bo'ladi. Kasr qismi tashlab yuboriladi:

natija := 10 / 3 // 3

Natija kasrli bo'lishi uchun operandlar kasr turida bo'lishi kerak:

package main

import "fmt"

func main() {
    jami := 10
    odamlar := 3
    harBiriga := float64(jami) / float64(odamlar)

    fmt.Printf("Har biriga: %.2f\n", harBiriga)
}

Natija:

Har biriga: 3.33

float64(jami) va float64(odamlar) butun sonlarni kasr(haqiqiy son) turiga o'tkazadi.

Warning

Sonni nolga bo'lish mumkin emas. Butun sonni 0ga bo'lish dastur bajarilayotgan paytda xatoga olib keladi.

Qoldiqli bo'lish

% operatori butun sonni bo'lgandan keyingi qoldiqni oladi. Masalan, 17 % 5 natijasi 2.

% Goda faqat butun sonlar bilan ishlaydi.

Birga oshirish(increment) va kamaytirish(decrement)

++ qiymatni birga oshiradi, -- esa birga kamaytiradi:

package main

import "fmt"

func main() {
    hisob := 5
    hisob++
    fmt.Println(hisob)

    hisob--
    fmt.Println(hisob)
}

Natija:

6
5

Goda hisob++ va hisob-- alohida buyruq. Ularni boshqa ifodaning ichida ishlatib bo'lmaydi:

// natija := hisob++ // kompilyatsiya xatosi sodir bo'ladi.

Tayinlash operatorlari

= o'ng tomondagi qiymatni chap tomondagi mavjud o'zgaruvchiga beradi:

son := 10
son = 20

Arifmetik amal va tayinlash operatorining qisqa ko'rinishi:

Qisqa yozuv	To'liq yozuv
son += 5	son = son + 5
son -= 5	son = son - 5
son *= 5	son = son * 5
son /= 5	son = son / 5
son %= 5	son = son % 5

package main

import "fmt"

func main() {
    balans := 100
    balans += 50
    balans -= 20

    fmt.Println("Balans:", balans)
}

Natija:

Balans: 130

:= yangi o'zgaruvchi e'lon qiladi va usha o'zgaruvchiga qiymatni tayinlaydi, = esa mavjud o'zgaruvchining qiymatini o'zgartiradi.

Taqqoslash operatorlari

Taqqoslash natijasi har doim bool, ya'ni true yoki false bo'ladi.

Operator	Ma'nosi	Misol	Natija
==	teng	10 == 10	true
!=	teng emas	10 != 3	true
>	katta	10 > 3	true
<	kichik	10 < 3	false
>=	katta yoki teng	10 >= 10	true
<=	kichik yoki teng	3 <= 10	true

package main

import "fmt"

func main() {
    yosh := 20
    minimalYosh := 18

    fmt.Println("Teng:", yosh == minimalYosh)
    fmt.Println("Teng emas:", yosh != minimalYosh)
    fmt.Println("Ruxsat etilgan:", yosh >= minimalYosh)
}

Natija:

Teng: false
Teng emas: true
Ruxsat etilgan: true

Info

= qiymat tayinlaydi, == esa tenglikni tekshiradi.

Mantiqiy operatorlar

Mantiqiy operatorlar bool qiymatlarni birlashtiradi yoki teskarisiga o'zgartiradi:

Operator	Nomi	Qachon true bo'ladi?
&&	VA	ikkala shart ham true bo'lsa
||	YOKI	shartlardan kamida biri true bo'lsa
!	EMAS	operand false bo'lsa

Info

Mantiqiy bool qiymatlarda faqat == va != ishlatiladi.

package main

import "fmt"

func main() {
    yosh := 22
    chiptasiBor := true
    taqiqlangan := false

    kirishiMumkin := yosh >= 18 && chiptasiBor && !taqiqlangan
    fmt.Println("Kirish mumkin:", kirishiMumkin)
}

Natija:

Kirish mumkin: true

Natija true, chunki yosh yetarli, chipta bor va foydalanuvchi taqiqlanmagan.

Mantiqiy jadval:

a	b	a && b	a \|\| b
false	false	false	false
false	true	false	true
true	false	false	true
true	true	true	true

!true natijasi false, !false natijasi esa true bo'ladi.

Qisqa tutashuv

&& va || natija ma'lum bo'lgach, ifodaning qolgan qismini tekshirmaydi. Bu qisqa tutashuv (short-circuit evaluation) deyiladi:

boluvchi := 0
xavfsiz := boluvchi != 0 && 10/boluvchi > 1

Birinchi shart false bo'lgani sababli 10/boluvchi bajarilmaydi va nolga bo'lish hisoblanmaydi.

Bit operatorlari

Bit operatorlari butun sonlarning ikkilik ko'rinishi ustida ishlaydi. Ular ruxsatlar to'plami, protokollar va past darajali hisob-kitoblarda qo'llaniladi.

Operator	Amal
&	bit bo'yicha VA
|	bit bo'yicha YOKI
^	bit bo'yicha XOR yoki bitlarni inkor qilish
&^	bitni tozalash (AND NOT)
<<	chapga surish
>>	o'ngga surish

package main

import "fmt"

func main() {
    a := 6 // ikkilik ko'rinishi: 110
    b := 3 // ikkilik ko'rinishi: 011

    fmt.Println(a & b)  // 010, ya'ni 2
    fmt.Println(a | b)  // 111, ya'ni 7
    fmt.Println(a ^ b)  // 101, ya'ni 5
    fmt.Println(a << 1) // 1100, ya'ni 12
}

Natija:

2
7
5
12

Hozir bu operatorlarning vazifasini bilib olish yetarli. Ular kerak bo'ladigan mavzularda batafsil ko'rib chiqiladi.

Operatorlar ustuvorligi

Bitta ifodada bir nechta operator bo'lsa, ayrim amallar boshqalaridan oldin bajariladi:

birinchi := 2 + 3*4   // 14
ikkinchi := (2 + 3) * 4 // 20

Ustuvorlikning soddalashtirilgan tartibi yuqoridan pastga:

1. *, /, %, <<, >>, &, &^;
2. +, -, |, ^;
3. ==, !=, <, <=, >, >=;
4. &&;
5. ||.

Ifoda murakkab ko'rinsa, maqsadni aniq ko'rsatish uchun qavs ishlatish to'g'ri bo'ladi.

Keyingi qismda qiymatlarni kodning ichida yozish o'rniga ularni konsoldan kiritishni o'rganamiz.

Misollar

1. Juft yoki toq sonni aniqlash

package main

import "fmt"

func main() {
    son := 17
    fmt.Println(son%2 == 0)
}

% bo‘lishdan qolgan qoldiqni beradi. Natija false, chunki 17ni 2ga bo‘lganda qoldiq 1.

2. Qiymatni oraliqda tekshirish

package main

import "fmt"

func main() {
    yosh := 24
    mehnatYoshi := yosh >= 18 && yosh <= 60
    fmt.Println(mehnatYoshi)
}

&& tufayli ikkala chegara ham bajarilgandagina natija true bo‘ladi.

3. Qiymatni ketma-ket yangilash

package main

import "fmt"

func main() {
    son := 10
    son += 5
    son *= 2
    son--
    fmt.Println(son)
}

+= qo‘shib saqlaydi, *= ko‘paytirib saqlaydi, -- esa bittaga kamaytiradi. Natija 29 bo‘ladi.

4. Qisqa tutashuv

package main

import "fmt"

func main() {
    boluvchi := 0
    xavfsiz := boluvchi != 0 && 10/boluvchi > 1
    fmt.Println(xavfsiz)
}

Birinchi shart false bo‘lgani uchun ikkinchisi hisoblanmaydi. Shu sababli nolga bo‘lish xatosi yuz bermaydi.

5. Qoldiq bilan vaqtni ajratish

package main

import "fmt"

func main() {
    jamiSekund := 3672
    soat := jamiSekund / 3600
    daqiqa := jamiSekund % 3600 / 60
    sekund := jamiSekund % 60
    fmt.Println(soat, daqiqa, sekund)
}

Natija 1 1 12. / to‘liq birliklarni, % esa keyingi hisob uchun qolgan qismini ajratadi.

6. Bit yordamida bayroqni yoqish

package main

import "fmt"

func main() {
    const yozish = 1 << 1
    ruxsat := 1
    ruxsat |= yozish
    fmt.Printf("%03b\n", ruxsat)
}

|= kerakli bitni yoqib, boshqa bitlarni o‘zgartirmaydi. Natija 011.

7. Bit yordamida bayroqni tekshirish

package main

import "fmt"

func main() {
    const yozish = 1 << 1
    ruxsat := 0b011
    fmt.Println(ruxsat&yozish != 0)
}

& faqat ikkala qiymatda ham yoqilgan bitlarni qoldiradi.

8. Bitni o‘chirish

package main

import "fmt"

func main() {
    const yozish = 1 << 1
    ruxsat := 0b111
    ruxsat &^= yozish
    fmt.Printf("%03b\n", ruxsat)
}

&^ operatori o‘ng tomonda ko‘rsatilgan bitlarni chap qiymatdan tozalaydi. Natija 101.

9. Eksklyuziv OR bilan qiymatlarni almashtirish

package main

import "fmt"

func main() {
    a, b := 5, 9
    a ^= b
    b ^= a
    a ^= b
    fmt.Println(a, b)
}

Natija 9 5. Bu ^ operatorining imkoniyatini ko‘rsatadi, ammo amaliy Go kodida tushunarliroq a, b = b, a usuli afzal.

10. Ustuvorlikni qavs bilan aniqlashtirish

package main

import "fmt"

func main() {
    chegirma := 100_000 - (100_000*15)/100
    fmt.Println(chegirma)
}

Qavs hisoblash maqsadini ko‘rsatadi. _ katta sonni o‘qishni osonlashtiradi va qiymatga ta’sir qilmaydi.