Go Üzerine

const, var, type, func , import , package

chan, map, interface, struct

break, continue, case ,default, fallthrough, for, if, goto, return, select, switch, else, range

go, defer2

append, bool, byte, cap, close, complex, complex64, complex128, uint16, copy, false, float32, float64, imag, int, int8, int16, uint32, int32, int64, iota, len, make, new, nil, panic, uint64, print, println, real, recover, string, true, uint, uint8, uintptr

Go üzerinde herhangi bir referans göstermeden kullanılabilecek fonksiyonlar mevcuttur. Go’da “import” anahtar kelimesi ile kütüphaneleri referans gösterebiliriz. Paketler içerisinde yer alan tüm fonksiyonlar erişilebilir ve kullanılabilir hale gelir. Println() fonksiyonu ekrana girdiyi yazdırmak için kullanılır. Ancak bu fonksiyonu kullanabilmek için “fmt” paketinin import edilmesi gerekir.

package main
import (
	"fmt"
)
func main() {
	fmt.Println("I learn Go!")
}

Object-Oriented programlama dillerindeki “object” anahtarına benzer bir yapısı vardır. Go’da Sınıf’a (Class) Struct diyebilirsiniz.

package main
import (
	"fmt"
	"strconv"
)

type Person struct {
   Name string
   Address string
   Phone string
   Age int
}

func main() {
	var person *Person
	person = &Person{Name:"Parta",Address:"IZMIR",Phone:"02322908811",Age:14}
	fmt.Println("My Name is",person.Name,".I am at",person.Address,".My phone number is",person.Phone,"I am",strconv.Itoa(person.Age),"years old.")	
}

Go’da statik tanımlamalar “const” anahtar kelimesi ile yapılabilmektedir. Gerek globalde gerekse lokal olarak const tanımı yapılabilir.

package main

import "fmt"

const (
    Name  		= "Parta"
    Sector 		= "Software"
    Age  		= 14
    BirthYear 	= 2006
)
const (
    First = 5 * iota
    Second
    Third
)
func main() {
	fmt.Println(Name)
	const localnumber = 1881
	fmt.Println(localnumber)
	const a = "50"
	fmt.Println(a)
	fmt.Println(First)
	fmt.Println(Second)
	fmt.Println(Third)
}

Çıktı:

Parta
1881
50
0
5
10

Go’da değişken tanımları yapılırken herhangi bir değişken tipi belirtme zorunluluğu yoktur. Değişken tipi belirtileceği zaman “var” anahtar kelimesini kullanıyoruz.

package main

import "fmt"

func main() {
	var a, b int = 1, 2
	c:="3"
	d:=4
	e, f, g, h := true, false, 4.5,"yes"
	fmt.Println(a, b, c, d, e, f, g, h)
}

Çıktı:

1 2 3 4 true false 4.5 yes

package main
import "fmt"

type Food interface {
    Cook() bool
    Mix() bool
    Eat() bool
}

type Meat struct {
	name string
    cookTime int
}

func (m Meat) Cook() bool {
    fmt.Printf("Food %s is started. It will be finished after %d seconds.\n",m.name,m.cookTime)
    return true
}

func (m Meat) Mix() bool {
    fmt.Printf("Food %s is being mixed.\n",m.name)
    return true
}

func (m Meat) Eat() bool{
	fmt.Printf("Food %s started to be eaten.\n",m.name)
	return true
}

func main() {
	var m *Meat
	m = &Meat{name:"Meatball",cookTime:100}
	m.Cook()
	m.Mix()
	m.Eat()
	fmt.Println("All is ok!")
}

Çıktı: 

Food Meatball is started. It will be finished after 100 seconds.
Food Meatball is being mixed.
Food Meatball started to be eaten.
All is ok!

Go’da fonksiyon tanımlamaları “func” anahtar kelimesi ile başlar.

package main

import "fmt"
// A function that sum all elements in array
func Sum(numbers []int) int{
	count:=0
	for _,cnt :=range numbers {
		count += cnt
	}
	return count
}

func main() {
	var elements = []int{1,2,3,4,5}
	fmt.Println(Sum(elements))
}

Çıktı:

15

Go yazılımcıları tarafından oluşturulmuş paketler import edilerek kullanılabilir.
“main” paketi çalıştırılabilir bir binary program yapmak için kullanılır.

package main
import (
	"strings"
	"github.com/google/gopacket"
	"fmt"
)

Go’da eş zamanlılık mimarisi gerçekten çok iyi işlenmiş. Aynı anda birden fazla işlem sinyalizasyon ile gerçekleştirilebilir.
“chan1 := make(chan int)” ile kanal oluşturulur.
“x:= <-chan1” ile veri alınır. Ok işareti verinin yönünü göstermektedir. “c <- count” ile veri kanala gönderilir. Aşağıda görüleceği üzere sum fonksiyonunda return kullanılmamış, count değeri bir kanala gönderilmiştir.

