Operators

Dasturlashda operator — bu qiymatlar yoki o'zgaruvchilar ustida muayyan amallarni bajarish uchun ishlatiladigan maxsus belgi hisoblanadi.

Masalan, + belgisi ikki sonni qo'shish uchun ishlatiladigan operatordir:

sum := 5 + 3 // 8

Go dasturlash tilida operatorlar quyidagi asosiy toifalarga bo'linadi:

1. Arifmetik operatorlar (Arithmetic operators)
2. O'zlashtirish operatorlari (Assignment operators)
3. Taqqoslash operatorlari (Relational operators)
4. Mantiqiy operatorlar (Logical operators)
5. Bit darajasidagi va boshqa maxsus operatorlar (Bitwise & Other operators)

1. Arifmetik operatorlar (Arithmetic Operators)

Arifmetik operatorlar qo'shish, ayirish, ko'paytirish, bo'lish kabi matematik amallarni bajarish uchun ishlatiladi.

Misol: Qo'shish, ayirish va ko'paytirish

package main

import "fmt"

func main() {
    num1 := 6
    num2 := 2

    // + operatori
    sum := num1 + num2
    fmt.Printf("%d + %d = %d\n", num1, num2, sum)

    // - operatori
    difference := num1 - num2
    fmt.Printf("%d - %d = %d\n", num1, num2, difference)

    // * operatori
    product := num1 * num2
    fmt.Printf("%d * %d = %d\n", num1, num2, product)
}

Natija:

6 + 2 = 8
6 - 2 = 4
6 * 2 = 12

Goda bo'lish operatori (/)

Go tilida butun sonlarni bo'lishda muhim xususiyat mavjud:

package main

import "fmt"

func main() {
    num1 := 11
    num2 := 4

    quotient := num1 / num2
    fmt.Printf("%d / %d = %d\n", num1, num2, quotient)
}

Natija:

11 / 4 = 2

Oddiy matematikada 11 / 4 = 2.75 bo'ladi. Biroq, Go tilida ikkala son ham int (butun son) bo'lgani uchun, bo'lish natijasi ham butun son qilib olinadi (kasr qismi shunchaki tashlab yuboriladi):

Aniq kasrli natija olish uchun kamida bitta son o'nlik kasr (float) ko'rinishida bo'lishi kerak:

package main

import "fmt"

func main() {
    num1 := 11.0
    num2 := 4.0

    result := num1 / num2
    fmt.Printf("%g / %g = %g\n", num1, num2, result)
}

Natija:

11 / 4 = 2.75

Qoldiqni olish operatori (%)

% (modulo) operatori bo'lish amalidan qolgan butun qoldiqni hisoblaydi:

package main

import "fmt"

func main() {
    num1 := 11
    num2 := 4

    remainder := num1 % num2
    fmt.Println("Qoldiq:", remainder)
}

Natija:

Qoldiq: 3

11 ni 4 ga bo'lsak, butun qismi 2 va qoldig'i 3 bo'ladi (11 = 4 * 2 + 3).

[!NOTE] Modulo (%) operatori faqat butun sonlar (int) bilan ishlatiladi. Kasr sonlar bilan ishlatib bo'lmaydi.

2. Oshirish va kamaytirish operatorlari (++ va --)

Go tilida o'zgaruvchi qiymatini 1 ga oshirish yoki 1 ga kamaytirish uchun qulay operatorlar mavjud:

• ++ — o'zgaruvchi qiymatini 1 ga oshiradi (inkrement).
• -- — o'zgaruvchi qiymatini 1 ga kamaytiradi (dekrement).

package main

import "fmt"

func main() {
    num := 5

    num++
    fmt.Println(num) // 6

    num--
    fmt.Println(num) // 5
}

[!WARNING] Go tilida ++ va -- operatorlari ifoda (expression) emas, balki alohida buyruq (statement) hisoblanadi. Shuning uchun result = num++ yoki ++num kabi yozuvlarga ruxsat berilmaydi. Faqat postfix ko'rinishida (num++, num--) ishlatiladi.

