# Go Diziler & Dilimler

Go diziler (arrays) ve dilimler(slices) dersini işliyoruz.

Dizi, homojen öğeleri bellekte saklamak için kullanılan belirli veya sonsuz uzunluklu bir değişken tipidir. Dilimler ise elimizde ki dizilerden parçalayarak oluşturduğumuz yeni dizilerdir.

Go programlama dilindeki diziler diğer programlama dillerine çok benzer. Dizilerde aynı türden bir veri koleksiyonunu depolamamız gerekir. Yani hem int hem string veri tipini aynı dizide bulunduramayız.

Go programlama dilinde bir diziyi birden fazla yöntemle oluşturabiliriz.

// boş dizi oluşturma
var hayvanlar []string
cicekler := []string{}

// boş ve eleman sayısını belirleyerek dizi oluşturma
var sayilar [3]int
var sehirler [10]string

// başlangıçta elemanlara sahip dizi oluşturma
rakamlar := [81]int{1,2,3,4,5,6}
var rastgele1 []int = []int{1,2,3,4,5,6}
var rastgele2 [6]int = [6]int{1,2,3,4,5,6}

// eleman sayısını dizi boyutu kadar belirleme
sira := [...]int{1,2,3,4,5,6}

// make() fonksiyonu ile belirli uzunlukta dizi 
a := make([]int, 5)

// make() fonksiyonu ile belirli uzunlukta (0) ve kapasitede (5) dizi 
b := make([]int, 0, 5)

[] içinde kalan değer dizimizin eleman sayısını belirtir. Eğer belirtmezseniz sonsuz kapasiteli dizi elde edersiniz. Fakat eleman sayısını belirtirseniz int diziler için öntanımlı olarak 0, string diziler için "" elemanı dizinin elemanlarına tanımlanır.

Yukarıdaki bilgi notunda verdiğimiz bilgiyi görelim.

var hayvanlar []string
cicekler := []string{}
var sayilar [3]int
var sehirler [10]string
rakamlar := [10]int{1,2,3,4,5,6}
var rastgele1 []int = []int{1,2,3,4,5}
var rastgele2 [5]int = [5]int{1,2,3,4,5}
sira := [...]int{1,2,3,4,5,6}
a := make([]int, 5)
b := make([]int, 0, 5)

fmt.Println(hayvanlar)    // []
fmt.Println(cicekler)     // []
fmt.Println(sayilar)      // [0 0 0]
fmt.Println(sehirler)     // [         ]
fmt.Println(rakamlar)     // [1 2 3 4 5 6 0 0 0 0]
fmt.Println(rastgele1)     // [1 2 3 4 5]
fmt.Println(rastgele2)     // [1 2 3 4 5]
fmt.Println(sira)         // [1 2 3 4 5 6]
fmt.Println(a)            // [0 0 0 0 0]
fmt.Println(b)            // []

Oluşturduğumuz liste değişkeninin tipini kontrol edelim.

package main

import (
    "fmt"
    "reflect"
)

func main() {

    var liste []string    
    fmt.Println(reflect.TypeOf(liste))    // []string

}

1. Dizi Elemanlarına Erişim

Go programlama dilinde elinizdeki bir listenin elemanlarına ulaşabilmek için indeksleri kullanmalısınız. Aşağıdaki örnekle indeksleri nasıl kullanacağınızı gösterelim.

liste := [...]string {"Sal","Vapur","Feribot","Korvet","Fırkateyn"}

fmt.Println(liste[0])    // Sal
fmt.Println(liste[1])    // Vapur
fmt.Println(liste[2])    // Feribot
fmt.Println(liste[3])    // Korvet
fmt.Println(liste[4])    // Fırkateyn

İndeks her zaman 0 dan başlar. Yani bir listede ilk elemanın indeksi 0 dır.

2. Dizi Elemanını Değiştirmek

Dizi elemanlarını görüntüledikten sonra eğer bir elamanı değiştirmek istiyorsanız direkt ilgili indekse değer atayabilirsiniz.

liste := [...]string {"Sal","Vapur","Feribot","Korvet","Fırkateyn"}

liste[0] = "Sandal" 
liste[4] = "Uçak Gemisi"

fmt.Print(liste)    // [Sandal Vapur Feribot Korvet Uçak Gemisi]

3. Dizi Eleman Sayısını Bulmak

Dizilerin eleman sayısını bulabilmek için len() fonksiyonunu kullanmalıyız.

liste := [...]string {"Sal","Vapur","Feribot","Korvet","Fırkateyn"}

fmt.Print(len(liste))    // 5

4. Bir Listeden Yeni Liste Oluşturma (Slice)

Elimizde mevcut olan bir listeden indeks belirterek yeni bir liste oluşturabiliriz. Bu işleme dilimleme yani slice denir. Örneğin mevcut listenin 2.indeksinden 5.indeksine kadar ( 5 dahil değil ) olan elemanlarla yeni bir liste oluşturalım.

var liste []string = []string{"a", "b", "c", "d", "e", "f", "g"}

yeniliste1 := liste[2:5]
yeniliste2 := liste[:3]
yeniliste3 := liste[1:]
yeniliste4 := liste[:]

fmt.Println(yeniliste1) // [c d e]
fmt.Println(yeniliste2) // [a b c]
fmt.Println(yeniliste3) // [b c d e f g]
fmt.Println(yeniliste4) // [a b c d e f g]

Bu şekilde yeni liste oluştururken [x:y] ifadesinde x dahil, y dahil değildir. Ayrıca indeksin 0 dan başladığını unutmayınız!

5. Diziye Yeni Eleman Ekleme

Diziler ile çalışırken dizinin sonuna rahatlıkla yeni bir eleman ekleyebilirsiniz. Bunun için append() fonksiyonunu kullanacağız.

meyveler := []string{"kivi", "çilek", "muz", "nar"}

meyveler = append(meyveler, "karpuz")

fmt.Println(meyveler)     // [kivi çilek muz nar karpuz]

Tek bir eleman yerine yeni bir dizide ekleyebilirsiniz.

sayilar := []int{99, 138, 652}
rakamlar := []int{3, 5, 7, 9}

sayilar = append(sayilar, rakamlar...)

fmt.Println(sayilar)     // [kivi çilek muz nar karpuz]

6. Diziden Bir Elemanı Çıkarmak

Diziden eleman çıkarmak için belirli bir fonksiyon yok ama aşağıdaki örneği inceleyebilirsiniz.

harfler := []string{"A", "B", "C", "D", "E"}

	// 2.indexte yer alan C elemanını çıkarmak
	harfler = append(harfler[:2], harfler[3:]...)

	fmt.Println(harfler)		// [A B D E]

7. Liste Kopyalamak ve Çoğaltmak

Elimizde olan bir listeyi kopyalayarak çoğaltmak istiyorsak kopyalayacağımız diziyi direkt yeni diziye eşitleyebiliriz.

harfler := []string{"A", "B", "C", "D", "E"}
var harfler_yeni []string

harfler_yeni = harfler

fmt.Println(harfler_yeni)     // [A B C D E]