Go Programlama

Go Programlama Dili Dersleri

Kasım 6, 2019
26 Okuma Süresi

Go Dili Dersleri

 


Go Diline Giriş

Go Nedir?

Go (Golang olarak da bilinir), Google tarafından geliştirilen açık kaynaklı bir programlama dilidir. Statik olarak yazılmış ve derlenmiş dildir. Go eşzamanlı programlamayı destekler, yani aynı anda birden fazla işlemi çalıştırmaya izin verir. Bu, kanallar, goroutinler vb. Kullanılarak elde edilir. Go, hafıza yönetimini yapan ve işlevlerin ertelenmiş yürütülmesine izin veren çöp toplama sistemine sahiptir.

GO nasıl indirilir ve kurulur

Adım 1) https://golang.org/dl/ adresine gidin. İşletim sisteminiz için gerekli dosyayı indirin.

 

Adım 2) Next’e tıklayın.

Adım 3) Kurulum sözleşmesini onaylayıp Next’e tıklayın.

Adım 4) Kurulum klasörünü seçin ve Next’e tıklayın.

Adım 5) Go kuruluma hazır. Install’a tıklayın.

Adım 5) Kurulum tamamlandıktan sonra Finish’e tıklayın.

Adım 6) Kurulum tamamlandıktan sonra, terminali açıp yazarak doğrulayabilirsiniz.

1
2
3
 
go version
 

Aşağıdakine benzer bir ekran görüntüsü alacaksınız.

Bu yüklü go sürümünü gösterecektir.

 


İlk Go Programı

GoOrnekleri adlı bir klasör oluşturun. Go programlarımızı bu klasörde oluşturacaksınız.  Visual Code gibi bir metin editörü açıp, proje dizini olarak bu klasörü belirtin. ilk_program.go adında bir dosya açıp, aşağıdaki kodları ekleyin.

1
2
3
4
5
6
7
 
package main
import "fmt"
func main() {
    fmt.Println("Merhaba Dünya!")
}
 

Şimdi terminalde aşağıdaki komutu verelim. <dosyaadı> oluşturmak istediğimiz go dosyasının adı olarak belirtilecektir.

1
2
3
 
go run <dosyadı> #go run ilk_program.go
 

programı çalıştırdığınızda yukarıdakine benzer bir çıktı alırsınız.

Şimdi yukarıdaki programı inceleyelim.

package main – Her go programı bir paket adı ile başlamalıdır. Go, paketleri başka bir go programında kullanmamıza izin veriyor ve bu nedenle kodun yeniden kullanılabilirliğini destekliyor. Bir go programının çalıştırılması main adlı paketin içindeki kodla başlar.

import fmt – fmt paketini alır. Bu paket, I/O  işlevlerini uygular.

func main() – Bu, program yürütmenin başladığı işlevdir. Ana işlev her zaman ana pakete yerleştirilmelidir. main() altına kodu {} içine yazabilirsiniz.

fmt.Println – Bu, ekrandaki metni fmt’nin Println işlevi ile yazdırır.

Not: Bahsettiğinizde, aşağıdaki bölümlerde kodu çalıştır/run ifadesi, kodu .go uzantılı bir dosyaya kaydetmek ve sözdizimini kullanarak çalıştırmak anlamına gelir.

1
2
3
 
go run <dosyadı>
 

Bir Go Programı Nasıl Okunur

Bu programa daha detaylı bakalım. Go programları yukarıdan aşağıya, soldan sağa okunur. (bir kitap gibi) İlk satır şöyle der:

1
2
3
 
package main
 

Bu bir “paket bildirimi” olarak bilinir. Her Go programı bir paket bildirimi ile başlamalıdır. Paketler Go’nun kodu düzenleme ve yeniden kullanma yöntemidir. İki tür Go programı vardır: yürütülebilir dosyalar ve kütüphaneler. Yürütülebilir uygulamalar, doğrudan terminalden çalıştırabileceğimiz program türleridir. (Windows’ta .exe ile bitiyorlar) Kütüphaneler birlikte paketlediğimiz kod koleksiyonlarıdır, böylece diğer programlarda kullanabiliriz. Kütüphaneleri daha sonra daha detaylı inceleyeceğiz, çünkü bu satırı yazdığınız herhangi bir programa dahil ettiğinizden emin olun.

Bir sonraki satır boş bir satır. Bilgisayarlar özel karakterli (veya birkaç karakterli) yeni satırları temsil eder. Yeni satırlar, boşluklar ve sekmeler boşluk olarak bilinir (çünkü onları göremezsiniz). Go çoğunlukla boşluklarla ilgilenmez, programları okumayı kolaylaştırmak için kullanırız. (Bu satırı kaldırabilirseniz program aynı şekilde davranır.)

O zaman şunu görüyoruz:

1
2
3
 
import "fmt"
 

import anahtar sözcüğü, programımızla kullanmak için diğer paketlerden gelen kodları nasıl eklediğimizdir. fmt paketi (format için shorthand) giriş ve çıkış için formatlama uygular. Paketler hakkında az önce öğrendiklerimizi göz önüne alındığında, fmt paketinin dosyalarının üst kısmında ne içereceğini düşünüyorsunuz?

Yukarıdaki fmt’nin çift tırnak işareti ile çevrili olduğuna dikkat edin. Bunun gibi çift tırnak işaretlerinin kullanılması, bir tür “ifade” olan “string literal” olarak bilinir. go dizelerinde belirli bir uzunlukta bir karakter dizisini (harfler, sayılar, semboller,…) temsil eder. Dizeler bir sonraki bölümde daha ayrıntılı olarak açıklanmaktadır, ancak şimdilik akılda tutulması gereken en önemli şey bir açılış “karakterinin sonunda başka bir karakter takip etmesi gerekir” karakteridir ve ikisi arasındaki her şeyin dizgide yer almasıdır. (“Karakterin kendisi dizgenin bir parçası değildir)

