O‘zgaruvchilar va o‘zgarmaslar

O‘zgaruvchi — qiymatni nom bilan saqlash uchun ajratilgan xotira qismi. Dastur davomida bu qiymatni o‘qish va o‘zgartirish mumkin.

Masalan, ob-havo dasturi shahar nomi va haroratni saqlashi kerak. shahar hamda harorat kabi nomlar koddagi qiymat nima anglatishini ko‘rsatadi.

O‘zgaruvchini e’lon qilish

O‘zgaruvchini ishlatishdan oldin uni e’lon qilish kerak. E’lon o‘zgaruvchining nomi va qanday turdagi qiymat saqlashini bildiradi:

var yosh int = 25

Bu qatorda:

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

To‘liq dasturda ko‘ramiz:

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.

Qiymatni o‘zgartirish

O‘zgaruvchiga = operatori orqali yangi qiymat beriladi:

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

Natijada 15 chiqadi. Yangi qiymat oldingi qiymatning o‘rnini egallaydi.

= 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 Go’ga aniqlatish

Boshlang‘ich qiymat mavjud bo‘lsa, tur nomini yozmaslik mumkin. Go qiymatga qarab turni aniqlaydi:

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

Bu tur chiqarish (type inference) deyiladi. Tur kodi yozilmagan bo‘lsa ham, o‘zgaruvchining aniq turi mavjud va keyinchalik o‘z-o‘zidan 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 qiymati almashtirildi

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 qolmaydi. 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 ishlatilgan.

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 qisqa e’lon ham mumkin:

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

Qiymatlar chapdagi nomlarga o‘z tartibida beriladi. Kodni o‘qish qiyinlashsa, e’lonlarni alohida qatorlarda yozgan ma’qul.

O‘zgaruvchining ko‘rinish sohasi

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.

O‘zgaruvchi nomlarini tanlash

O‘zgaruvchi nomi uning vazifasini anglatishi kerak. x o‘rniga yosh, narx yoki foydalanuvchiSoni kabi nomlar kodni tushunarli qiladi.

Go identifikatorlari 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 bo‘la olmaydi;
• 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 nomlardan qoching.

Ishlatilmagan o‘zgaruvchi

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

func main() {
    yosh := 25
}

Bu kod uchun kompilyator declared and not used mazmunidagi xabar qaytaradi. O‘zgaruvchini ishlating yoki kerak bo‘lmasa olib tashlang. Bu qoida kodda ortiqcha qismlar qolishining oldini oladi.

O‘zgarmaslar: const

O‘zgarmas (constant) — dastur davomida almashtirib 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

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

Info

Go’da o‘zgarmaslarni faqat katta harflarda yozish shart emas. Ularni boshqa nomlar kabi qisqa va mazmunli nomlang.

Xulosa

var o‘zgaruvchi e’lon qiladi, := esa funksiya ichida qisqa e’lon uchun ishlatiladi. = mavjud o‘zgaruvchining qiymatini almashtiradi. Boshlang‘ich qiymat berilmasa, Go turga mos nol qiymat beradi. O‘zgarmaydigan qiymatlar const bilan e’lon qilinadi.

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