DEV Community: Aydın Yakar

Golang 101: Metotlar (Methods)

Aydın Yakar — Sun, 25 Sep 2022 13:56:04 +0000

Yapıların girdi olarak verildiği fonksiyonlar method olarak tanımlanır. Böylelikle yapıya özel işlemleri nesne yönelimli programlama da olduğu gibi kullanım kolaylığı sağlar.

package main

import (
    "fmt"
)

// Yapı
type dikdortgen struct {
    genislik  int
    yukseklik int
}

// Metotlar
func (d *dikdortgen) alan() int {
    return d.genislik * d.yukseklik
}
func (d dikdortgen) cevre() int {
    return d.genislik + d.yukseklik
}

func main() {
    // Yapıyı tanımlama
    d := dikdortgen{genislik: 10, yukseklik: 8}

    // Metodların kullanımı
    fmt.Println("Alan:", d.alan())
    fmt.Println("Çevre:", d.cevre())
}

Alan: 80
Çevre: 18

çalıştır

Yapı tanımlama

type dikdortgen struct {
    genislik  int
    yukseklik int
}

Dikdörtgen için öncelikle bir yapı struct tanımlaması oluşturuyoruz.

Metot ile Alan/Çevre Hesaplama

func (d *dikdortgen) alan() int {
    return d.genislik * d.yukseklik
}

func (d dikdortgen) cevre() int {
    return d.genislik + d.yukseklik
}

alan() ve cevre() metotları dikdortgen yapısında alıcıya sahiptir. Bu da yapıya özel fonksiyon tanımlama yöntemidir ve sadece bu yapıya sahip tanımlamalar ile kullanılabilir. Pointer ile tanımlanabilir ve bu yapının kopyası yerine üzerinde çalışmanıza izin verir.

Kullanımı

    // Metodların kullanımı
    fmt.Println("Alan:", d.alan())
    fmt.Println("Çevre:", d.cevre())

Metotlar yapı.fonksiyon() şeklinde kullanılmaktadır.

Golang 101: Yapılar (Structs)

Aydın Yakar — Fri, 29 Oct 2021 14:24:27 +0000

Yapı struct nesne benzeri gruplama için kullanılır. Bir çok alanda kullanılırlar örn database işlemlerinde, json/xml çıktılarında vb.

package main

import "fmt"

// Yapı
type Ogrenci struct {
    ad    string
    soyad string
    yas   int
    sinif string
}

// İç içe Yapılar
type Laptop struct {
    islemci    string
    ekranKarti string
    disk       string
    ram        int
}
type Uretici struct {
    firma  string
    model  string
    Laptop // yapı
}

func main() {

    // Boş yapı oluşturma
    ogr := new(Ogrenci)
    fmt.Println(ogr)

    // Yapıya Değer Atama
    fmt.Println(Ogrenci{"Aydın", "Yakar", 40, "3A"})

    // Yapıya alan adları ile birlikte değer atama
    fmt.Println(Ogrenci{ad: "Hasan", soyad: "Ünsal", yas: 45, sinif: "5C"})

    // Boş alanlar ile değer atama
    fmt.Println(Ogrenci{ad: "Osman"})

    // Yapıdaki değeri yazdırma
    o := Ogrenci{ad: "Hüseyin", yas: 20}
    fmt.Println(o.ad)

    // Yapıyı işaretçi ile kullanmak
    ogrenci := &o
    fmt.Println(ogrenci.ad)

    // İşaret edilen yapıda değişiklik yapılabilir
    ogrenci.yas = 22
    fmt.Println(ogrenci.yas)

    // İşaretçi ile belirtilen değişkenlerin değerleri işaret edilen değişkenin adresidir
    fmt.Println("o değişkeni:", &o, "\nogrenci degişkeni:", &ogrenci)

    // Gömülü yapılar
    laptop := Laptop{islemci: "i7 8750h", ekranKarti: "GTX 1060", disk: "250 gb m2 SSD", ram: 16}
    uretici := Uretici{firma: "Monster Notebook", model: "Tulpar T5 v17.1", Laptop: laptop}
    fmt.Println(laptop, uretici)
}

&{  0 }
{Aydın Yakar 40 3A}
{Hasan Ünsal 45 5C}
{Osman  0 }
Hüseyin
Hüseyin
22
o değişkeni: &{Hüseyin  22 } 
ogrenci degişkeni: 0xc00000e030
{i7 8750h GTX 1060 250 gb m2 SSD 16} {Monster Notebook Tulpar T5 v17.1 {i7 8750h GTX 1060 250 gb m2 SSD 16}}

çalıştır

Yapı Tanımlama

type Ogrenci struct {
    ad string
    soyad string
    yas  int
    sinif string
}

Yapı tanımları struct anahtar kelimesi ile yapılır. Ardından alanların türleri girilmelidir.

İç içe Yapılar

type Laptop struct {
    islemci string
    ekranKarti string
    disk string
    ram int
}
type Uretici struct {
    firma string
    model string
    Laptop // yapı
}

