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.
AA

Notlarımı toparladıkça aşağıdaki listelere eklemeler yapacağım.

Golang 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ışmayabilir1 2. Bu durumda doğrudan gotour komutu üzerinden local go yardımcı dökümanını görüntüleyebilirsiniz3.

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 <paket-adi>

go doc strings split

Yukadaki komutu uygulamanızın ardından ş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 etmektedir4. İ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örebilirsiniz5.

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 iletiyorum5 6. Döngüler ve matematiksel problemlere dair Project Euler oldukça işinize yarayacaktır7. 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

Önerdiğim Eğitimler

 Önerdiğim Kitaplar

Diğer Yardımcı Kaynaklar

Çevrimiçi Topluluklar

Takip Edebileceğiniz Gopherlar

Videolar

  1. Command go. The Go Programming Language ↩
  2. tour: go tool: no such tool "tour". golang/tour. GitHub ↩
  3. Go offline (optional). A Tour of Go ↩
  4. Türkçe Go Turu ↩
  5. Package fmt. The Go Programming Language ↩ ↩
  6. tetsuok/answer_exercise_gotour.go. GitHub ↩
  7. About Project Euler ↩
Yorum alanını göster
Beğendim
Beğenmedim