Dilimler (Slices)

slice ifadeleri array ifalerinin bir segmenti(alt bölümü)dür. array ifadelerinde olduğu gibi slice ifadeleri de indekslenebilir(numaralandırılabilir) ve belirli bir uzunlukları vardır. array ifadelerinden farklı olarak bu uzunluklar değiştirilebilirler.

Bir slice ifadesi aşağıdaki şekilde tanımlanır.

var slicename [slicelength]slicetype

Bir örnek ifade ile göstermek gerekirse :

package main


func main(){
  var x []float64
  fmt.Print(len(x))
}

Yukarıdaki ifadede sıfır öğeli bir slice ifadesi oluşturuldu. slice ifadeleri oluşturulurken değer ataması yapılmaz ise slice ifadesinin uzunluğu sıfır kabul edilir.

Diğer bir slice oluşturma yöntemi ise make() yardımıyla slice oluşturmaktır.

func main(){
  myslice := make([]int)
}

slice ifadesini oluşturken eğer alacağı değerleri de belirlemek istiyorsanız {} ifadesini slice ifadesinin sonuna eklenmeniz gerekir.

func main(){
  myarr := make([3]int{22,24,32})

  // index 0 'dan index 2 değerine kadar
  myslice := [0:2]
  fmt.Print(myslice)

}

Slice ifadelerine Eleman eklenmesi

slice ifadelerine eleman ekleme işlemleri append() fonksiyonu aracılığıyla sağlanır.

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

  fmt.Println("slice1 :" , slice1)
  fmt.Println("slice2 :" , slice2)

}

append() fonksiyonu slice1 isimli ilk slice ifadesini temel alarak üstüne 4,5 değerlerini ekleyip yeni bir slice ifadesi olan slice2 ifadesini oluşturur.

Yukarıdaki ifadenin çıktısı :

slice1 : [1 2 3]
slice2 : [1 2 3 4 5]

şeklinde olacaktır.

Mevcut bir slice ifadesine tekrar atama yapmak için aşağıdaki şekilde bir yazım gerçekleştirmeniz gerekir.

func main(){

	cities := []string{}
	// WARN: Tanımlama sonrasında değer atamada : işareti kullanılmaz!

	cities = append(cities, "Bursa", "Edirne", "İstanbul")
	fmt.Println(cities)
}

DİKKAT: cities ifadesinde tanımlama sonrasında append () fonksiyonu kullanırken yalnızca = kullandık. değişken tanımlama sonrasında yapılan işlemlerde aynı değişken için : işareti kullanılmaz!

Yukarıdaki ifadeyi çalıştırdığımızda aşağıdaki çıktıyı elde ederiz :

["Bursa", "Edirne","İstanbul"]

slice ifadelerinin kopyalanması

slice ifadelerini kopyalamak için copy() isimli fonksiyon ifadesini kullanırız.

func main() {
  slice1 := []int{1,2,3}
  slice2 := make([]int, 2)
  copy(slice2, slice1)

  fmt.Println("slice1:", slice1)
  fmt.Println("slice2:", slice2)
}

Bu fonksiyon slice1 isimli bir slice oluşturur ve slice2 ismiyle oluşturulan 2 adet değer alabilen fonksiyona slice ifadesini kopyalar. İki adet değer alabileceği için slice1 isimli slice öğelerinden 1,2 öğelerini kendi içine kopyalar. Kod çalıştırıldığında aşağıdaki sonuç elde edilir.

slice1: [1 2 3]
slice2: [1 2]

Bir slice ifadesinin içindeki değerleri fmt.Printf() aracılığıyla görüntülemek istedimizde %q argümanını kullanırız.

func main() {
  cities := []string{}
  cities = append(cities, "Edirne", "Bursa")
  fmt.Printf("%q", cities)

}

Yukarıdaki işleme ait çıktı şu şekilde olacaktır:

["Edirne" "Bursa"]

Slice ifadelerini birbirine direkt olarak eklemek istedimizde aşağıdaki yazım biçimiyle bu işlemleri gerçekleştiriz.