Eğer iç içe yapılar olacak ise eklenen yapı için tür belirtecine gerek yoktur. Eğer dizi olarak atanacak ise laptop []Laptop şeklinde de belirtilebilir.

    laptop   := Laptop{islemci: "i7 8750h", ekranKarti: "GTX 1060", disk: "250 gb m2 SSD", ram: 16}
    uretici  := Uretici{firma: "Monster Notebook", model: "Tulpar T5 v17.1", Laptop: laptop}
    fmt.Println(laptop, uretici)

Boş Yapı Oluşturma

    ogr := new(Ogrenci)

Boş bir yapı oluşturmak için new() fonksiyonu kullanılır. Tüm değerler boş/sıfır (zero-valued) olacaktır.

Yapıya Değer Atama Yöntemleri

    // Yapıya Değer Atama
    fmt.Println(Ogrenci{"Aydın", "Yakar", 40, "3A"})

    // Yapıya alan adları ile birlikte değer atama
    fmt.Println(Ogrenci{ad: "Hasan", soyad: "Ünsal", yas: 45, sinif: "5C"})

    // Boş alanlar ile değer atama
    fmt.Println(Ogrenci{ad: "Osman"})

Yukarıda 3 farklı değer atama yöntemi görülmektedir. İlkinde sırasıyla değerler belirtilmiştir, ikinci yöntemde ise alan adları belirtilmiştir fakat istenirse sırası değiştirilerek de belirtilebilir. Son yöntem ise sadece ad atanmış, diğer alanlar boş bırakılmıştır.

Yapıdaki Değeri Yazdırma

    o := Ogrenci{ad: "Hüseyin", yas: 20}
    fmt.Println(o.ad)

Değişken.alan şeklinde erişim sağlanabilmektedir.

Yapıyı İşaretçi ile Kullanmak

    ogrenci := &o
    fmt.Println(ogrenci.ad)

    // İşaret edilen yapıda değişiklik yapılabilir
    ogrenci.yas = 22
    fmt.Println(ogrenci.yas)

Değişkeni işaretçi pointer ile farklı bir değişkene atayabilirsiniz. Fakat unutulmaması gereken aslında ogrenci değişkeninin sadece bir işaretçi olduğu yani o değişkeninin adresini barındırdığıdır. Yine de işaret edilen yapıda yapılan değişiklikler diğer değişkeni de değiştirmektedir. Karışık mı oldu? Örneğin aşağıdaki kısmını incelediğiniz de daha net oturacaktır.

    fmt.Println("o değişkeni:", &o, "\nogrenci degişkeni:", &ogrenci)

Golang 101: İşaretçiler (Pointers)

Aydın Yakar — Wed, 20 Oct 2021 07:44:59 +0000

Değişkenler hafıza da (memory) "değişken adresi" ve "değeri" şeklinde tutulurlar. Bir değişkenin değerini değiştirmek istediğimizde hafıza da o değişkenin adresine gider ve değerini değiştiririz.

İşaretçiler ise hafızadaki değişkenin adresini almak veya bu adresteki değeri değiştirebilmemiz için kullanılmaktadır.

package main

import "fmt"

func main() {

    i := 1
    fmt.Println(i)

    islem(i)
    fmt.Println(i)

    islemptr(&i)
    fmt.Println(i)

    fmt.Println(&i)

}

func islem(deger int) {
    deger = 0
}

func islemptr(deger *int) {
    *deger = 0
}

1
1
0
0xc000126000

çalıştır!

Örnekte görüldüğü üzere i değişkenine değer atanıp ekrana yazdırılıyor.

func islem(deger int) {
    deger = 0
}

Fonksiyonlar da girdi için kullanılan parametreler aslında girilen değerin hafıza da yeniden oluşturulmasını sağlar. Yani örnekte deger adında yeni bir değişken oluşturup buna fonksiyon içerisinde atama yapmaktadır. Bu durumda fonksiyon dışındaki i değişkenine bir etkisi olamamıştır.

func islemptr(deger *int) {
    *deger = 0
}

Bu fonksiyonda ise int değer bulunduran hafıza adresi alacağını *int türü ile belirtiyoruz. Fonksiyonu çalıştırırken ise işaretçimiz (pointer) i değişkeninin adresini & sembolü ile fonksiyona giriyor. Ardından fonksiyon içerisinde * sembolü ile de ilgili adresin değerini değiştireceğimiz belirtilmiş oluyor.

Yani değişkenin adresini & sembolü ile, değişken adresindeki değerini * sembolü ile belirtiyoruz.

Golang 101: Fonksiyonlar (Functions)

Aydın Yakar — Mon, 11 Oct 2021 16:00:58 +0000

Fonksiyonlar main() fonksiyonu dışında tanımlanmalıdır fakat bir istisna olan Fonksiyonun Değişkene Atanması ise tam tersi main() içerisinde tanımlanmak zorundadır.

package main

import "fmt"

