O‘zgaruvchilar va o‘zgarmaslar

O‘zgaruvchi — xotiraning nomlangan qismi. Dastur ishlashi davomida bu qiymatni o‘qishi va o‘zgartirishi mumkin.

Masalan, ob-havo dasturi shahar nomi va haroratini saqlashi kerak. shahar hamda harorat kabi nomlar koddagi qiymat nima anglatishini bildiradi.

O‘zgaruvchini e’lon qilish

O‘zgaruvchidad foydalanish uchu avval uni e’lon qilish kerak. E’lon qilish o‘zgaruvchining nomi va qanday turdagi qiymat saqlashini oldindan belgilash hisoblanadi:

var yosh int = 25

Bu qatorda:

• var — o‘zgaruvchi e’lon qiluvchi kalit so‘z;
• yosh — o‘zgaruvchining nomi;
• int — o'zgaruvchi turi. int butun sonlar uchun;
• 25 — boshlang‘ich qiymat.

To‘liq dasturda quyidagicha:

package main

import "fmt"

func main() {
    var yosh int = 25
    var harorat float64 = 36.6

    fmt.Println("Yosh:", yosh)
    fmt.Println("Harorat:", harorat)
}

Natija:

Yosh: 25
Harorat: 36.6

fmt.Println()ga vergul bilan bir nechta qiymat berish mumkin. Ularni natijada bo‘sh joy bilan ajratib chiqaradi.

package main

import "fmt"

func main() {
    var yosh int = 25
    var harorat float64 = 36.6

    fmt.Println("Yosh:", yosh, "Harorat:", harorat)
}

Qiymatni o‘zgartirish

O‘zgaruvchiga = operatori orqali yangi qiymat berish mumkin:

var hisob int = 10
hisob = 15
fmt.Println(hisob)

Natijada 15 chiqadi. Yangi qiymat oldingi qiymatning o‘rniga yoziladi.

= yangi o‘zgaruvchi yaratmaydi. U avval e’lon qilingan o‘zgaruvchiga qiymat beradi. Qiymat o‘zgaruvchining turiga mos bo‘lishi kerak:

var yosh int = 25
// yosh = "yigirma besh" // string qiymatni int o‘zgaruvchiga berib bo‘lmaydi

Turini aniqlash

Boshlang‘ich qiymat mavjud bo‘lsa, tur nomini yozish shart emas. Go qiymatga qarab turni o'zi aniqlaydi:

var ism = "Aziza" // string
var yosh = 24     // int
var narx = 19.5   // float64

Bu type inference deyiladi. Tur nomi yozilmagan bo‘lsa ham o‘zgaruvchining qiymatidan aniqlaydi va keyinchalik ham o‘zgarmaydi.

Qisqa e’lon: :=

Funksiya ichida o‘zgaruvchini := yordamida qisqa e’lon qilish mumkin:

package main

import "fmt"

func main() {
    ism := "Aziza"
    yosh := 24

    fmt.Println(ism, yosh)
}

ism := "Aziza" qatori o‘zgaruvchini yaratadi va unga boshlang‘ich qiymat beradi. := faqat funksiya ichida ishlatiladi.

= va := bir xil emas:

son := 10 // yangi o‘zgaruvchi e’lon qilindi
son = 20  // mavjud o‘zgaruvchining qiymatini o'zgartirdi

Yangi boshlovchilar uchun funksiya ichida boshlang‘ich qiymati bor o‘zgaruvchilarga := yozish qulay. Turini alohida ko‘rsatish kerak bo‘lsa yoki o‘zgaruvchi keyin qiymat olsa, var ishlatiladi.

Boshlang‘ich qiymatsiz o‘zgaruvchi

var bilan qiymat bermasdan ham o‘zgaruvchi e’lon qilish mumkin:

var son int
var matn string
var faol bool

Bunday o‘zgaruvchi bo‘sh yoki noma’lum holatda bo'lmaydi. Go unga turining nol qiymatini (zero value) beradi:

Tur	Nol qiymat
son turlari	0
string	"" — bo‘sh matn
bool	false

package main

import "fmt"

func main() {
    var urinishlar int
    var xabar string
    var tayyor bool

    fmt.Printf("urinishlar=%d, xabar=%q, tayyor=%t\n", urinishlar, xabar, tayyor)
}

Natija:

urinishlar=0, xabar="", tayyor=false