3. O'zlashtirish operatorlari (Assignment Operators)

O'zlashtirish operatori o'ng tomondagi qiymatni chap tomondagi o'zgaruvchiga yuklash uchun ishlatiladi:

var number = 34

Bu yerda = operatori 34 sonini number o'zgaruvchisiga o'zlashtiradi.

Qisqartirilgan (murakkab) o'zlashtirish operatorlari

Go tilida arifmetik amallarni o'zlashtirish bilan birlashtiruvchi qisqa formalar mavjud:

Misol:

package main

import "fmt"

func main() {
    num := 10

    num += 5  // num = num + 5
    fmt.Println(num) // 15

    num -= 3  // num = num - 3
    fmt.Println(num) // 12

    num *= 2  // num = num * 2
    fmt.Println(num) // 24

    num /= 4  // num = num / 4
    fmt.Println(num) // 6
}

4. Taqqoslash operatorlari (Relational Operators)

Taqqoslash operatorlari ikki qiymatni o'zaro solishtirish uchun ishlatiladi va har doim mantiqiy natija — true yoki false qaytaradi.

Misol:

package main

import "fmt"

func main() {
    a := 5
    b := 9

    fmt.Println(a == b) // false
    fmt.Println(a != b) // true
    fmt.Println(a > b)  // false
    fmt.Println(a < b)  // true
}

5. Mantiqiy operatorlar (Logical Operators)

Mantiqiy operatorlar shartli ifodalarni birlashtirish yoki inkor qilish uchun ishlatiladi:

Misol:

package main

import "fmt"

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

    fmt.Println((a > 5) && (b > 15)) // true
    fmt.Println((a > 15) || (b > 15)) // true
    fmt.Println(!(a == b))            // true
}

6. Bit darajasidagi siljitish operatorlari (Bitwise Shift)

• O'ngga siljitish (>>): Sonning ikkilik sanoq sistemasidagi bitlarini ko'rsatilgan miqdorcha o'ngga suradi.
• Chapga siljitish (<<): Sonning ikkilik bitlarini ko'rsatilgan miqdorcha chapga suradi va bo'shagan joylarga 0 qo'shadi.

package main

import "fmt"

func main() {
    num := 4 // ikkilikda: 0000 0100

    fmt.Println(num << 1) // 8  (0000 1000 - 2 ga ko'paytirish)
    fmt.Println(num >> 1) // 2  (0000 0010 - 2 ga bo'lish)
}

7. Boshqa maxsus operatorlar: & va *

Go tilida ko'rsatkichlar (pointer) bilan ishlashda ikkita maxsus belgidan foydalaniladi:

• & (Address of): O'zgaruvchining xotiradagi manzilini oladi.
• * (Dereference / Pointer declaration): Ko'rsatkich turini e'lon qilish yoki manzil ichidagi qiymatni o'qish uchun ishlatiladi.

package main

import "fmt"

func main() {
    num := 20

    // &num xotira manzilini beradi
    fmt.Println("Xotira manzili:", &num) // Masalan: 0xc000018098

    var ptr *int = &num
    fmt.Println("Ko'rsatkich orqali qiymat:", *ptr) // 20
}

Operatorlarning bajarilish ustunligi (Operator Precedence)

Murakkab ifodalarda qaysi amal birinchi bajarilishi operatorlarning ustunligiga (precedence) bog'liq. Masalan:

result := 32 / 8 + 2 * 9 - 4

Bu yerda:

1. Avval / va * amallari bajariladi: 32 / 8 = 4 va 2 * 9 = 18.
2. So'ng + va - amallari: 4 + 18 - 4 = 18.

Amallar ketma-ketligini aniq va xatosiz boshqarish uchun har doim qavslar () dan foydalanish tavsiya etiladi.