func main() {
  cities := []string{"Lüleburgaz", "Babaeski"}
  otherCities := []string{"Havsa", "Uzunköprü"}


  /* ... - ellipsis işaretiyle otherCities isimli slice
  ifadesinin her elemanını tek tek
  string olarak eklemek istediğimizi belirttik
  */

  cities = append(cities, otherCities...)
  fmt.Printf("%q", cities)
}

Çıktı şu şekilde olacaktır :

 ["Lüleburgaz" "Babaeski" "Havsa" "Uzunköprü"]

... (ellipsis) işareti ile dilimin her elemanını tek tek eklemek istediğimizi belirttik. Eğer böyle belirtmemiş olsak string ifadeleri içeren bir slice a slice ifadesi eklemeye çalışacağımız için hata mesajı alırdık. otherCities isimli slice içindeki string ifadelerini teker teker string ifadeleri olarak eklememiz için ifadeden sonra ... ellipsis işareti kullanmamız gerekir.

Slice ifadelerinin sıralanması

slice ifadelerinin sıralanması sırasında sort.Slice() isimli bir fonksiyon kullanılır.

func main(){

	cities := []string{
		"Bursa",
		"İstanbul",
		"Çanakkale",
		"Balıkesir",
		"Tekirdağ",
		"Edirne",
		"Kırklareli",
		"Yalova",
		"Kocaeli",
		"Sakarya",
	}

	sort.Strings(cities)

	// before sort  cities
	fmt.Printf("%q", cities)
}

Bu ifadeyi çalıştırdığımızda sort.Strings() fonksiyonu yardımıyla string ifadeleri alfabetik olarak dizilecektir. Burada dikkat etmeniz gereken konu Çanakkale ve İstanbul ifadelerindeki karakterler Türkçe karakterler olduğu için sıralamaya dahil edilmeyip sıralamanın en sonuna eklenir. Programlama dillerinde Türkçe karakterlerle sıralama işlemi yaptığınızda benzer durumlarla karşılaşabilirsiniz. Kodun çıktısı aşağıda verilmiştir.

["Balıkesir" "Bursa" "Edirne" "Kocaeli" "Kırklareli" "Sakarya" "Tekirdağ" "Yalova" "Çanakkale" "İstanbul"]%

Diğer ifadeleri sıralamak için sort kütüphanesindeki :

• sort.Strings()
• sort.Ints()
• sort.Float64s()

ifadelerini de pkg.go.dev - sort sayfasından araştırabilirsiniz.

slice ifadelerinin kapasitelerinin ölçülmesi

slice ifadelerinin kapasitelerinin ölçülmesi için cap() isimli bir fonksiyon kullanırız. cap() fonksiyonu ile len() fonksiyonunun farkı, cap() dizinin alabileceği azami eleman miktarını belirtirken, len() fonksiyonu dizinin mevcut eleman miktarını belirtir.

func main(){
	firstslice := [4]int{12, 23, 44}

	// myslice
	myslice := firstslice[0:2]

	fmt.Printf("%v \n", myslice)
	fmt.Printf("Capacity : %d \n", cap(myslice))
	fmt.Printf("Length: %d \n", len(myslice))
}

Yukarıdaki ifade çalıştırıldığında aşağıdaki ekran çıktısı ile karşılaşılır.

[12 23]
Capacity : 4
Length: 2

nil slice ifadeleri

Bir slice ifadesi oluşturulurken eğer sayısal bir değer belirtilmezse ifade nil yani elemansız kabul edilir. Bu slice ifadelerinin veri uzunluğu sıfır ve kapasiteleri sıfırdır.

func main() {

	var z []int

	fmt.Printf("Slice: %v \n", z)
	fmt.Printf("len : %d \n", len(z))
	fmt.Printf("cap : %d \n", cap(z))

	if z == nil {
		fmt.Println("Z is nil!")
	} else {
		fmt.Println("This is not nil!")
	}

}

Bu kodun çıktısı aşağıdaki şekilde olacaktır.

Slice: []
len : 0
cap : 0
Z is nil!