Go Academy · Ders

Dilimler: Dinamik Listeler

make, append, copy, len ve cap

Dilimler: Dinamik Listeler, CoddyKit'te ücretsiz bir Go Academy dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Go Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Go Academy kursu toplamda 4 dersten oluşur.

Dilim Nedir?

Bir dilim, temelindeki diziye bakan dinamik boyutlu bir görünümdür. Üç bileşeni vardır: diziye işaretçi, uzunluk ve kapasite.

Dilimler başvuru türüdür; birden çok dilim aynı temel diziyi paylaşabilir
Go'da liste benzeri işlerin çoğunda diziler yerine dilimler kullanılır

Dilim Değişmezleri ve make

Dilimleri bir değişmezle veya make ile oluşturunuz:

package main
import "fmt"

func main() {
    nums := []int{1, 2, 3, 4, 5}      // literal
    strs := make([]string, 3)          // len=3, cap=3, zero values
    buf  := make([]byte, 0, 64)        // len=0, cap=64
    fmt.Println(nums, strs, len(buf), cap(buf))
}

len ve cap

len, dilimde o anda bulunan öğe sayısını döndürür. cap, dilimin başlangıç işaretçisinden itibaren temel dizinin kapasitesini döndürür.

package main
import "fmt"

func main() {
    s := make([]int, 3, 8)
    fmt.Println(len(s)) // 3
    fmt.Println(cap(s)) // 8
}

append: Dilimi Büyütme

append, dilime öğeler ekler; kapasite aşıldığında yeni bir temel dizi ayırır:

package main
import "fmt"

func main() {
    s := []int{1, 2, 3}
    s = append(s, 4, 5)
    s = append(s, []int{6, 7, 8}...)
    fmt.Println(s) // [1 2 3 4 5 6 7 8]
}

Dilimden Alt Dilim Alma

Bir alt dilim oluşturmak için [low:high] söz dizimini kullanınız; alt dilim temel diziyi paylaşır:

package main
import "fmt"

func main() {
    a := []int{0, 1, 2, 3, 4, 5}
    b := a[1:4]   // [1 2 3]
    c := a[:3]    // [0 1 2]
    d := a[3:]    // [3 4 5]
    fmt.Println(b, c, d)
}

copy: Bağımsız Dilimler

copy, dilimler arasındaki öğeleri kopyalar ve kopyalanan öğe sayısını döndürür. Hedef ve kaynak belleği paylaşmaz:

package main
import "fmt"

func main() {
    src := []int{1, 2, 3}
    dst := make([]int, len(src))
    n := copy(dst, src)
    dst[0] = 99
    fmt.Println(src, dst, n) // [1 2 3] [99 2 3] 3
}

nil Dilim ve Boş Dilim

nil dilimin temel dizisi yoktur. Boş dilimin temel dizisi vardır, ancak uzunluğu 0'dır. Her ikisinde de len == 0 olur:

package main
import "fmt"

func main() {
    var nilSlice []int
    emptySlice  := []int{}
    fmt.Println(nilSlice  == nil) // true
    fmt.Println(emptySlice == nil) // false
    fmt.Println(len(nilSlice), len(emptySlice)) // 0 0
    nilSlice = append(nilSlice, 1) // safe!
}

Öğe Silme

Go'da dilimler için yerleşik bir silme işlemi yoktur. Deyimsel yaklaşım append kullanır:

package main
import "fmt"

func main() {
    s := []int{1, 2, 3, 4, 5}
    i := 2 // delete index 2
    s = append(s[:i], s[i+1:]...)
    fmt.Println(s) // [1 2 4 5]
}

Öğe Ekleme

i konumuna eklemek için append ile dilimlemeyi birlikte kullanınız:

package main
import "fmt"

func main() {
    s := []int{1, 2, 4, 5}
    i := 2
    s = append(s[:i+1], s[i:]...)
    s[i] = 3
    fmt.Println(s) // [1 2 3 4 5]
}

Dilim Tuzağı: Paylaşılan Temel Dizi

Alt dilimler temel diziyi paylaşır; yeniden ayırma gerçekleşene kadar birini değiştirmek diğerini de etkiler:

package main
import "fmt"

func main() {
    a := []int{1, 2, 3, 4}
    b := a[:2]   // shares backing array
    b[0] = 99
    fmt.Println(a) // [99 2 3 4] — a is changed!
}

Hızlı Kontrol

append ne döndürür?

Özet: Dilimler

Temel çıkarımlar:

Dilimler = işaretçi + len + cap; dizileri sararlar
Kapasiteyi önceden ayırmak için make kullanınız
append sonucunu her zaman atayınız
copy bağımsız dilimler oluşturur
Alt dilimlerde paylaşılan temel dizilere dikkat ediniz

Alıştırma Görevi

make ile 5 tam sayılık bir dilim oluşturunuz, üç değer daha ekleyiniz, ardından bu dilimi yeni bir dilime kopyalayınız ve özgün dilimi etkilemeden kopyayı değiştiriniz. İkisini de yazdırınız.

Sıkça Sorulan Sorular

“Dilimler: Dinamik Listeler” dersi ücretsiz mi?

Evet — “Dilimler: Dinamik Listeler” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Go Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Go Academy kursu toplamda 4 dersten oluşur.

“Dilimler: Dinamik Listeler” dersinde ne öğreneceğim?

make, append, copy, len ve cap Go Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Go Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Go Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“Dilimler: Dinamik Listeler” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Go Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Go Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Go Academy Sayfasına Dön