GoLang 101 [TR]

GoLang › 101

GoLang Temel Kavramlar

İFADELERİN YAZDIRILMASI

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main
import "fmt"

func main() {
	/*
		%T değişken tipi
		%s string
		%d integer
		%f float
		%t boolean
		\n Bir Satır Ekle
		\t Bir Tab Ekle
	*/
	fmt.Print("S.A.\n")
	fmt.Println("\t :)")
}

GİRDİ (INPUT) KAVRAMI

Reader ile Girdi Alma

1
2
3
4
5
6
7
8
9
10
11
12
13
package main
import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	fmt.Print("Username:")
	input := bufio.NewReader(os.Stdin)
	name, _ := input.ReadString('\n')
	fmt.Println(":>", name)
}

Scanln ile Girdi Alma

1
2
3
4
5
6
7
8
9
10
11
package main
import "fmt"

func main() {
	var name string
	var surname string

	fmt.Print("Name Surname: ") //1
	fmt.Scanf("%s %s", &name, &surname)
	fmt.Printf("Name: %s Surname: %s\n", name, surname) //2
}
  • Girdi, boşlukla ayrılacak bir şekilde ardışık olarak değişkenlere atanır.
output
1
2
Name Surname: Samet Emiroğlu
Name: Samet Surname: Emiroğlu

DEĞİŞKENLERİN KULLANIMI

1
2
3
4
5
6
7
8
9
10
11
12
package main
func main() {
	/*
		var name string = "j0nliv" // string varsayılan değer ""
		var x int = 7              // integer varsayılan değeri 0
		var y = 6
		z := 5
		var avg float64 = 23.5 // float varsayılan değer 0
		var accept bool = true // boolean varsayılan değer false
		const cnst = "Const Value" // Sabit
	*/
}

DİZİ (ARRAY) KAVRAMI

Dizilerin Oluşturulması & Kullanılması

1
2
3
4
5
6
7
8
9
10
11
12
package main
import "fmt"

func main() {
	arr := []int{1, 2, 3, 4, 5, 6, 7}
	fmt.Println(arr) //1
	var arr2 = arr[3:7]
	fmt.Println(arr2) //2
	arr2d := [][]int{{1, 2}, {3, 4}, {5, 6}}
	fmt.Println(arr2d) //3
	arr2d := [][]int{{1, 2}, {3, 4}, {5, 6}}
}
output
1
2
3
[1 2 3 4 5 6 7]
[4 5 6 7]
[[1 2] [3 4] [5 6]]

SLICE & MAP KAVRAMLARI

Slice

1
2
3
4
5
6
7
8
9
package main
import "fmt"

func main() {
	numbers := make([]int, 7)
	numbers[7] = 23
	numbers = append(numbers, 14)
	fmt.Println(numbers) // 1
}
  • Çok boyutlu dizi yapısı ve dinamik işlemler için dizilerin sınırladığı alanlarda devreye slice (dilim) girmektedir.
output
1
[0 0 0 0 0 0 12 14]
  • Çıktı incelendiğinde, slice’nin dinamik yapısından dolayı, 7 elemanlı olacak şekilde oluşturulan diziye 8. elemanın eklenebildiği görülüyor.

Map

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main
import "fmt"

func main() {
	var colors map[string]string
	colors = make(map[string]string)
	colors["black"] = "#000000"
	colors["white"] = "#FFFFFF"
	fmt.Println(colors) // 1

	hexes := map[string]string{
		"#000000": "black",
		"#FFFFFF": "white",
	}
	for key, value := range hexes {
		fmt.Println(key, value) // 2 - 3
	}
}
  • Slice’den farklı olarak anahtar-değer yapısı mevcuttur.