package main

import "fmt"
// Function that sum of all integer array elements
func sum(numbers []int, c chan int) {
	count := 0
	for _, numb := range numbers {
		count += numb
	}
	c <- count
}

func main() {
	s := []int{1,2,3,4,5,6}
	t := []int{10,20,30,40,50,60}
	chan1 := make(chan int)
	chan2 := make(chan int)
	go sum(s, chan1)
	go sum(t, chan2)
	x:= <-chan1
	y:= <-chan2
	fmt.Println(x,y)
}

Çıktı:

21 210

map, aslında key-value şeklinde verilerin tutulmasını sağlayan bir veri yapısı gibi düşünebiliriz. “make” fonksiyonu ile oluşturulur. map değişkeni oluşturulurken herhangi bir büyüklük belirtmeye gerek yoktur. Veri eklendikçe otomatik olarak büyür. Eklendiği sırada bir sıralama oluşturmaz. İlgili map değişkenini bir döngüde verileri yazdırmak istediğinizde, her defasında farklı bir sırada olduğunu gözlemlersiniz.

Verinin fazla olduğu map array’lerinde, arama çok hızlı yapılabilmektedir. Bunun nedeni Go tasarımcılarının map’i unsafe olarak bırakmalarıdır. Oluşturulan global bir map’e aynı anda birden fazla mikro servisin yazma işlemi sırasında programınız crash olabilir. Mutex ile bu sorunu çözmeniz gerekecektir. Ancak aynı anda erişim söz konusu olmadığında mutex’e gerek yoktur. Dolayısıyla daha hızlı bir erişim sağlar.

package main

import "fmt"

type People struct {
	IdentityNu  string
	Sex 	    string
	Nationality string
	Likes 		[]string
}

var w map[string]*People

func main() {
	w= make(map[string]*People)
	w["PartaNetworks"] = &People{IdentityNu:"11111111111",Sex:"man",Nationality:"Turkey",Likes:[]string{"Football","Basketball","Chess"}}
	fmt.Println(w["PartaNetworks"].IdentityNu)
	fmt.Println(w["PartaNetworks"].Sex)
	fmt.Println(w["PartaNetworks"].Nationality)
	fmt.Println(w["PartaNetworks"].Likes)
}

Çıktı: 

11111111111
man
Turkey
[Football Basketball Chess]

Go jenerik (generics) değildir. Eğer Object-Oriented bir programalama dili kullandıysanız jenerik yapılara hakimsinizdir. Jenerik yapılar olmadığında type yazımı biraz sizi zorlayabilir. Bu durumu interface{} ile biraz da olsa aşabilirsiniz.

package main
import "fmt"

type Food interface {
    Cook() bool
    Mix() bool
    Eat() bool
}

type Meat struct {
	name string
    cookTime int
}

func (m Meat) Cook() bool {
    fmt.Printf("Food %s is started. It will be finished after %d seconds.\n",m.name,m.cookTime)
    return true
}

func (m Meat) Mix() bool {
    fmt.Printf("Food %s is being mixed.\n",m.name)
    return true
}

func (m Meat) Eat() bool{
	fmt.Printf("Food %s started to be eaten.\n",m.name)
	return true
}

func main() {
	var m *Meat
	m = &Meat{name:"Meatball",cookTime:100}
	m.Cook()
	m.Mix()
	m.Eat()
	fmt.Println("All is ok!")
}

Çıktı:

Food Meatball is started. It will be finished after 100 seconds.
Food Meatball is being mixed.
Food Meatball started to be eaten.
All is ok!

“break” devam eden işleyişi durdurur. Eğer döngü içerisinde belirtilmiş ise döngüden çıkış yapar. Switch/case yapısında belirtilmiş ise ilgili durumdan(case) çıkış yapar.

package main

import "fmt"

func main() {
	var words = []string{"TR","EN","EU","GR"}
	for _, word := range words {
		if(word=="TR"){
			fmt.Println("Word "+word+" found.")
			break
		}
	}
}

Çıktı:

Word TR found.

Bir loop içerisinde tanımlandığında “continue” satırının akabinde gelen satırlar çalıştırılmaz. Döngüye bir sonraki değerden devam ederek çalışır.

package main

import "fmt"

func main() {
	var words = []string{"TR","EN","EU","GR"}
	for _, word := range words {
		if(word!="TR"){
			continue
		}
		fmt.Println("Word "+word+" found.")
	}
}

Çıktı:

Word TR found.

package main

import (
	"fmt"
	"time"
)
 
func main() {
	today := time.Now()
	switch today.Day() {
	case 5:
		fmt.Println("Watch the film.")
		break
	case 10:
		fmt.Println("Go to the gym.")
		fallthrough
	case 15:
		fmt.Println("Watch the football match")
		break
	case 25:
		fmt.Println("Eat some fruit.")
		break
	default:
		fmt.Println("No information for this day.")
	}
}