// Ayrı Ayrı Argüman Tanımları ve Değer Dönme
func topla(a int, b int) int {
    return a + b
}

// Ayrı Türlerden Argümanları Gruplama
func cikar(a, b int) int {
    return a - b
}

// Fonksiyona Kesit (Slice) Argümanı
func ortalama(kesit []int) int {
    var toplam int
    for _, sayi := range kesit {
        toplam += sayi
    }

    return toplam / len(kesit)
}

// Çift Çıktı
func hesapla(kesit []int) (int, int) {
    var toplam, ortalama int
    for _, sayi := range kesit {
        toplam += sayi
    }

    ortalama = toplam / len(kesit)

    return toplam, ortalama
}

// Değişken Sayılı Argüman Kullanma
func topla2(sayilar ...int) int {
    var toplam int
    for _, sayi := range sayilar {
        toplam += sayi
    }

    return toplam
}

// Fonksiyonun Çağrılması
func main() {

    sonuc := topla(1, 2)
    fmt.Println("Toplam:", sonuc)

    sonuc = cikar(3, 1)
    fmt.Println("Kalan:", sonuc)

    kesit := []int{100, 200, 300, 400, 500}
    sonuc = ortalama(kesit)
    fmt.Println("Ortalama:", sonuc)

    // Fonksiyonun Değişkene Atanması
    a, b := 3, 5
    topla := func() int {
        return a + b
    }()
    topla2 := func() int {
        return a + b
    }
    fmt.Println(topla)
    fmt.Println(topla2())
}

Toplam: 3
Kalan: 2
Ortalama: 300
8
8

çalıştır!

Ayrı Ayrı Argüman Tanımları ve Değer Dönme

func topla(a int, b int) int {
    return a + b
}

Fonksiyon argümanlarından a ve b için int türünde girdi tanımlandı. Toplama işleminin dışarı çıkarılabilmesi return için de int türü tanımlandı.

Ayrı Türlerden Argümanları Gruplama

func cikar(a, b int) int {
    return a - b
}

Fonksiyon da belirtilecek argümanlar aynı türden ve ardışık ise virgülle ayrılarak topluca belirtilebilir. Örnekte a ve b türleri aynı olduğu için tek seferde int olarak belirtildi.

Fonksiyona Kesit (Slice) Argümanı

func ortalama(kesit []int) int {
    var toplam int
    for _, sayi := range kesit {
        toplam += sayi
    }

    return toplam / len(kesit)
}

Fonksiyona girilen kesit (slice) for ve range ile toplanıp, sonuç kesit eleman sayısına (len()) bölünerek döndürülüyor.

Çift Çıktı

func hesapla(kesit []int) (int, int) {
    var toplam, ortalama int
    for _, sayi := range kesit {
        toplam += sayi
    }

    ortalama = toplam / len(kesit)

    return toplam, ortalama
}

Range ile yapılan döngü içi atamalarda (a, b := range degisken) kullanımındaki örneklerde çoğunlukla çift değer görmüştük, burada da fonksiyondan return ile çift değer dönüyoruz. Fakat öncesinde fonksiyondan çift değer döneceği belirtilmelidir (int, int).

Değişken Sayılı Argüman Kullanma

func topla2(sayilar ...int) int {
    var toplam int
    for _, sayi := range sayilar {
        toplam += sayi
    }

    return toplam
}

Argümanda tür belirtecinden önce konulan ... nokta ile belirsiz sayıda argüman girileceği belirtilmiştir. Eğer girilecek argüman sayısı belli farklı argümanlar var ise belirsiz olan en sona girilmelidir: func fonksiyon(sayi int, harfler ...string) gibi.

Fonksiyonun Değişkene Atanması

    a, b := 3, 5
    topla := func() int {
        return a + b
    }()
    topla2 := func() int {
        return a + b
    }
    fmt.Println(topla)
    fmt.Println(topla2())

Bu en ilginç fonksiyon tanımlama yöntemidir. Değişkene atanan fonksiyon da fonksiyon adı değişkenin kendisidir. Girdi için argüman belirtilmiyor ve çıktılar (return) var ise türler belirtilmelidir. İki ayrı fonksiyon olan topla ve topla2 arasında küçük bir fark vardır o da Println ile ekrana yazma sırasında da açıkça görülmektedir. Dikkatlice inceleyerek aradaki farkı bulacağınızı düşünüyorum. Bu fark aslında fonksiyon tanımlama ve çağırma sırasında () kullanımının zorunlu olduğunu gösteriyor. Aksi bir kullanım görmedim ama varsa lütfen yorumlarda belirtiniz.

NOT: Fonksiyonların çağrılması ile ilgili kısımlar main() fonksiyonunda gösterilmiştir.

Golang 101: Range

Aydın Yakar — Sun, 10 Oct 2021 08:57:58 +0000

Dizi, Kesit ve Harita verilerinden indis, anahtar ve değer çekmek için for döngüsü ile birlikte range kullanılır.

package main

import "fmt"

