Çalıştırılabilir Go Dokümanları: Slice'lar

Q: Go'da bir slice'ın uzunluğu ile kapasitesi arasındaki fark nedir?

len(s), slice'ın şu anda tuttuğu eleman sayısıdır. cap(s), slice'ın ilk elemanından başlayarak arka diziye sığan eleman sayısıdır. append, boş kapasite varsa oraya yazar, yoksa yeni ve daha büyük bir dizi ayırır.

Q: Go'da bir slice'a nasıl eleman eklenir?

Yerleşik append'i çağırın ve sonucu geri atayın: s = append(s, x). Birkaç değer (append(s, 1, 2, 3)) ya da başka bir slice (append(s, other...)) ekleyebilir. Dönüş değerini her zaman kullanın, çünkü append yeni bir diziye işaret eden bir slice döndürebilir.

Q: Go'da bir slice'ın bir değeri içerip içermediği nasıl kontrol edilir?

Standart slices paketinden (Go 1.21) slices.Contains(s, v) kullanın. slices.Index(s, v) konumu ya da -1 döndürür, slices.ContainsFunc ise bir koşul fonksiyonu alır. Büyük veride tekrarlanan aramalar için bunun yerine bir map oluşturun.

Q: Go'da nil slice ile boş slice arasındaki fark nedir?

var s []int nil'dir; s := []int{} boştur ama nil değildir. İkisinin de uzunluğu 0'dır, ikisi de len, range ve append ile çalışır. Fark s == nil kontrollerinde ve nil bir slice'ı null, boş bir slice'ı [] olarak kodlayan encoding/json'da ortaya çıkar.

Tek örnekte slice

Slice, bir diziye açılan büyüyebilen bir görünümdür. Bir literal ya da make ile oluşturur, append ile büyütür ve boyutunu len ile okursunuz.

package main

import "fmt"

func main() {
	langs := []string{"Go", "Rust"}
	langs = append(langs, "Zig", "C")
	fmt.Println(langs, len(langs))

	for i, l := range langs {
		fmt.Println(i, l)
	}

	fmt.Println(langs[1:3]) // elements 1 and 2
}

[]string'in köşeli parantezlerinde uzunluk yoktur. Boyutu sabit olan [4]string gibi bir dizi tipinden farkı budur.

Slice nedir

Bir slice değeri üç alanlı küçük bir başlıktır:

arka dizideki bir elemana işaret eden bir pointer
bir uzunluk: slice'ın kaç elemanı görebildiği
bir kapasite: o pointer'dan arka dizinin sonuna kadar kaç eleman olduğu

Bir slice'ı kopyalamak (atamak, bir fonksiyona aktarmak) yalnızca bu başlığı kopyalar. İki kopya da aynı elemanlara işaret eder. Neredeyse her slice sürprizi bunu unutmaktan gelir.

make: uzunluk ve kapasite

make([]T, len, cap) bir arka dizi ayırır ve onun üzerinde bir slice döndürür. Kapasite isteğe bağlıdır ve varsayılan olarak uzunluğa eşittir.

package main

import "fmt"

func main() {
	a := make([]int, 3) // len 3, cap 3, all zeros
	fmt.Println(a, len(a), cap(a))

	b := make([]int, 0, 10) // len 0, room for 10
	fmt.Println(b, len(b), cap(b))

	for i := range 5 {
		b = append(b, i*i)
	}
	fmt.Println(b, len(b), cap(b)) // no reallocation happened
}

Yaygın bir karışıklık: make([]int, 5) ardından beş append çağrısı size ilk beşi sıfır olan on eleman verir. Eleman eklemeyi planlıyorsanız make([]int, 0, 5), indeksle atamayı planlıyorsanız make([]int, 5) kullanın.

Son boyutu bildiğinizde kapasiteyi önceden ayırmak tekrarlanan büyümeyi önler. Bu bir optimizasyondur, zorunluluk değil.

append ve büyüme

append, elemanları mevcut uzunluğun ardına ekler. Kapasite yeterliyse yerinde yazar. Değilse daha büyük bir dizi ayırır, eski elemanları oraya kopyalar ve yeni diziye işaret eden bir slice döndürür.

package main

import "fmt"

func main() {
	var s []int
	prevCap := cap(s)
	for i := range 2000 {
		s = append(s, i)
		if cap(s) != prevCap {
			fmt.Printf("len %4d  cap %4d\n", len(s), cap(s))
			prevCap = cap(s)
		}
	}
}