// ile başlayan satır, yorum olarak bilinir. Yorumlar Go derleyicisi tarafından yok sayılır ve kendi iyiliğiniz için oradadır (veya programınız için kaynak kodunu kim seçerse). Go iki farklı yorum stilini destekler: // ile satırın sonu arasındaki tüm metnin yorumun bir parçası olduğu yorumlar / *     */ arasındaki her şeyin yorumun bir parçası olduğu yorumlar. (Ve birden fazla satır içerebilir)

Bundan sonra bir işlev bildirimi görürsünüz:

1
2
3
4
5
 
func main() {
    fmt.Println("Merhaba Dünya!")
}
 

İşlevler bir Go programının yapı taşlarıdır. Girdileri, çıktıları ve sırayla ifadeleri adı verilen bir dizi adımı vardır. Tüm işlevler, func işlevi ile başlayan ve işlev adı (bu durumda ana), parantezlerle çevrili sıfır veya daha fazla “parametre” listesi, isteğe bağlı bir dönüş türü ve kıvrımlı parantezlerle çevrili bir “gövde” ile başlar. Bu işlevin hiçbir parametresi yoktur, hiçbir şey döndürmez ve yalnızca bir ifadeye sahiptir. Ana isim özeldir çünkü programı çalıştırdığınızda çağrılan işlev budur.

Programımızın son parçası bu satır:

1
2
3
 
fmt.Println("Merhaba Dünya!")
 

Bu ifade üç bileşenden oluşmaktadır. İlk önce Println adındaki fmt paketinin içindeki başka bir fonksiyona erişiriz (bu, fmt.Println parçası, Println, Print Line anlamına gelir). Daha sonra, Merhaba Dünya! içeren yeni bir dize yaratır ve ilk ve tek argüman olarak dizeyle çalışan bu dizeyi çağırır (çağrı veya yürütme olarak da bilinir).

Bu noktada biz zaten çok fazla yeni terminoloji gördük ve biraz bunalmış olabilirsiniz. Bazen, programınızı kasten yüksek sesle okumak yararlı olabilir. Yeni yazdığımız programın bir okuması şöyle olabilir:

fmt kütüphanesine referans veren ve main adlı bir fonksiyon içeren yeni bir çalıştırılabilir program yaratın. Bu işlev hiçbir argüman almaz, hiçbir şey döndürmez ve aşağıdakileri yapar: fmt paketinin içindeki Println işlevine erişin ve bir argüman kullanarak çağırın – Merhaba Dünya! dizesi.

Println işlevi bu programdaki asıl işi yapar. Terminalinize aşağıdakileri yazarak bunun hakkında daha fazla bilgi edinebilirsiniz:

1
2
3
 
godoc fmt Println
 


Veri tipleri

Tipler (veri tipleri) değişkende saklanan değerin tipini, fonksiyonun döndürdüğü değerin tipini, vb.

Go’da üç temel tip vardır.

Tam Sayı Tipleri

Go’nun tamsayı türleri: uint8, uint16, uint32, uint64, int8, int16, int32 ve int64. 8, 16, 32 ve 64 bize her bir tipin kaç bit kullandığını anlatıyor.

uint “işaretsiz tam sayı”,

int ise “işaretli tam sayı” anlamına gelir.

İşaretsiz tamsayılar yalnızca pozitif sayılar (veya sıfır) içerir.

  • int8 – 8 bit işaretli tam sayılar.
  • int16 – 16 bit işaretli tam sayılar.
  • int32 – 32 bit işaretli tam sayılar.
  • int64 – 64 bit işaretli tam sayılar.
  • uint8 – 8 bit işaretsiz tamsayılar.
  • uint16 – 16 bit işaretsiz tamsayılar.
  • uint32 – 32 bit işaretsiz tamsayılar.
  • uint64 – 64 bit işaretsiz tamsayılar.

Ayrıca iki takma ad vardır: uint8 ile aynı olan bayt ve int32 ile aynı olan rune.

Bayt, bilgisayarlarda kullanılan son derece yaygın bir ölçüm birimidir (1 bayt = 8 bit, 1024 bayt = 1 kilobayt, 1024 kilobayt = 1 megabayt,…) ve bu nedenle Go bayt veri türü genellikle diğer türlerin tanımında kullanılır. Makineye bağlı 3 tamsayı türü de vardır: uint, int ve uintptr. Makineye bağlıdır çünkü boyutları, kullandığınız mimarinin türüne bağlıdır.

 

Ondalıklı (Kayan nokta) Sayılar

Kayan nokta sayıları, ondalık bileşen içeren sayılardır (gerçek sayılar). (1.234, 123.4, 0.00001234, 12340000) Bir bilgisayardaki gerçek temsilleri oldukça karmaşık ve bunların nasıl kullanılacağını bilmek için gerçekten gerekli değil. Şimdilik sadece aşağıdakileri aklımızda tutabilirsiniz.

Go iki kayan nokta tipine sahiptir: float32 ve float64 (aynı zamanda sırasıyla tek hassasiyet ve çift hassasiyet olarak da adlandırılır) ve ayrıca karmaşık sayıları (hayali parçalara sahip sayılar) temsil etmek için iki ek türün yanı sıra: complex64 ve complex128 sayıları vardır. Genel olarak kayan nokta sayıları ile çalışırken float64 ile bağlantı kurarız.

  • float32 – 32 bit kayan nokta sayıları.
  • float64 – 64 bit kayan nokta sayıları.
  • complex64 – float32 gerçek ve hayali parçalara sahip.
  • complex128 – float32 gerçek ve hayali parçalara sahiptir.

String Tipler

Bir bayt sırası (karakter) gösterir. Dize bitiştirme, çıkarma alt dize vb. gibi dizelerde çeşitli işlemler yapabilirsiniz.

Yukarıda dediğim gibi dize metni temsil etmek için kullanılan belirli bir uzunlukta bir karakter dizisidir. Go dizeleri ayrı ayrı baytlardan oluşur, genellikle her karakter için birer tane byte ile ifade edilir. (Çince gibi diğer dillerden gelen karakterler birden fazla byte ile gösterilir)

Dize değişmezleri, "Merhaba Dünya"  çift tırnak işaretleri kullanılarak oluşturulabilir veya  Merhaba Dünya ile yapılır. Bunların arasındaki fark, çift tırnaklı dizelerin yeni satırlar içerememesi ve özel kaçış dizilerine izin vermesidir. Örneğin, \n yeni bir satırla değiştirilir ve \t bir sekme karakteriyle değiştirilir.