Bu yerda Printf() natijani berilgan qolip bo‘yicha chiqaradi. %d butun son, %q qo‘shtirnoq ichidagi matn, %t esa bool qiymat uchun ishlatiladi.

Bir nechta o‘zgaruvchini e’lon qilish

Bir xil turdagi o‘zgaruvchilarni bitta qatorda e’lon qilish mumkin:

var kenglik, balandlik int = 800, 600

Bir nechta o'zgaruvchini qisqa e'lon qilish:

ism, shahar := "Ali", "Samarqand"

Qiymatlar chapdagi nomlarga o‘z tartibida beriladi. Kodni o‘qish qiyinlashsa, e'lonlarni alohida qatorlarda yozish tog' ri bo'ladi.

O‘zgaruvchilarga murojaat qilish

O‘zgaruvchini kodning istalgan joyida ishlatib bo‘lmaydi. U e’lon qilingan blok ichida ko‘rinadi. Blok { va } bilan chegaralanadi:

package main

import "fmt"

func main() {
    shahar := "Toshkent"

    if true {
        harorat := 28
        fmt.Println(shahar, harorat)
    }

    // fmt.Println(harorat) // bu yerda harorat ko‘rinmaydi
}

shahar main() funksiyasining ichida e'lon qilingan, shuning uchun ichki if blokida ham ko'rinadi. harorat esa faqat if blokining ichida mavjud. Shu sabab harorat ni tashqarida ishlatib bo'lmaydi.

O‘zgaruvchilarni nomlash

O‘zgaruvchi nomi uning vazifasini anglatishi kerak. x o‘rniga yosh, narx yoki foydalanuvchiSoni kabi nomlar kodni tushunarli qiladi. Ko'proq ingliz tilida nomlash tavfsiya qilinadi.

O'zgaruvchilari uchun asosiy qoidalar:

• nom harf yoki _ belgisi bilan boshlanadi;
• keyingi belgilarda harf va raqam ishlatish mumkin;
• probel va - belgisi ishlatilmaydi;
• var, func, package kabi kalit so‘zlar nom sifatida ishlatib bo‘lmaydi;
• katta va kichik harflar farqlanadi: yosh va Yosh boshqa-boshqa nomlar.

Bir nechta so‘zdan iborat nomlar odatda foydalanuvchiSoni kabi yoziladi. Juda qisqa yoki ma’nosiz nomlamaslikga harakat qilish kerak.

Ishlatilmagan o‘zgaruvchi

Go e’lon qilingan, ammo ishlatilmagan o‘zgaruvchini xato deb hisoblaydi:

func main() {
    yosh := 25
}

Bu kod uchun kompilyator xato qaytaradi. O‘zgaruvchini ishlating yoki kerak bo‘lmasa olib tashlang. Bu qoida kodda ortiqcha qismlar qolishini oldini oladi.

O‘zgarmaslar: const

O‘zgarmas (constant) — dastur davomida qiymatini o'zgartitib bo‘lmaydigan nomlangan qiymat. U const kalit so‘zi bilan e’lon qilinadi:

package main

import "fmt"

func main() {
    const kunlikSoat = 24
    const salomlashuv string = "Salom"

    fmt.Println(salomlashuv, kunlikSoat)
}

O‘zgarmasga keyin yangi qiymat berib bo‘lmaydi:

const pi = 3.14
// pi = 3.1415 // kompilyatsiya xatosi chiqadi

O‘zgarmas son, matn yoki mantiqiy qiymat bo‘lishi mumkin. Uning qiymati kompilyatsiya vaqtida aniqlanishi kerak. Funksiya natijasini o‘zgarmasga berib bo‘lmaydi:

// const vaqt = time.Now() // funksiya natijasi const bo‘la olmaydi

Keyingi darsda Go’dagi asosiy ma’lumot turlari va ular bilan bajariladigan amallarni ko‘rib chiqamiz.

Misollar

1. Qiymatlarni bir vaqtda almashtirish

Go’da vaqtinchalik o‘zgaruvchi yaratmasdan ikki qiymatni almashtirish mumkin:

package main

import "fmt"

func main() {
    a, b := 10, 20
    a, b = b, a
    fmt.Println(a, b)
}

Natija 20 10 bo‘ladi. O‘ng tomondagi qiymatlar avval hisoblanadi, keyin chap tomondagi o‘zgaruvchilarga beriladi.

