> 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-karakter-dizileri.md).

# # Go Karakter Dizileri

Her programlama dilinde olduğu gibi Go programlama dilinde de **karakter dizileri** yani **string** değişken tipi büyük önem arz eder. Çünkü tanımlayacağınız birçok değişken string ifadeler içerir. Üstelik string değişken tipleri üzerinden yürütebileceğiniz birçok Go fonksiyonu mevcuttur. Bir `string` veri tipinde değerler **`"`** (çift tırnak) ve `` ` `` (yatay tek tırnak) ifadeleri arasında gösterilir. Ayrıca `string()` fonksiyonu ile de yeni bir `string` değişken oluşturabilirsiniz.

```go
var isim string = "Kerteriz"
var sehir = `Ankara`
ulke := string("Türkiye")
```

Diğer programlama dillerinde `'` (tek çizgi) veya `"""` (üç tırnak) işareti kullanıyor olabilirsiniz ama Go programlama dilinde tek doğru vardır. Bu sebeple yalnızca `"` (çift tırnak) veya `` ` `` (yatay tek tırnak) kullanmanız gerekmektedir.

```go
// DOĞRU
blog := "Kerteriz"

// DOĞRU
blog := `Kerteriz`

// YANLIŞ
sehir := 'Ankara'

// YANLIŞ
arac := """Otobüs"""
```

{% hint style="info" %}
`String` değişken tanımlarken birden fazla satırdan oluşan değerler oluşturabilirsiniz.
{% endhint %}

```go
a := `Merhaba arkadaşlar,
Bu örnekte gördüğünüz gibi,
birden fazla satıra sahip
değişken oluşturabilirsiniz.`
```

Bir `string` tanımlarken değerine atayacağınız metinde `"` işareti varsa **Kaçış Karakteri** olan `\` kullanarak `"` işaretini kullanabilirsiniz.

```go
// YANLIŞ
metin := "okuduğum kitabın adı "1984" idi."

// DOĞRU
metin := "okuduğum kitabın adı \"1984\" idi."
```

## 1. String Değerler Aynı Zamanda Dizidir

Bir **string** veri tipinde değişken oluşturmuşsanız aynı zamanda bir dizi oluşturmuşsunuz demektir. Çünkü ders başlığında da yazdığımız gibi bir string değişken **karakter dizisi** şeklinde veri tipidir. Örneğin " **Kerteriz** " kelimesi `K` , `e` , `r` , `t` , `e` , `r` , `i` , `z` harflerinden meydana gelir. Bunu hemen başka bir örnekle gösterelim:

```go
sehir := "Ankara"

fmt.Println(sehir[0])    //65
fmt.Println(sehir[1])    //110
fmt.Println(sehir[2])    //107
fmt.Println(sehir[3])    //97
fmt.Println(sehir[4])    //114
fmt.Println(sehir[5])    //97
```

{% hint style="info" %}
Dizilerde (ilerleyen derslerde göreceğiz) index her zaman 0 dan başlar. Yani 0.index ilk elemandır.
{% endhint %}