Boolean Tipler

Boolean değeri (George Boole’den sonra adlandırılmış), true ve false (veya açık ve kapalı) temsil etmek için kullanılan özel bir 1 tam sayı türüdür. Üç mantıksal işleç boolean değerlerle kullanılır.

&&and
||or
!not


Değişkenler

Şimdiye kadar sadece değerleri kullanan programlar gördük (sayılar, dizgiler, vb.), Ancak bu programlar özellikle kullanışlı değil. Gerçekten faydalı programlar yapmak için iki yeni kavram öğrenmeliyiz: değişkenler ve kontrol akışı ifadeleri. Bu bölüm değişkenleri daha ayrıntılı olarak inceleyecektir.

Değişkenler, bir tür değer depolayan bir hafıza konumunu işaret eder. tip parametresi (aşağıdaki sözdiziminde), bellek konumunda depolanabilecek değer türünü temsil eder.

1
2
3
4
5
6
7
8
9
10
 
package main
 
import "fmt"
 
func main() {
  var x string = "Merhaba Dünya"
  fmt.Println(x)
}
 

Dize orijinal programdaki değişmez dizinin hala bu programda göründüğüne dikkat edin, ancak doğrudan Println işlevine göndermek yerine, bunun yerine bir değişkene atarız. Go’daki değişkenler önce var anahtar sözcüğü kullanılarak, ardından değişken adını (x), type (string) belirterek ve son olarak değişkene (Merhaba Dünya) bir değer atayarak yaratılır.

Değişken Tanımlama

Değişken sözdizimi kullanılarak bildirilebilir.

1
2
3
 
var <degisken_adi> <tip>
 

Bir kez bir değişkeni tanımladığınızda, değişkeni o tipin herhangi bir değerine atayabilirsiniz.

Ayrıca değer atama operatörü kullanarak bir değişkene ilk değer verebilirsiniz.

1
2
3
 
var <degisken_adi> <tip> = <değer>
 

Değişkeni başlangıç değeriyle bildirirseniz, değişkene ait türün atanan değer türünden çıkarımını go dili kendisi yapabilir. Bu nedenle, aşağıdaki sözdizimini kullanarak bildirim sırasında türü ihmal edebilirsiniz.

1
2
3
 
var <degisken_adi> = <değer>
 

Birden Fazla Değişken Tanımlama

Ayrıca, sözdizimi ile birden fazla değişken bildirebilirsiniz.

1
2
3
 
var <degisken1>, <degisken2>  = <deger1>, <deger2>
 

yada

1
2
3
4
5
6
7
 
var (
    <degisken1> = <deger1>
    <degisken2> = <deger2>
    <degisken3> = <deger3>
)
 

Kapsam

Bölüm başında gördüğümüz programa geri dönersek:

1
2
3
4
5
6
7
8
9
10
 
package main
 
import "fmt"
 
func main() {
  var x string = "Merhaba Dünya"
  fmt.Println(x)
}
 

Bu programı yazmanın bir başka yolu şöyle olabilir:

1
2
3
4
5
6
7
8
9
10
11
 
package main
 
import "fmt"
 
var x string = "Merhaba Dünya"
 
func main() {
fmt.Println(x)
}
 

Değişkeni ana fonksiyonun dışına taşıdığımızı fark edin. Bu, diğer fonksiyonların bu değişkene erişebileceği anlamına gelir:

1
2
3
4
5
6
7
8
9
10
11
 
var x string = "Merhaba Dünya"
 
func main() {
  fmt.Println(x)
}
 
func f() {
  fmt.Println(x)
}
 

f işlevi şimdi x değişkenine erişebilir. Şimdi bunun yerine şunu yazdığımızı varsayalım:

1
2
3
4
5
6
7
8
9
10
 
func main() {
    var x string = "Merhaba Dünya"
    fmt.Println(x)
  }
  
  func f() {
    fmt.Println(x)
  }
 

Bu programı çalıştırırsanız bir hata alırsınız.

Değişken Tanımlama Örnekleri

Örnek: Aşağıdaki programda bazı değişken bildirimleri örnekleri var.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
package main
import "fmt"
 
func main() {
    //bir tam sayı değişkeni bildirir
    var x int
    x=3 //x'e 3 depeğerini atar
    fmt.Println("x:", x) //3 yazdırır
    
    //tam sayı türünde 20 değerine sahip y değişkenini tanımlar.
    var y int=20
    fmt.Println("y:", y)
    
    //50 değerine sahip z değişkenini tanımlar.
    // Burada int türü açıkça belirtilmez
    var z=50
    fmt.Println("z:", z)
    
    //Tek satırda bir tamsayı ile birden çok değişken ve bir dizeyi j değişkenine atar
    var i, j = 100,"merhaba"
    fmt.Println("i ve j:", i,j)
}
 

Çıktı:

Go ayrıca, var anahtar kelimesini atlayarak değişkenleri, değere sahip olarak bildirmenin kolay bir yolunu sunar.

1
2
3
 
<degisken_adi> := <değer>
 

Örnek:Değer okuma, okunan değeri değişkene aktarma ve değişkeni ekrana yazdırma

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
package main
 
import "fmt"
 
func main() {
fmt.Print("Bir Sayı Girin: ")
var sayi float64
fmt.Scanf("%f", &sayi)
 
cikti := sayi * 2
 
fmt.Println(cikti)
}
 


Sabitler

Go ayrıca sabitleri de destekliyor. Sabitler, temelde değerleri daha sonra değiştirilemeyen değişkenlerdir. Değişkenler yarattığınız şekilde yaratılırlar, ancak var anahtar sözcüğünü kullanmak yerine const anahtar sözcüğünü kullanırız:

1
2
3
4
5
6
7
8
9
10
 
package main
 
import "fmt"
 
func main() {
  const x string = "Merhaba Dünya"
  fmt.Println(x)
}
 


Kontrol Yapıları

