Slice

Go tilida slays (slice) — massiv kabi bir xil turdagi ma'lumotlar to'plamidir. Ammo massivdan farqli o'laroq, slaysning o'lchami qat'iy (o'zgarmas) emas — unga elementlar qo'shish yoki o'chirish orqali hajmini dinamik ravishda o'zgartirish mumkin.

1. Goda slays yaratish

Slays quyidagicha e'lon qilinadi:

numbers := []int{1, 2, 3, 4, 5}

Bu yerda:

• numbers — slays nomi.
• int — slays faqat butun sonlarni saqlashini bildiradi.
• {1, 2, 3, 4, 5} — slays elementlari.
• [] qavslar ichi bo'sh qoldiriladi.

[!NOTE] Agar [] ichida o'lcham ko'rsatilsa, u massiv (array) bo'ladi. Agar bo'sh qoldirilsa, u slays (slice) hisoblanadi:

example.go

Copy

numbers := [5]int{1, 2, 3, 4, 5} // Massiv (Array) - hajmi qat'iy 5
numbers := []int{1, 2, 3, 4, 5}  // Slays (Slice) - hajmi dinamik o'zgaruvchan

Shuningdek, slaysni var kalit so'zi bilan ham yaratish mumkin:

var numbers = []int{1, 2, 3, 4}

Misol: Slays yaratish va chop etish

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5}

    fmt.Println("Numbers: ", numbers)
}

Natija:

Numbers:  [1 2 3 4 5]

2. Massivdan slays ajratib olish (Slice from Array)

Mavjud massivning ma'lum bir qismini kesib olib, yangi slays hosil qilish mumkin:

package main

import "fmt"

func main() {
    numbers := [8]int{10, 20, 30, 40, 50, 60, 70, 80}

    // 4-indeksdan 7-indeksgacha kesib olamiz
    sliceNumbers := numbers[4:7]

    fmt.Println(sliceNumbers)
}

Natija:

[50 60 70]

[!IMPORTANT] numbers[boshlang'ich : oxirgi] sintaksisida:

• boshlang'ich indeks natijaga kiradi (inclusive).
• oxirgi indeks natijaga kirmaydi (exclusive). Shuning uchun 4:7 indeksi 4, 5 va 6-indekslardagi [50, 60, 70] elementlarini qaytaradi.

3. Slays bilan ishlovchi funksiyalar

Goda slayslar ustida turli amallarni bajarish uchun o'rnatilgan bir qator qulay funksiyalar mavjud.

Slaysga element qo'shish: append()

Slaysga yangi element qo'shish uchun append() funksiyasi ishlatiladi:

package main

import "fmt"

func main() {
    primeNumbers := []int{2, 3}

    // 5 va 7 sonlarini slaysga qo'shamiz
    primeNumbers = append(primeNumbers, 5, 7)

    fmt.Println("Tub sonlar:", primeNumbers)
}

Natija:

Tub sonlar: [2 3 5 7]

Bitta slaysni ikkinchisiga qo'shish (append() + ...)

Bir slaysning barcha elementlarini ikkinchi slaysga ulash uchun ... (spread) operatori qo'llaniladi:

package main

import "fmt"

func main() {
    evenNumbers := []int{2, 4}
    oddNumbers := []int{1, 3}

    // oddNumbers elementlarini evenNumbers oxiriga qo'shamiz
    evenNumbers = append(evenNumbers, oddNumbers...)

    fmt.Println("Sonlar:", evenNumbers)
}

Natija:

Sonlar: [2 4 1 3]

Slaysdan nusxa olish: copy()

Bir slaysdagi ma'lumotlarni boshqa slaysga nusxalash uchun copy(qabul_qiluvchi, manba) funksiyasi ishlatiladi:

package main

import "fmt"

func main() {
    primeNumbers := []int{2, 3, 5, 7}
    numbers := []int{1, 2, 3}

    // primeNumbers elementlarini numbers slaysiga nusxalaymiz
    copy(numbers, primeNumbers)

    fmt.Println("Numbers:", numbers)
}

Natija:

Numbers: [2 3 5]

[!NOTE] copy() funksiyasi faqat qabul qiluvchi slays sig'adigan miqdordagi elementlarni ko'chiradi. Yuqoridagi misolda numbers slaysi 3 ta elementli bo'lgani sababli, primeNumbers dan faqat birinchi 3 ta element ko'chirildi.

Ikkita slaysni solishtirish: slices.Equal()

Go tilida slayslarni to'g'ridan-to'g'ri == operatori bilan solishtirib bo'lmaydi. Buning o'rniga standart kutubxonadagi slices paketining Equal() funksiyasidan foydalaniladi:

package main

import (
    "fmt"
    "slices"
)

func main() {
    a := []int{1, 2, 3}
    b := []int{1, 2, 3}
    c := []int{1, 2, 4}

    fmt.Println(slices.Equal(a, b)) // true
    fmt.Println(slices.Equal(a, c)) // false
}

Natija:

true
false

4. Slays uzunligini aniqlash (len())

Slaysdagi joriy elementlar sonini len() funksiyasi orqali aniqlanadi:

package main

import "fmt"

func main() {
    numbers := []int{1, 5, 8, 0, 3}

    length := len(numbers)
    fmt.Println("Uzunlik:", length)
}

Natija:

Uzunlik: 5

5. Slays elementlariga murojaat qilish va ularni o'zgartirish

Slays elementlari ham xuddi massiv kabi 0 dan boshlanuvchi indeks orqali boshqariladi:

package main

import "fmt"

func main() {
    languages := []string{"Go", "Java", "C++"}

    // 0 va 2-indeksdagi elementlarni olish
    fmt.Println(languages[0]) // Go
    fmt.Println(languages[2]) // C++

    // 0 dan 3-gacha bo'lgan oraliqni olish
    fmt.Println(languages[0:3])

    // Qiymatni o'zgartirish
    languages[2] = "Python"
    fmt.Println("Yangilangan:", languages)
}

Natija:

Go
C++
[Go Java C++]
Yangilangan: [Go Java Python]

6. make() funksiyasi yordamida slays yaratish

Go tilida make() funksiyasi orqali slays yaratganda uning uzunligi (length) va sig'imi (capacity) ni oldindan ko'rsatish mumkin:

numbers := make([]int, 5, 7)

Bu yerda:

• 5 — slays uzunligi (len), ya'ni dastlab mavjud bo'lgan elementlar soni.
• 7 — slays sig'imi (cap), ya'ni uning xotiradagi maksimal hajmi (qayta xotira ajratmasdan nechta element qabul qila olishi).

package main

import "fmt"

func main() {
    numbers := make([]int, 5, 7)

    // Elementlarga qiymat beramiz
    numbers[0] = 13
    numbers[1] = 23
    numbers[2] = 33

    fmt.Println("Numbers:", numbers)
}

Natija:

Numbers: [13 23 33 0 0]

Qiymat berilmagan qolgan 2 ta indeks avtomatik ravishda 0 qiymatini oladi.

7. Slays bo'ylab sikl aylanish

Oddiy for sikli bilan:

package main

import "fmt"

func main() {
    numbers := []int{2, 4, 6, 8, 10}

    for i := 0; i < len(numbers); i++ {
        fmt.Println(numbers[i])
    }
}

for range sikli bilan:

package main

import "fmt"

func main() {
    numbers := []int{2, 4, 6, 8, 10}

    for _, value := range numbers {
        fmt.Println(value)
    }
}

Natija:

2
4
6
8
10