Kapasite, slice küçükken kabaca iki katına çıkar, 256 elemanı geçtikten sonra ise daha küçük bir çarpanla (1.25x'e doğru) büyür. Kesin sayılar Go sürümleri arasında değişmiş bir çalışma zamanı ayrıntısıdır, bu yüzden asla onlara bağımlı kod yazmayın.

append farklı bir dizi döndürebileceği için sonucunu kullanmak zorundasınız:

append(s, 4)     // compile error: append(s, 4) (value of type []int) is not used
s = append(s, 4) // correct

Bütün bir slice'ı eklemek açma söz dizimini kullanır: s = append(s, other...).

Dilimleme arka diziyi paylaşır

s[low:high], aynı dizi üzerinde low indeksinden başlayıp high indeksinden hemen önce biten yeni bir slice başlığı oluşturur. Sınırlardan herhangi biri yazılmayabilir. Hiçbir eleman kopyalanmaz.

package main

import "fmt"

func main() {
	nums := []int{10, 20, 30, 40, 50}
	mid := nums[1:4] // 20 30 40
	mid[0] = 99
	fmt.Println(nums) // the write shows up in nums

	fmt.Println(len(mid), cap(mid)) // cap runs to the end of nums
}

Çıktı:

[10 99 30 40 50]
3 4

Dilimlemeyi ucuz yapan bu paylaşımdır. En ünlü slice hatasının kaynağı da odur.

append paylaşım (aliasing) hatası

Bir alt slice'ın boş kapasitesi varsa ona eleman eklemek, üst slice'ın dizisine, üst slice'ın hâlâ kullandığı elemanların üzerine yazar.

package main

import "fmt"

func main() {
	base := []int{1, 2, 3, 4, 5}
	first := base[:2] // [1 2], cap 5

	first = append(first, 100) // fits in capacity: overwrites base[2]
	fmt.Println(base)
	fmt.Println(first)

	// Two slices built from the same prefix clobber each other.
	prefix := make([]string, 0, 4)
	prefix = append(prefix, "cmd")
	a := append(prefix, "build")
	b := append(prefix, "test")
	fmt.Println(a, b) // both print test
}

Çıktı:

[1 2 100 4 5]
[1 2 100]
[cmd test] [cmd test]

a ve b, "cmd"'den sonraki dizi yuvasını paylaşır, bu yüzden ikinci append ilkinin üzerine yazdı. Kod düzgün görünür ve kapasite tesadüfen dolu olduğunda çalışır; bu hatanın yalnızca bazen ortaya çıkmasının nedeni budur.

İki çözüm:

Tam slice ifadesi s[low:high:max], kapasiteyi max-low ile sınırlar. Boş kapasite olmadığında bir sonraki append yeni bellek ayırmak zorundadır. first := base[:2:2] ilk örneği güvenli hale getirir.
Bir slice çağrıdan uzun yaşayacaksa ya da bağımsız olarak büyütülecekse açıkça kopyalayın: slices.Clone(prefix) ya da append([]string(nil), prefix...).

İlgili bir tuzak: devasa bir dizinin küçük bir slice'ı, dizinin tamamını çöp toplayıcı için canlı tutar. 100 MB'lık bir dosyayı okuyup data[:10]'u tutarsanız 100 MB bellekte kalır. Tuttuğunuz kısmı klonlayın.

copy

Yerleşik copy(dst, src), min(len(dst), len(src)) eleman kopyalar ve bu sayıyı döndürür. dst'yi asla büyütmez.

package main

import (
	"fmt"
	"slices"
)

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

	dst := make([]int, len(src))
	n := copy(dst, src)
	dst[0] = 100
	fmt.Println(n, src, dst) // independent

	var empty []int
	fmt.Println(copy(empty, src)) // 0: dst has no length

	c := slices.Clone(src) // the one-line version (Go 1.21)
	fmt.Println(c)
}

copy çakışan kaynak ve hedefi doğru ele alır, bu yüzden copy(s[1:], s) elemanları bozmadan sağa kaydırır.

slices paketi

Go 1.21'den beri standart slices paketi, eskiden elle yazdığınız işlemler için generic yardımcılar sunar.

package main

import (
	"fmt"
	"slices"
)

func main() {
	s := []int{5, 2, 8, 2, 9}

	fmt.Println(slices.Contains(s, 8)) // true
	fmt.Println(slices.Index(s, 2))    // 1
	fmt.Println(slices.Max(s), slices.Min(s))

	slices.Sort(s)
	fmt.Println(s)
	i, found := slices.BinarySearch(s, 8)
	fmt.Println(i, found)

	s = slices.Compact(s) // drop adjacent duplicates
	fmt.Println(s)

	s = slices.Delete(s, 1, 2) // remove index 1
	fmt.Println(s)

	s = slices.Insert(s, 1, 3, 4)
	fmt.Println(s)

	slices.Reverse(s)
	fmt.Println(s, slices.Equal(s, []int{9, 8, 4, 3, 2}))
}

Fonksiyon	Ne yapar
`Contains`, `Index`	bir değer bulur (`ContainsFunc`, `IndexFunc` bir koşul fonksiyonu alır)
`Sort`, `SortFunc`, `SortStableFunc`	yerinde sıralar
`BinarySearch`	sıralı bir slice'ta arar
`Insert`, `Delete`, `DeleteFunc`	ekler ya da siler, yeni slice'ı döndürür
`Compact`	ardışık tekrarları kaldırır
`Equal`, `Compare`	eleman eleman karşılaştırır
`Clone`, `Reverse`, `Max`, `Min`	adlarının söylediğini
`Collect`, `Sorted`, `Values`, `All`	iterator'larla çalışır (Go 1.23)