Artık değişkenleri nasıl kullanacağımızı bildiğimize göre, bazı yararlı programlar yazmaya başlamanın zamanı geldi. İlk önce, her biri kendi satırında olmak üzere 1’den başlayarak 10’a kadar sayılan bir program yazalım. Şimdiye kadar öğrendiklerimizi kullanarak şunu yazabiliriz:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
package main
 
import "fmt"
 
func main() {
  fmt.Println(1)
  fmt.Println(2)
  fmt.Println(3)
  fmt.Println(4)
  fmt.Println(5)
  fmt.Println(6)
  fmt.Println(7)
  fmt.Println(8)
  fmt.Println(9)
  fmt.Println(10)
}
 

yada

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
package main
import "fmt"
 
func main() {
  fmt.Println(`1
2
3
4
5
6
7
8
9
10`)
}
 

Ancak bu programların her ikisi de yazmak için oldukça sıkıcı. İhtiyacımız olan şey, defalarca bir şeyler yapmanın bir yoludur.

for Döngüsü

Döngüler, bir koşula bağlı olarak art arda bir deyim bloğunu yürütmek için kullanılır. Programlama dillerinin çoğu, 3 tür döngü sağlar. Ancak Go sadece for döngüsünü destekler.

For döngüsünün sözdizimi

1
2
3
4
5
 
for başlama_ifadesi; değerlendirme_ifadesi; değişim_ifadesi{
   // bir yada daha fazla ifade
}
 

başlama_ifadesi: ilk önce (ve sadece bir kez) gerçekleştirilir.(zorunlu değil)

değerlendirme_ifadesi: Döngünün devam edip etmeyeceği değerlendirilir ve eğer doğruysa bloğun içindeki kod çalıştırılır.

değişim_ifadesi: değerlendirme_ifadesinin değerini değiştirmek için başlama_ifadesini artan yada azalan şekilde değiştirme işlemi yapar.(zorunlu değil)

Nasıl Çalışır: Değerlendirme ifadesi doğru olduğu sürece {  } bloklar arasındaki kod/kodlar çalıştırılır. Değerlendirme ifadesi false değerini ürettiğinde döngüden sonraki bloktan devam eder.

Örnek: Aşağıdaki programı bir dosyaya kopyalayın ve 1 ila 5 arasındaki sayıları ekrana basan kodları inceleyin:

1
2
3
4
5
6
7
8
9
10
11
12
 
package main
 
import "fmt"
 
func main() {
var i int
for i = 1; i <= 5; i++ {
fmt.Println(i)
}
}
 

Çıktı:

1
2
3
4
5
6
7
 
1
2
3
4
5
 

 

Örnek: Önceki programımızı bir for ifadesi kullanarak yeniden yazmak şuna benziyor:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
package main
 
import "fmt"
 
func main() {
  i := 1
  for i <= 10 {
    fmt.Println(i)
    i = i + 1
  }
}
 

Çıktı:

1
2
3
4
5
6
7
8
9
10
11
12
 
1
2
3
4
5
6
7
8
9
10
 

if else karar yapısı

Şimdi yazdığımız programı değiştirelim, böylece her satırda sadece 1-10 sayıları yazdırmak yerine, sayının sayının çift mi tek mi olduğunu yazdıralım. Bunun gibi:

Öncelikle bir sayının çift mi yoksa tek mi olduğunu tespit etmenin bir yoluna ihtiyacımız var. Söylemenin kolay bir yolu, sayıyı 2’ye bölmektir. Kalan hiçbir şeyiniz yoksa, o zaman sayı çift olur, aksi halde tektir. Öyleyse Go’daki bölünmeden sonra kalanları nasıl bulacağız? % operatörünü kullanıyoruz. 1 % 2 eşittir1, 2 % 2 eşittir 0, 3 % 2 eşittir1 vb

Daha sonra, bir koşula dayanarak farklı şeyler yapmayı seçmenin bir yoluna ihtiyacımız var. Bunun için if ifadesini kullanıyoruz:

1
2
3
4
5
6
7
 
if i % 2 == 0 {
  // çift
} else {
  // tek
}
 

Şimdi if else yazım kuralına bir bakalım:

1
2
3
4
5
6
7
 
if koşul{
// ifade_1
}else{
// ifade_2
}
 

Burada koşul değerlendirilir ve doğru  ise ifadeler_1 çalıştırılır, aksi takdirde ifadeler_2 çalıştırılır.

if deyimini else olmadan da kullanabilirsiniz. Ayrıca başka ifadeler varsa zincirleme yapmış olabilirsiniz. Aşağıdaki programlar, if else hakkında daha fazla bilgi verecektir.

Aşağıdaki programı yürütün. Bir sayı, x, 10’dan küçük olup olmadığını kontrol eder,eğer doğru ise “x 10’dan küçük” yazacaktır.

1
2
3
4
5
6
7
8
9
10
11
 
package main
import "fmt"
 