func main() {

    // Kesitteki Sayıları Toplama
    kesit := []int{1, 2, 3, 4}
    toplam := 0
    for _, sayi := range kesit {
        toplam += sayi
    }
    fmt.Println("Toplam:", toplam)

    // Değerin Indis'ini Bulmak
    for indis, deger := range kesit {
        if deger == 3 {
            fmt.Println("Indis:", indis)
        }
    }

    // Harita'dan Anahtar/Değer Alma
    iller := map[string]string{"m": "mersin", "a": "antalya"}
    for k, v := range iller {
        fmt.Printf("%s -> %s\n", k, v)
    }

    // Sadece Anahtar Verisin Almak
    for k := range iller {
        fmt.Println("Anahtar:", k)
    }
}

Toplam: 10
Indis: 2
m -> mersin
a -> antalya
Anahtar: m
Anahtar: a

çalıştır!

Kesitteki Sayıları Toplama

    kesit := []int{1, 2, 3, 4}
    toplam := 0
    for _, sayi := range kesit {
        toplam += sayi
    }
    fmt.Println("Toplam:", toplam)

Kesitteki sayıları range ile her döngü de sırayla indis (_) ve deger (sayi) atamalarını yaparak toplamını buluyoruz. Indis numarasına ihtiyacımız olmadığı için _ boş tanımlayıcı (blank identifier) kullandık.

Değerin Indis'ini Bulmak

    for indis, deger := range kesit {
        if deger == 3 {
            fmt.Println("Indis:", indis)
        }
    }

Değeri 3 olan değişkenin indis değerini bulup yazdırıyoruz.

Harita'dan Anahtar/Değer Alma

    iller := map[string]string{"m": "mersin", "a": "antalya"}
    for k, v := range iller {
        fmt.Printf("%s -> %s\n", k, v)
    }

Harita dizisinden anahtar ve değeri ekrana yazdırıyoruz.

Anahtar Verisi Almak

    for k := range iller {
        fmt.Println("Anahtar:", k)
    }

Range ile tek değişken verildiğinde map'tan anahtar verisi dönmektedir.

Golang 101: Harita (Map)

Aydın Yakar — Fri, 08 Oct 2021 17:40:21 +0000

Haritalar (map) diziden (array) ve kesitten (slice) farklı olarak degisken["anahtar"] = değer şeklinde anahtar (key) verisinin türünü de belirlemenize imkan tanır. Böylelikle string bir anahtar tanımlayabilirsiniz. Hatırlarsanız dizi ve kesitte degisken[indis]=deger şeklinde anahtar yerine indis (index) numerik ve sıralı olarak oluşturuluyordu.

package main

import "fmt"

func main() {

    // Boş Map Tanımlama
    h := make(map[string]int)

    // Değer Atama
    h["k1"] = 7
    h["k2"] = 13
    fmt.Println("Harita:", h)

    x := h["k1"]
    fmt.Println("x: ", x)

    fmt.Println("Boyut:", len(h))

    // Öğeyi Silme
    delete(h, "k2")
    fmt.Println("Yeni Harita:", h)
    fmt.Println("Yeni Boyut:", len(h))

    _, prs := h["k2"]
    fmt.Println("Mevcut mu:", prs)

    // Tanımlama ve Değer Atama
    n := map[string]int{"go": 1, "lang": 2}
    fmt.Println("Harita2:", n)
}

Harita: map[k1:7 k2:13]
x:  7
Boyut: 2
Yeni Harita: map[k1:7]
Yeni Boyut: 1
Mevcut mu: false
Harita2: map[go:1 lang:2]

çalıştır!

Boş Map Tanımlama

    h := make(map[string]int)

Boş bir map tanımlamak için slice'da olduğu gibi make() fonksiyonu kullanılır. Örnekte anahtar (key) değeri string, değer (value) türü ise integer'dır.

Değer Atama

    h["k1"] = 7
    h["k2"] = 13
    fmt.Println("Harita:", h)

    x := h["k1"]
    fmt.Println("x: ", x)

    fmt.Println("Boyut:", len(h))

Oluşturulan değişkenin anahtar değerlerinin (k1, k2) ve değerlerinin (7, 13) atanması görülmektedir. Akabinde ise x değişkenine k1 anahtarına sahip değişkenin değerini atamakta ve son olarak da len ile mevcut eleman sayısı ekrana yazdırılmaktadır.

Öğeyi Silme

    delete(h, "k2")
    fmt.Println("Yeni Harita:", h)
    fmt.Println("Yeni Boyut:", len(h))

    _, prs := h["k2"]
    fmt.Println("Mevcut mu:", prs)

Map'ten delete() fonksiyonu ile belirtilen anahtarı ve değerini silebilirsiniz. Silinen anahtarı kontrol için de _, prs := h["k2"] ile değerini (örnekte: 0) ve varlık durumu bool olarak alabilirsiniz. Böylelikle değerin varlığını kontrol edebilirsiniz. Örnekte silinen anahtarın değeri olmadığından 0 alırken varlık durumu false olarak döner.

