Go Programlama Diline Dair Notlarım

Go programlama diline dair gereksinimler üzerinden paylaştığım yazıları ve farklı kaynaklardaki notlarımı bir arada derlemenin daha uygun olacağını düşünüyorum. Bu sayede go ile ilgili araştırmalar yapan, dile yeni başlayan gopher‘lara da bir ölçüde yardımcı olabilirsem ne mutlu. Notlarımı toparladıkça aşağıdaki listelere eklemeler yapacağım.

Notlarım

Offline Go Turu

Go tool tour ile local olarak go yardımcı dökümanını görüntüleyebilirsiniz. Eğer kurulum işlemini bir paket yönetici ile yaptıysanız ya da kurulum ayarlarında değişikliğe gittiyseniz tour araç çalışmayabilir. Bu durumda doğrudan gotour komutu üzerinden local go yardımcı dökümanını görüntüleyebilirsiniz.

go tool tour
# yukarıdaki komut işlemiyorsa aşağıdaki komutu kullanabilirsiniz
 
go get golang.org/x/tour/gotour && gotour
# dökümanı görüntülemek istediğinizde gotour komutunu kullanabilirsiniz

Offline Go Yardımcı İçerikleri

Paketlerle ilgili bilgilendirmelere offline olarak ulaşmanızı sağlar.

# kullanımı şu şekildedir: go doc  
go doc strings split
 
# yukadaki komut sonucunda şu bilgilere ulaşırsınız:
func Split(s, sep string) []string
    Split slices s into all substrings separated by sep and returns a slice of
    the substrings between those separators.
 
    If s does not contain sep and sep is not empty, Split returns a slice of
    length 1 whose only element is s.
 
    If sep is empty, Split splits after each UTF-8 sequence. If both s and sep
    are empty, Split returns an empty slice.
 
    It is equivalent to SplitN with a count of -1.

Dışa Aktarılan İsimler

Değişken isimlerinde büyük harf kullanmak ilgili değişkenin paket dışından da erişilebilmesini sağlayacaktır. Örneğin burada örnek verilen math.Pi math paketi içerisinde tanımlı matematiksel sabitlerden (mathematical constants) Pi’yi ifade etmektedir. İlgili kod örneğini çalıştırdığınızda pi (küçük p) paket içerisindeki Pi‘ye erişemeyecek ve hata döndürecektir. Pi düzenlemesiyle birlikte (math.Pi) matematiksel sabitlerde yer alan 3.141592653589793 değeri elde edersiniz. Örnekteki işlemi paket içeriğinde tanımlı diğer sabitler ile yineleyebilirsiniz.

package main
 
import (
	"fmt"
	"math"
)
 
func main() {
	fmt.Println(math.E)
	fmt.Println(math.Pi)
	fmt.Println(math.Phi)
	fmt.Println(math.MaxFloat32)
	fmt.Println(math.MaxInt8)
}

Fonksiyon Yazım Biçimleri

Aşağıdaki örnekler ve daha fazlası için Go’s Declaration Syntax sayfasını inceleyebilirsiniz.

package main
 
import (
	"fmt"
	"math"
)
 
func topla(nums ...int) {
	total := 0
 
	for _, num := range nums {
		total += num
	}
 
	fmt.Println(total)
}
 
func cikar(x, y int) (z int) {
	func() int {
		z = x - y
		return z
	}()
	return
}
 
func main() {
	nums := []int{1, 2, 3, 4}
	topla(nums...)
	fmt.Println(cikar(42, 13))
 
	carp := func(x, y int) int { return x * y }(42, 13)
	fmt.Println(carp)
 
	fmt.Println(func(x, y int) int { return x / y }(42, 13))
 
	sqrt := func(x float64) float64 {
		z := float64(1)
		min_delta := 0.00000000001
		delta := z
		i := 0
		for ; math.Abs(delta) > min_delta; i++ {
			delta = (z*z - x) / (2 * z)
			z = z - delta
		}
		fmt.Println(i)
		return z
 
	}
	sqrt(9987665555.0)
}

Değişkenler

var ifadesi değişken (variable) tanımlamak için paket veya fonksiyon düzeyinde kullanılır. Aşağıda farklı kullanım biçimlerini bir arada görebilirsiniz.

package main
 
import "fmt"
 
var (
	x int    = 10
	y string = "test"
)
var z bool = true
 
func main() {
	fmt.Printf("%d %s %t", func() int {
		return x
	}(), func() string {
		return y
	}(), func() bool {
		return z
	}())
}

Alıştırma: Döngüler ve Fonksiyonlar