{% hint style="warning" %}
Bu örnekte dönen karakter değerleri ASCII Tablosunda yer alan karakterlerin decimal (ondalık) karşılıklarıdır. Tüm tabloya ulaşmak için [Tıklayınız.](http://www.asciitable.com/)
{% endhint %}

## 2. ASCII Kodundan Karakter İfadesine Dönüştürme

Yukarıda verdiğimiz örnekte karakterlerin ASCII tablosundaki değerini elde ettik. Şimdi ise elimizde bulunan bu ASCII değerinden `string()` fonksiyonu ile nasıl karakteri elde edebileceğimizi göreceğiz.

```go
asciiKod := 65
karakter := string(asciiKod)

fmt.Println(karakter)    // A
```

## 3. Metin Birleştirme ve Toplama

Bazı durumlarda elinizde bulunan string değerleri birbirleriyle birleştirmek ve yan yana eklemek isteyebilirsiniz. Bunun için matematiksel ifade olan **+** işareti kullanılır. Örneklerini aşağıda görebilirsiniz.

```go
ad := "Fatih"
ek := "Sultan"
ad2 := "Mehmet"

sonuc := ad + ek + ad2

fmt.Println(sonuc)    // FatihSultanMehmet
```

String değişkenlerimizi birleştirdik ama araya boşluklarda eklemek istersek direkt değişken yerine metin ekleme işlemi yapabiliriz. Tabi amacınız sadece göstermekse **Println()** fonksiyonunda , kullanarakta yapabilirsiniz.

```go
ad := "Fatih"
ek := "Sultan"
ad2 := "Mehmet"

sonuc := ad + " " + ek + " " + ad2

fmt.Println(sonuc)    // Fatih Sultan Mehmet
fmt.Print(ad,ek,ad2)    // FatihSultanMehmet
fmt.Println(ad,ek,ad2)    // Fatih Sultan Mehmet
```

## 4. Metin Dilimleme (String Parçalama)

Programlamanızı yaparken elinizdeki `string` değişkenlerin belirli bir parçasını kullanmak, başından veya sonundan kırpmak, tersine çevirmek gibi işlemlere tabi tutmak isteyebilirsiniz. İlk olarak elinizdeki metinin bir karakter dizisi olduğunu hatırlayalım.

```go
sehir := "Ankara"

fmt.Print(sehir[0])    //65
fmt.Print(sehir[1])    //110
fmt.Print(sehir[2])    //107
fmt.Print(sehir[3])    //97
fmt.Print(sehir[4])    //114
fmt.Print(sehir[5])    //97

//Tersinede işlem yapabiliriz

fmt.Print(sehir[len(sehir)-1])    //97
fmt.Print(sehir[len(sehir)-2])    //114
fmt.Print(sehir[len(sehir)-3])    //97
fmt.Print(sehir[len(sehir)-4])    //107
fmt.Print(sehir[len(sehir)-5])    //110
fmt.Print(sehir[len(sehir)-6])    //65
```

{% hint style="info" %}
**len()** fonksiyonu bize değişkenin karakter uzunluğunu verir.
{% endhint %}

Öyleyse elimizdeki metin üzerinde x. karakterden y. karaktere kadar kırpma işlemini gerçekleştirelim.

```go
isim := "Kerteriz ile Go öğreniyorum"

// 4. indeksten 10.indekse kadar
fmt.Print(isim[4:10]) // eriz i

// En baştan 10.indekse kadar
fmt.Print(isim[:10]) // Kerteriz i

// 4. indeksten sonuna kadar
fmt.Print(isim[4:]) // eriz ile Go öğreniyorum'

// İki değer de belirtilmemişse tüm stringi al.
fmt.Print(isim[:]) // Kerteriz ile Go öğreniyorum

// Son karaktere kadar al.
fmt.Print(isim[:len(isim)-1]) // kerteriz ile Go öğreniyoru'
```

## 5. String Fonksiyonları

### 5.1 Metinin Karakter Uzunluğunu Öğrenme

Elinizdeki string değişkenin kaç karakterden oluştuğunu öğrenmek için **len()** fonksiyonunu kullanabilirsiniz.

```go
a := "Merhaba Dünya!"

fmt.Print(len(a))     // 14
```

### 5.2 Metindeki Boşlukları ve Özel Karakterleri Temizleme

Bir metinin başındaki ve sonundaki boşlukları ve özel karakterleri temizlemek için **TrimSpace(),** **Trim()**, **TrimLeft()**,  **TrimRight()** fonksiyonlarını kullanabilirsiniz. Fakat öncelikle **strings** kütüphanesini eklemelisiniz.

```go
package main

import (
	"fmt"
	"strings"
)

func main() {

	a := " \t\t Merhaba Dünya! \n "
	
	a = strings.TrimSpace(a)	// Boşlukları ve özel karakterleri temizler
	fmt.Println(a)     // Merhaba Dünya!
	
	a = strings.Trim(a,"\t \n")	// Boşlukları ve belirtilen özel karakterleri temizler
	fmt.Println(a)     // Merhaba Dünya!
	
	a = strings.TrimLeft(a,"\t \n")	// Boşlukları ve belirtilen özel karakterleri metinin başından temizler
	fmt.Println(a)     // Merhaba Dünya!
	
	a = strings.TrimRight(a,"\t \n")	// Boşlukları ve belirtilen özel karakterleri metinin sonundan temizler
	fmt.Println(a)     // Merhaba Dünya!

}
```

### 5.3 Metindeki Tüm Karakterleri Büyük Harfe Çevirme

Elinizdeki metini tamamen büyük harflere çevirmek istiyorsanız **ToUpper()** fonksiyonunu kullanabilirsiniz.

```go
package main

import (
	"fmt"
	"strings"
)

func main() {

	s := "kerteriz"

	fmt.Println(strings.ToUpper(s))		// KERTERIZ

}
```

### 5.4 Metindeki Tüm Karakterleri Küçük Harfe Çevirme

Elinizdeki metini tamamen küçük harflere çevirmek istiyorsanız **ToLower()** fonksiyonunu kullanabilirsiniz.

```go
package main

import (
	"fmt"
	"strings"
)

func main() {

	s := "BLOG"

	fmt.Println(strings.ToLower(s))		// blog

}
```

### 5.5 Metindeki Baş Harfleri Büyük Harfe Çevirme

Elinizdeki metinin sadece baş harflerini büyük harflere çevirmek istiyorsanız **Title()** fonksiyonunu kullanabilirsiniz.

```go
package main

import (
	"fmt"
	"strings"
)

func main() {

	s := "merhaba blog okuyucuları"

	fmt.Println(strings.Title(s))		// Merhaba Blog Okuyucuları

}
```

### 5.6 Metindeki Karakterleri Başka Karakterlerle Değiştirmek

Metindeki bir karakter veya bir kelime grubunu başka bir karakter veya metin grubuyla değiştirmek istediğinizde **Replace()** fonksiyonunu kullanabilirsiniz.

```go
package main

import (
	"fmt"
	"strings"
)

func main() {

	s := "Muz tatlı bir meyvedir."

	fmt.Println(strings.Replace(s,"Muz","Çilek",-1))		// Çilek tatlı bir meyvedir.

}
```

{% hint style="info" %}
Fonksiyonun dördüncü parametresini **-1** verirseniz metindeki bulduğu tüm değişimleri yapar. Fakat **-1** yerine başka bir sayı verirseniz verdiğiniz sayı kadar değişim yapar. Örneğin **2** verirseniz sadece **2** tane değişim işlemi yapar, diğer eşleşmelere ellemez. Ayrıca fonksiyon küçük-büyük harf duyarlıdır.
{% endhint %}

### 5.7 Metini İstenilen Bir Karakterden Bölerek Diziye Atmak

Elinizdeki metini  **Split()** fonksiyonu ile belirlediğiniz bir karakterden bölerek diziye atayabilirsiniz. Aşağıdaki örnekte örnek kullanımını görebilirsiniz.

```go
package main

import (
	"fmt"
	"strings"
)

func main() {

	s := "Kayseri,Nevşehir,Kırşehir İç Anadolu bölgesindedir"
	dizi := strings.Split(s,",")
	
	fmt.Println(dizi)				// [Kayseri Nevşehir Kırşehir İç Anadolu bölgesindedir]
	fmt.Println(len(dizi))	// 3

}
```

### 5.8 Metin İçinde Karakter veya Metin Aramak

Bir metin editöründe nasıl karakter veya metin arayabiliyorsanız Go programlama diliyle de `string` değişkeniniz içinde **Contains()** fonksiyonuyla herhangi bir karakter veya metin arayabilirsiniz.

```go
package main

import (
	"fmt"
	"strings"
)

func main() {

	s := "En sevdiğim hava yağmurlu havadır"
	
	fmt.Println(strings.Contains(s,"mur"))	// true 

}
```

### 5.9 Metin İçindeki Bir Karakterin Kaç Adet Olduğunu Bulmak

Elimizdeki bir metinde bir karakterin kaç adet geçtiğini bulmak için **Count()** fonksiyonunu kullanabiliriz.

```go
package main

import (
	"fmt"
	"strings"
)

func main() {

	s := "Corona ile mücadele için evde kalmalıyız."
	
	fmt.Println(strings.Count(s,"e"))	// 5

}
```

### 5.10 Bir Kelimenin Ne ile Başlayıp Başlamadığını Kontrol Etmek

Doğrulama işlemlerin de işimize yarayacak bir fonksiyon olan **HasPrefix()** ile bir string değişkenin belirlediğimiz bir karakter dizisi ile başlayıp başlamadığını kontrol edebiliriz.

```go
package main

import (
	"fmt"
	"strings"
)

func main() {

	s := "Profesyonel blogculuk için Kerteriz Blog"
	
	fmt.Println(strings.HasPrefix(s,"Pro"))	// true
	fmt.Println(strings.HasPrefix(s,"a"))	// false

}
```

### 5.11 Bir Kelimenin Ne ile Bitip Bitmediğini Kontrol Etmek

Doğrulama işlemlerin de işimize yarayacak başka bir fonksiyon olan **HasSuffix()** ile bir string değişkenin belirlediğimiz bir karakter dizisi ile bitip bitmediğini kontrol edebiliriz.

```go
package main

import (
	"fmt"
	"strings"
)

func main() {

	s := "Profesyonel blogculuk için Kerteriz Blog"
	
	fmt.Println(strings.HasSuffix(s,"og"))	// true
	fmt.Println(strings.HasSuffix(s,"y"))	// false

}
```

### 5.12 Bir Karakterin Metindeki Yerini Bulmak

String değişken üzerinden bir karakterin veya metinin ilk index numarasını bulmak için **Index()** fonksiyonunu kullanabiliriz. Eğer sonuç bulunumazsa -1 dönecektir.

```go
package main

import (
	"fmt"
	"strings"
)

func main() {

	s := "Kerteriz"
	
	fmt.Println(strings.Index(s,"iz"))	// 6
	fmt.Println(strings.Index(s,"t"))		// 3
	fmt.Println(strings.Index(s,"a"))		// -1
		
}
```

### 5.13 Dizi Elemanlarını Bir Karakterle Birleştirmek

Dizi elemanlarını herhangi bir karakter veya metin ile birleştirmek isterseniz **Join()** fonksiyonunu kullanabilirsiniz.

```go
package main

import (
	"fmt"
	"strings"
)

func main() {
	
	fmt.Println(strings.Join([]string{"a", "b", "c"}, "-"))	// a-b-c

}
```

### 5.14 Bir İfadeyi İstenilen Sayıda Tekrar Ettirmek

String değişkenimizi istediğimiz adette tekrar ettirerek çoğaltabiliriz. Bunun için **Repeat()** fonksiyonunu kullanabilirsiniz.

```go
package main

import (
	"fmt"
	"strings"
)

func main() {
	
	fmt.Println(strings.Repeat("xXx",3))	// xXxxXxxXx
}
```