Go da operatorlar

Go da bir nechta operator turlari mavjud, bular quyidagilar:

Arifmetik operatorlari
Munosabat operatorlari
Mantiqiy operatorlari
Bit operatorlari(Bitwise)
Tayinlash operatorlari
Ko'rsatkich(pointer) operatorlari

Endi har biriga navbat bilan to'xtalib o'tamiz.

Arifmetik operatorlari

Quyidagi jadval uchun A ni 10, B ni 20 deb oldik.

Operator	Ta'rif	Misol
+	Qo'shish	A + B, natija=30
-	Ayirish	A - B, natija= -10
*	Ko'paytirish	A * B, natija= 200
/	Bo'lish	B / A, natija= 2
%	B ni A ga bo'lgandagi qoldiq	B % A, natija= 0
++	Increment: Birga oshirish	A++, natija= 11
--	Decrement: Birga kamaytirish	A--, natija= 9

Misol:

package main

import "fmt"

func main() {
    // Qo'shish
    a := 20
    b := 10
    sum := a + b
    fmt.Printf("Addition: %d + %d = %d\n", a, b, sum)

    // Ayirish
    difference := a - b
    fmt.Printf("Subtraction: %d - %d = %d\n", a, b, difference)

    // Ko'paytirish
    product := a * b
    fmt.Printf("Multiplication: %d * %d = %d\n", a, b, product)

    // Bo'lish
    quotient := b / a
    fmt.Printf("Division: %d / %d = %d\n", b, a, quotient)

    // Qoldiqli bo'lish
    remainder := b % a
    fmt.Printf("Modulus: %d %% %d = %d\n", b, a, remainder)

    // Increment
    a++
    fmt.Printf("Increment: After incrementing, a is %d\n", a)

    // Decrement
    a--
    fmt.Printf("Decrement: After decrementing, a is %d\n", a)
}

Munosabat operatorlari

Munosabat operatorlari ikki operant o'rtasidagi munosabatni tekshirish uchun qo'laniladi. Misol uchun A va B bir-biriga tengmi, yokki katta kichikligini tekshirish uchun hizmat qiladi. Quyidagi jadval uchun A ni 10, B ni 20 deb oldik.

Operator	Ta'rif	Misol
==	Ikkila qiymatni bir-biriga tengligini tekshiradi. Agar teng bo'lsa `true`, aks holda `false` natija qaytaradi.	(A == B), natija=false.
!=	Ikkita qiymat bir-biriga teng emasligini tekshiradi. Agar teng bo'lmasa `ture`, aks holda `false` natija chiqadi.	(A != B), natija=true.
>	Agar chap tomondagi qiymat, o'ng tomondagidan katta bo'lsa `true`, aks holda `false` natija chiqadi.	(A > B), natija=false.
<	Agar chap tomondagi qiymat, o'ng tomondagidan kichik bo'lsa `true`, aks holda `false` natija chiqadi.	(A < B) , natija=true.
>=	Agar chap tomondagi qiymat, o'ng tomondagidan katta yoki teng bo'lsa `true`, aks holda `false` natija chiqadi.	(A >= B) , natija=false.
<=	Agar chap tomondagi qiymat, o'ng tomondagidan kichik yoki teng bo'lsa `true`, aks holda `false` natija chiqadi	(A <= B), natija=true.

Misol:

package main

import "fmt"

func main() {
    // o'zgaruvchilarni e'lon qilish
    A := 10
    B := 20

    // ==
    isEqual := A == B
    fmt.Printf("(%d == %d) is %t\n", A, B, isEqual)

    // !=
    isNotEqual := A != B
    fmt.Printf("(%d != %d) is %t\n", A, B, isNotEqual)

    // >
    isGreaterThan := A > B
    fmt.Printf("(%d > %d) is %t\n", A, B, isGreaterThan)

    // <
    isLessThan := A < B
    fmt.Printf("(%d < %d) is %t\n", A, B, isLessThan)

    // >=
    isGreaterOrEqual := A >= B
    fmt.Printf("(%d >= %d) is %t\n", A, B, isGreaterOrEqual)

    // <=
    isLessOrEqual := A <= B
    fmt.Printf("(%d <= %d) is %t\n", A, B, isLessOrEqual)
}

Mantiqiy operatorlari

&&(AND) - mantiqiy ko'paytirish
||(OR) - mantiqiy qo'shish
!(NOT) - mantiqiy inkor

Mantiqiy operatorlar matematik operatorlar kabi faqat asosiy farqi mantiqiy operatorlar sonlar utida emas mantiqiy turlar ustida amallar bajaradi.

