Go’da asosiy ma’lumot turlari

Ma’lumot turi qiymat nimani ifodalashi va u bilan qanday amallar bajarish mumkinligini belgilaydi. Masalan, int butun sonni, string matnni, bool esa mantiqiy holatni saqlaydi.

Tasavvur qiling, dastur foydalanuvchining ismi, yoshi va tizimga kirgan-kirmaganini saqlaydi. Har bir qiymatning vazifasi boshqa bo‘lgani uchun ularning turlari ham boshqa bo‘ladi:

package main

import "fmt"

func main() {
    ism := "Ali"        // string
    yosh := 25           // int
    tizimgaKirdi := true // bool

    fmt.Println(ism, yosh, tizimgaKirdi)
}

Bu misolda yosh bilan arifmetik amal bajarish, ism bilan matn sifatida ishlash, tizimgaKirdi orqali esa biror shartni tekshirish mumkin.

Ma’lumot turi nima uchun kerak?

Go statik turlangan til. Har bir o‘zgaruvchining turi kod kompilyatsiya qilinayotgan paytda ma’lum bo‘ladi. Bu kompilyatorga noto‘g‘ri amallarni dastur ishga tushishidan oldin topishga yordam beradi.

Masalan, butun son saqlaydigan o‘zgaruvchiga matn berib bo‘lmaydi:

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

Go boshlang‘ich qiymatga qarab turni o‘zi aniqlashi ham mumkin:

ism := "Ali" // string
yosh := 25   // int
narx := 19.5 // float64

Tur nomi yozilmagan bo‘lsa ham, har bir o‘zgaruvchi aniq bir turga ega. Turni %T yordamida ko‘rish mumkin:

package main

import "fmt"

func main() {
    qiymat := 42
    fmt.Printf("Qiymat: %v, turi: %T\n", qiymat, qiymat)
}

Natija:

Qiymat: 42, turi: int

%v qiymatni odatiy ko‘rinishda, %T esa uning turini chiqaradi.

Butun sonlar

Butun sonlarda kasr qismi bo‘lmaydi: -12, 0, 25. Kundalik hisob-kitoblarda ko‘pincha int ishlatiladi:

var yosh int = 25
var harorat int = -5
var talabalarSoni = 30 // Go bu qiymatni int deb aniqlaydi

int turi kompyuter arxitekturasiga qarab 32 yoki 64 bit bo‘ladi. Oddiy hisoblagich, yosh, mahsulot soni va indeks kabi qiymatlar uchun odatda int tanlanadi.

Aniq o‘lchamdagi ishorali sonlar

Ishorali (signed) turlar musbat, manfiy va nol qiymatlarni saqlaydi:

Tur	O‘lchami	Qiymatlar oralig‘i
int8	8 bit	-128 dan 127 gacha
int16	16 bit	-32 768 dan 32 767 gacha
int32	32 bit	-2 147 483 648 dan 2 147 483 647 gacha
int64	64 bit	-9 223 372 036 854 775 808 dan 9 223 372 036 854 775 807 gacha

Ishorasiz butun sonlar

Ishorasiz (unsigned) turlar manfiy qiymat saqlamaydi:

Tur	O‘lchami	Qiymatlar oralig‘i
uint8	8 bit	0 dan 255 gacha
uint16	16 bit	0 dan 65 535 gacha
uint32	32 bit	0 dan 4 294 967 295 gacha
uint64	64 bit	0 dan 18 446 744 073 709 551 615 gacha

uint ham kompyuter arxitekturasiga qarab 32 yoki 64 bit bo‘ladi. Qiymat hech qachon manfiy bo‘lmasligining o‘zi uint tanlash uchun har doim yetarli sabab emas. Umumiy hisob-kitoblarda int qulayroq, chunki Go turli son turlarini avtomatik aralashtirmaydi.