Golang'de _ (alt çizgi) özel bir boş tanımlayıcıdır. Herhangi bir işlemde kullanılmayacak değerler bu değişkene atanır.

Tanımlama ve Değer Atama

    n := map[string]int{"go": 1, "lang": 2}

Map tanımlamlarken değer de yukarıdaki örnekte olduğu gibi atanabilir.

Golang 101: Kesit (Slice)

Aydın Yakar — Thu, 07 Oct 2021 11:06:55 +0000

Kesit (Slice) bir bakıma dizidir fakat diziden en önemli farkı boyutunun değiştirilebilir olmasıdır. Kesitler genişleyebilirler, bölünebilirler.

package main

import "fmt"

func main() {

    // Kesit Oluşturma
    kesit := make([]string, 3)
    fmt.Println("Boş kesit:", kesit)

    // Değer Atama
    kesit[0] = "a"
    kesit[1] = "b"
    kesit[2] = "c"
    fmt.Println("Kesit:", kesit)
    fmt.Println("Boyut:", len(kesit))
    fmt.Println("Kapasite:", cap(kesit))

    // Kesiti Genişletme
    kesit = append(kesit, "d")
    kesit = append(kesit, "e", "f")
    fmt.Println("Yeni Kesit:", kesit)

    // Kesiti Kopyalama
    c := make([]string, len(kesit))
    copy(c, kesit)
    fmt.Println("Kopya Kesit:", c)

    // Kesiti Bölme
    k := kesit[2:5]
    fmt.Println("Kesit Bölme 1:", k)

    k = kesit[:5]
    fmt.Println("Kesit Bölme 2:", k)

    k = kesit[2:]
    fmt.Println("Kesit Bölme 3:", k)

    // Kesit Tanımı ve Değer Atama
    t := []string{"g", "h", "i"}
    fmt.Println("Kesit 2:", t)

    // 2 Boyutlu Kesit
    kesit2 := make([][]int, 3)
    for i := 0; i < 3; i++ {
        boyut := i + 1
        kesit2[i] = make([]int, boyut)
        for j := 0; j < boyut; j++ {
            kesit2[i][j] = i + j
        }
    }
    fmt.Println("2 Boyutlu Kesit: ", kesit2)
}

Boş kesit: [  ]
Kesit: [a b c]
Boyut: 3
Kapasite: 3
Yeni Kesit: [a b c d e f]
Kopya Kesit: [a b c d e f]
Kesit Bölme 1: [c d e]
Kesit Bölme 2: [a b c d e]
Kesit Bölme 3: [c d e f]
Kesit 2: [g h i]
2 Boyutlu Kesit:  [[0] [1 2] [2 3 4]]

çalıştır!

Kesit Oluşturma

    kesit := make([]string, 3)
    fmt.Println("Boş kesit:", kesit)

Kesitler make fonksiyonu ile tür ve eleman sayısı belirtilerek oluşturulur. Örnekte 3 elemanlı []string türünde bir slice oluşturuldu.

Değer Atama

    kesit[0] = "a"
    kesit[1] = "b"
    kesit[2] = "c"
    fmt.Println("Kesit:", kesit)
    fmt.Println("Boyut:", len(kesit))
    fmt.Println("Kapasite:", cap(kesit))

Kesitlere dizilerde olduğu gibi değer atanır. Kesit boyutuna dizide olduğu gibi len() ile bakılabilir. Aynı zamanda kesitin kapasitesine de cap() ile bakabilirsiniz.

Kesiti Genişletme, Değer Ekleme

    kesit = append(kesit, "d")
    kesit = append(kesit, "e", "f")

Kesiti genişletmek için append() fonksiyonu kullanılır. Birden fazla değeri tek seferde ekleyebilirsiniz.

Kesiti Kopyalama

    c := make([]string, len(kesit))
    copy(c, kesit)

Mevcut kesiti copy() fonksiyonu ile kopyalayabilirsiniz. Örnekte önce boş bir kesit olarak c değişkeni oluşturuluyor. Oluşturulan c'nin eleman sayısı kopyalanacak kesitin sayısıyla eşit olsun diye len() ile belirtiliyor.

Kesiti Bölme

    k := kesit[2:5]

    k = kesit[:5]

    k = kesit[2:]

Kesiti belirli bir elemanından başlayarak kesit[2:5], belirli bir elemanına kadar kesit[:5] veya belirli bir elemanından başlayarak sonuna kadar bölüp yeni değişkene atanabilirsiniz.

Kesit Tanımı ve Değer Atama

    t := []string{"g", "h", "i"}

Kesitler tanımlanırken de değer ataması yapılabilir.

2 Boyutlu Kesit

    kesit2 := make([][]int, 3)
    for i := 0; i < 3; i++ {
        boyut := i + 1
        kesit2[i] = make([]int, boyut)
        for j := 0; j < boyut; j++ {
            kesit2[i][j] = i + j
        }
    }