2. Bir nechta o‘zgaruvchini bir vaqtda e’lon qilish

Bir xil qatorda bir nechta o‘zgaruvchini e’lon qilish mumkin:

package main

import "fmt"

func main() {
    ism, yosh, faol := "Ali", 24, true
    fmt.Println(ism, yosh, faol)
}

O‘ng tomondagi qiymatlar chap tomondagi o‘zgaruvchilarga yozilish tartibida beriladi. Har bir o‘zgaruvchining turi o‘z qiymatidan aniqlanadi.

3. O‘zgaruvchining nol qiymati

Boshlang‘ich qiymat berilmagan o‘zgaruvchi o‘z turining nol qiymatini oladi:

package main

import "fmt"

func main() {
    var son int
    var matn string
    var faol bool
    fmt.Printf("son=%d, matn=%q, faol=%t\n", son, matn, faol)
}

int uchun 0, string uchun bo‘sh matn, bool uchun false nol qiymat hisoblanadi. O‘zgaruvchi qiymatsiz qolmaydi.

4. Qisqa e’londa mavjud o‘zgaruvchini yangilash

:= chap tomonda kamida bitta yangi o‘zgaruvchi bo‘lsa ishlaydi:

package main

import "fmt"

func main() {
    son := 8
    son, kvadrat := son+1, son*son
    fmt.Println(son, kvadrat)
}

son yangilanadi, kvadrat esa yangi e’lon qilinadi. O‘ng tomon eski son, ya’ni 8 bilan hisoblanadi.

5. O‘zgaruvchining ko‘rinish sohasi

Ichki blokda tashqi o‘zgaruvchi bilan bir xil nomli yangi o‘zgaruvchi yaratilishi mumkin:

package main

import "fmt"

func main() {
    xabar := "tashqi"
    {
        xabar := "ichki"
        fmt.Println(xabar)
    }
    fmt.Println(xabar)
}

Natijada avval ichki, keyin tashqi chiqadi. Bu holat nomni soyalash (shadowing) deyiladi.

6. Paket darajasidagi o‘zgaruvchi

Funksiyadan tashqarida e’lon qilingan o‘zgaruvchi shu paketdagi funksiyalarga ko‘rinadi:

package main

import "fmt"

var tashriflar int

func main() {
    tashriflar++
    tashriflar++
    fmt.Println(tashriflar)
}

Natija 2 bo‘ladi. tashriflar funksiyadan tashqarida e’lon qilingani uchun main() ichida ham ko‘rinadi.

7. Turini aniq ko‘rsatib e’lon qilish

Boshlang‘ich qiymat keyin berilsa, o‘zgaruvchining turi oldindan yoziladi:

package main

import "fmt"

func main() {
    var masofa float64
    masofa = 12
    fmt.Printf("%.1f km\n", masofa)
}

12 butun son ko‘rinishida yozilgan bo‘lsa ham, masofa o‘zgaruvchisida float64 sifatida saqlanadi.

8. Guruhlab e’lon qilish

Bir vazifaga tegishli o‘zgaruvchilarni var bloki ichida guruhlash mumkin:

package main

import "fmt"

func main() {
    var (
        mahsulot = "kitob"
        soni     = 3
        narx     = 25000
    )
    fmt.Println(mahsulot, soni*narx)
}

Bu usul sozlama yoki bir-biriga bog‘liq qiymatlarni o‘qishni osonlashtiradi.

9. iota bilan ketma-ket o‘zgarmaslar

iota const blokidagi har bir qatorda noldan boshlab bittaga ortadi:

package main

import "fmt"

const (
    Dushanba = iota + 1
    Seshanba
    Chorshanba
)

func main() {
    fmt.Println(Dushanba, Seshanba, Chorshanba)
}

Natija 1 2 3 bo‘ladi. Bu usul o‘zaro bog‘liq o‘zgarmas qiymatlarni tartib bilan berishda qulay.

10. O‘zgarmas ifodani hisoblash

O‘zgarmas qiymat boshqa o‘zgarmaslardan tuzilgan ifoda orqali aniqlanishi mumkin:

package main

import "fmt"

const (
    soniya = 1
    daqiqa = 60 * soniya
    soat   = 60 * daqiqa
)

func main() {
    fmt.Println(soat)
}

soat kompilyatsiya vaqtida 3600 deb hisoblanadi. Bunday nomlangan qiymatlar koddagi noma’lum sonlarni kamaytiradi.