Aniq o‘lchamdagi turlar fayl formati, tarmoq protokoli yoki tashqi tizim bilan ma’lumot almashishda kerak bo‘ladi. Masalan, uint8 bitta baytdagi 0–255 oralig‘idagi qiymatni saqlaydi.

Warning

Tur sig‘dira oladigan oraliqdan chiqish overflow deb ataladi. Son uchun yetarli oraliqqa ega turni tanlang. Kompilyator o‘zgarmas qiymat sig‘masa xato beradi, ammo dastur bajarilishidagi ayrim hisoblarda qiymat o‘ralib ketishi mumkin.

Kasrli sonlar

Kasr qismi bor sonlar uchun float32 va float64 ishlatiladi:

var harorat float64 = 36.6
var masofa float32 = 12.5

Tur	O‘lchami	Taxminiy aniqligi
float32	32 bit	6–7 ta o‘nlik raqam
float64	64 bit	15–16 ta o‘nlik raqam

Go kasrli son literalini odatda float64 deb aniqlaydi. Shu sababli umumiy hisob-kitoblarda float64 ko‘proq ishlatiladi.

package main

import "fmt"

func main() {
    narx := 12.5
    miqdor := 3.0
    jami := narx * miqdor

    fmt.Printf("Jami: %.2f\n", jami)
}

Natija:

Jami: 37.50

%.2f kasrli sonni verguldan keyin ikki xona bilan chiqaradi.

Info

float32 va float64 ayrim o‘nli kasrlarni ikkilik ko‘rinishda mutlaqo aniq saqlay olmaydi. Pul hisobida yaxlitlash xatosi muhim bo‘lsa, summani eng kichik birlikda butun son sifatida saqlash mumkin. Masalan, 1250 tiyin — 12.50 so‘m.

Mantiqiy tur: bool

bool faqat ikki qiymatdan birini saqlaydi: true yoki false. U “ha yoki yo‘q” ko‘rinishidagi holatlar uchun ishlatiladi:

var faol bool = true
var bloklangan bool = false

Taqqoslash natijasi ham bool bo‘ladi:

package main

import "fmt"

func main() {
    yosh := 20
    balogatgaYetgan := yosh >= 18

    fmt.Println("Balog‘atga yetgan:", balogatgaYetgan)
}

Natija:

Balog‘atga yetgan: true

Keyingi darslarda bool qiymatlarni if shartlarida ishlatamiz.

Matn turi: string

string matnni, ya’ni baytlar ketma-ketligini saqlaydi. Matn qo‘shtirnoq ichida yoziladi:

ism := "Dilshod"
xabar := "Go’ni o‘rganamiz"
boshMatn := ""

Ikki matnni + operatori bilan birlashtirish mumkin:

package main

import "fmt"

func main() {
    ism := "Dilshod"
    xabar := "Salom, " + ism + "!"

    fmt.Println(xabar)
}

Natija:

Salom, Dilshod!

Go manba kodidagi matn UTF-8 kodlashida yoziladi. Shu sababli o‘zbekcha harflar va boshqa yozuv tizimlari bilan ishlash mumkin.

byte va rune

byte — uint8 turining boshqa nomi. U ko‘pincha xom ma’lumotning bitta baytini ifodalash uchun ishlatiladi.

rune — int32 turining boshqa nomi. U Unicode kod nuqtasini, odatda bitta belgini ifodalaydi. Rune literali bittalik tirnoq ichida yoziladi:

var harf rune = 'O'
var maxsusHarf rune = '‘'

string uzunligini len() bilan olganda baytlar soni qaytadi. Unicode belgilar soni bundan farq qilishi mumkin:

package main

import "fmt"

func main() {
    matn := "Go😊"

    fmt.Println("Baytlar:", len(matn))
    fmt.Println("Belgilar:", len([]rune(matn)))
}

Natija:

Baytlar: 6
Belgilar: 3

G va o bittadan bayt, 😊 esa UTF-8 da to‘rt bayt egallaydi. []rune(matn) matnni Unicode belgilar ketma-ketligiga aylantiradi. Slice turi keyingi darslarda batafsil tushuntiriladi.