Delete ve Insert, append gibi atamanız gereken bir slice döndürür. Sıralamanın kendi sayfası var: sıralama.

İndeksle dönerken eleman silmek bazı elemanları atlar. Bunun yerine slices.DeleteFunc kullanın:

s = slices.DeleteFunc(s, func(n int) bool { return n%2 == 0 }) // drop evens

2 boyutlu slice'lar

Slice'lardan oluşan bir slice, satırlarının uzunluğu farklı olabilen bir ızgara verir. Her satır ayrı ayrı ayrılmalıdır.

package main

import "fmt"

func main() {
	rows, cols := 3, 4
	grid := make([][]int, rows)
	for r := range grid {
		grid[r] = make([]int, cols)
	}
	grid[1][2] = 7

	for _, row := range grid {
		fmt.Println(row)
	}

	// Rows of different lengths are fine.
	triangle := [][]int{{1}, {1, 1}, {1, 2, 1}}
	fmt.Println(triangle)
}

İçteki make'i unutmak her satırı nil bırakır ve grid[1][2] = 7, index out of range [2] with length 0 ile panic olur.

nil slice'lar ve boş slice'lar

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	var a []int  // nil
	b := []int{} // empty, not nil

	fmt.Println(len(a), len(b), a == nil, b == nil)

	a = append(a, 1) // append works on nil
	fmt.Println(a)

	ja, _ := json.Marshal(struct{ Items []int }{})
	jb, _ := json.Marshal(struct{ Items []int }{Items: []int{}})
	fmt.Println(string(ja), string(jb))
}

Nil bir slice len, cap, range ve append için boş bir slice gibi davranır, bu yüzden sıfır durum olarak var s []T'yi tercih edin. Yalnızca fark önemliyse []T{} ile başlatın; bu da çoğunlukla JSON çıktısıdır (null ile []). Boşluğu s == nil ile değil, len(s) == 0 ile kontrol edin.

Slice'lar ve fonksiyonlar

Bir slice alan fonksiyon elemanlarını değiştirebilir ve çağıran değişiklikleri görür. Çağıranın uzunluğunu değiştiremez, çünkü başlığın bir kopyasını almıştır. Eleman ekleyen bir fonksiyon yeni slice'ı döndürmelidir:

func addAll(s []int, vals ...int) []int {
	return append(s, vals...)
}

append, slices.Delete ve slices.Insert'ün hepsinin bir slice döndürmesinin nedeni budur.

Sık yapılan hatalar

append'in sonucunu yok saymak. Tamamen atıldığında derlenmez, ama append(s, x)'i kullanmaya devam ettiğinizden farklı bir değişkene atamak bir mantık hatasıdır.
Tek bir tabandan iki append. Depolamayı paylaşabilirler. Tabanı klonlayın ya da tam slice ifadesi kullanın.
make([]T, n) ardından append. Başta n sıfır bırakır.
Index out of range. s[len(s)] panic olur. Son eleman s[len(s)-1]'dir.
Slice'ları == ile karşılaştırmak. Yalnızca s == nil derlenir. slices.Equal kullanın.

Sıkça Sorulan Sorular

Go'da bir slice'ın uzunluğu ile kapasitesi arasındaki fark nedir?

len(s), slice'ın şu anda tuttuğu eleman sayısıdır. cap(s), slice'ın ilk elemanından başlayarak arka diziye sığan eleman sayısıdır. append, boş kapasite varsa oraya yazar, yoksa yeni ve daha büyük bir dizi ayırır.

Go'da bir slice'a nasıl eleman eklenir?

Yerleşik append'i çağırın ve sonucu geri atayın: s = append(s, x). Birkaç değer (append(s, 1, 2, 3)) ya da başka bir slice (append(s, other...)) ekleyebilir. Dönüş değerini her zaman kullanın, çünkü append yeni bir diziye işaret eden bir slice döndürebilir.

Go'da bir slice'tan eleman nasıl silinir?

Sonraki elemanları aşağı kaydırıp kısalmış slice'ı döndüren slices.Delete(s, i, i+1) (Go 1.21) kullanın. Go 1.22'den beri boşalan kuyruk yuvalarını da sıfırlar. Sıra önemli değilse son elemanla yer değiştirip kırpın: s[i] = s[len(s)-1]; s = s[:len(s)-1].

Go'da bir slice'ın bir değeri içerip içermediği nasıl kontrol edilir?

Standart slices paketinden (Go 1.21) slices.Contains(s, v) kullanın. slices.Index(s, v) konumu ya da -1 döndürür, slices.ContainsFunc ise bir koşul fonksiyonu alır. Büyük veride tekrarlanan aramalar için bunun yerine bir map oluşturun.

Go'da nil slice ile boş slice arasındaki fark nedir?

var s []int nil'dir; s := []int{} boştur ama nil değildir. İkisinin de uzunluğu 0'dır, ikisi de len, range ve append ile çalışır. Fark s == nil kontrollerinde ve nil bir slice'ı null, boş bir slice'ı [] olarak kodlayan encoding/json'da ortaya çıkar.

İlgili kavramlar