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.
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
- Golang (Go Programlama Dili) Nedir?
- macOS GoLang Kurulumu
- DigitalOcean – Linux (Ubuntu) Ortamında Go Kurulumu
- Golang İle İşletim Sistemlerine Göre Build İşlemi
- Go İle WordPress Draft Postları BibTex Olarak İndirmek
- Golang (net/http) Web Server Oluşturma
Önerdiğim Eğitimler
- Go Programlama Dili
- Learn How To Code: Google’s Go (golang) Programming Language
- Modern Golang Programming
- Advanced Google’s Go (golang) Programming Course
- Web Development w/ Google’s Go (golang) Programming Language
- Go: The Complete Developer’s Guide (Golang)
Önerdiğim Kitaplar
- Go Bootcamp
- Introducing Go
- Go Programming Blueprints
- Mastering Concurrency in Go
- Go in Practice
- Build Web Application with Golang
- Mastering Go Web Services
Diğer Yardımcı Kaynaklar
- The Go Programming Language
- Go Turu
- Golang Playground
- The Go Programming Language Specification
- Go Paket Index
- Go by Example
- Golang Programs