O'zgaruvchilar va turlar

Go - statik turlar tili: har bir o'zgaruvchining turi kompilyatsiya paytida ma'lum bo'ladi va keyin o'zgarmaydi.

Lekin turni har doim yozish shart emas - Go uni ko'pincha o'zi aniqlaydi.

E'lon qilishning uch yo'li #

package main

import "fmt"

func main() {
    var ism string = "Malika"
    var yosh = 20
    shahar := "Namangan"

    fmt.Println(ism, yosh, shahar)
    fmt.Printf("%T %T %T\n", ism, yosh, shahar)
}

Malika 20 Namangan
string int string

%T - qiymatning turini chiqaradi. Uchala shakl ham bir xil natija beradi, farq faqat yozuvda.

var Versiya = "1.0"   // to'g'ri
Versiya := "1.0"      // xato: syntax error

Nol qiymatlar #

Go da e'lon qilingan, lekin qiymat berilmagan o'zgaruvchi hech qachon "chiqindi" bo'lmaydi. U doim aniq boshlang'ich qiymat oladi.

package main

import "fmt"

func main() {
    var son int
    var kasr float64
    var matn string
    var bayroq bool

    fmt.Println(son, kasr, bayroq)
    fmt.Printf("matn: %q (uzunligi %d)\n", matn, len(matn))
}

0 0 false
matn: "" (uzunligi 0)

Son turlari #

package main

import "fmt"

func main() {
    var kichik int8 = 127
    var katta int64 = 9223372036854775807
    var musbat uint8 = 255

    fmt.Println(kichik, musbat)
    fmt.Println(katta)

    kichik++
    fmt.Println("127 ga 1 qo'shilgandan keyin:", kichik)
}

127 255
9223372036854775807
127 ga 1 qo'shilgandan keyin: -128

Oxirgi qatorga e'tibor bering. int8 eng kattasi 127; unga 1 qo'shilsa, u eng kichigiga aylanadi.

byte - bu uint8 ning boshqa nomi, rune esa int32 niki. Ularni 4-bo'limda ko'ramiz.

Turlar aralashmaydi #

Bu Go ni ko'p tillardan ajratib turadigan qoida:

package main

import "fmt"

func main() {
    var butun int = 7
    var kasr float64 = 2.5

    natija := float64(butun) * kasr
    fmt.Println(natija)

    yosh := 25
    fmt.Println("Yosh: " + fmt.Sprint(yosh))
}

17.5
Yosh: 25

var butun int = 7
var kasr float64 = 2.5
natija := butun * kasr   // mismatched types int and float64

Butun va kasr bo'linish #

package main

import "fmt"

func main() {
    fmt.Println(7 / 2)
    fmt.Println(7 % 2)
    fmt.Println(7.0 / 2.0)
    fmt.Println(float64(7) / float64(2))

    fmt.Println(0.1 + 0.2)

    birinchi := 0.1
    ikkinchi := 0.2
    fmt.Println(birinchi + ikkinchi)
    fmt.Println(birinchi+ikkinchi == 0.3)
}

3
1
3.5
3.5
0.3
0.30000000000000004
false

Ikkita butun sonni bo'lsangiz, natija ham butun bo'ladi: 7 / 2 bu 3, 3.5 emas.

Oxirgi uch qator esa diqqat bilan qarashga arziydi. 0.1 + 0.2 aniq 0.3 chiqardi, lekin xuddi o'sha amal o'zgaruvchilar bilan bajarilganda boshqa natija berdi.

Bir vaqtda bir nechta #

package main

import "fmt"

func main() {
    ism, yosh, shahar := "Husanboy", 25, "Namangan"
    fmt.Println(ism, yosh, shahar)

    a, b := 10, 20
    a, b = b, a
    fmt.Println(a, b)

    var (
        sarlavha = "Hisobot"
        sahifa   = 12
        tayyor   = false
    )
    fmt.Println(sarlavha, sahifa, tayyor)
}

Husanboy 25 Namangan
20 10
Hisobot 12 false

a, b = b, a - ikki qiymatni almashtirishning eng qisqa yo'li. Vaqtinchalik o'zgaruvchi kerak emas.

var ( ... ) bloki esa bir nechta e'lonni bir joyga yig'adi.

Doimiylar #

package main

import "fmt"

const Soliq = 0.12
const Shahar = "Namangan"

func main() {
    const MaxUrinish = 3

    maosh := 5000000.0
    fmt.Println("Soliq:", maosh*Soliq)
    fmt.Println(Shahar, MaxUrinish)
}

Soliq: 600000
Namangan 3

const qiymati kompilyatsiya paytida ma'lum bo'lishi kerak va keyin uni o'zgartirib bo'lmaydi.

iota - avtomatik raqamlash #

package main

import "fmt"

const (
    Yangi = iota
    Jarayonda
    Bajarilgan
    Bekor
)

func main() {
    fmt.Println(Yangi, Jarayonda, Bajarilgan, Bekor)

    const (
        KB = 1 << (10 * (iota + 1))
        MB
        GB
    )
    fmt.Println(KB, MB, GB)
}

0 1 2 3
1024 1048576 1073741824

iota - const blokidagi qator raqami. U har bir yangi qatorda bittaga oshadi va blok boshida noldan boshlanadi.

Ikkinchi blokda ifoda takrorlanadi: qator bo'sh bo'lsa, Go yuqoridagi ifodani iota ning yangi qiymati bilan qayta hisoblaydi.

type Holat int

const (
    Yangi Holat = iota
    Jarayonda
    Bajarilgan
)

Turni tekshirish #

package main

import "fmt"

func main() {
    qiymatlar := []any{42, "salom", 3.14, true}

    for _, q := range qiymatlar {
        fmt.Printf("%v -> %T\n", q, q)
    }
}

42 -> int
salom -> string
3.14 -> float64
true -> bool

any - istalgan turni saqlay oladigan tur. Uni 13-bo'limda, interfeyslar bilan birga tushunamiz.

%v - qiymatning odatiy ko'rinishi, %T esa turi.

Xulosa #

• Uch shakl bor: var turi bilan, var tursiz va :=. Oxirgisi faqat funksiya ichida ishlaydi.
• E'lon qilingan o'zgaruvchi doim nol qiymat oladi - hech qachon chiqindi emas.
• Son chegaradan oshganda jimgina aylanadi; odatda oddiy int ishlating.
• Go turlarni avtomatik o'tkazmaydi: float64(butun) deb aniq yozish kerak.
• Ikki butun sonning bo'linishi ham butun bo'ladi.
• float64 da 0.1 + 0.2 aniq 0.3 bermaydi - pulni tiyinda, butun son sifatida saqlang.
• const qiymati kompilyatsiya paytida ma'lum; turi belgilanmagan doimiy mos turga moslashadi.
• iota - const blokidagi avtomatik raqamlash, Go dagi enum ning o'rnini bosadi.

Keyingi bo'limda satrlar, runalar va baytlarni o'rganamiz.