Go turu içeriğinde yer alan ve döngü/fonksiyon bilgilerini pekiştirmek için sunulan alıştırmaya dair ürettiğim çözümü aşağıda iletiyorum. Döngüler ve matematiksel problemlere dair Project Euler oldukça işinize yarayacaktır. Yayınladığım yazılar altında Project Euler Go çözümlerimi de ayrıca paylaşacağım.

package main
 
import (
	"fmt"
	"math"
)
 
func Sqrt(x float64) float64 {
	z := float64(1)
	for i := 0; i < 10; i++ {
		z = z-(z*z-x)/(2*z)
	}
	return z
}
 
func main() {
	i := float64(169)
	fmt.Println(fmt.Sprintf("%v", Sqrt(i)), Sqrt(i) == math.Sqrt(i))
}

Defer Kullanımı

Yer aldığı scope içerisindeki işlemler tamamlanana kadar bekler ve ilişkilendirildiği işlemi başlatır. Örnek olarak bir dosya ve veri tabanı bağlantısı başlattığınızı düşünün. Normal şartlarda bağlantı sonlandırma işlemini fonksiyonun sonunda yapmanız gerekir. Ancak defer ile işlemi ilişkili olan değişkenler tamamlandıktan, işlemler başlatıldıktan sonra tanımlayabilirsiniz. Biraz daha netleştirmek adına aşağıdaki örnekleri inceleyebilirsiniz.

package main
 
import "fmt"
 
func main() {
	defer ornek1()
	ornek2()
}
func ornek1() {
	fmt.Println("Ornek 1")
	for i := 0; i < 10; i++ {
		defer fmt.Println(i)
	}
}
 
type foo struct{ i int }
 
func (f *foo) Close() { fmt.Println(f.i) }
 
func ornek2() {
	fmt.Println("Ornek 2")
	fmt.Println("başlangıç")
	for i := 0; i < 10; i++ {
		f := &foo{i}
		defer f.Close()
	}
	fmt.Println("bitiş")
}

Pointer Kullanımı

Go programlama dilinde işaretçi (“pointer”) kullanımı mevcuttur, her işaretçi oluşturulan değişkenin bellekteki adresini tutar. Ön tanımlı olarak Sıfır nil değerine sahiptir.

package main
 
import "fmt"
 
func main() {
	i, j := 42, 2701
	p := &i // p i'nin bellek adresini (memory address) alır
	fmt.Printf("%v\n", p) // bellek adresi
	fmt.Printf("%v\n", *&i) // bellek adresini gösterir (point)
	fmt.Printf("%v\n", *p) // p göstericisi üzerinden i'nin değerini okur
	*p = 21 // p göstericisi üzerinden i'ye değer atayabiliriz
	fmt.Printf("%v\n", *p)
	fmt.Printf("%v\n", i)
	p = &j
	*p = *p / 37
	fmt.Printf("%v\n", j)
	var k *int
	fmt.Printf("%v\n", *&k)
}

Struct Kullanımı

package main
 
import "fmt"
 
type person struct {
	firstName, lastName string
	age                 int
	city                string
}
 
var (
	v1 = person{"Marty", "Red", 20, "Berlin"}
	v2 = person{age: 22}
	v3 = person{}
	p  = &person{"Adam", "Gray", 35, "Riga"}
	x = *p
)
 
func main() {
	defer fmt.Println(v1, p, v2, v3, x)
 
	fmt.Println(person{"Mark", "Black", 33, "London"})
	fmt.Println(person{firstName: "Frank", lastName: "White", city: "Paris", age: 23})
	fmt.Println(person{firstName: "Fred"})
	fmt.Println(&person{firstName: "Ann", age: 40})
 
	s := person{firstName: "Sean", age: 50}
	fmt.Println(s)
	fmt.Println(s.firstName)
 
	sp := &s
	sp.age = 51
	fmt.Println(sp.age)
	fmt.Println(sp)
	fmt.Println(s)
 
	sp = new(person)
	fmt.Println(sp.age)
	sp.age = 51
	fmt.Println(sp.age)
	fmt.Println(sp)
	fmt.Println(s)
 
	a := person{"Lynda", "Blue", 38, "Oslo"}
	fmt.Println(a)
 
	location := struct {
		latitude float32
		longitude float32
	}{61.8982873, -7.5147064}
	fmt.Println(location.latitude)
 
	var newPerson person
	newPerson = person{"","",0,""}
	fmt.Println(newPerson)
}

Yayınladığım Yazılar

Eğitimler

Kitaplar

Yardımcı Kaynaklar

Çevrimiçi Topluluklar

Gopherlar

Videolar

Go Hakkındaki Yazılardan Haberdar Olmak İster Misin?

E-posta listesine katılarak yeni yazılardan haberdar olabilirsin.

One reply on “Go Programlama Diline Dair Notlarım

Leave a Reply