Munosabat amallari ikki xil qiymat qaytaradi bular true(rost) va false(yolg'on). Bu qiymatlar mantiqiy(bool) turida bo'ladi.

Mantiqiy operatorlar yuqorida aytilgan true va false qiymatlar ustida amallar bajaradi.

Quyidagi jadval uchun A ni 1, B ni 0 deb oldik.

Operator	Ta'rif	Misol
&&	Mantiqiy AND(va) operatori. Ikkala operandlar `true` bo'lsa `true` aks holda natija `false` bo'ladi.	(A && B), natija=false.
\|\|	Mantiqiy OR(yoki) Operatori. Ikkala operandlardan biri `true` bo'lsa `true`, aks holda natija `false` bo'ladi.	(A \|\| B), natija=true.
!	Mantiqiy NOT(emas) Operatori. Mantiqiy inkor amali natijani qarama-qarshi natijaga o'zgartiradi. Agar natija `true` bo'lsa mantiqiy inkor amali `false` ga o'zgartiradi.	!(A && B), natija=true.

Mantiqiy operatorlarga ta'rif

not (inkor qilish) - mantiqiy operatori mantiqiy ifodalar yoki o'zgaruvchilar oldidan qo'yiladi. Mantiqiy ifoda yoki o'zgaruvchining qiymatini teskarisiga o'zgartiradi.
and (Mantiqiy ko'paytirish) - mantiqiy operatori ikkita mantiqiy o'zgaruvchini birlashtiradi. Agar ikkala o'zgaruvchi ham rost qiymatga ega bo'lsa natija rost, aks holda yolg`on natija beradi.
or (mantiqiy qo'shish) - mantiqiy operatori ikkita mantiqiy o'zgaruvchini birlashtiradi. Agar o'zgaruvchilardan kamida bittasi rost qiymatga ega bo'lsa natija rost, aks holda yolg`on natija beradi.

Mantiqiy inkor(not) jadvali

X	not X
False	True
True	False

Mantiqiy qo'shish(or) va ko'paytirish(and) jadvali

X	Y	X and Y	X or Y
False	False	False	False
False	True	False	True
True	False	False	True
True	True	True	True

Misol:

package main

import "fmt"

func main() {
    // mantiqiy toifa o'zgaruvchilarini e'lon qilish.
    A := true
    B := false

    // &&
    andResult := A && B
    fmt.Printf("(%t && %t) is %t\n", A, B, andResult)

    // ||
    orResult := A || B
    fmt.Printf("(%t || %t) is %t\n", A, B, orResult)

    // !
    notResult := !(A && B)
    fmt.Printf("!(%t && %t) is %t\n", A, B, notResult)
}

Tayinlash operatorlari

Operator	Ta'rif	Misol
=	Oddiy tayinlash operatori. Chap tomondagi o'zgaruvchiga, o'ng tomondagi yig'inidi tayinlanadi.	C = A + B
+=	Qo'shish va tayinlash operatori. Chap tomondagi o'zgaruvchiga, o'ng tomondagi yig'inidi tayinlanadi. Bu `C = C + A`ni qisqa ko'rinishi.	C += A, C = C + A
-=	Ayirish va tayinlash operatori. Chap tomondagi o'zgaruvchiga, o'ng tomondagi ayirma tayinlanadi. Bu `C = C - A`ni qisqa ko'rinishi.	C -= A, C = C - A
*=	Ko'paytirish va tayinlash operatori. Chap tomondagi o'zgaruvchiga, o'ng tomondagi ko'paytma tayinlanadi. Bu `C = C * A`ni qisqa ko'rinishi.	C = A, C = C A
/=	Bo'lish va tayinlash operatori. Chap tomondagi o'zgaruvchiga, o'ng tomondagi bo'linma tayinlanadi. Bu `C = C / A`ni qisqa ko'rinishi.	C /= A, C = C / A
%=	Qoldiqli bo'lish va tayinlash operatori. Chap tomondagi o'zgaruvchiga, o'ng tomondagi qoldiqli bo'lish natijasi tayinlanadi. Bu `C = C % A`ni qisqa ko'rinishi.	C %= A, C = C % A

Misol:

package main

import "fmt"

func main() {
    A := 10
    B := 5
    C := 0

    // =
    C = A + B
    fmt.Printf("Oddiy tayinlash operatori (C = A + B): C is %d\n", C)

    // +=
    C += A
    fmt.Printf("Qo'shish va tayinlash operatori (C += A): C is %d\n", C)

    // -=
    C -= A
    fmt.Printf("Ayirish va tayinlash operatori (C -= A): C is %d\n", C)

    // *=
    C *= A
    fmt.Printf("Ko'paytirish va tayinlash operatori (C *= A): C is %d\n", C)

    // /=
    C /= A
    fmt.Printf("Bo'lish va tayinlash operatori (C /= A): C is %d\n", C)

    // %=
    C %= A
    fmt.Printf("Qoldiqli bo'lish va tayinlash operatori (C %%= A): C is %d\n", C)
}

Eslatma

Yuqorida ko'rsatilgan misollarni barchasini ishga tushirib sinab ko'ring. Yaxshiroq tushinish uchun boshqa qiymatlar bilan sinab ko'ring. Shunda yaxshiroq natija olasiz. Hech qachon darslikdagi misollar bilan cheklanib qolmang.