func main() {  
    var x = 50
    if x < 10 {
        fmt.Println("x 10'dan küçük)
    }
}
 

Burada x değeri 10’dan büyük olduğundan, blok koşulu yürütmez içerideki ifade çalışmamış olur.

Şimdi aşağıdaki programa bakınız. Eğer if değerlendirmesinin başarısızlığı üzerine çalıştırılacak başka bir bloğumuz var.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
package main
 
import "fmt"
 
func main() {
var x = 50
if x < 10 {
fmt.Println("x 10dan küçük")
} else {
fmt.Println("x 10dan büyük")
}
}
 

Örnek: Şimdi yukarıdaki 1-10 arasındaki çift ve tek sayıları ayırma örneğini tekrar döngü ve if else ile yapalım.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
package main
 
import "fmt"
 
func main() {
for i := 1; i <= 10; i++ {
if i%2 == 0 {
fmt.Println(i, "çift")
} else {
fmt.Println(i, "tek")
}
}
}
 

Çıktı:

switch

switch, başka bir koşullu ifadedir. switchifadeleri bir ifadeyi değerlendirir ve sonuç bir dizi kullanılabilir değerle (caseler) karşılaştırılır. Bir eşleşme bulunduğunda, o eşleşmeyle ilgili ifadeler (case) yürütülür. Eşleşme bulunamazsa hiçbir şey yürütülmez. Başka eşleşme bulunmazsa yürütülecek olanı değiştirmek için varsayılan bir durum da ekleyebilirsiniz.

switch sözdizimi:

1
2
3
4
5
6
7
8
9
10
11
12
 
switch kosul{
    case deger1:
        ifadeler
    case deger2:
        ifadeler2
    case geder_n:
        ifadelerN
    default:
        varsayılan_ifadeler
    }
 

Diyelim ki numaralara isimler basan bir program yazmak istedik. if-else ile bunu yapmak mümkün. Önce if-else kullanarak programı yapalım.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
if i == 0 {
  fmt.Println("Sıfır")
} else if i == 1 {
  fmt.Println("Bir")
} else if i == 2 {
  fmt.Println("İki")
} else if i == 3 {
  fmt.Println("Üç")
} else if i == 4 {
  fmt.Println("Dört")
} else if i == 5 {
  fmt.Println("Beş")
}
 

Yukarıdaki örneği, az önce öğrendiğimiz switch ifadesini kullanarak karmaşadan daha sade olarak yazmak mümkün hale getirebiliriz.

1
2
3
4
5
6
7
8
9
10
11
 
switch i {
case 0: fmt.Println("sıfır")
case 1: fmt.Println("bir")
case 2: fmt.Println("iki")
case 3: fmt.Println("üç")
case 4: fmt.Println("dört")
case 5: fmt.Println("beş")
default: fmt.Println("Bilinmeyen Numara")
}
 


Diziler(Arrays), Dilimler(Slices) ve Haritalar(Maps)

Diziler(Arrays)

Dizi, aynı türden öğeler dizisinin adlandırılmış sabit bir boyutunu temsil eder. İçinde hem tamsayı hem de karakter içeren bir diziniz olamaz. Bir dizinin boyutunu tanımladıktan sonra tekrar değiştiremezsiniz.

Bir dizi sözdizimi:

1
2
3
 
var diziadi[boyut] tip
 

Diziye Değer Atama: Her dizi elemanına sözdizimi kullanılarak değer atanabilir

1
2
3
 
diziadi[index] = degeri
 

Dizinin index numaraları 0’dan dizi boyutu-1 şeklindedir. (0- [boyut-1]) aralığında index numaraları vardır.

Sözdizimini kullanarak bildirim sırasında dizi öğelerine değer atayabilirsiniz.

1
2
3
 
diziadi:= [boyut] tip {deger_1,deger_2,…,deger_boyut-1}
 

Dizi boyutunu  … ile değiştirerek diziyi değerlerle bildirirken size parametresini de görmezden gelebilirsiniz; derleyici değerlerin uzunluğunu bulur.

Sözdizimi:

1
2
3
 
diziadi:= [...] tip {deger_1,deger_2,…,deger_boyut-1}
 

Dizi Uzunluğu: Dizinin uzunluğunu len kullanarak bulabilirsiniz.

1
2
3
 
len(diziadi)
 

Örnek: Diziyi anlamak için aşağıdaki örneği yürütün

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
package main
 
import "fmt"
 
func main() {
var sayilar [3]string //Dizi tanımlama
sayilar[0] = "Bir"
sayilar[1] = "İki"
sayilar[2] = "Üç"
fmt.Println(sayilar[1])   //dizinin ikinci öğesini yazdır
fmt.Println(len(sayilar)) //Dizi uzunluğunu yazdır
fmt.Println(sayilar)      // diziyi yazdır
 
// bir tam sayı dizisi oluşturma ve dizinin boyutu öğe sayısı ile tanımlanır...
liste := [...]int{1, 2, 3, 4, 5}
fmt.Println(liste)      // [1 2 3 4 5]
fmt.Println(len(liste)) // 5
 
//Dizinin son elemanını yazdırma
fmt.Println(liste[len(liste)-1])
}
 

Çıktı:

 

Dilimler(Slices)

Dilim, dizinin bir kısmı veya kesimidir. Ya da işaret ettiği temel dizinin kısmi görünümüdür. Dilim adını ve dizin numarasını, bir dizide yaptığınız gibi, bir dilimin öğelerine erişebilirsiniz. Bir dizinin uzunluğunu değiştiremezsiniz, ancak bir dilimin boyutunu değiştirebilirsiniz.

Bir dilimin içeriği aslında bir dizinin elemanlarına işaretçilerdir. Dilimdeki herhangi bir öğeyi değiştirirseniz, altta yatan dizi içeriği de etkilenir.

 İşte bir dilim örneği:

1
2
3
 
var x []float64
 

Bu ve bir dizi arasındaki tek fark, parantez arasındaki eksik uzunluktur. Bu durumda x, 0(sıfır) uzunluğunda yaratılmıştır.

Dilim oluşturmak istiyorsanız, yerleşik make işlevini kullanmanız gerekir:

1
2
3
 
x := make([]float64, 5)
 

Dilimler her zaman bazı dizilerle ilişkilendirilir ve diziden asla daha uzun olmamasına rağmen, daha küçük olabilirler. Make işlevi ayrıca bir üçüncü parametreye de izin verir:

1
2
3
 
x := make([]float64, 5, 10)
 

10, dilimin işaret ettiği temel dizinin kapasitesini gösterir:

Tanımlı bir diziden dilim oluşturma örneği:

1
2
3
 
var slice_adi[] tip= dizi_adi[baslangic:bitis]
 

Bu, dizi_adi adlı bir diziden slice_adi adlı bir dilim yaratacak, dizindeki baslangic ile bitis arasındaki değerleri slice’a aktaracaktır.

1
2
3
4
 
dizi:= [5]float64{1,2,3,4,5}
x := dizi[0:5]
 

Aşağıdaki programı yürütün. Program diziden bir dilim oluşturur ve yazdırır. Ayrıca dilimdeki içerikleri değiştirmenin asıl diziyi değiştireceğini de görebilirsiniz.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
package main
 
import "fmt"
 
func main() {
// dizi tanımlama
a := [5]string{"bir", "iki", "üç", "dört", "beş"}
fmt.Println("tanımlanan diziyi yazdır:", a)
 
var b []string = a[1:4] //diziden bir dilim oluştur
fmt.Println("oluşturulan dilimi yazdır:", b)
 
b[0] = "yirmi" // slice içindeki değeri değiştir
fmt.Println("dilimi yeniden yazdır:", b)
fmt.Println("diziyi yeniden yazdır:", a)
}
 

Çıktı:

Slice Fonksiyonları

Dilimlere uygulayabileceğiniz bazı işlevler vardır.

len (dilim_adı) – dilimin uzunluğunu döndürür

append (dilim_adı, değer_1, değer_2) – Mevcut bir dilime değer_1 ve değer_2 eklemek için kullanılır.

append (slice_1, slice_2…) – slice_1’e slice_2 ekler

Aşağıdaki programı yürütün.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
package main
 
import "fmt"
 
func main() {
a := [5]string{"1", "2", "3", "4", "5"}
slice_a := a[1:3]
b := [5]string{"a", "b", "c", "ç", "d"}
slice_b := b[1:3]
 
fmt.Println("Slice_a:", slice_a)
fmt.Println("Slice_b:", slice_b)
fmt.Println("slice_a uzunluk:", len(slice_a))
fmt.Println("slice_b uzunluk:", len(slice_b))
 
slice_a = append(slice_a, slice_b...) // ekleme
fmt.Println("slice_a, slice_b eklendikten sonrası: :", slice_a)
 
slice_a = append(slice_a, "merhaba") // değer eklendikten sonra
fmt.Println("merhaba eklendikten sonra slice_ad  :", slice_a)
}
 

Çıktı:

Haritalar(Maps)

Harita, sıradışı bir anahtar / değer çiftleri koleksiyonudur. Bir ilişkisel dizi, bir karma tablo veya sözlük olarak da bilinen haritalar, ilişkili bir anahtar tarafından bir değer aramak için kullanılır. İşte Go’da bir harita örneği:

1
2
3
 
var x map[string]int
 

Harita türü, anahtar kelime haritası, ardından parantez içindeki anahtar türü ve son olarak değer türü tarafından gösterilir. Bunu yüksek sesle okuyacak olsaydınız, “x, dizelerin bir haritasıdır” derdiniz.

Diziler ve dilimler gibi haritalara parantez kullanarak erişilebilir. Aşağıdaki programı çalıştırmayı deneyin:

1
2
3
4
5
6
7
8
9
10
11
 
package main
 
import "fmt"
 
func main() {
var x map[string]int
x["anahtar"] = 10
fmt.Println(x)
}
 

Buna benzer bir hata görmelisiniz:

Şimdiye kadar sadece derleme zamanı hataları gördük. Bu bir çalışma zamanı hatası örneğidir. Adından da anlaşılacağı gibi, programı çalıştırdığınızda çalışma zamanı hataları, programı derlemeye çalıştığınızda derleme zamanı hataları olur.

Programımızdaki sorun, kullanmadan önce haritaların başlatılması gerektiğidir. Bunu yazmalıydık:

1
2
3
4
5
6
7
8
9
10
11
 
package main
 
import "fmt"
 
func main() {
x := make(map[string]int)
x["key1"] = 10
fmt.Println(x["key1"])
}
 

Çıktı:

Bu programı çalıştırırsanız, 10 görüntülenen görmelisiniz.

x[“key1”] = 10 ifadesi, dizilerde gördüğümüze benzer, ancak tamsayı yerine anahtar, dizedir, çünkü haritanın anahtar türü dizedir. Anahtar int türüyle haritalar da oluşturabiliriz:

1
2
3
4
5
6
7
8
9
10
11
 
package main
 
import "fmt"
 
func main() {
x := make(map[int]int)
x[1] = 10
fmt.Println(x[1])
}
 

Bu bir diziye çok benziyor ama birkaç fark var. İlk önce bir haritanın uzunluğu (len(x) yaparak bulunur), ona yeni öğeler ekledikçe değişebilir. İlk oluşturulduğunda 0 uzunluğuna sahiptir, x [1] = 10 değerinden sonra 1 uzunluğuna sahiptir. İkinci haritalar sıralı değildir. x[1] ‘e sahibiz ve bir x [0] olması gerektiğini belirten bir diziyle, ancak haritaların bu gereksinimi yoktur.

Yerleşik delete işlevini kullanarak öğeleri bir haritadan da silebiliriz:

1
2
3
 
delete(x, 1)
 

map kullanan bir örnek programa bakalım:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
package main
 
import "fmt"
 
func main() {
kisaltmalar := make(map[string]string)
kisaltmalar["md"] = "Müdür"
kisaltmalar["mdyard"] = "Müdür Yardımcısı"
kisaltmalar["dr"] = "Doktor"
kisaltmalar["doc"] = "Doçent"
kisaltmalar["prof"] = "Profosör"
fmt.Println(kisaltmalar["doc"])
}
 

Çıktı:

Listede olmayan bir öğeyi aramaya çalıştığımızı varsayalım:

1
2
3
 
fmt.Println(kisaltmalar["tek"])
 

Eğer bunu çalıştırırsan, hiçbir şeyin geri dönmediğini görmelisin. Teknik olarak bir harita, değer türü için sıfır değerini döndürür (dizeler için boş dizedir). Bir koşulda sıfır değerini kontrol etmemize rağmen (kisaltmalar[“tek”] == “”) ile Go daha iyi bir yol sunar:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
package main
 
import "fmt"
 
func main() {
kisaltmalar := make(map[string]string)
kisaltmalar["md"] = "Müdür"
kisaltmalar["mdyard"] = "Müdür Yardımcısı"
kisaltmalar["dr"] = "Doktor"
kisaltmalar["doc"] = "Doçent"
kisaltmalar["prof"] = "Profosör"
 
isim, sonuc := kisaltmalar["tek"]
fmt.Println(sonuc, isim)
}
 

Haritanın bir öğesine erişmek, yalnızca bir tane yerine iki değer döndürür. Birincisi aramanın sonucudur, ikincisi bize aramanın başarılı olup olmadığını söyler. Go’da sık sık şöyle kod görüyoruz:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
package main
 
import "fmt"
 
func main() {
kisaltmalar := make(map[string]string)
kisaltmalar["md"] = "Müdür"
kisaltmalar["mdyard"] = "Müdür Yardımcısı"
kisaltmalar["dr"] = "Doktor"
kisaltmalar["doc"] = "Doçent"
kisaltmalar["prof"] = "Profosör"
 
if isim, sonuc := kisaltmalar["tek"]; sonuc {
fmt.Println(isim, sonuc)
}
}
 

 


Fonksiyonlar(İşlevler)

Bir işlev, belirli bir görevi gerçekleştiren ifadeler bloğunu temsil eder. Bir fonksiyon bildirimi bize fonksiyon adını, dönüş tipini ve giriş parametrelerini bildirir. İşlev tanımı, işlevde bulunan kodu temsil eder. İşlev bildirmek için sözdizimi

1
2
3
4
5
 
func fonksiyon_adi(parametre_1 tip, parametre_n tip) donutipi{
    //ifadeler
}
 

Parametreler ve dönüş tipleri isteğe bağlıdır. Ayrıca, bir işlevden birden çok değer döndürebilirsiniz.

Ortalama hesaplamak için bir fonksiyon yazalım. Daha önce for döngüsünü anlatırken kullandığımız bir örneği burada bir işlev içinde ortalama hesaplamak için nasıl kullanıyoruz inceleyelim.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
package main
 
import "fmt"
 
func ortalama(gelen []float64) float64 {
toplam := 0.0
for _, v := range gelen {
toplam += v
}
return toplam / float64(len(gelen))
}
 
func main() {
sayilar := []float64{98, 93, 77, 82, 83}
fmt.Println("Sayıların Ortalaması:", ortalama(sayilar))
}
 

Çıktı:

1
2
3
 
Sayıların Ortalaması: 86.6
 

Birden Fazla Değer Döndürme

Go bir işlevden birden fazla değer döndürme yeteneğine de sahiptir:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
package main
 
import "fmt"
 
func f() (int, int) {
return 5, 6
  }
  
  func main() {
x, y := f()
  }
 

Aşağıdaki örneği çalıştıralım. Burada hesap isimli fonksiyon 2 sayı kabul eder, toplama ve çıkarma işlemini gerçekleştirir ve her iki değeri de döndürür.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
package main
 
import "fmt"
 
func hesapla(num1 int, num2 int) (int, int) {
toplam := num1 + num2
fark := num1 - num2
return toplam, fark
}
 
func main() {
x, y := 15, 10
 
toplam, fark := hesapla(x, y)
fmt.Println("Toplam :", toplam)
fmt.Println("Fark :", fark)
}
 

Çıktı:

1
2
3
4
 
Toplam : 25
Fark : 5
 

Arguman Kullanımı

Go işlevindeki son parametre için özel bir form var:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
package main
 
import "fmt"
 
func topla(args ...int) int {
toplam := 0
for _, v := range args {
toplam += v
}
return toplam
}
func main() {
fmt.Println(topla(1, 2, 3))
}
 

Son parametrenin türünün adından önce … seçeneğini kullanarak, bu parametrelerin sıfır veya daha fazlasını aldığını belirtebilirsiniz. Bu durumda sıfır ya da daha fazla inç alıyoruz. Fonksiyonu, istediğimiz kadar girdi aktarabilmemiz dışında, diğer fonksiyonlar gibi çağırıyoruz.

Anonim Fonksiyon

İşlevlerin içinde işlevler oluşturmak mümkündür:

1
2
3
4
5
6
7
8
9
10
11
12
 
package main
 
import "fmt"
 
func main() {
topla := func(x, y int) int {
return x + y
}
fmt.Println(topla(1, 1))
}
 

topla func(int, int) int türüne sahip bir yerel değişkendir (iki inç alan ve bir int döndüren bir işlevdir). Bunun gibi bir yerel işlev oluşturduğunuzda, diğer yerel değişkenlere de erişebilir.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
package main
 
import "fmt"
 
func main() {
x := 0
attir := func() int {
x++
return x
}
fmt.Println(attir())
fmt.Println(attir())
}
 

 

Rercursive Fonksiyon

Bir işlev kendini çağırabilir. En basit özyinelemeli fonksiyon örneği olarak sayının faktöriyelini hesaplayalım.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
package main
 
import "fmt"
 
func faktoriyel(x uint) uint {
if x == 0 {
return 1
}
return x * faktoriyel(x-1)
}
func main() {
fmt.Println(faktoriyel(5))
}
 

Anonim ve özyineleme, fonksiyonel programlama olarak bilinen bir paradigmanın temelini oluşturan güçlü programlama teknikleridir.

Defer, Panic & Recover

Go, fonksiyon tamamlandıktan sonra çalıştırılacak bir fonksiyon çağrısını zamanlayan defer adında özel bir ifadeye sahiptir. Aşağıdaki örneği düşünün:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
package main
 
import "fmt"
 
func birinci() {
fmt.Println("1.Fonksiyon")
}
func ikinci() {
fmt.Println("2.Fonksiyon")
}
func main() {
defer ikinci()
birinci()
}
 

Çıktı:

Bu program önce 1’i sonra 2’yi yazdırır. Temel olarak erteleme, çağrıyı işlevin sonuna kadar taşır:

1
2
3
4
5
6
 
func main() {
ikinci()
birinci()
}
 

erteleme genellikle kaynakların bir şekilde serbest bırakılması gerektiğinde kullanılır. Örneğin bir dosyayı açtığımızda daha sonra kapattığımızdan emin olmalıyız. Erteleme ile:

1
2
3
4
 
f, _ := os.Open(filename)
defer f.Close()
 

Bunun 3 avantajı vardır: (1) Yakın çağrımızı Açık çağrımızın yakınında tutar, böylece anlaşılması daha kolaydır, (2) fonksiyonumuzda birden fazla dönüş ifadesi varsa (belki bir if ve diğerinde diğeri) Kapat her ikisinden önce gerçekleşir ve (3) ertelenmiş fonksiyonlar bir çalışma zamanı paniği meydana gelse bile çalıştırılır.

Panic & Recover

Daha önce panik fonksiyonunu çağıran bir fonksiyon oluşturduk. Yerleşik kurtarma işleviyle çalışma zamanı paniklerini halledebiliriz. recover paniği durdurur ve panik çağrısına iletilen değeri döndürür. Bu şekilde kullanmak cazip olabilir:

1
2
3
4
5
6
7
8
9
10
11
 
package main
 
import "fmt"
 
func main() {
panic("PANİK")
str := recover()
fmt.Println(str)
}
 

Ancak bu durumda recover çağrısı asla gerçekleşmeyecektir çünkü panik çağrısı hemen fonksiyonun yürütülmesini durdurur. Bunun yerine erteleme ile eşleştirmeliyiz:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
package main
 
import "fmt"
 
func main() {
defer func() {
str := recover()
fmt.Println(str)
}()
panic("PANİK")
}
 

Panik genellikle bir programcı hatasını (örneğin, sınırların dışında bir dizinin dizinine erişmeye çalışmak, bir haritayı başlatmayı unutmak vb.) Veya kurtarmanın kolay bir yolu olmayan istisnai bir durumu belirtir. (Dolayısıyla “panik” adı)

 


İşaretçiler(Pointers)

Bağımsız değişken alan bir işlevi çağırdığımızda, bu bağımsız değişken işleve kopyalanır:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
package main
 
import "fmt"
 
func sifir(x int) {
x = 0
}
func main() {
x := 5
sifir(x)
fmt.Println(x) // x hala 5
}
 

Bu programda, sıfır fonksiyonu ana fonksiyondaki orijinal x değişkenini değiştirmeyecektir. Ama ya isteseydik? Bunu yapmanın bir yolu, işaretçi olarak bilinen özel bir veri türü kullanmaktır:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
package main
 
import "fmt"
 
func sifir(xPtr *int) {
*xPtr = 0
}
func main() {
x := 5
sifir(&x)
fmt.Println(x) // x artık 0
}
 

İşaretçiler, bellekteki değerin kendisi yerine bir değerin depolandığı bir konuma başvurur. (Başka bir şeye işaret ederler) İşaretçi (* int) kullanarak sıfır işlevi orijinal değişkeni değiştirebilir.

* ve & operatörleri

GO’da bir işaretçi * (yıldız) karakteri ve ardından saklanan değerin türü kullanılarak temsil edilir. Sıfır fonksiyonunda xPtr bir int işaretçisidir.

* ayrıca işaret değişkenlerini “dereference” için de kullanılır. İşaretçinin kaydının kaldırılması, işaretçinin işaret ettiği değere erişmemizi sağlar. *xPtr = 0 yazdığımızda “int 0’ı xPtr’in başvurduğu bellek konumuna kaydet” diyoruz. Bunun yerine xPtr = 0‘ı denersek, bir derleyici hatası alırız çünkü xPtr bir int değildir *int, sadece başka bir *int verilebilir.

Son olarak, bir değişkenin adresini bulmak için & işlecini kullanırız. &x, * bir int olduğu için *int (int’e işaretçi) döndürür. Orijinal değişkeni değiştirmemize izin veren budur. &x ana ve xPtr sıfır aynı bellek konumuna karşılık gelir.

new

İşaretçi almanın başka bir yolu, yerleşik new işlevi kullanmaktır:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
package main
 
import "fmt"
 
func bir(xPtr *int) {
*xPtr = 1
}
func main() {
xPtr := new(int)
bir(xPtr)
fmt.Println(*xPtr) // x değeri 1
}
 

new, türü bağımsız değişken olarak alır, bu tür bir değere sığacak kadar bellek ayırır ve ona bir işaretçi döndürür.

Bazı programlama dillerinde yeni ile & arasında önemli bir fark vardır ve sonunda yeni ile yaratılan her şeyi silmek için çok dikkatli olunması gerekir. GO böyle değil, artık toplanan hiçbir şey olmadığında belleğin otomatik olarak temizlendiği anlamına gelen çöp toplanma yapısına sahip bir programlama dilidir.

İşaretçiler Go’nun yerleşik türleriyle nadiren kullanılır, ancak bir sonraki bölümde göreceğimiz gibi, yapılarla eşleştirildiğinde son derece yararlıdır.

Struct ve Interface

Her ne kadar Go’nun yerleşik veri türlerini kullanarak program yazmamız mümkün olsa da, bir noktada oldukça sıkıcı hale gelecektir.

Yapılar (Struct)

Yapı, kendisi tarafından aynı veya farklı türde bir öğe daha içeren kullanıcı tanımlı bir veri türüdür.

Bir yapı kullanmak 2 adımlı bir işlemdir.

İlk olarak, bir yapı türü oluşturun (beyan edin)

İkinci olarak, değerleri saklamak için bu türden değişkenler oluşturun.

Yapılar çoğunlukla ilgili verileri birlikte saklamak istediğinizde kullanılır.

Adı, yaşı ve adresi olan bir çalışan bilgisi düşünün. Bunu 2 şekilde halledebilirsiniz

3 dizi oluşturun – bir dizi çalışanların isimlerini, bir dizi yaşı ve üçüncü bir dizi yaşı saklar.

Ad, adres ve yaş olmak üzere 3 alanlı bir yapı türü bildirin. Her bir öğenin adı, adresi ve yaşı olan bir yapı nesnesi olduğu yapı tipinde bir dizi oluşturun.

İlk yaklaşım verimli değildir. Bu tür senaryolarda, yapılar daha uygundur.

Bir yapıyı sözdizimi:

Bir yapı bildirimi örneği

Burada musteri adlı yeni bir kullanıcı tanımlı tür oluşturulur. Artık sözdizimini kullanarak musteri türünde değişkenler oluşturabilirsiniz.

Örn:

musteri1 için değerleri şu şekilde ayarlayabilirsiniz:

Ayrıca bir yapı değişkeni değerler ile de oluşturabilir,

Burada, öğelerin sırasını korumanız gerekir. Ahmet isimle, adreslenecek bir sonraki elemanla ve en son yaşla eşleştirilecek.

Aşağıdaki kodu yürütün

Çıktı:

 

 

 

 

 

Etiketler

2 Yorum

Yorum yapmak için tıklayın