> For the complete documentation index, see [llms.txt](https://derslik.kerteriz.net/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://derslik.kerteriz.net/go/temel-dersler/go-veri-tipleri/go-diziler.md).

# # Go Diziler & Dilimler

**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.

```go
// 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)
```

{% hint style="info" %}
**`[]`** 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.
{% endhint %}

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

```go
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.

```go
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.

```go
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
```

{% hint style="warning" %}
İndeks her zaman **0** dan başlar. Yani bir listede ilk elemanın indeksi 0 dır.
{% endhint %}

## 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.

```go
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.

```go
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.

```go
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]
```

{% hint style="info" %}
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!
{% endhint %}

## 5. Diziye Yeni Eleman Ekleme

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

```go
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.

```go
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.

```go
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.

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

harfler_yeni = harfler

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