Go Programlama Dili Cheat Sheet

Go (aynı zamanda Golang olarak da bilinir), Google’da Robert Griesemer, Rob Pike ve Ken Thompson tarafından geliştirilmiş statik olarak yazılmış, derlenmiş bir dildir. Go sözdizimi C’ye benzer, ancak bellek güvenliği, GC (çöp toplama), yapısal tipleme ve CSP tarzı eşzamanlılık özelliklerine sahiptir.

Merhaba dünya (Hello world)

package main

import "fmt"

func main() {
  message := greetMe("dünya")
  fmt.Println(message)
}

func greetMe(name string) (string) {
  return "Merhaba, " + name + "!"
}
$ go build

Değişkenler

Değişken bildirimi

var msg string
msg = "Merhaba"

Kısa yazım

msg := "Merhaba"

Sabitler

const Phi = 1.618

Sabitler karakterler, dizeler, boolean değerler veya sayısal değerler olabilir.

Temel Tipler

Dizeler (Strings)

str := "Merhaba"
str := `Çok satırlı
dize`

Dizeler için tip stringdir.

Sayılar

Tipik tipler

num := 3          // int
num := 3.         // float64
num := 3 + 4i     // complex128
num := byte('a')  // byte (uint8 için takma ad)

Diğer tipler

var u uint = 7        // uint (işaretsiz)
var p float32 = 22.7  // 32-bit float

İşaretçiler (Pointers)

func main () {
  b := *getPointer()
  fmt.Println("Değer:", b)
}
 
func getPointer () (myPointer *int) {
  a := 234
  return &a
}

İşaretçiler bir değişkenin bellek konumunu gösterir. Go tamamen çöp toplama (garbage collection) özelliğine sahiptir.

Diziler (Arrays)

// var numbers [5]int
numbers := [...]int{0, 0, 0, 0, 0}

Dizilerin boyutu sabittir.

Dilimler (Slices)

slice := []int{2, 3, 4}
slice := []byte("Merhaba")

Dizilerin aksine, dilimler dinamik bir boyuta sahiptir.

Akış Kontrolü

Koşullu İfadeler

if day == "pazar" || day == "cumartesi" {
  rest()
} else if day == "pazartesi" && isTired() {
  groan()
} else {
  work()
}

if İçindeki İfade

if _, err := getResult(); err != nil {
  fmt.Println("Eyvah")
}

Bir if ifadesi, koşullu ifadeden önce basit bir ifade yürütebilir.

Switch

switch day {
  case "pazar":
    // durumlar varsayılan olarak "birbirine geçmez" (fallthrough)!
    fallthrough

  case "cumartesi":
    rest()

  default:
    work()
}

Fonksiyonlar

Lambdalar (Anonim fonksiyonlar)

myfunc := func() bool {
  return x > 10000
}

Fonksiyonlar birinci sınıf nesnelerdir.

Çoklu dönüş tipleri

a, b := getMessage()
func getMessage() (a string, b string) {
  return "Merhaba", "Dünya"
}

Adlandırılmış dönüş değerleri

func split(sum int) (x, y int) {
  x := sum * 4 / 9
  y := sum - x
  return
}

Dönüş değerlerini bildirimde adlandırarak, return (argüman olmadan) bu adlara sahip değişkenleri döndürür.

Paketler

Yükleme

import "fmt"
import "math/rand"
import (
  "fmt"        // fmt.Println verir
  "math/rand"  // rand.Intn verir
)

Her ikisi de aynıdır.

Takma Adlar (Aliases)

import r "math/rand"
 
r.Intn()

Dışa Aktarılan İsimler

func Hello () {
  ···
}

Dışa aktarılan isimler büyük harfle başlar.

Paketler

package hello

Her paket dosyası package ile başlamalıdır.

Eşzamanlılık (Concurrency)

Gorutinler (Goroutines)

func main() {
  // Bir "kanal" (channel)
  ch := make(chan string)

  // Eşzamanlı rutinleri başlat
  go push("Moe", ch)
  go push("Larry", ch)
  go push("Curly", ch)

  // 3 sonucu oku
  // (Gorutinlerimiz eşzamanlı olduğu için
  // sıra garanti edilmez!)
  fmt.Println(<-ch, <-ch, <-ch)
}
 
func push(name string, ch chan string) {
  msg := "Hey, " + name
  ch <- msg
}

Kanallar, gorutinlerde kullanılan eşzamanlılık açısından güvenli iletişim nesneleridir.

Tamponlu Kanallar

ch := make(chan int, 2)
ch <- 1
ch <-  Turkish
ch <- Turkish
// önemli hata:
// tüm gorutinler uykuda - kilitlenme (deadlock)!

Tamponlu kanallar tutabileceği mesaj sayısını sınırlar.

Kanalları Kapatma

Bir kanalı kapatır

ch <- 1
ch <- Turkish
ch <- Turkish
close(ch)

Kapanana kadar bir kanalı yineler

for i := range ch {
  ···
}

ok == false ise kapalıdır

v, ok := <- ch

Defer & Panic

Defer (Erteleme)

func main() {
  defer fmt.Println("Bitti")
  fmt.Println("Çalışıyor...")
}

Bir fonksiyonun yürütülmesini çevreleyen fonksiyon dönene kadar erteler. Argümanlar hemen değerlendirilir, ancak fonksiyon çağrısı sonuna kadar çalışmaz.

Lambdalarla Defer

func main() {
  defer func() {
    fmt.Println("Bitti")
  }()
  fmt.Println("Çalışıyor...")
}

Lambdalar ertelenen bloklar için daha uygundur.

Yapılar (Structs)

Tanımlama

type Vertex struct {
  X int
  Y int
}

func main() {
  v := Vertex{1, 2}
  v.X = 4
  fmt.Println(v.X, v.Y)
}

Değişmezler (Literals)

v := Vertex{X: 1, Y: 2}
// Alan adları atlanabilir
v := Vertex{1, 2}
// Y örtüktür
v := Vertex{X: 1}

Alan adlarını da belirtebilirsiniz.

Yapılara İşaretçiler

v := &Vertex{1, 2}
v.X = 2

v bir işaretçi olduğunda, v.X ve (*v).X aynıdır.

Metotlar

Alıcılar (Receivers)

type Vertex struct {
  X, Y float64
}
func (v Vertex) Abs() float64 {
  return math.Sqrt(v.X * v.X + v.Y * v.Y)
}
 
v := Vertex{1, 2}
v.Abs()

Sınıflar yoktur, ancak alıcıları kullanarak tipler üzerinde fonksiyonlar tanımlayabilirsiniz.

İşaretçi Alıcıları

func (v *Vertex) Scale(f float64) {
  v.X = v.X * f
  v.Y = v.Y * f
}
 
v := Vertex{6, 12}
v.Scale(0.5)
// `v` güncellendi