011. Array ma'lumot turi va Make

Golangda Array, Slice va make Funktsiyasi

Golangda ma'lumotlar strukturalari va ularga ishlov berish juda muhim. Bu maqolada Array (Massiv), Slice (Kesma) va make funksiyasi haqida to'liq tushunchalar beriladi. Ma'lumotlarni bosqichma-bosqich ko'rib chiqamiz: boshlang'ichdan ilg'or tushunchalargacha.

1. Array (Massiv)

Massiv — bu bir xil turdagi elementlar to'plami. Golangda massivlar statik bo'lib, uning o'lchami bir martada belgilanadi va keyinchalik o'zgartirib bo'lmaydi. Massivlar o'zgaruvchan uzunlikka ega emas, shuning uchun ular faqat boshlang'ich o'lcham bilan ishlatiladi.

Massivni yaratish va ishlatish:

package main

import "fmt"

func main() {
    // 5 elementli butun sonlar massivi
    var arr [5]int

    // Elementlarga qiymat tayinlash
    arr[0] = 10
    arr[1] = 20
    arr[2] = 30
    arr[3] = 40
    arr[4] = 50

    // Massivni chop etish
    fmt.Println(arr) // [10 20 30 40 50]
}

Massivlar bilan ishlash:

• Massivning o'lchami: Massivni yaratishda uning o'lchamini ko'rsatish kerak, bu o'lchamni keyin o'zgartirish mumkin emas.
• Indekslar: Massivning har bir elementiga indeks orqali murojaat qilinadi. Indekslar 0 dan boshlanadi.

• Fiksatsiya: Massivning o'lchami o'zgarmaydi, shuning uchun u juda katta yoki kichik bo'lsa, samarali ishlamaydi.

• Slice (Kesma)

Slice — bu massivning dinamik ko'rinishi bo'lib, uning o'lchami va qobiliyati o'zgarishi mumkin. Golangda kesmalarni ishlatish ko'pincha massivlardan ko'ra qulayroq, chunki ular o'lchami doimiy emas va qo'shimcha elementlar qo'shish yoki olib tashlash mumkin.

Slice yaratish:

package main

import "fmt"

func main() {
    // Sliceni yaratish va boshlang'ich qiymat berish
    slice := []int{10, 20, 30, 40, 50}

    fmt.Println(slice) // [10 20 30 40 50]
}

Slice bilan ishlash:

Uzunlik va qobiliyat: Slice o'lchami dinamik ravishda o'zgarishi mumkin, chunki bu ma'lumotlar ko'proq "oyna" sifatida ishlaydi. Indekslar: Slice-da ham indekslar 0 dan boshlanadi, lekin elementlar qo'shilib yoki o'chirilganda uning uzunligi o'zgaradi. Slicing (Kesish): Slice'dan qismini olish uchun arr[start:end] sintaksisidan foydalaniladi.

Slice misoli:

package main

import "fmt"

func main() {
    arr := []int{10, 20, 30, 40, 50}

    // Slice'ni kesib olish (start va end indekslari)
    subSlice := arr[1:4] // [20 30 40]

    fmt.Println(subSlice) // [20 30 40]
}

Slice-dan kesish (arr[start:end]) yordamida yangi kesmalar yaratish mumkin.

1. make Funktsiyasi va Slice’lar

make — bu Golangda kesma (slice), kanal (channel) va xarita (map) yaratish uchun ishlatiladigan maxsus funksiya. make funktsiyasi yordamida kesmalarni yaratishda o'lchamni va qobiliyatni belgilash mumkin.

make sintaksisi:

make([], , )

• — kesma elementlarining tipi.
• — kesmaning boshlang'ich uzunligi.
• — ixtiyoriy, kesmaning maksimal o'lchami (agar berilmasa, length qiymati o'rniga ishlatiladi).

make bilan kesma yaratish:

package main

import "fmt"

func main() {
    // 5 elementli kesma yaratish
    slice := make([]int, 5)

    // Elementlarga qiymat berish
    slice[0] = 1
    slice[1] = 2
    slice[2] = 3
    slice[3] = 4
    slice[4] = 5

    fmt.Println(slice) // [1 2 3 4 5]
}

make bilan kesma yaratish va qo'shish:

package main

import "fmt"

func main() {
    // 3 ta elementli kesma yaratish
    slice := make([]int, 3)

    slice[0] = 10
    slice[1] = 20
    slice[2] = 30

    // Slice'ni kengaytirish (append)
    slice = append(slice, 40)

    fmt.Println(slice) // [10 20 30 40]
}

append funktsiyasi yordamida kesmaga yangi elementlar qo'shish mumkin. capacity (kabi) ko'rsatilmasa, bu kesma uchun maksimal o'lcham yo'q, lekin Golang avtomatik ravishda kesmaning hajmini oshiradi.

1. Advanced Xususiyatlar:

Cap (Qobiliyat) va Len (Uzunlik):

len(slice): Slice elementlarining sonini qaytaradi.
cap(slice): Slice ning maksimal hajmini qaytaradi.

Misol:

package main

import "fmt"

func main() { // 3 ta elementli kesma yaratish slice := make([]int, 3, 5)

fmt.Println("Length:", len(slice))  // 3
fmt.Println("Capacity:", cap(slice)) // 5

}

len kesmaning uzunligini, cap esa uning qobiliyatini qaytaradi. Qobiliyat — bu kesma o'zgartirilganda avtomatik ravishda o'sadigan maksimal o'lcham.

copy funksiyasi:

Golangda copy funksiyasi yordamida bir slice'dan ikkinchisiga elementlar nusxalash mumkin.

Misol:

package main

import "fmt"

func main() { // Asl kesma original := []int{1, 2, 3, 4, 5}

// Yangi kesma yaratish
copySlice := make([]int, len(original))

// Nusxalash
copy(copySlice, original)

fmt.Println("Original:", original)  // [1 2 3 4 5]
fmt.Println("Copy:", copySlice)     // [1 2 3 4 5]

}

Slice va Garbage Collection:

Slice'lar dinamik xotira ajratishning samarali usulidir, ammo kerak bo'lmagan ma'lumotlar avtomatik ravishda tozalanadi (garbage collection), bu xotira samaradorligini oshiradi.

Xulosa

Array (Massiv): O'lchami o'zgarmaydi va ko'pincha statik ma'lumotlar bilan ishlash uchun qo'llaniladi.
Slice (Kesma): O'lchami dinamik, qismlarga ajratish, qo'shish yoki olib tashlash mumkin.
make: Kesmalar va boshqa ma'lumotlar strukturasi uchun maxsus funksiyadir, uning yordamida slice yaratish, uzunlik va qobiliyatni belgilash mumkin.

Golangda massivlar va kesmalarni samarali ishlatish uchun bu tushunchalar juda muhimdir. Keyingi bosqichlarda bu konseptlarni murakkab tizimlarda, API'larda va yuqori samarali dasturlarda qo'llash mumkin.