Kompleks sonlar

Go complex64 va complex128 turlariga ham ega. Kompleks son haqiqiy va mavhum qismlardan tuziladi:

var z complex128 = complex(2, 3) // 2 + 3i

Bu turlar ilmiy va muhandislik hisoblarida ishlatiladi. Oddiy dasturlarda kam uchraydi, shu sababli hozircha ularni tanib olish yetarli.

Turlarni o‘zgartirish

Go son turlarini avtomatik ravishda bir-biriga aylantirmaydi. Turlar boshqa bo‘lsa, aniq konvertatsiya yoziladi:

package main

import "fmt"

func main() {
    var dona int = 5
    var narx float64 = 12.5

    jami := float64(dona) * narx
    fmt.Println(jami)
}

float64(dona) dona qiymatini hisob uchun float64 turiga aylantiradi. Asl dona o‘zgaruvchisi int bo‘lib qoladi.

Kasrli sonni butun songa aylantirganda kasr qismi tashlab yuboriladi:

kasr := 9.8
son := int(kasr) // 9

Bu yaxlitlash emas. 9.8 ham, 9.2 ham intga aylantirilganda 9 bo‘ladi.

Warning

Katta sonni kichik oraliqli turga aylantirish qiymatni buzishi mumkin. Masalan, qiymat := 300 dan keyin uint8(qiymat) natijasi 44 bo‘ladi. uint8(300) kabi sig‘maydigan o‘zgarmas qiymatni aylantirishga esa kompilyator ruxsat bermaydi. Konvertatsiyadan oldin qiymat yangi tur oralig‘iga sig‘ishini tekshirish kerak.

Sonni matnga yoki matnni songa aylantirish oddiy tur konvertatsiyasidan farq qiladi. Buning uchun odatda strconv paketi ishlatiladi; bu mavzuni ma’lumot kiritish va paketlar bilan ishlashda ko‘ramiz.

Nol qiymatlar

Boshlang‘ich qiymat berilmagan o‘zgaruvchi turiga mos nol qiymat oladi:

Tur	Nol qiymat
butun va kasrli sonlar	0
kompleks sonlar	0+0i
bool	false
string	""

package main

import "fmt"

func main() {
    var son int
    var narx float64
    var faol bool
    var xabar string

    fmt.Printf("son=%d, narx=%.1f, faol=%t, xabar=%q\n", son, narx, faol, xabar)
}

Natija:

son=0, narx=0.0, faol=false, xabar=""

Qaysi turni tanlash kerak?

Yangi boshlaganda quyidagi oddiy qoida yetarli:

• butun son uchun int;
• kasrli son uchun float64;
• matn uchun string;
• “ha yoki yo‘q” holati uchun bool;
• bitta Unicode belgisi uchun rune;
• protokol yoki fayl formati aniq o‘lcham talab qilsa, int32, uint64 kabi mos turni tanlang.

Massiv, slice, map, struct, pointer, funksiya, interface va channel ham Go’dagi turlardir. Ular bir nechta qiymatni saqlash yoki murakkab dastur tuzilishini ifodalash uchun ishlatiladi va keyingi darslarda alohida ko‘rib chiqiladi. nil esa alohida tur emas; ayrim turlarda qiymat mavjud emasligini bildiruvchi maxsus qiymat.

Xulosa

Go’da har bir qiymat aniq turga ega. int butun son, float64 kasrli son, bool mantiqiy holat, string matn, byte bayt va rune Unicode belgisini ifodalaydi. Go tur xavfsizligini saqlash uchun turli son turlarini avtomatik aralashtirmaydi; kerak bo‘lsa konvertatsiya ochiq yoziladi.

Keyingi darsda bu qiymatlar ustida hisoblash, taqqoslash va mantiqiy amallar bajarish uchun operatorlardan foydalanamiz.