hkucuk

GoLang'de Array ve Slice Arasındaki Farklar

9 Ekim 2021 • ☕️ 2 dk okuma • 🏷 bilgisayar, yazılım

Yazar tarafından şu dillere çevrildi: English


Array

Array (dizi) veri tipi, bir dizi elemanın aynı veri tipinden olduğu, sabit uzunluklu bir veri yapısıdır. Arrayler tanımlanırken eleman sayısı ve her elemanın veri tipi belirtilir. Örneğin aşağıdaki kod bloğunda “int” veri tipinde bir array oluşturulmuştur ve bu arrayin elemanları 0 ile 9 arasında değişen 10 tane sayıdır:

package main

import "fmt"

func main() {
    var a [10]int
    for i := 0; i < 10; i++ {
        a[i] = i
    }
    fmt.Println(a)  // Output: [0 1 2 3 4 5 6 7 8 9]
}

Aşağıdaki örnekte ise array’e yeni bir veri eklenmeye çalışılmaktadır. Bu durumda çalışma zamanı hatası oluşacaktır.

package main

import "fmt"

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

    a[5] = 6  // This line will cause a runtime error

    fmt.Println(a)  // This line will not be executed
}

Hata:

invalid argument: index 5 out of bounds [0:5]

Slice

Slice (dilim) veri tipi ise arraylerden farklı olarak sabit uzunluklu olmayan, dinamik uzunluklu bir veri yapısıdır. Slice’lar tanımlanırken eleman sayısı belirtilmez.

Slice’lar daha esnek ve kullanışlı olmaları nedeniyle arraylerden daha sık kullanılır. Örneğin slice’lar üzerinde dinamik olarak eleman ekleyebilir, silebilir veya değiştirebiliriz.

Aşağıda bir slice oluşturma ve bu slice’a yeni bir eleman ekleme örneği görülmektedir.

package main

import "fmt"

func main() {
    // Create a slice with the shorthand syntax
    a := []int{1, 2, 3, 4, 5}

    // Add a new element to the slice
    a = append(a, 6)

    // Print the slice
    fmt.Println(a)  // Output: [1 2 3 4 5 6]
}

Ayrıca slice’ları bir array üzerinden oluşturduğumuzda, oluşturduğumuz slice ile orjinal array arasında bir bağlantı oluşur ve slice üzerinde yaptığımız değişiklikler orjinal array’e de yansır.

package main

import "fmt"

func main() {
    a := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    b := a[0:3]
    b = append(b, 10)
    fmt.Println(a)  // Output: [0 1 2 3 4 5 6 7 8 9 10]
    fmt.Println(b)  // Output: [0 1 2 10]
}

Slice’ların bir diğer avantajı ise “make” fonksiyonu ile oluşturulabiliyor olmalarıdır. “make” fonksiyonu ile oluşturulan slice’lar, belirtilen eleman sayısı kadar yer ayırır ve slice’ın elemanları varsayılan değerleri alır. Örneğin, aşağıdaki kod bloğunda “int” veri tipinde bir slice oluşturulmuş ve bu slice’ın elemanları 0 değerini almıştır:

package main

import "fmt"

func main() {
    a := make([]int, 5)
    fmt.Println(a)  // Output: [0 0 0 0 0]
}

Slice’lar “make” fonksiyonu ile oluşturulurken 3. bir parametre de verilebilir ve bu parametre slice’ın “capacity” özelliğini belirler. Örneğin, aşağıdaki kod bloğunda “b” isimli slice’ı “make” fonksiyonu ile oluştururken “capacity” özelliğini 10 olarak belirttik:

package main

import "fmt"

func main() {
    // Create a slice with make function
    b := make([]int, 5, 10)  // Creates a slice with 5 elements and capacity 10
    b[0] = 1
    b[1] = 2
    b[2] = 3
    b[3] = 4
    b[4] = 5

    // Print the slice and its capacity
    fmt.Println(b)        // Output: [1 2 3 4 5]
    fmt.Println(len(b))   // Output: 5
    fmt.Println(cap(b))   // Output: 10
}

Bir slice’ın uzunluğu o anda dilimde bulunan öğelerin sayısı ifade ederken, kapasite ise slice’ın yeniden memory tahsis (reallocated) edilmeye ihtiyaç duymadan önce tutabileceği öğelerin sayısını ifade eder.

Kaynaklar