Kesit 2 boyutlu olarak oluşturulabilir. Yukarıdaki örnekte öncelikle kesit2 adıyla 2 boyutlu kesit oluşturulmaktadır. for döngüsü ile de kesit2'ye yeni kesitler ve onlara da yeni kesitler eklenerek 2. boyut elde edilmiş olur, Inception :)

Golang 101: Diziler (Arrays)

Aydın Yakar — Wed, 06 Oct 2021 15:51:59 +0000

Diziler aynı türden verileri tutmak için uygundur. İndis (index) değerleri 0'dan başlarlar.

package main

import "fmt"

func main() {

    // Dizi tanımlama
    var i [4]int
    fmt.Println("Boş dizi:", i)

    // Değer atama
    i[3] = 100
    fmt.Println("Atama sonrası:", i)

    // Dizi boyutu
    fmt.Println("Dizi boyutu:", len(i))

    // Diziye tanımlarken değer atama
    x := [5]int{1, 2, 3, 4, 5}
    fmt.Println("Dizi:", x)

    // Çok boyutlu dizi
    var y [2][3]int
    for i := 0; i < 2; i++ {
        for j := 0; j < 3; j++ {
            y[i][j] = i + j
        }
    }
    fmt.Println("2 boyutlu dizi: ", y)
}

Boş dizi: [0 0 0 0]
Atama sonrası: [0 0 0 100]
Dizi boyutu: 4
Dizi: [1 2 3 4 5]
2 boyutlu dizi:  [[0 1 2] [1 2 3]]

çalıştır!

Dizi Tanımlama

    var i [4]int

4 değer alabilen integer bir dizi tanımı yukarıdaki gibi yapılır.

Diziye Değer Atama

    i[3] = 100