output
1
2
3
map[black:#000000 white:#FFFFFF]
#000000 black
#FFFFFF white

KOŞUL İFADELERİ

IF Statement

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main
import "fmt"

func main() {
	var username string
	fmt.Print("Username:")
	fmt.Scanln(&username)

	if username == "j0nl1v" {
		fmt.Println("Username is valid!")
	} else if username == "sametemirogl" {
		fmt.Println("Username is old!")
	} else {
		fmt.Println("Username is unvalid!")
	}
}

Switch Case

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main
import "fmt"

func main() {
	var password string
	fmt.Print("Password:")
	fmt.Scanln(&password)
s
	switch password {
	case "12345":
		fmt.Println("Password is valid!")
	case "34567":
		fmt.Println("Password is old!")
	default:
		fmt.Println("Password is unvalid!")
	}
}

DÖNGÜLER

For Döngüsü

1
2
3
4
5
6
7
8
9
10
11
12
package main
import "fmt"

func main() {
	for i := 0; i < 8; {
		i += 2
		fmt.Println(i)
	}
	for j := 1; j < 5; j++ {
		fmt.Print("*")
	}
}

For Döngüsünün Belirli Aralık için Kullanımı

1
2
3
4
5
6
7
8
9
10
11
12
13
package main
import "fmt"

func main() {
	hexes := map[string]string{
		"#000000": "black",
		"#FFFFFF": "white",
	}

	for key, value := range hexes {
		fmt.Println(key, value)
	}
}

Koşullu Döngüler

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main
import "fmt"

func main() {
	var x int
	for x < 3 {
		fmt.Println(x)
		x++
	}
	var y int
	for {
		fmt.Println(y)
		if y >= 3 {
			break
		}
		y++
	}
}
  • Örnek kod bloğunda yapı olarak farklı bir kullanım mevcuttur fakat döngüler mantık olarak aynı işlevi görmektedir. (x ve y değerleri “< 3” olduğu sürece işlem sürecektir.)

FONKSİYON KAVRAMI

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main
import "fmt"

func print(text string) string {
	return text
}

func calc(x int, y int) int {
	return x * y
}

func info(now int, date int, name string, surname string) (int, string) {
	return (date - now) * -1, name + " " + surname
}

func main() {
	fmt.Println(print("S.A"))
	fmt.Println(calc(3, 2))
	fmt.Println(info(2020, 1997, "Samet", "Emiroğlu"))
}
  • Fonksiyonlar yapı olarak aşağıdaki gibi tanımlanmaktadır.
1
2
3
func fonksiyon_adi(degisken_adı degişken_tipi) {
	// Kod bloğu
}
  • Herhangi bir değeri return ediyorsa yapı aşağıdaki gibi olmaktadır.
1
2
3
func fonksiyon_adi(degisken_adı degişken_tipi) donus_tipi {
	return degisken_adi
}
  • Birden fazla değer return edilecekse eğer yapı aşağıdaki gibi olmaktadır.
1
2
3
func fonksiyon_adi(degisken_adı degişken_tipi) (donus_tipi,donus_tipi2) {
	return (degisken_adi,"Değer 2")
}

STRUCT KAVRAMI

  • Struct ile bellek içerisinde aynı tipte veri grubu oluşturulmaktadır. Oluşturulan bu değişkenlere bellek üzerinde tek bir adres ve pointer atanmaktadır.
Struct Oluşturma
1
2
3
4
5
6
type car struct {
	model string
	brand int
	hp    int
	year  int
}
  • Struct oluşturma, örnekte olduğu gibi gerçekleşmektedir.
  • Oluşturulan Struct yapısı farklı bir Struct grubu ile extend edilebildiği gibi çeşitli fonksiyonlar da eklenebilmektedir.
Struct Genişletme
1
2
3
4
5
6
7
8
type car struct {
	// Elemanlar
}

type suv struct {
	car 
	yeniEleman string
}
  • Struct içerisindeki elemanlar yeni veri grubu ile extend edilmek istendiğinde, oluşturulan yeni Struct içerisinde eklenmesi istenen Struct’ın adı belirtilmelidir.
1
2
3
func (calc car) oldCalculator() int {
	return (time.Now().Year() - calc.year)
}
  • Struct için fonksiyon özelliği eklenmek istediğinde, ilgili Struct, oluşturulan fonksiyona parametre olarak verilmelidir.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package main
import (
	"fmt"
	"time"
)

type car struct {
	model string
	brand int
	hp    int
	year  int
}

func (calc car) oldCalculator() int {
	return (time.Now().Year() - calc.year)
}
type suv struct {
	car
	fuel string
}
func main() {
	mercy := car{model: "e200", brand: 100000, hp: 200, year: 2002}
	fmt.Println("Model: ", mercy.model, " Brand: ", mercy.brand, " Horse Power: ", mercy.hp, " Old:", mercy.oldCalculator()) // 1
	merso := suv{car{"GLC350", 1000000, 320, 2019}, "hybrid"}
	fmt.Println("Model: ", merso.model, " Brand: ", merso.brand, " Horse Power: ", merso.hp, " Old:", merso.oldCalculator(), " Fuelt Type: ", merso.fuel) // 2
}
  • Struct’ın oluşturulması, extend edilmesi, fonksiyon eklenmesi ve kullanılmasına dair basit bir örnek.
output
1
2
Model:  e200  Brand:  100000  Horse Power:  200  Old: 18
Model:  GLC350  Brand:  1000000  Horse Power:  320  Old: 1  Fuelt Type:  hybrid

INTERFACE KAVRAMI

interface.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package main
import "fmt"

type calculate interface {
	area() float64
}

type square struct {
	long  float64
	short float64
}

type circle struct {
	r float64
}

func (s square) area() float64 {
	return s.short * s.long
}

func (d circle) area() float64 {
	return 3.14 * (d.r * d.r)
}

func areaCalc(i calculate) {
	fmt.Println(i.area())
}

func main() {
	var myInterface calculate
	var myInterface2 calculate
	circleAreaCalc := circle{7}
	squareAreaCalc := square{3, 2}
	myInterface = &circleAreaCalc
	myInterface2 = &squareAreaCalc
	areaCalc(myInterface)
	areaCalc(myInterface2)
}
  • Interfaceler mantık olarak class yapısına benzer fakat static değişkenlere sahiptir. Bu static değişkenler kullanılarak tanımlanan metodlar gerçekleştirilmektedir.