Çıktı:

Go to the gym.
Watch the football match

Aynı diğer dillerde olduğu gibi döngü için “for” anahtarını kullanırız. Döngü için while gibi bir seçenek yok. “for” ile her çeşit döngüyü oluşturabilirsiniz.

package main

import "fmt"

type People struct {
	IdentityNu  string
	Sex 	    string
	Nationality string
	Likes 		[]string
}

var w map[string]*People

func main() {
	w= make(map[string]*People)
	w["Jack"] = &People{IdentityNu:"11111111111",Sex:"man",Nationality:"Turkey",Likes:[]string{"Football","Basketball","Chess"}}
	w["Joe"] = &People{IdentityNu:"2222222222",Sex:"man",Nationality:"England",Likes:[]string{"Football","Swimming","Chess"}}
	for name, p := range w{
		fmt.Println(name+" is a "+p.Sex)
	}
}

Çıktı:

Jack is a man
Joe is a man

Koşula göre seçim yapar. “if” koşulu desteklerse ilgili alana, desteklemezse “else” kısmındaki koda girer.

package main

import (
	"fmt"
)

func main() {
	var number = 56
	if number%2 == 0 {
        fmt.Printf("%d is even",number)
    } else {
        fmt.Printf("%d is odd",number)
    }
}

Çıktı:

56 is even

goto anahtarının kullanımının faydası konusunda pek çok tartışma olmuştur. Zamanla Yüksek Seviyeli Dillerden (High Level Programming Language) uzaklaştıkça GOTO kullanımının kodu karmaşıklaştırdığı ve sonrasında da spagetti koda sebep olduğu düşünülüyor (Bkz: https://homepages.cwi.nl/~storm/teaching/reader/Dijkstra68.pdf).

goto ilk olarak Assembly (Makine Kodu) de karşımıza çıkmaktadır. goto yerine kullanılabilecek pek çok anahtar vardır.

package main

import "fmt"

func main() {
   var numb int = 90
   LOOP: for numb < 100 {
      if numb == 15 {
         numb = numb + 1
         goto LOOP
      }
      fmt.Printf("value of number: %d\n", numb)
      numb++     
   }  
}

Çıktı:

value of number: 90
value of number: 91
value of number: 92
value of number: 93
value of number: 94
value of number: 95
value of number: 96
value of number: 97
value of number: 98
value of number: 99

İşleyişin devam ettiği durumdan çıkış yapmak için kullanılan bir anahtar kelimedir. Bir fonksiyondan değer döndürmek için kullanılır.

package main

import (
	"fmt"
	"strings"
)
// A function that sum all elements in array
func Search(searchstr string) ([]string,bool){
	var foundTeams []string
	var found bool
	for _,team :=range teams {
		if(strings.HasPrefix(team,searchstr)){
			foundTeams=append(foundTeams,team)
			found = true
		}
	}
	return foundTeams,found
}
var teams = []string{"Real Madrid","Real Zaragoza","Barcelona"}
func main() {
	foundStr,foundBool:=Search("Real")
	fmt.Println(foundStr)
	fmt.Println(foundBool)
}

Çıktı:

[Real Madrid Real Zaragoza]
true

Eşzamanlılık, birbirinden bağımsız çalışmaların bir araya gelmesi ve kullanılmasıdır. Paralellik ile çoğu zaman karıştırılır. Metotlar/Fonksiyonlar, “go” kelimesi ile işleyişten bağımsız olarak çalışmaya devam eder. goroutine kesinlikle bir thread değildir.

package main

import (
	"fmt"
	"time"
)

func routine(from string) {
	for i := 0; i < 3; i++ {
		fmt.Println(from, i)
	}
}

func main() {
	routine("call direct")
	go routine("call goroutine")
	go func(msg string) {
		fmt.Println(msg)
	}("going")
	time.Sleep(time.Second)
	fmt.Println("done")
}

Çıktı:

call direct 0
call direct 1
call direct 2
call goroutine 0
call goroutine 1
going
call goroutine 2
done

Kendisini çevreleyen fonksiyon tamamen bitene kadar defer satırında çağırılan fonksiyonun çalışmasını erteler.

package main

import (
	"fmt"
	"os"
)

var f *os.File

func main() {
	f = Create("/tmp/defer.txt")
	defer Close()
	Write()
}

func Create(p string) *os.File {
	fmt.Println("creating")
	f, err := os.Create(p)
	if err != nil {
		panic(err)
	}
	return f
}

func Write() {
	fmt.Println("writing")
	fmt.Fprintln(f, "data")
}

func Close() {
	fmt.Println("closing")
	err := f.Close()
	if err != nil {
		fmt.Fprintf(os.Stderr, "error: %v\n", err)
		os.Exit(1)
	}
}

Çıktı:

creating
writing
closing