Dizinin 3. elemanına (indis'ine) değer atanması

Dizi Boyutu

    fmt.Println("Dizi boyutu:", len(i))

Dizideki eleman sayısı len ile bulunabilir.

Diziyi Tanımlarken Değer Atama

    x := [5]int{1, 2, 3, 4, 5}

Değişken tanımlarında olduğu gibi dizi tanımlarında da tanımlama ve değer atama işlemleri birlikte yapılabilir.

Golang 101: Switch

Aydın Yakar — Tue, 05 Oct 2021 09:13:40 +0000

Çoklu sayıda koşulun sınanması durumunda tercih edilir. Sayfa sonuna fallthrough ile ilgili bilgi eklendi, daha önce yazıyı okuyanlar o kısmı da tekrardan gözden geçirmelidir.

package main

import (
    "fmt"
    "time"
)

func main() {

    // Genel Kullanım
    i := 2
    switch i {
    case 1:
        fmt.Println("i değişkeni 1'e eşittir.")
    case 2:
        fmt.Println("i değişkeni 2'ye eşittir.")
    case 3:
        fmt.Println("i değişkeni 3'e eşittir.")
    }

    // Çoklu Değer
    switch time.Now().Weekday() {
    case time.Saturday, time.Sunday:
        fmt.Println("Hafta sonu..")
    default:
        fmt.Println("Hafta içi..")
    }

    // Koşullu Switch
    t := time.Now()
    switch {
    case t.Hour() < 12:
        fmt.Println("Öğleden önce")
    default:
        fmt.Println("Öğleden sonra")
    }
}

i değişkeni 2'ye eşittir.
Hafta içi..
Öğleden sonra

çalıştır!

Genel Kullanım

    i := 2
    switch i {
    case 1:
        fmt.Println("i değişkeni 1'e eşittir.")
    case 2:
        fmt.Println("i değişkeni 2'ye eşittir.")
    case 3:
        fmt.Println("i değişkeni 3'e eşittir.")
    }

Tanımlanan değişken case ile eşit ise ilgili işlev gerçeleşir.

Çoklu Seçim

    switch time.Now().Weekday() {
    case time.Saturday, time.Sunday:
        fmt.Println("Hafta sonu..")
    default:
        fmt.Println("Hafta içi..")
    }

Günlerin Cumartesi ve Pazar olması durumu yani iki koşulunda gerçekleşmesi durumununa örnektir. Koşulun birden fazla sonuca uygunluğu bu yöntemle denetlenebilir.

Koşullu Switch

    t := time.Now()
    switch {
    case t.Hour() < 12:
        fmt.Println("Öğleden önce")
    default:
        fmt.Println("Öğleden sonra")
    }

Diğer örnekler de eşit olması durumu göz önüne alınarak koşul belirtiliyordu fakat sonucun eşit olmaması durumları da switch ile denetlenebilir.

YENİ BİLGİ: Yeni öğrendiğim fallthrough komutu ile sonraki case'e yani koşula geçmesi sağlanabilir.

    i := 45
    switch {
    case i < 10:
        fmt.Println("i 10'dan küçük")
        fallthrough
    case i < 50:
        fmt.Println("i 50'den küçük")
        fallthrough
    case i < 100:
        fmt.Println("i 100'den küçük")
    }

Bu durumda çıktı önce "i 50'den küçük" yazdıracak ve fallthrough belirtildiği için sonraki casee geçip "i 100'den küçük" yazdıracaktır.

Golang 101: Koşul (If/Else)

Aydın Yakar — Mon, 04 Oct 2021 10:37:10 +0000

Koşul operatörleri olan If ve Else detaylarına bakalım.

package main

import "fmt"

func main() {

    i := 10

    // Basit if kullanımı
    if i%5 == 0 {
        fmt.Printf("%d rakamı 5'e kalansız bölünebilir.\n", i)
    }


    // If/Else kullanımı
    if i < 5 {
        fmt.Printf("%d küçüktür 5'ten\n", i)
    } else {
        fmt.Printf("%d büyüktür 5'ten\n", i)
    }

    // Değişkenin tanımıyla If kullanımı
    if sayi := 7; sayi < 0 {
        fmt.Printf("%d rakamı 0'dan küçüktür!\n", i)
    } else if sayi < 10 {
        fmt.Printf("%d rakamı 10'dan küçüktür!\n", sayi)
    } else {
        fmt.Printf("%d iki koşulu da sağlamıyor!\n", sayi)
    }
}

10 rakamı 0'a bölünebilir.
10 büyüktür 5'ten
7 rakamı 10'dan küçüktür!

Çalıştır!

Basit If Kullanımı

    if i%5 == 0 {
        fmt.Printf("%d rakamı 5'e kalansız bölünebilir.\n", i)
    }

Basit if koşulunda i değişkeninin mod(5)'i alınarak 0'a eşit olup olmadığı kontrol ediliyor.

If/Else Birlikte Kullanımı

    if i < 5 {
        fmt.Printf("%d küçüktür 5'ten\n", i)
    } else {
        fmt.Printf("%d büyüktür 5'ten\n", i)
    }

If koşul bloğu koşulu sağlamaz ise else bloğu çalışmaktadır.

Değişken Tanımlama; If / Else If / Else Kullanımı

    if sayi := 7; sayi < 0 {
        fmt.Printf("%d rakamı 0'dan küçüktür!\n", i)
    } else if sayi < 10 {
        fmt.Printf("%d rakamı 10'dan küçüktür!\n", sayi)
    } else {
        fmt.Printf("%d iki koşulu da sağlamıyor!\n", sayi)
    }

Standart if kullanımlarından farklı olarak önce sayi değişkeni tanımlanıp ardından koşul belirtilmiştir. Unutulmaması gereken ise sayi değişkeninin koşul blokları tamamen bittikten ölmesidir.

Printf

Örnekler de fmt.Printf fonksiyonunu kullandık. Çıktı formatını düzenlemekte kullanılmaktadır. Aynı zamanda \n ile de new line yani çıktı sonrası yeni satır oluşturulması sağlanmıştır.

Golang 101: Döngü (For)

Aydın Yakar — Sun, 03 Oct 2021 08:25:21 +0000

Golang döngüler için sadece for kullanır. Örnek üzerinden inceleyelim.

package main

import "fmt"

func main() {

    // Basit koşul
    x := 1
    for x <= 4 {
        fmt.Println(x)
        x = x + 1
    }

    // Klasik döngü
    for i := 7; i <= 10; i++ {
        fmt.Println(i)
    }

    // Sonsuz döngü
    for {
        fmt.Println("sonsuz döngü")
        break
    }

    // Kontrollü döngü (tek sayılar)
    for y := 0; y <= 9; y++ {
        if y%2 == 0 {
            continue
        }
        fmt.Println(y)
    }

    // Koşulsuz Sonsuz Döngü
    for i := 0; ; i++ {
        fmt.Println(i)
        if i == 4 {
            break
        }
    }
}

1
2
3
4
7
8
9
10
sonsuz döngü
1
3
5
7
9
0
1
2
3
4

çalıştır!

Basit Koşul

    x := 1
    for x <= 4 {
        fmt.Println(x)
        x = x + 1
    }

Döngüden önce tanımlanan i değişkeni for içerisinde değeri arttırılarak diğer dillerdeki while benzeri bir yöntemle kullanılıyor. Burada atanan değer eşitliği (x <= 4) sağladığında döngümüz sonlanıyor.

Klasik Döngü

    for i := 7; i <= 10; i++ {
        fmt.Println(i)
    }

Klasik döngü de diğer dillerden alışık olduğumuz değişken atama, eşitlik kontrolü ve değişkenin arttırılması işlemleri for ile birlikte tanımlanıyor. For içerisindeki işlemler bu kontröle göre devam ediyor.

Sonsuz Döngü

    for {
        fmt.Println("sonsuz döngü")
        break
    }

Sonsuz döngü herhangi bir koşul belirtilmeden for ile oluşturulabilir. İşlevi tamamladığında döngünün sonlandırılması için break kullanılmalıdır.

Kontrollü Döngü

    for y := 0; y <= 9; y++ {
        if y%2 == 0 {
            continue
        }
        fmt.Println(y)
    }

Döngü belirli bir koşulu sağladığında (örnekte y%2 ile değişkenin mod'u alınıyor) döngü continue ile bir sonraki adıma atlatılıyor. Yani döngü sonlanmıyor ve başa dönüp işlemlere devam ediyor.

Koşulsuz Sonsuz Döngü

    for i := 0; ; i++ {
        fmt.Println(i)
        if i == 4 {
            break;
        }
    }

Son anda koşulsuz döngüden bahsetmediğimi fark ettim. Bu örnekte değişken tanımlama ve değişkenin arttırımı belirtiliyor fakat herhangi bir koşul tanımlama sırasında belirtilmiyor. Aslında sonsuz döngü oluşturuyoruz ve break ile döngüden çıkış işlemini önceki örnekteki gibi unutmamalıyız. Örnekte 1, 2, 3, 4 ekrana yazılıp uygulama sonlandırılıyor.

NOT: range ile de bir dizi (array), kesit (slice) veya haritadan (map) veriyi for ile çekebilirsiniz. Bu konuya ileri ki yazılarda dizi çeşitlerini gördükten sonra detaylıca değineceğiz.

Golang 101: Değişkenler (Variables)

Aydın Yakar — Sat, 02 Oct 2021 12:59:15 +0000

Değişkenler tanımlanma yöntemleri açısından sabit değişkenler ve değişkenler olarak ikiye ayrılır. Her iki tanımlama yönteminin türleri aynıdır. Sabit değişkenler bir defa değer atanır ve akış içerisinde değişmez. Değişken türlerini string, int, float ve bool olarak inceleyeceğiz.

package main

import (
    "fmt"
    "reflect"
)

// global değişken
const global = "Global Değişken"

func main() {

    // sabit değişken
    const sabit string = "Golang!"
    const (
        sabit2 int    = 1
        sabit3 float32 = 3.14
        sabit4 bool   = true
    )
    fmt.Println("Sabit Değişkenler:")
    fmt.Println(global)
    fmt.Println(sabit)
    fmt.Println(sabit2)
    fmt.Println(sabit3)
    fmt.Println(sabit4)

    // var ile tanımlama
    var dize string = "test"
    var (
        dize2 int
        dize3 string = "değişken"
    )

    fmt.Println("\nvar ile tanımlama:")
    fmt.Println(dize)
    fmt.Println(dize2)
    fmt.Println(dize3)

    // var kullanmadan değişken tanımlama
    degisken := 1
    a, b, c := 1, 3.14, "golang öğreniyoruz!"

    fmt.Println("\nvar kullanmadan değişken tanımlama:")
    fmt.Println(degisken)
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)

    // değişken türleri
    fmt.Println("\nDeğişken türünü çıktı alma:")
    fmt.Println("Dize: ", reflect.TypeOf(sabit))
    fmt.Println("Kesirli: ", reflect.TypeOf(sabit3))
    fmt.Println("Tam Sayı: ", reflect.TypeOf(dize2))
    fmt.Println("Boolean: ", reflect.TypeOf(sabit4))

}

Sabit Değişkenler:
Global Değişken
Golang!
1
3.14
true

var ile tanımlama:
test
0
değişken tanımlama

var kullanmadan değişken tanımlama:
1
1
3.14
golang öğreniyoruz!

Değişken türünü çıktı alma:
Dize:  string
Kesirli:  float32
Tam Sayı:  int
Boolean:  bool

çalıştır!

Örnekte çeşitli değişken tanımlama yöntemleri ve başlangıç değeri atamaları yapılmıştır. Başlangıç değerleri sabit değişkenler dışında verilmek zorunda değildir ama örnek olması açısından belirtilmiştir. Değişken türlerini ekrana çıktı alabilmek için reflect paketinin TypeOf fonksiyonu kullanılmıştır.

Sabit Değişkenler (const)

Genellikle değişmesine ihtiyaç duyulmayan ama uygulamanın derlenmesi öncesi elle değiştirilmeye ihtiyaç duyulan değerler için kullanılır. Örneğin versiyon bilgi gibi.

Değişken Türleri

Genel değişken türlerini sırayla detaylandıralım. Karmaşık sayılara değinilmedi.

String (Dize)

Golang 101: Değerler yazısında da değindiğimiz gibi harfler, sayılar ve özel karakterlerden oluşan değişken türüdür.

Integer (Tam Sayı)

İşaretli ve işaretsiz tam sayıları kapsar. Türler: int, int8, int16, int32, int64, uint, uint8.. uinptr. u ile başlayanlar unsigned yani işaretsiz sayıları belirtmektedir. İşletim sistemi mimarisine, işlem yapılacak tam sayının bellekte kaplayacağı alana göre uygun olan kullanılır.

Float (Kesirli Sayı)

Kesirli sayılar float32 ve float64'dır.

Boolean (Mantıksal)

Mantıksal değişkenler true ve false değerlerini alır. Mantıksal işlemlerde ve karşılaştırmalarda kullanılır.