├── .gitignore ├── Bonus ├── CreateChart │ ├── client.go │ └── stocks.png ├── GoQuery │ └── find.go ├── NueralNetworkSample │ ├── NueralNetworkSample.exe │ └── client.go ├── ProtoBuf │ ├── Southwind.proto │ └── client.go ├── Testing │ ├── operations.go │ └── operations_test.go ├── UseWithRuby │ ├── SomeMath.go │ └── client.rb └── Work with Redis │ └── samples.go ├── Cover.JPG ├── Lesson_01.go ├── Lesson_02.go ├── Lesson_03.go ├── Lesson_04.go ├── Lesson_05.go ├── Lesson_06.go ├── Lesson_07.go ├── Lesson_08.go ├── Lesson_09.go ├── Lesson_10.go ├── Lesson_11.go ├── Lesson_12.go ├── Lesson_13.go ├── Lesson_14.go ├── Lesson_15.go ├── Lesson_16.go ├── Lesson_17.go ├── Lesson_18.go ├── Lesson_19.go ├── Lesson_20.go ├── Lesson_21.go ├── Lesson_22.go ├── README.md ├── Web Programming ├── Lesson_23 │ ├── Server.go │ └── static │ │ ├── go_rocks.jpg │ │ ├── index.html │ │ └── main.css ├── Lesson_24 │ ├── pages │ │ ├── common.css │ │ ├── index.html │ │ ├── players.html │ │ └── stronger.gif │ └── server.go ├── Lesson_25 │ └── server.go ├── Lesson_26 │ ├── Server.go │ ├── entity │ │ └── starwars │ │ │ └── starwars.go │ └── static │ │ ├── common.css │ │ ├── cover.gif │ │ └── index.html ├── Lesson_27 │ ├── server.go │ └── starwars.sdb ├── Lesson_28 │ ├── db │ │ └── southwind.sdb │ ├── server.go │ └── southwind │ │ └── southwind.go ├── Lesson_29 │ └── NewsRoom │ │ ├── conf │ │ └── app.conf │ │ ├── controllers │ │ └── default.go │ │ ├── main.go │ │ ├── routers │ │ └── router.go │ │ ├── static │ │ └── js │ │ │ └── reload.min.js │ │ ├── tests │ │ └── default_test.go │ │ └── views │ │ ├── default │ │ └── hello-newsroom.tpl │ │ └── index.tpl └── Lesson_30 │ ├── index.go │ └── index_test.go ├── _config.yml └── mainPage.html /.gitignore: -------------------------------------------------------------------------------- 1 | *.exe -------------------------------------------------------------------------------- /Bonus/CreateChart/client.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "image" 5 | "image/color" 6 | "image/draw" 7 | "image/png" 8 | "os" 9 | 10 | "github.com/vdobler/chart" 11 | "github.com/vdobler/chart/imgg" 12 | ) 13 | 14 | const ( 15 | Width = 640 16 | Height = 480 17 | ) 18 | 19 | func main() { 20 | var axis []string 21 | axis = append(axis, "OEM", "core i7 Cpu", "keyboard", "mouse", "1080P Monitor") 22 | var values []float64 23 | values = append(values, 40, 7, 12, 12, 45) 24 | // PieChart üzerinde sunacağımız veriyi tutan yapımız 25 | // Chart başlığını, x ve y değerlerini taşıyor 26 | data := ChartData{Title: "Stock Values", Axis: axis, Values: values} 27 | c := CreatePieChart("Our Stock Report", data) 28 | SavePieToFile("stocks.png", c) 29 | } 30 | 31 | // PieChart'ı dosyaya kaydeden fonksiyon 32 | func SavePieToFile(fileName string, c chart.PieChart) { 33 | imgFile, _ := os.Create(fileName) //Sistemde bir dosya oluştur 34 | img := image.NewRGBA(image.Rect(0, 0, Width, Height)) 35 | bg := image.NewUniform(color.RGBA{0xff, 0xff, 0xff, 0xff}) 36 | draw.Draw(img, img.Bounds(), bg, image.ZP, draw.Src) 37 | igr := imgg.AddTo(img, 0, 0, Width, Height, color.RGBA{0xff, 0xff, 0xff, 0xff}, nil, nil) 38 | c.Plot(igr) //char ile imajı burada eşleştirdik 39 | png.Encode(imgFile, img) // img zaten igr ilişkilendirilmişti. Burada fiziki dosyaya kaydedilmiş oluyor 40 | imgFile.Close() 41 | } 42 | 43 | //Pie Chart oluşturan fonksiyonumuz 44 | func CreatePieChart(title string, data ChartData) chart.PieChart { 45 | pie := chart.PieChart{Title: title} //Başlığını verdik 46 | pie.AddDataPair(data.Title, data.Axis, data.Values) //Verileri aktardık 47 | pie.Inner = 0 48 | pie.Key.Border = -1 49 | pie.FmtVal = chart.AbsoluteValue 50 | return pie 51 | } 52 | 53 | type ChartData struct { 54 | Title string 55 | Axis []string 56 | Values []float64 57 | } 58 | -------------------------------------------------------------------------------- /Bonus/CreateChart/stocks.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/buraksenyurt/golangsamples/0d02cb4e3b9673ccf6100526772d17ebee78bc5a/Bonus/CreateChart/stocks.png -------------------------------------------------------------------------------- /Bonus/GoQuery/find.go: -------------------------------------------------------------------------------- 1 | /* 2 | Kod bir web sayfasındaki HTML elementlerinde arama yapmak için kullanılıyor. 3 | Örnekte www.buraksenyurt.com adresindeki post-title css sınıfını kullanan 4 | satırlardaki a elementi yakalanıp text içeriği döndürülüyor. 5 | Bir başka deyişle makale başlıklarını yakalıyoruz. 6 | */ 7 | package main 8 | 9 | import ( 10 | "fmt" 11 | "log" 12 | 13 | q "github.com/PuerkitoBio/goquery" //q ile bir alias tanımlamış olduk 14 | ) 15 | 16 | func main() { 17 | // Web dokümanını aç 18 | doc, err := q.NewDocument("http://www.buraksenyurt.com") 19 | if err != nil { 20 | log.Fatal(err) 21 | } 22 | 23 | // post-title css'inin uygulandığı her bir element için iç fonksiyonu çalıştır 24 | doc.Find(".post-title").Each(func( 25 | i int, s *q.Selection) { 26 | title := s.Find("a").Text() //Selection üzerinden a elementini ara 27 | fmt.Printf("%d\t%s\n", i, title) 28 | }) 29 | } 30 | -------------------------------------------------------------------------------- /Bonus/NueralNetworkSample/NueralNetworkSample.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/buraksenyurt/golangsamples/0d02cb4e3b9673ccf6100526772d17ebee78bc5a/Bonus/NueralNetworkSample/NueralNetworkSample.exe -------------------------------------------------------------------------------- /Bonus/NueralNetworkSample/client.go: -------------------------------------------------------------------------------- 1 | /* 2 | Basit bir yapay sinir ağı uygulaması 3 | goml/gobrain paketinden yararlanıştır 4 | and işlemi öğretilmiştir 5 | */ 6 | package main 7 | 8 | import ( 9 | "fmt" 10 | "math/rand" 11 | 12 | "github.com/goml/gobrain" //LiteIDE'de Build->Get ile paketi yüklemeyi unutmayalım 13 | ) 14 | 15 | func main() { 16 | fmt.Println("Yapay sinir ağına VE işlemini öğretiyoruz") 17 | rand.Seed(0) 18 | 19 | //sinir ağına öğreteceğimiz VE işlemine ait örnekleme kümesi 20 | patterns := [][][]float64{ 21 | {{0, 0}, {1}}, 22 | {{0, 1}, {0}}, 23 | {{1, 0}, {0}}, 24 | {{1, 1}, {1}}, 25 | } 26 | 27 | // FeedForward adı verilen fonksiyonellik oluşturuluyor 28 | //neural network function 29 | nnf := &gobrain.FeedForward{} 30 | nnf.Init(2, 2, 1) //2 giriş boğumu,2 gizli katman boğumu ve 1 sonuç boğumu olacak 31 | nnf.Train(patterns, 6000, 0.6, 0.4, true) //6000 devirlik bir öğrenme olacak. Öğrenme oranı 0.6, momentum katsayısı 0.4 ve öğrenme sırasındaki hataları da alalım mı sorusunun cevabı son parametre 32 | nnf.Test(patterns) //Testi başlat 33 | 34 | // Çıktıda -> önceki kısım test verisi, -> dan sonraki kısım o test için elde edilen sonuç ve :dan sonraki kısım beklenen sonuçtur. 35 | 36 | inputs := []float64{4, 2} //Girdiğimiz değerler için bir tahminleme yaptırıp sonucunu bastırıyoruz 37 | result := nnf.Update(inputs) 38 | fmt.Println(result) 39 | } 40 | -------------------------------------------------------------------------------- /Bonus/ProtoBuf/Southwind.proto: -------------------------------------------------------------------------------- 1 | syntax="proto3"; 2 | package Southwind; 3 | 4 | enum PlayerType{ 5 | SEMI=0; 6 | PRO=1; 7 | MASTER=2; 8 | } 9 | 10 | message Player{ 11 | string nickName=1; 12 | int32 playerId=2; 13 | PlayerType type=3; 14 | 15 | message Weapon{ 16 | string name=4; 17 | string ability=5; 18 | } 19 | 20 | repeated Weapon weapons=6; 21 | } 22 | 23 | message Game{ 24 | repeated Player player=1; 25 | } -------------------------------------------------------------------------------- /Bonus/ProtoBuf/client.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | 6 | data "message/Southwind" 7 | 8 | "github.com/golang/protobuf/proto" 9 | ) 10 | 11 | func main() { 12 | taverna := data.Game{Player: []*data.Player{ 13 | { 14 | NickName: "Leksar", 15 | PlayerId: 10, 16 | Type: data.PlayerType_SEMI, 17 | Weapons: []*data.Player_Weapon{ 18 | {Name: "Sword", Ability: "High level sword"}, 19 | {Name: "Machine Gun", Ability: "7.65mm"}, 20 | }, 21 | }, 22 | { 23 | NickName: "Valira", 24 | PlayerId: 12, 25 | Type: data.PlayerType_SEMI, 26 | Weapons: []*data.Player_Weapon{ 27 | {Name: "Poison Bottle", Ability: "Dangeres green"}, 28 | }, 29 | }, 30 | }, 31 | } 32 | sData, err := proto.Marshal(&taverna) 33 | if err != nil { 34 | fmt.Println(err.Error()) 35 | } else { 36 | fmt.Println(sData) 37 | fmt.Println(string(sData)) 38 | } 39 | 40 | dsData := &data.Game{} 41 | err = proto.Unmarshal(sData, dsData) 42 | if err != nil { 43 | fmt.Println(err.Error()) 44 | } else { 45 | for _, p := range dsData.Player { 46 | fmt.Println(p.NickName) 47 | for _, w := range p.Weapons { 48 | fmt.Printf("\t%s\t%s\n", w.Name, w.Ability) 49 | } 50 | } 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /Bonus/Testing/operations.go: -------------------------------------------------------------------------------- 1 | package operations 2 | 3 | import ( 4 | "math" 5 | ) 6 | 7 | func CircleSpace(r float32) float32 { 8 | return math.Pi * (r * r) 9 | } 10 | 11 | func Sum(numbers ...int) int { 12 | var total int = 0 13 | for _, n := range numbers { 14 | total += n 15 | } 16 | return total 17 | } 18 | -------------------------------------------------------------------------------- /Bonus/Testing/operations_test.go: -------------------------------------------------------------------------------- 1 | package operations 2 | 3 | import ( 4 | "testing" 5 | ) 6 | 7 | func TestCircleSpace(t *testing.T) { 8 | //var expected float32 = 314.159271 9 | var expected float32 = 314.15 10 | calculated := CircleSpace(10) 11 | if expected != calculated { 12 | t.Errorf("Test Fail : Calculated [%f]\tExpected [%f]\n", calculated, expected) 13 | } 14 | } 15 | 16 | func TestSum(t *testing.T) { 17 | //expected := 13 18 | expected := -1 19 | calculated := Sum(3, 4, 1, 5) 20 | if expected != calculated { 21 | t.Errorf("Test Fail : Calculated [%d]\tExptected [%d]\n", calculated, expected) 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /Bonus/UseWithRuby/SomeMath.go: -------------------------------------------------------------------------------- 1 | /* 2 | Bir go kütüphanesini shared library olarak derleyip 3 | Ruby kodundan kullanma 4 | Konu detayı için http://www.buraksenyurt.com/post/golang-bir-go-paketini-ruby-den-cagirmak 5 | */ 6 | 7 | package main 8 | 9 | import "C" 10 | 11 | import ( 12 | "math" 13 | ) 14 | 15 | //export CircleSpace 16 | func CircleSpace(r float64) float64 { 17 | return math.Pi * math.Pow(r, 2) 18 | } 19 | 20 | func main() {} 21 | -------------------------------------------------------------------------------- /Bonus/UseWithRuby/client.rb: -------------------------------------------------------------------------------- 1 | require 'ffi' 2 | 3 | module SomeMath 4 | extend FFI::Library 5 | 6 | ffi_lib './SomeMath.so' 7 | 8 | attach_function :CircleSpace, [:double], :double 9 | end 10 | 11 | puts SomeMath.CircleSpace(10) -------------------------------------------------------------------------------- /Bonus/Work with Redis/samples.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "strconv" 6 | 7 | "github.com/mediocregopher/radix.v2/redis" 8 | ) 9 | 10 | func main() { 11 | //AddAndReadHash() 12 | //AddLudwig() 13 | //aragorn := Card{NickName: "Aragorn", Greetings: "Well Met!", Price: 9, Attack: 10, Defense: 12, Owner: "Luktar"} 14 | //AddCard(aragorn, "card:45") 15 | card := GetCard("card:100") 16 | card.ToString() 17 | } 18 | 19 | //func AddAndReadHash() { 20 | // conn, err := redis.Dial("tcp", "localhost:6379") 21 | // if err != nil { 22 | // fmt.Println(err.Error()) 23 | // } else { 24 | // defer conn.Close() 25 | // response := conn.Cmd("HMSET", "card:93", "nickName", "murlock", "greetings", "I'am ready, I'am not ready", "price", 5, "attack", 4, "defense", 4, "owner", "shammon") 26 | // if response.Err != nil { 27 | // fmt.Println(response.Err) 28 | // } 29 | // fmt.Println(response.String()) 30 | // read, _ := conn.Cmd("HGETALL", "card:93").Map() 31 | // for k, v := range read { 32 | // fmt.Printf("%s\t%s\n", k, v) 33 | // } 34 | // } 35 | //} 36 | 37 | //func AddLudwig() { 38 | // conn, err := redis.Dial("tcp", "localhost:6379") 39 | // if err != nil { 40 | // fmt.Println(err.Error()) 41 | // } else { 42 | // defer conn.Close() 43 | // pong := conn.Cmd("ping") 44 | // fmt.Println(pong.String()) 45 | 46 | // response := conn.Cmd("set", "players:ludwig", "{\"nick\":ludwig,\"genre\":classic,\"SongCount\":98}") 47 | // if response.Err != nil { 48 | // fmt.Println(response.Err) 49 | // } 50 | // fmt.Println(response.String()) 51 | // } 52 | //} 53 | 54 | func AddCard(card Card, id string) { 55 | conn, err := redis.Dial("tcp", "localhost:6379") 56 | if err != nil { 57 | fmt.Println(err.Error()) 58 | } else { 59 | defer conn.Close() 60 | 61 | response := conn.Cmd("HMSET", id, "nickName", card.NickName, "greetings", card.Greetings, "price", card.Price, "attack", card.Attack, "defense", card.Defense, "owner", card.Owner) 62 | if response.Err != nil { 63 | fmt.Println(response.Err) 64 | } 65 | fmt.Println(response.String()) 66 | } 67 | } 68 | 69 | func GetCard(id string) *Card { 70 | card := new(Card) 71 | conn, err := redis.Dial("tcp", "localhost:6379") 72 | if err != nil { 73 | fmt.Println(err.Error()) 74 | } else { 75 | defer conn.Close() 76 | response, _ := conn.Cmd("HGETALL", id).Map() 77 | if response != nil { 78 | card.NickName = response["nickName"] 79 | card.Greetings = response["greetings"] 80 | card.Owner = response["owner"] 81 | card.Attack, _ = strconv.Atoi(response["attack"]) 82 | card.Price, _ = strconv.Atoi(response["price"]) 83 | card.Defense, _ = strconv.Atoi(response["defense"]) 84 | } 85 | } 86 | return card 87 | } 88 | 89 | func (card *Card) ToString() { 90 | fmt.Printf("Nickname:%s\n", card.NickName) 91 | fmt.Printf("Greetings:%s\n", card.Greetings) 92 | fmt.Printf("Owner:%s\n", card.Owner) 93 | fmt.Printf("Price:%d\n", card.Price) 94 | fmt.Printf("Attack:%d\n", card.Price) 95 | fmt.Printf("Defense:%d\n", card.Defense) 96 | } 97 | 98 | type Card struct { 99 | NickName string 100 | Greetings string 101 | Price int 102 | Attack int 103 | Defense int 104 | Owner string 105 | } 106 | -------------------------------------------------------------------------------- /Cover.JPG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/buraksenyurt/golangsamples/0d02cb4e3b9673ccf6100526772d17ebee78bc5a/Cover.JPG -------------------------------------------------------------------------------- /Lesson_01.go: -------------------------------------------------------------------------------- 1 | /* 2 | // Lesson_01 3 | Merhaba Dünya 4 | Temel değişken tanımlamaları 5 | */ 6 | package main 7 | 8 | // Uygulamada kullanacağımız paket bildirimleri 9 | import ( 10 | "fmt" 11 | "reflect" 12 | ) 13 | 14 | //birden fazla sabit değer tanımı 15 | const ( 16 | izmir = 35 17 | istanbul = 34 18 | ) 19 | 20 | // Uygulamanın giriş noktası her zaman main fonksiyonudur(entry point) 21 | func main() { 22 | fmt.Println("Merhaba. Benim adım Gopher!\nŞimdi temel tipleri görelim.") 23 | fmt.Println("Şu an\t", izmir, "\tplakalı bir ilden yazıyorum") 24 | var x, y int //önce değişken adı sonra tipi 25 | x = 4 26 | y = x + 8 27 | z := x + y //dinamik değişken ataması. z'nin tipini belirtmeden atadık. 28 | fmt.Println("Sayıların toplamı", z) 29 | 30 | var cap float32 = 3.89 31 | var alan = 3.14 * ((cap / 2) * (cap / 2)) 32 | fmt.Println("Dairenin alanı", alan) 33 | 34 | var ad string = "jan\tclaud\n" //kaçış karakterlerinin kullanımı 35 | var soyad string = "van\tdam" 36 | fmt.Println(ad + soyad) 37 | 38 | var isim, parola, email bool 39 | isim = true 40 | parola = false 41 | email = true 42 | fmt.Println(isim && parola && email) // Mantıksal ve kullanımı 43 | fmt.Println(isim || parola || email) // Mantıksal veya kullanımı 44 | fmt.Println("İstanbul" == "Ankara") //Eşitlik kullanımı 45 | 46 | const pi float32 = 3.1415 47 | fmt.Println(pi) 48 | 49 | birDeger := false 50 | 51 | //bir değişkenin tipini anlamak için reflect paketinin TypeOf fonksiyonu kullanılabilir 52 | fmt.Println(reflect.TypeOf(pi), reflect.TypeOf(birDeger)) 53 | } 54 | -------------------------------------------------------------------------------- /Lesson_02.go: -------------------------------------------------------------------------------- 1 | /* 2 | Lesson_02 3 | Temel for kullanımı 4 | if ve switch case kullanımı 5 | */ 6 | package main 7 | 8 | import ( 9 | "fmt" 10 | ) 11 | 12 | // Go dilinde sadece for döngüsü varmış biliyor muydunuz? :) 13 | func main() { 14 | //1 ile 100 arasındaki sayılardan iki ile bölünebilenlerin toplamı 15 | toplam := 0 16 | for i := 0; i < 100; i++ { 17 | if i%2 == 0 { //Mod operatörü ile kalan hesaplanır 18 | toplam += i 19 | } 20 | } 21 | fmt.Println("2 ile bölünebilenlerin toplamı=", toplam) 22 | 23 | // While döngüsünün GO dilinde for ile yapılışı 24 | // 3 ile bölünebilen sayıların toplamı hesap ediliyor 25 | i := 0 26 | toplam = 0 27 | for i < 100 { 28 | i++ 29 | if i%3 == 0 { 30 | toplam += i 31 | } 32 | } 33 | fmt.Println("3 ile bölünebilenlerin toplamı", toplam) 34 | 35 | //sonsuz döngü kurmak istersek bu şekilde 36 | //for { 37 | 38 | //} 39 | 40 | var t1, t2, t3 int 41 | 42 | for i := 0; i < 100; i++ { 43 | if i%2 == 0 { 44 | t2++ 45 | } else if i%3 == 0 { 46 | t3++ 47 | } else { 48 | t1++ 49 | } 50 | } 51 | fmt.Printf("1 ile 100 arasında 2 ile bölünebilen %d sayı\n3 ile bölünebilen %d sayı var. Diğer kalan %d\n", t1, t2, t3) 52 | 53 | // switch case kullanımı 54 | // sinav_notu değerine göre ekrana bir bilgi yazılıyor 55 | sinav_notu := 46 56 | switch { 57 | case sinav_notu >= 0 && sinav_notu < 45: 58 | fmt.Println("üzgünüm ama sınıfta kaldın") 59 | case sinav_notu >= 45 && sinav_notu < 50: 60 | fmt.Println("Himmm bir kannat notu kullansam iyi olacak") 61 | case sinav_notu >= 50 && sinav_notu < 75: 62 | fmt.Println("Yeterli bir not görünüyor") 63 | case sinav_notu >= 75 && sinav_notu <= 100: 64 | fmt.Println("Güzelll") 65 | default: //Yukarıdaki koşullardan hiçbirisine uyulmadıysa 66 | fmt.Println("Sanki geçerli bir aralıkta değil gibisin") 67 | } 68 | } 69 | -------------------------------------------------------------------------------- /Lesson_03.go: -------------------------------------------------------------------------------- 1 | /* 2 | // Lesson_03 3 | Array, Slice, Map kullanımları 4 | Array'ler de boyut sabittir 5 | Slice'lar dinamik boyutludur. Kapasiteleri belirlenebilir. 6 | Map tipleri key:value veri modeline uygun şekilde kullanılır 7 | range fonskiyonu ile bir dizi,kesit veya harita'yı for döngüsü ile kullanabiliriz 8 | _ ile istersek bir fonksiyondan dönen değeri kullanmayacağımızı ifade edebiliriz 9 | */ 10 | package main 11 | 12 | import ( 13 | "encoding/json" //Basit json serileştirme için kullanacağımız paket 14 | "fmt" 15 | "reflect" 16 | ) 17 | 18 | func main() { 19 | // 82 elemanlı şehirler dizisi tanımladık 20 | var sehirler [81]string 21 | sehirler[34] = "istanbul" 22 | sehirler[6] = "Ankara" 23 | sehirler[16] = "Bursa" 24 | sehirler[35] = "İzmir" 25 | 26 | fmt.Println(len(sehirler)) //len ile dizinin eleman sayısını bulabiliriz. 27 | 28 | //indis bazlı olacak şekilde tüm şehirleri dolaşıyoruz. 29 | for i := 0; i < len(sehirler); i++ { 30 | if sehirler[i] != "" { 31 | fmt.Println(sehirler[i]) 32 | } 33 | } 34 | 35 | //bu sefer 5 elemanlı float tipinden bir dizi oluşturduk 36 | adaylar := [5]float32{ 37 | 34, 38 | 55, 39 | 90, 40 | 10, 41 | 88, 42 | } 43 | var toplam float32 44 | var eleman_sayisi = len(adaylar) 45 | fmt.Println(reflect.TypeOf(eleman_sayisi)) //eleman_Sayisi dizisinin tipini yazdırdık. 46 | for i := 0; i < eleman_sayisi; i++ { 47 | toplam += adaylar[i] 48 | } 49 | ortalama := toplam / float32(eleman_sayisi) 50 | fmt.Printf("Ortalama %f\n", ortalama) //adayların not ortalamasını hesap ediyoruz 51 | 52 | // range kullanımına ait örnek 53 | // foreach benzeri bir döngü oluşuyor 54 | isimler := [4]string{"jan", "claud", "van", "dam"} 55 | for i, isim := range isimler { 56 | fmt.Printf("%d\t->\t%s\n", i, isim) 57 | } 58 | 59 | var basarililar int = 0 60 | puanlar := [5]int{34, 55, 23, 90, 98} 61 | for _, puan := range puanlar { 62 | if puan >= 50 { 63 | basarililar++ 64 | } 65 | } 66 | fmt.Printf("Başarılı %d öğrenci var\n", basarililar) 67 | 68 | // iki boyutlu bir dizi örneği. 3X2lik bir matris oluşturduk. 69 | matris := [3][2]int{{2, 3}, {6, 1}, {-9, 8}} 70 | for i := 0; i < 3; i++ { 71 | for j := 0; j < 2; j++ { 72 | fmt.Printf("%d\t", matris[i][j]) 73 | } 74 | fmt.Println() 75 | } 76 | 77 | //Örnek bir slice tanımı. string elemanlardan oluşuyor 78 | oyuncu_adlari := []string{"mayk", "miki", "lora", "clara", "zorro", "dam", "edriyın", "raki", "barbarossa"} 79 | // indis değerlerini ele almadık. _ operatörü ile. 80 | // sadece value'ları işliyoruz. Yani string içerikleri 81 | for _, value := range oyuncu_adlari { 82 | fmt.Println(value) 83 | } 84 | fmt.Println() 85 | //alt_kume := oyuncu_adlari[3:6] 86 | alt_kume := oyuncu_adlari[6:] 87 | //: işareti ile bir diziden veya kesittten alt kesitler alabiliriz. 88 | // Baştan itibaren, sondan itibaren veya iki rakam arasındaki kısımlardan 89 | alt_kume = append(alt_kume, "hera") //append ile slice sonuna eleman eklenebilir 90 | alt_kume = append(alt_kume, "sizar") 91 | for _, value := range alt_kume { 92 | fmt.Println(value) 93 | } 94 | var iller []string 95 | iller = make([]string, 5, 10) //5 eleman içeren 10a kadar genişleyebilen kesit. Eleman sayısı ve başlangıç kapasitesini belirttik 96 | iller[0] = "istanbul" 97 | iller[1] = "izmir" 98 | iller[2] = "ankara" 99 | iller[3] = "bursa" 100 | iller[4] = "gaziantep" 101 | iller = append(iller, "trabzon") 102 | for i := 0; i < len(iller); i++ { 103 | fmt.Printf("%d:%s\n", i, iller[i]) 104 | } 105 | for i, il := range iller { 106 | fmt.Printf("%d:%s\n", i, il) 107 | } 108 | 109 | // Basit bir map tanımlaması 110 | // key ve value içerikleri string tipten olacaklar 111 | sozluk := make(map[string]string) 112 | sozluk["white"] = "beyaz" 113 | sozluk["black"] = "siyah" 114 | sozluk["red"] = "kirmizi" 115 | sozluk["blue"] = "mavi" 116 | for key, value := range sozluk { //hem key hem de value değerlerini alıyoruz. 117 | fmt.Printf("[%s:%s]\n", key, value) 118 | } 119 | // sozluk map içeriğini json formatına dönüştürüyoruz ve ekrana basıyoruz 120 | jsonContent, _ := json.MarshalIndent(sozluk, "", " ") 121 | fmt.Println(string(jsonContent)) 122 | 123 | //Bu sefer key içerikleri string value içerikleri int olan 124 | //bir map değişkeni tanımlandı 125 | envanvter := map[string]int{ 126 | "Laptop": 34, 127 | "Desktop": 5, 128 | "Tablet": 12, 129 | "Cep Telefonu": 34, 130 | } 131 | // Envanterdeki toplam cihaz sayısını buluyoruz. 132 | var toplam_cihaz int = 0 133 | for _, value := range envanvter { 134 | toplam_cihaz += value 135 | } 136 | fmt.Printf("Envanterde %d cihaz var\n", toplam_cihaz) 137 | } 138 | -------------------------------------------------------------------------------- /Lesson_04.go: -------------------------------------------------------------------------------- 1 | /* 2 | Lesson_04 3 | Fonksiyonlar 4 | */ 5 | package main 6 | 7 | import ( 8 | "fmt" 9 | ) 10 | 11 | func main() { 12 | fmt.Println("Fonksiyonları tanıyalım") 13 | toplam := Topla(4, 5) 14 | fmt.Println(toplam) 15 | a, b, c, d := DortIslem(3, 2) 16 | fmt.Printf("%f\t%f\t%f\t%f\n", a, b, c, d) 17 | fmt.Println(CokluToplam(1, 2, 3, 4, 5)) 18 | fmt.Println(CokluToplam(125, 2, 3, 4, 7, -9, 0, 12, 4, 5, 90, 2, -6)) 19 | sayiSlice := []int{3, 7, 1, 9, 10} 20 | fmt.Println(SliceToplam(sayiSlice)) 21 | sozluk := map[string]string{ 22 | "black": "kara", 23 | "white": "beyaz", 24 | "gold": "altın", 25 | } 26 | map_yazdir(sozluk) 27 | fmt.Println(Faktoryel(10)) 28 | 29 | //iç içe fonksiyon tanımlanabilir. 30 | //Yani bir fonksiyon içerisinde fonksiyon tanımlayıp kullanabiliriz 31 | var puan int 32 | fmt.Println("Aldığınız puanı girer misiniz?") 33 | fmt.Scanln(&puan) 34 | //geriye bool döndüren bir iç fonksiyon tanımladık 35 | puan_kontrol_fonksiyon := func(d int) bool { 36 | if d <= 50 { 37 | return false 38 | } 39 | return true 40 | } 41 | fmt.Println(puan_kontrol_fonksiyon(puan)) 42 | } 43 | 44 | // En basit haliyle bir fonksiyon tanımı 45 | func Topla(x, y int) int { 46 | return x + y 47 | } 48 | 49 | // Bir fonksiyondan birden fazla değer döndürebiliriz 50 | // Hatta dönüş değişkenlerini adlandırabilir ve fonskiyon içerisinde 51 | // Bu isimlerle kullanabiliriz 52 | func DortIslem(x, y float32) (toplam, carpim, bolum, fark float32) { 53 | toplam = x + y 54 | carpim = x * y 55 | bolum = x / y 56 | fark = x - y 57 | return toplam, carpim, fark, bolum 58 | } 59 | 60 | // Bir fonksiyona n sayıda parametrede gönderebiliriz(Variadic fonksiyon) 61 | func CokluToplam(sayilar ...int) int { 62 | toplam := 0 //toplam değişkenini dönüş parametre adı olarak da tanımlayabilirdik. DortIslem fonksiyonundaki gibi 63 | for _, sayi := range sayilar { 64 | toplam += sayi 65 | } 66 | return toplam 67 | } 68 | 69 | // Fonksiyon parametresi olarak Array, Slice, Map'de kullanabiliriz 70 | func SliceToplam(sayilar []int) (toplam int) { 71 | for _, sayi := range sayilar { 72 | toplam += sayi 73 | } 74 | return toplam 75 | } 76 | 77 | func map_yazdir(icerik map[string]string) { 78 | for k, v := range icerik { 79 | fmt.Printf("%s\t%s\n", k, v) 80 | } 81 | } 82 | 83 | // Standart recursive(Özyinelemeli) fonksiyon örneği 84 | func Faktoryel(sayi int) int { 85 | if sayi == 0 || sayi == 1 { 86 | return 1 87 | } else { 88 | return sayi * Faktoryel(sayi-1) 89 | } 90 | } 91 | -------------------------------------------------------------------------------- /Lesson_05.go: -------------------------------------------------------------------------------- 1 | /* 2 | Lesson_05 3 | defer kullanımı 4 | bir fonksiyon tamamlanmadan hemen önce çalıştırılmasını istediğimiz fonksiyonlar için kullanırız 5 | */ 6 | package main 7 | 8 | import ( 9 | "fmt" 10 | ) 11 | 12 | func main() { 13 | fmt.Println("main başlangıcı") 14 | sonuc := dosya_sifrele("bilgiler.dat") 15 | fmt.Println(sonuc) 16 | fmt.Println("main bitişi") 17 | fmt.Println(dosya_ayristir("urunler.json")) 18 | } 19 | 20 | func dosya_sifrele(dosya string) bool { 21 | defer dosyayi_kapat(dosya) // sonra bu çalışır 22 | defer bellegi_temizle() // fonksiyondan çıkılırken önce bu 23 | fmt.Println("Şifreleme operasyonu yapılıyor") 24 | return true 25 | } 26 | 27 | func dosyayi_kapat(dosya string) { 28 | fmt.Println("kalan veriler dosyaya yazilip kapatiliyor") 29 | } 30 | func bellegi_temizle() { 31 | fmt.Println("Ön bellek temizleniyor") 32 | } 33 | func dosya_ayristir(dosya string)string{ 34 | //defer operasyonları iç fonksiyon olarak da tanımlanabilir 35 | defer func(){ 36 | fmt.Printf("%s için gerekli kapatma operasyonları yapılacaktır\n",dosya) 37 | }() 38 | fmt.Println("Dosya açılıyor...") 39 | fmt.Println("Ayrıştırma işlemi yapılıyor") 40 | return "operasyon başarılı" 41 | } 42 | 43 | //defer genellikle panic oluşma hallerinde de ele alınır. 44 | //panic durumlarında defer ile işaret edilen fonksiyon veya fonksiyon bloğu 45 | //otomatik olarak çalışır. try...catch...finally'deki finally gibi işlem görür 46 | // diyebiliriz. 47 | -------------------------------------------------------------------------------- /Lesson_06.go: -------------------------------------------------------------------------------- 1 | /* 2 | Lesson_06 3 | panic recover defer kullanımı 4 | */ 5 | package main 6 | 7 | import ( 8 | "fmt" 9 | ) 10 | 11 | func main() { 12 | // main içerisinden çıkılırkan bu iç fonksiyon devreye girecektir 13 | //eğer bir hata varsa içeride yakalanıp ekrana basılır 14 | defer func() { 15 | err := recover() //bir hata varsa yakalayalım 16 | if err != nil { 17 | fmt.Printf("Ana program fonksiyonunda hata oluştu\n\tError:%s\n", err) 18 | } 19 | }() 20 | 21 | fmt.Println("Uygulama başlıyor") 22 | sonuc := baglan("net.tcp://localhost:9023/services/data") 23 | fmt.Println(sonuc) //panic nedeniyle return sonuc çalışmayacağından sonuc boş dönecektir 24 | 25 | sayilar := make([]int, 5) //5 elamanlı tanımladığımız slice 26 | sayilar[6] = 100 //olmayan bir indise eleman atamaya çalışıyoruz. Built-in runtime hatası oluşacaktır 27 | sayilar[1] = 90 28 | fmt.Println("Ana program sonu") //main'deki hata nedeniyle burası hiç çalışmayacak 29 | //slice'a hata olmayacak şekilde değer atayıp tekrar deneyin 30 | } 31 | 32 | func baglan(conStr string) string { 33 | defer func() { // defer ile hata oluştuğunda devreye girecek son operasyonu işaret edebiliriz 34 | err := recover() //hatayı yakalayalım 35 | if err != nil { //eğer bir hata varsa 36 | fmt.Printf("Servis bağlantı hatası\n\tError:%s\n", err) //err mesajı panic ile ürettiğimiz mesaj olacaktır 37 | //loglama yapılabilir 38 | } 39 | }() 40 | 41 | //normal kod satırları 42 | fmt.Println("Bağlantı açılıyor") 43 | panic("Bağlantı yapılırken hata oluştu") //sembolik olarak bir hata fırlatıldı 44 | return "durum bilgisi" 45 | } 46 | -------------------------------------------------------------------------------- /Lesson_07.go: -------------------------------------------------------------------------------- 1 | /* 2 | Lesson_07 3 | Basit pointer kullanımı 4 | */ 5 | package main 6 | 7 | import ( 8 | "fmt" 9 | ) 10 | 11 | func main() { 12 | var point int = 41 13 | fmt.Println(&point) 14 | // & ile değişken adresini yakalayabiliriz 15 | fmt.Printf("%d sayısının bellek adresi %x dir\n", point, &point) 16 | pntr := &point // point değişkeninin bellek adresini aldık 17 | fmt.Println(pntr, " adresindeki sayı", *pntr) //* operatörü ile pointer'ın işaret ettiği alandaki değer yakalanabilir 18 | 19 | newLocation := pntr //Pointer'ı başka bir pointer değişkenine atayabiliriz. 20 | *newLocation = 99 //newLocation ve pntr aynı bellek adresini işaret ediyorlar. Bu yüzden birisindeki değişim diğerini de etkileyecektir 21 | fmt.Println("Bellek adresleri pntr=>", pntr, " newLocation=>", newLocation) 22 | fmt.Println("Atama sonrası değerler\npntr=", *pntr, " newLocation=", *newLocation) 23 | 24 | lucky_number := 7 25 | calculate(&lucky_number) 26 | fmt.Println("Lucky Number = ", lucky_number) 27 | 28 | stk := Stock{125, 25} // Stock bir struct'tır. Value Type olarak çalışır. Ama pointer yardımıyla fonksiyonlara referans tipi olarak geçirilebilir 29 | increase_Stock_By_Fifty(&stk) 30 | fmt.Printf("Stock min %f max %f\n", stk.low, stk.high) 31 | } 32 | 33 | func calculate(number *int) { 34 | //fonksiyonlara parametre olarak pointer verebiliriz. 35 | //Böylece fonksiyon içerisinde değişken kopyası oluşturmak yerine 36 | //referans adresi taşıdığımızdan daha optimize ve bellek dostu kod üretmiş olabiliriz 37 | fmt.Println("Fonksiyona gelen adres ", number, "\nDeğişken değeri ", *number) 38 | *number += 100 //şimdi gelen pointer üzerinden değer değişikliği yaptık. Buna göre calculate'i çağırdığımız main fonksiyonundaki lucky_number içeriği de değişmiş olur 39 | 40 | some_points := []float32{3.4, 2.1, 1.98, -4} 41 | do_something(some_points) //slice'lar referans tipidir. Bu yüzden fonksiyonlara parametre olarak geçtiklerinde ilgili fonksiyonda yapılacak değişiklikler orjinal konumlarındakini de etkiler 42 | for _, p := range some_points { 43 | fmt.Println(p) 44 | } 45 | } 46 | 47 | //points bir slice ve referans türü 48 | func do_something(points []float32) { 49 | for i, point := range points { 50 | points[i] = point + 1 //buradaki değişiklik some_points üzerinde de etkili olacaktır 51 | } 52 | } 53 | 54 | type Stock struct { 55 | high float64 56 | low float64 57 | } 58 | 59 | func increase_Stock_By_Fifty(stock *Stock) { 60 | stock.high += 50 //calculate fonksiyonunda parametre değerini değiştirirken kullandığımız * operatörü burada kullanılmamıştır dikkat edelim 61 | stock.low += 50 62 | } 63 | -------------------------------------------------------------------------------- /Lesson_08.go: -------------------------------------------------------------------------------- 1 | /* 2 | Lesson_08 3 | Temel struct kullanımı 4 | ve metodlar 5 | */ 6 | package main 7 | 8 | import ( 9 | "fmt" 10 | ) 11 | 12 | func main() { 13 | //struct' ları farklı şekillerde üretebiliriz. 14 | // var ile tanımlayıp niteliklerine sonradan değer atayabiliriz 15 | var veyron Vehicle 16 | veyron.id = 1 17 | veyron.name = "bugatti veyron" 18 | veyron.color = "black" 19 | 20 | // yine var ile tanımlayıp niteliklerine o anda değer atayabiliriz 21 | var gayyardo Vehicle = Vehicle{2, "lamborghini gayyardo", "gold"} 22 | 23 | // dinamik olarak tanımlarken atayabiliriz 24 | sesto := Vehicle{id: 3, name: "ferrari testo elemento", color: "red"} 25 | 26 | write_vehice_to_console(&veyron) 27 | write_vehice_to_console(&gayyardo) 28 | write_vehice_to_console(&sesto) 29 | 30 | // Vehicle tipinden bir slice tanımlıyoruz 31 | var some_vehicles []Vehicle 32 | // append fonksiyonu yardımıyla slice içerisine Vehicle örneklerini ekliyoruz 33 | some_vehicles = append(some_vehicles, sesto) 34 | some_vehicles = append(some_vehicles, gayyardo) 35 | some_vehicles = append(some_vehicles, veyron) 36 | write_all_vehicle_to_console(some_vehicles) //slice içeriğini fonksiyona parametre olarak geçiyoruz 37 | 38 | veyron.move(12, 10, -8) // veyron isimli yapı örneği üzerinden move metodunu kullanıyoruz 39 | for _, vehicle := range some_vehicles { 40 | vehicle.move(-3, 4, 10) // some_vehicles slice'ı içerisindeki tüm Vehicle nesneleri üzerinden move metodunu çağırıyoruz 41 | } 42 | 43 | var motto word = "it's a lovely day" // word aslında string türünden bir type 44 | fmt.Println(motto.write_with_space()) // word tipine eklediğimiz(dolayısıyla string türüne) write_with_space metodunu kullandık 45 | } 46 | 47 | // fonksiyonlara struct tipini pointer üzerinden aktardık 48 | func write_vehice_to_console(v *Vehicle) { 49 | fmt.Printf("(%d)-%s,%s\n", v.id, v.name, v.color) 50 | } 51 | 52 | func write_all_vehicle_to_console(vehicles []Vehicle) { 53 | for _, vehicle := range vehicles { 54 | write_vehice_to_console(&vehicle) 55 | } 56 | } 57 | 58 | // id, name ve color nitelikleri olan bir struct tanımladık 59 | type Vehicle struct { 60 | id int 61 | name, color string 62 | } 63 | 64 | // move isimli bir metod(kavramsal olarak fonksiyon değil metod ismini kullandığımıza dikkat edelim) oluşturduk 65 | // Bu metod Vehicle tipinden yapılara uygulanabiliyor 66 | func (vehicle Vehicle) move(x, y, z int) { 67 | fmt.Printf("%s, (%d:%d:%d) lokasyonuna gidiyor\n", vehicle.name, x, y, z) 68 | } 69 | 70 | // metodları built-in tiplere de uygulayabiliriz 71 | type word string 72 | 73 | // word tipine(dolayısıyla string türüne) uygulayabileceğimiz bir metod 74 | func (content word) write_with_space() string { 75 | var result string 76 | for _, c := range content { 77 | result = result + string(c) + " " //c ile metindeki her bir harfi işare edebiliriz. string dönüşümüne dikkat 78 | } 79 | return result //geriye string içeriğinin harfleri arasına boşluk konulmuş bir içerik döndürür 80 | } 81 | -------------------------------------------------------------------------------- /Lesson_09.go: -------------------------------------------------------------------------------- 1 | /* 2 | Lesson 09 3 | Embedded type kullanımı 4 | gömülü türlerden yararlanarak çoklu türetme özelliğini kullanabiliriz 5 | */ 6 | package main 7 | 8 | import ( 9 | "fmt" 10 | ) 11 | 12 | func main() { 13 | var zidane FootballPlayer 14 | zidane.self = Player{id: 10, nickName: "Zinadine Zidane"} 15 | zidane.position = "Midfield" 16 | zidane.abilities = []Ability{ 17 | Ability{name: "shoot", power: 92}, 18 | Ability{name: "high pass", power: 84}, 19 | } 20 | zidane.abilities[1].useAbility() 21 | zidane.self.saySomething("What can I do sometimes. This is football.") 22 | zidane.abilities[0].useAbility() 23 | 24 | var tayson Boxer 25 | tayson.self = Player{id: 88, nickName: "Bulldog"} 26 | tayson.knockdownCount = 32 27 | tayson.abilities = []Ability{ 28 | Ability{name: "defense", power: 76}, //virgül koymayınca derleme hatası verir ;) 29 | } 30 | tayson.self.saySomething("I will win this game") 31 | tayson.abilities[0].useAbility() 32 | } 33 | 34 | // oyuncuların ortak niteliklerini barındıran bir struct 35 | type Player struct { 36 | id int 37 | nickName string 38 | } 39 | 40 | // player yapısına monte edilmiş saySomething metodu 41 | // oyuncunun bir şeyler söylemesi için kullanılabilecek bir metod 42 | func (player *Player) saySomething(message string) { 43 | fmt.Printf("%s says that '%s'\n", player.nickName, message) 44 | } 45 | 46 | // oyuncuların farklı yeteneklerini tanımlayacak olan Ability isimli yapı 47 | type Ability struct { 48 | name string 49 | power int 50 | } 51 | 52 | // Ability yapısına monte edilmiş olan useAbility isimli bir metod 53 | // oyuncunun bir yeteneğini kullandırmak için 54 | func (ability *Ability) useAbility() { 55 | fmt.Printf("[%s] yeteneği kullanılıyor. Güç %d\n", ability.name, ability.power) 56 | } 57 | 58 | // Player ve Ability yapılarını gömülü tip olarak kullanan ve 59 | // futbolcuları tanımlayan yapı 60 | type FootballPlayer struct { 61 | position string 62 | self Player 63 | abilities []Ability 64 | } 65 | 66 | // farklı bir oyuncu tipi 67 | type Boxer struct { 68 | knockdownCount int 69 | self Player 70 | abilities []Ability 71 | } 72 | -------------------------------------------------------------------------------- /Lesson_10.go: -------------------------------------------------------------------------------- 1 | /* 2 | Lesson_10 3 | interface kullanımı 4 | Bir interface yardımıyla metod bazlı sözleşmeler(contract) sunabiliriz 5 | */ 6 | package main 7 | 8 | import ( 9 | "fmt" 10 | ) 11 | 12 | func main() { 13 | vosvos := Car{id: 10, name: "Orange Vos Vos"} 14 | cesna := Plane{id: 900, owner: "Chesna", maxAltitude: 3000} 15 | pejo205 := Car{id: 12, name: "Pejo 205 GTI"} 16 | 17 | startVehicleEngine(vosvos) 18 | startVehicleEngine(cesna) 19 | startVehicleEngine(pejo205) 20 | 21 | // allTeam isimli slice içerisinde Car ve Plane tipli yapı örnekleri bulunuyor 22 | allTeam := []VehicleContract{ 23 | vosvos, 24 | Car{id: 2, name: "Little Dori FSI"}, 25 | cesna, 26 | pejo205, 27 | Plane{id: 16, owner: "Loched Martin", maxAltitude: 35000}, 28 | } 29 | // tüm üyelerinde dolaşıp o anki yapı örneği kimse onun için startEngine metodunun çalıştırılması sağlanabilir 30 | for _, member := range allTeam { 31 | startVehicleEngine(member) 32 | } 33 | } 34 | 35 | // bu interface sözleşmesi startEngine isimli bir metod sunuyor 36 | // yapılarda da bu metod tanımlanırsa 37 | // startVehicleEngine metoduna parametre olarak ilgili yapılar da gönderilebilir 38 | // nitekim ilgili yapılar sözleşmenin belirttiği metodu uygulamışlardır 39 | type VehicleContract interface { 40 | startEngine() 41 | } 42 | 43 | // Metod parametre olarak VehicleContract arayüzünü alır 44 | // Car ve Plane yapıları arayüzde belirtilen startEngine metodunu uyguladıklarından 45 | // vehicle değişkeni içeride çok biçimli(Polymorphic) yapı gösterebilir 46 | func startVehicleEngine(vehicle VehicleContract) { 47 | vehicle.startEngine() 48 | } 49 | 50 | type Car struct { 51 | id int 52 | name string 53 | } 54 | 55 | // Car yapılarına uygulanabilen startEngine metodu aynı zamanda interface sözleşmesinde de yer alır 56 | func (v Car) startEngine() { 57 | fmt.Printf("'%s' motoru çalıştırıyor\n", v.name) 58 | } 59 | 60 | type Plane struct { 61 | id int 62 | owner string 63 | maxAltitude int 64 | } 65 | 66 | // Plane tipine tanımlanan startEngine metodu yine interface sözleşmesinde yer alan metoddur 67 | func (p Plane) startEngine() { 68 | fmt.Printf("[%s] uçuş öncesi motorlar çalıştırılıyor. Hedef yükseklik %d\n", p.owner, p.maxAltitude) 69 | } 70 | -------------------------------------------------------------------------------- /Lesson_11.go: -------------------------------------------------------------------------------- 1 | /* 2 | Lesson_11 3 | En basit haliyle GoRoutine kullanımı 4 | GoRoutine'ler eş zamanlı çalışan fonksiyonlardır 5 | Bir fonksiyonun eş zamanlı çalışması için go anahtar kelimesi ile çağırılması yeterlidir 6 | */ 7 | package main 8 | 9 | import ( 10 | "fmt" 11 | "time" 12 | ) 13 | 14 | func main() { 15 | go loop1(0, 25) //Bu 3 fonksiyon GoRoutine olarak eş zamanlı çalışırlar 16 | go loop2() 17 | go loop1(-25, -5) 18 | 19 | // Yukarıdaki işlemler bitmeden ana uygulama sonlanabilir. Bunu şu an için önlemek 20 | // ve yukarıdaki işlemlerin bittiğini görmek için ekrandan tuşa basılması beklenir 21 | var enter string 22 | fmt.Println("\nÇıkmak için bir tuşa basınız") 23 | fmt.Scanln(&enter) 24 | } 25 | 26 | func loop1(min, max int) { 27 | for i := min; i < max; i++ { 28 | fmt.Printf("%d", i) 29 | time.Sleep(time.Microsecond * 500) 30 | } 31 | } 32 | func loop2() { 33 | letters := "abcçdefgğhijklmnoöprsştuüvyz" 34 | for _, c := range letters { 35 | fmt.Printf("%s", string(c)) 36 | time.Sleep(time.Millisecond * 550) 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /Lesson_12.go: -------------------------------------------------------------------------------- 1 | /* 2 | Lesson_12 3 | Channels 4 | kanallar yardımıyla GoRoutine'ler arası veya GoRoutine'ler ile çağıran yerler arası 5 | bilgi transferi yapma şansına sahip oluruz 6 | */ 7 | package main 8 | 9 | import ( 10 | "fmt" 11 | "time" 12 | ) 13 | 14 | func main() { 15 | // 1nci örnek en ilkel haliyle kanal kullanımı 16 | 17 | transitInfo := make(chan string) //içerisinden string veri taşınabilecek bir kanal tanımı yapıldı 18 | go func() { //iç fonksiyon tanımladık ve bunu go ile bir GoRoutine haline getirdik 19 | fmt.Println("Burası mapping işlemlerini yapar") 20 | time.Sleep(time.Millisecond * 1000) 21 | transitInfo <- "mapping sonucu uygun 3 donör bulundu" // kanala string bir veri içeriği bırakıyoruz 22 | }() 23 | incomingInfo := <-transitInfo // GoRoutine içerisinden kanala yazılan bilgi <- operatörü ile değişkene atanıyor 24 | fmt.Printf("Map isimli goroutine'den '%s' bilgisi döndü\n", incomingInfo) 25 | close(transitInfo) // kanalı kapatıyoruz 26 | 27 | // 2nci örnek 28 | // oluşturduğumuz kanalı Listener ve Listener içerisindeki iç fonksiyon da ortaklaşa kullanmaktayız 29 | message := make(chan string) 30 | go Listener(message) 31 | input := <-message 32 | fmt.Printf("Listener dedi ki [%s]\n", input) 33 | 34 | close(message) 35 | 36 | // 3ncü örnek 37 | // Dilersek kanallardaki içerik sayısını kısıtlayabilir ve tampon bazlı kullanılmalarını sağlayabiliriz 38 | // Sadece 5 eleman alabilecek bir Channel için 39 | parts := make(chan string, 5) 40 | parts <- "ayakkabılar" 41 | parts <- "ceketler" 42 | parts <- "pantalonlar" 43 | parts <- "bluzlar" 44 | parts <- "çoraplar" 45 | 46 | // döngü içerisinde 5 GoRoutine çağırılıyor ve her birisinde kanaldaki bilgi yakalanıyor 47 | for i := 0; i < 5; i++ { 48 | go func(p chan string) { 49 | value := <-p 50 | fmt.Printf("\t[%s] parçalar işlenecek\n", value) 51 | }(parts) 52 | } 53 | close(parts) 54 | 55 | // 4ncü örnek 56 | // kanallarda yön verilebilir ve tek yönlü çalışacak hale getirilebilir 57 | // Yani sadece mesaj alma veya mesaj gönderme şeklinde kanallar tanımlanabilir 58 | soundChannel := make(chan string, 1) //sadece 1 eleman taşıyacak bir kanal tanımlandı 59 | microphone(soundChannel, "HOLA!") 60 | soundBox(soundChannel, 10, 1500) 61 | 62 | // 5nci örnek 63 | // GoRoutine'lerin senkronizasyonu için kanallardan yararlanılabilir 64 | statusChannel := make(chan bool) 65 | go worker(statusChannel) 66 | <-statusChannel //Burada kanaldan bilgi alınacaya kadar ana iş parçacığını bloklamış olduk. 67 | 68 | var enter string 69 | fmt.Printf("\nÇıkmak için Enter\n") 70 | fmt.Scanln(&enter) 71 | } 72 | 73 | func worker(completed chan bool) { 74 | fmt.Println("Bir takım işlemler yapılıyor") 75 | time.Sleep(time.Millisecond * 2000) 76 | fmt.Println("İşlemler tamamlandı") 77 | completed <- true //burada kanala işlemin bittiğine dair bir mesaj bırakıyoruz 78 | } 79 | 80 | func soundBox(sound <-chan string, volumeLevel int, duration int) { //<-chan nedeniyle kanaldan sadece veri alabilir(kanaldan veri okuyabilir ama yazamaz) 81 | fmt.Printf("Sound is %s.\nLevel = %d\nDuration = %d\n", <-sound, volumeLevel, duration) 82 | } 83 | func microphone(sound chan<- string, message string) { // chan<- nedeniyle sadece veri gönderebilir(kanala veri yazabilir ama okuyamaz) 84 | sound <- message 85 | } 86 | 87 | func Listener(msg chan string) { 88 | msg <- "pong" 89 | go func(chn chan string) { 90 | chn <- "ping" 91 | }(msg) 92 | output := <-msg 93 | fmt.Printf("\tiç fonksiyon dedi ki [%s]\n", output) 94 | } 95 | -------------------------------------------------------------------------------- /Lesson_13.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "encoding/json" 5 | "fmt" 6 | "os" 7 | ) 8 | 9 | func main() { 10 | // json serileştirme için kullanacağımız Game yapısından bir tip tanımlıyoruz 11 | goldZone := Game{ 12 | 5555, 13 | "Mohani Gezegeni Görevi", 14 | []Player{ 15 | Player{100, "deli", "cevat", 10.90}, 16 | Player{102, "nadya", "komenaççi", 12.45}, 17 | Player{103, "biricit", "bardot", 900.45}, 18 | }, 19 | } 20 | 21 | jsonOutput, _ := json.Marshal(goldZone) 22 | fmt.Println(string(jsonOutput)) 23 | 24 | var game Game 25 | if err := json.Unmarshal(jsonOutput, &game); err != nil { 26 | panic(err) 27 | } 28 | 29 | fmt.Printf("Game : %s\n", game.Name) 30 | for _, player := range game.Players { 31 | fmt.Println(player.Id, player.FirstName, player.Point) 32 | } 33 | 34 | // dilersek json sınıfının NewEncoder metodunu kullanarak 35 | // çıktıları farklı yerlere yönlendirebiliriz 36 | // işletim sistemi ekranı veya bir HTTP mesajının gövdesi gibi 37 | encoder := json.NewEncoder(os.Stdout) 38 | encoder.Encode(game) 39 | } 40 | 41 | type Player struct { 42 | Id int `json:"PlayerId"` // İstersek bir alanın JSON çıktısında nasıl adlandırılacağını söyleyebiliriz 43 | FirstName string // Büyük harf public'lik anlamındadır! 44 | lastName string //küçük harfle başlayanlar private'lık kazanır. O yüzden json çıktısına yansımaz 45 | Point float32 46 | } 47 | 48 | type Game struct { 49 | Id int 50 | Name string 51 | Players []Player 52 | } 53 | -------------------------------------------------------------------------------- /Lesson_14.go: -------------------------------------------------------------------------------- 1 | /* Lesson_14 2 | Çok sayıda kanal kullanımı ve select ile senkronizasyonun sağlanması 3 | */ 4 | package main 5 | 6 | import ( 7 | "fmt" 8 | "time" 9 | ) 10 | 11 | func main() { 12 | fmt.Println(time.Now()) 13 | 14 | m1 := make(chan string) //kanallar tanımlanıyor 15 | m2 := make(chan string) 16 | m3 := make(chan string) 17 | 18 | go jobA(m1, "A..C") 19 | go jobB(m2, "C..M") 20 | go jobC(m3, "M..Z") 21 | 22 | for i := 0; i < 3; i++ { 23 | select { // işlemlerden hangisinin bittiğini anlamak için select ifadesi kullandık 24 | case messageA := <-m1: //m1 kanalından işin bittiğine dair bilgi geldiyse 25 | fmt.Println(messageA) 26 | case messageB := <-m2: 27 | fmt.Println(messageB) //m2 kanalından işin bittiğine dair bilgi geldiyse 28 | case messageC := <-m3: 29 | fmt.Println(messageC) //m3 kanalından işin bittiğine dair bilgi geldiyse 30 | } 31 | } 32 | fmt.Println(time.Now()) 33 | } 34 | 35 | func jobA(msg chan string, sets string) { 36 | fmt.Println(sets, "için işlemler yapılacak") 37 | time.Sleep(time.Second * 10) // belli bir süre uyutalım 38 | msg <- "A görevi tamamlandı" 39 | } 40 | func jobB(msg chan string, sets string) { 41 | fmt.Println(sets, "için işlemler yapılacak") 42 | time.Sleep(time.Second * 3) 43 | msg <- "B görevi tamamlandı" 44 | } 45 | func jobC(msg chan string, sets string) { 46 | fmt.Println(sets, "için işlemler yapılacak") 47 | time.Sleep(time.Second * 6) 48 | msg <- "C görevi tamamlandı" 49 | } 50 | -------------------------------------------------------------------------------- /Lesson_15.go: -------------------------------------------------------------------------------- 1 | /* 2 | Lesson_15 3 | 4 | Kanallar ve Select ifadesi ile birlikte GoRoutine'ler için timeout kontrolü nasıl yapılır? 5 | Pratik olarak eş zamanlı iş parçacığı ile birlikte yürütülecek ve geri sayım yapacak bir başka iş parçacığı kullanılabilir 6 | */ 7 | package main 8 | 9 | import ( 10 | "fmt" 11 | "time" 12 | ) 13 | 14 | func main() { 15 | timeout := time.Second * 10 //bu süreyi someJob'un içindekiş 5 saniyenin altına düşürüp denediğimizde timeout oluştuğunu görebiliriz 16 | fmt.Println("Eş zamanlı iş için zaman aşımı süresi", timeout) 17 | cnl := make(chan string, 1) 18 | go someJob(cnl) 19 | select { 20 | case result := <-cnl: 21 | fmt.Println(result) 22 | case <-time.After(timeout): //burada timeout kontrolü yapıyoruz 23 | fmt.Println("İş istenen sürede tamamlanamadı. :/") 24 | } 25 | 26 | // Timeout kontrolü ayrı bir fonksiyona da verebiliriz 27 | timeout = 2 28 | fmt.Println("Yeni Zaman Aşımı(Timeout) süresi", timeout) 29 | jobCnl := make(chan string, 1) 30 | counterCnl := make(chan bool, 1) 31 | go someJob(jobCnl) 32 | go counter(counterCnl, timeout) // sayacı 2 saniyeye ayarladık 33 | select { 34 | case jobMsg := <-jobCnl: 35 | fmt.Println(jobMsg) 36 | case counterMsg := <-counterCnl: 37 | fmt.Println("Zaman aşımı oluşma durumu", counterMsg) 38 | } 39 | } 40 | 41 | func someJob(msg chan string) { 42 | fmt.Println("\tEş zamanlı işler yapılıyor.") 43 | time.Sleep(time.Second * 5) //belli bir süre uyutma 44 | msg <- "İş tamamlandı" 45 | } 46 | 47 | func counter(info chan bool, duration time.Duration) { 48 | fmt.Println("Sayaç", duration, "kadar bekleyecek") 49 | time.Sleep(time.Second * duration) 50 | info <- true 51 | } 52 | -------------------------------------------------------------------------------- /Lesson_16.go: -------------------------------------------------------------------------------- 1 | /* 2 | Lesson_16 3 | Timer kullanımı 4 | belli bir süre sonra başlatılacak işler veya belirli zaman peryitolarında başlatılacak işler için kullanabiliriz 5 | */ 6 | package main 7 | 8 | import ( 9 | "fmt" 10 | "time" 11 | ) 12 | 13 | func main() { 14 | timer := time.NewTimer(time.Second * 4) 15 | 16 | fmt.Println("timer nesnesi tanımlandı. Kod akışına devam ediyor.") 17 | fmt.Println(time.Now()) 18 | now := <-timer.C //C ile timer'ın NewTimer'a parametre olarak gelen süre sonrasındaki zaman elde edilir 19 | fmt.Println("Timer ile belirtilen süre doldu.") 20 | fmt.Println(now) 21 | 22 | // Bu seferki Timer, süresi dolduğu için Expire durumuna düşecek 23 | // Bir Timer'ı expire olmadan önce durdurmak istediğimiz senaryolarda ele alabiliriz 24 | timer = time.NewTimer(time.Second) 25 | go func() { 26 | <-timer.C 27 | fmt.Println("İkinci timer süresi geçti") // time.Second nedeniyle func içerisinde timer.C yakalanamadan Stop metoduna düşülür 28 | }() 29 | stop := timer.Stop() 30 | if stop { 31 | fmt.Println("Timer durduruldu") 32 | } 33 | 34 | // ticker ile zamanlanmış görevler hazırlayabiliriz. 35 | tickTime := time.NewTicker(time.Second * 2) // iki saniyede bir zaman döndürecek Ticker tanımlandı 36 | go func() { 37 | fmt.Println("İş yapıyorum...") 38 | for t := range tickTime.C { // C ile yukarıdaki tickTime'ın o anki süresi ele yakalandı 39 | fmt.Println(t) 40 | } 41 | }() 42 | //time.Sleep(time.Second * 12) // main thread 12 saniye duracak. Bu süre boyunca 2 saniyede bir for t:=range bloğu çalışacaktır 43 | //tickTime.Stop() //Ticker durduruldu 44 | 45 | // Yukarıdaki kullanımdan farklı olarak şimdi kullanıcı Enter tuşuna basana kadar for t:=range bloğu çalışacaktır 46 | var enter string 47 | fmt.Println("Çıkmak için Enter tuşuna basınız") 48 | fmt.Scanln(&enter) 49 | tickTime.Stop() 50 | } 51 | -------------------------------------------------------------------------------- /Lesson_17.go: -------------------------------------------------------------------------------- 1 | // Lesson_17 2 | package main 3 | 4 | import ( 5 | "fmt" 6 | "os" 7 | "path/filepath" 8 | "time" 9 | ) 10 | 11 | func main() { 12 | var pathName string = "C:\\Reports" 13 | ticker := time.NewTicker(time.Second * 10) 14 | go func() { 15 | for t := range ticker.C { 16 | fmt.Printf("Time : %s\n", t) 17 | getFileList(pathName) 18 | } 19 | }() 20 | 21 | var enter string 22 | fmt.Println("Press Enter for Exit") 23 | fmt.Scanln(&enter) 24 | ticker.Stop() 25 | } 26 | 27 | func getFileList(pathName string) { 28 | fmt.Println("___", pathName, "___") 29 | filepath.Walk(pathName, 30 | func(path string, fileInfo os.FileInfo, err error) error { 31 | if !fileInfo.IsDir() { 32 | fmt.Printf("\t%s\t%d bytes\n", fileInfo.Name(), fileInfo.Size()) 33 | } 34 | return nil 35 | }) 36 | fmt.Println("____________________________________") 37 | } 38 | -------------------------------------------------------------------------------- /Lesson_18.go: -------------------------------------------------------------------------------- 1 | /* 2 | Lesson_18 3 | strings paketinin kullanımı 4 | Temel metinsel işlemler 5 | Burada geçenler dışındaki String işlemleri için 6 | https://golang.org/pkg/strings/ 7 | adresine bakılabilir 8 | */ 9 | package main 10 | 11 | import ( 12 | "fmt" 13 | "strings" 14 | "unicode" 15 | ) 16 | 17 | func main() { 18 | paragraph := `Line 1 : If there was a problem walking to the file or directory named by path, 19 | Line 2 : the incoming error will describe the problem and the function can decide 20 | Line 3 : how to handle that error. If an error is returned, processing stops. 21 | Line 4 : The sole exception is when the function returns the special value SkipDir. 22 | Line 5:end of code !` // " yerine ` kullanarak birden fazla satırdan oluşan metinler belirtebiliriz 23 | 24 | containsSample("an") 25 | containsSample("ist") 26 | countSample(paragraph) 27 | fieldsSample(paragraph, 7) 28 | fieldsFuncSample(paragraph) 29 | 30 | sampleText := "bir bilmecem var çocuklar! Haydi sor sor, çay'da kahvaltı da yenir :) Acaba nedir nedir?" 31 | hasPrefixSample(sampleText, "bir") 32 | hasPrefixSample(sampleText, "peki") 33 | 34 | //IndexAny ile bir metinde ilgili veri setindeki karakterlerden ilkinin görüldüğü indis değeri bulunur 35 | indexNo := strings.IndexAny(sampleText, ":,?!;.") 36 | fmt.Println(indexNo) //26 döndürür. Çünkü ikinci parametrede aranan içerikteki bilgilerden ilk görülen yerin indisi döner 37 | 38 | // Kullanışlı fonksiyonlardan biris de Join 39 | // Örneğin 40 | values := []string{"data source", "tcp", "connection", "log", "function"} 41 | newValue := strings.Join(values, "|") // values isimli string dizideki elemanların arasına | işareti koyarak birleştirir 42 | fmt.Println(newValue) 43 | 44 | // Join benzeri eğlenceli fonksiyonlardan birisi de Repeat 45 | // Bir ifadenin n sayıda tekrarı için kullanılıyor. 46 | fmt.Printf("Hey Ney%s\n", strings.Repeat("Na", 3)) 47 | 48 | //Map kullanımı. Bu fonksiyon ile bir metnin tüm karakterlerinin belli bir kurala göre değiştirilmesi sağlanabilir. 49 | //Şifreleme işlemlerinde mesela. Popüler örnek ROT13 şifreleme algoritması 50 | rot13 := func(c rune) rune { //rune tipinin anlamlandığı bir yer. int32 gibi olan rune aslında karakterin sayısal karşılığını veriyor. 51 | return c + 13 52 | } 53 | encryptedText := strings.Map(rot13, "ordu sağ kanattan sabah şafakla harekete geçecek") 54 | fmt.Println(encryptedText) 55 | decryptedText := strings.Map(func(c rune) rune { 56 | return c - 13 57 | }, encryptedText) 58 | fmt.Println(decryptedText) 59 | 60 | //Split fonksiyonu ile bir metni belli bir karaktere göre ayırmamız mümkündür 61 | product := "Pro Go Lang|Book|35,50|550|ISBN:345676" 62 | columns := strings.Split(product, "|") 63 | for _, column := range columns { 64 | fmt.Println(column) 65 | } 66 | 67 | // Title, ToLower, ToUpper ile harf çevirimleri 68 | motto := "bEniM hala UMUDUM vaAArr" 69 | fmt.Println(motto) 70 | fmt.Println(strings.Title(motto)) //sadece başharfleri büyüğe çevirdi 71 | fmt.Println(strings.ToUpper(motto)) // tüm harfleri büyüye çevirdi 72 | fmt.Println(strings.ToLower(motto)) // tüm harfleri küçüğe çevirdi 73 | } 74 | 75 | // Bir metnin başında belirtilen ifadenin olup olmadığını söyler 76 | // HasSuffix kullanımı da benzerdir. Sonunda aranan ifadenin olup olmadığını söyler 77 | func hasPrefixSample(text string, searching string) { 78 | if strings.HasPrefix(text, searching) { 79 | fmt.Printf("\n'%s' in başında '%s' VAR!\n", text, searching) 80 | } else { 81 | fmt.Printf("\n'%s' in başında '%s' YOK!\n", text, searching) 82 | } 83 | } 84 | 85 | /*FieldsFunc örneği. İkinci parametreye dikkat. Normalde orada bir fonksiyon tanımı var. 86 | Parametre olarak geçen fonksiyon karakterin sayı olmama koşuluna bakara bir sonuç döndürüyor. 87 | Böylece metin içerisinde geçen sayısal değerleri elde ediyoruz.*/ 88 | func fieldsFuncSample(paragraph string) { 89 | words := strings.FieldsFunc(paragraph, func(c rune) bool { //rune int32'nin alias'ıdır. Karakter değerlerini tam sayı değerlerinden ayırt ederken kullanırız. 90 | return !unicode.IsNumber(c) 91 | }) 92 | fmt.Printf("%q", words) 93 | } 94 | 95 | // fields fonksiyon örneği. Metinde geçen kelimelerden belli bir değerden uzun olanlarını listelemek 96 | func fieldsSample(paragraph string, charCount int) { 97 | fmt.Println("Harf sayısı -", charCount, "- dan fazla olanlar") 98 | words := strings.Fields(paragraph) 99 | for _, word := range words { 100 | if len(word) >= charCount { 101 | fmt.Println(word) 102 | } 103 | } 104 | } 105 | 106 | // bir paragraftaki kelime sayısını bulma örneğinde Count fonksiyonu kullanımı 107 | func countSample(paragraph string) { 108 | space_count := strings.Count(paragraph, " ") 109 | line_count := strings.Count(paragraph, "\n") 110 | fmt.Printf("Metinde %d boşluk ve %d satır bulundu.\nBuna göre toplam kelime sayısı %d\n", space_count, line_count, space_count+line_count-1) 111 | } 112 | 113 | // contains ile metin için metin arama örnek kullanımı 114 | func containsSample(part string) { 115 | words := []string{ 116 | "istanbul", 117 | "mavi", 118 | "yeşil", 119 | "antalya", 120 | "pist", 121 | "ankara", 122 | "izmir", 123 | "antartika", 124 | "arktika", 125 | "anason", 126 | "mandalina", 127 | "banana", 128 | } 129 | fmt.Println("'", part, "' geçen kelimeler") 130 | for _, word := range words { 131 | if strings.Contains(word, part) { 132 | fmt.Println(word) 133 | } 134 | } 135 | } 136 | -------------------------------------------------------------------------------- /Lesson_19.go: -------------------------------------------------------------------------------- 1 | /* Lesson_19 2 | Parametre olarak fonksiyon kullanmak 3 | */ 4 | package main 5 | 6 | import ( 7 | "fmt" 8 | "strings" 9 | ) 10 | 11 | func main() { 12 | colors := []string{ 13 | "red", "blue", "green", "orange", "black", "yellow", 14 | "gray", "brown", "silver", "pink", "gold", "dark red", 15 | } 16 | result := Select(colors, func(c string) bool { 17 | return len(c) >= 5 18 | }) 19 | for _, r := range result { 20 | fmt.Printf("%s,", r) 21 | } 22 | fmt.Println() 23 | g := func(w string) bool { 24 | return strings.HasPrefix(w, "g") 25 | } 26 | result = Select(colors, g) 27 | for _, r := range result { 28 | fmt.Printf("%s,", r) 29 | } 30 | fmt.Println() 31 | } 32 | 33 | type predicate func(w string) bool 34 | 35 | func Select(words []string, f predicate) []string { 36 | findings := []string{} 37 | for _, word := range words { 38 | if f(word) { 39 | findings = append(findings, word) 40 | } 41 | } 42 | return findings 43 | } 44 | -------------------------------------------------------------------------------- /Lesson_20.go: -------------------------------------------------------------------------------- 1 | /* 2 | Lesson_20 3 | Temel Dosya işlemlerine bir bakalım 4 | Tüm fonksiyonlar için https://golang.org/pkg/os/ adresine gidebiliriz 5 | */ 6 | package main 7 | 8 | import ( 9 | "fmt" 10 | "io/ioutil" 11 | "os" 12 | "strconv" 13 | ) 14 | 15 | func main() { 16 | writeFileStats("Cover.jpg") 17 | writeFileStats("NoFile.jpg") 18 | writeToFile("golang.txt", "go inanılmaz keyifli bir dilmiş. Sanırım C kökenlilerin kolayca öğrenebileceği bir dil.") 19 | readFile("golang.txt") 20 | //readFile("cover.jpg") 21 | readFileWithIO("golang.txt") 22 | //readFileWithIO("cover.jpg") 23 | 24 | // Aşağıdaki kod parçasında Player yapısından bir slice içeriğini 25 | // satır satır bir dosyaya aktarma işlemi yapılmaktadır 26 | players := []Player{ 27 | Player{1, "baltazar", 80}, 28 | Player{2, "orvel", 23}, 29 | Player{3, "nadya", 48}, 30 | Player{4, "obi van", 91}, 31 | Player{5, "şumi", 77}, 32 | } 33 | f, err := os.Create("players.dat") 34 | if err == nil { 35 | var content string = "Players\n" 36 | for _, player := range players { 37 | content += player.ToString() 38 | } 39 | f.WriteString(content) 40 | } else { 41 | fmt.Printf("Dosya oluşturulurken hata oluştu\n\t%s\n", err.Error()) 42 | } 43 | 44 | count := dir("C:\\Go Works\\Samples\\book\\20") 45 | fmt.Println(count, "dosya bulundu") 46 | } 47 | 48 | type Player struct { 49 | Id int 50 | Title string 51 | Level int 52 | } 53 | 54 | func (p Player) ToString() string { 55 | // int değerleri string'e dönüştürmek için strconv paketindeki Itoa fonksiyonunu kullandık 56 | return strconv.Itoa(p.Id) + "|" + p.Title + "|" + strconv.Itoa(p.Level) + "\n" 57 | } 58 | 59 | //dosya içeriğini okuma örneği - 1 60 | //parametre olarak gelen dosya içeriğini byte byte okuyup ekrana basacak 61 | func readFile(fullpath string) { 62 | f, err := os.Open(fullpath) 63 | if err == nil { 64 | defer f.Close() 65 | fileInfo, _ := f.Stat() // dosya boyutunu bulmak için 66 | fileBytes := make([]byte, fileInfo.Size()) //dosya boyutu kadarlık bir slice oluşturulur 67 | read, _ := f.Read(fileBytes) //dosya içeriği fileBytes kesitine yazılır. read'e okunan byte sayısı döner 68 | fmt.Printf("\n%s (%d byte okundu)\n\t%s\n", fullpath, read, fileBytes) 69 | } else { 70 | fmt.Printf("Dosyayı açamadım dostum\n\t%s\n", err.Error()) 71 | } 72 | } 73 | 74 | // Dosya içeriğini okuma örneği - 2 75 | func readFileWithIO(fullpath string) { 76 | content, err := ioutil.ReadFile(fullpath) //dosya içeriğini byte array olarak döndürür 77 | if err == nil { 78 | fmt.Println("'", string(content), "'") //content ASCII değerlerini barındırır. Bu nedenle string dönüşümü yapılmıştır. txt dışında jpg içeriğini okuduğumuzda ekrana nasıl bastığına bakın. 79 | } else { 80 | fmt.Printf("Dosya okunmaya çalışılırken hata oluştu\n\t%s\n", err.Error()) 81 | } 82 | } 83 | 84 | //dosya oluşturma ve içerisine string içerik yazma örneği 85 | func writeToFile(fullpath string, content string) { 86 | f, err := os.Create(fullpath) 87 | if err == nil { //dosya yaratılırken hata oluşmadıysa 88 | defer f.Close() //fonksiyondan çıkarken çalışacak 89 | r, _ := f.WriteString(content) //içeriği dosyaya yazıyor 90 | fmt.Println("işlem sonucu", r) 91 | } else { 92 | fmt.Printf("Dosya oluşturulurken hata oluştu\n\t%s\n", err.Error()) 93 | } 94 | } 95 | 96 | //bir dosya hakkında bilgiler edinme örneği 97 | func writeFileStats(file string) { 98 | f, err := os.Open(file) //dosyayı açtık 99 | if err == nil { 100 | defer f.Close() //writeFileStats fonksiyonundan çıkarken çalışacak 101 | fInfo, _ := f.Stat() // Stat fonksiyonu da Open gibi iki değer döndürür. _ error değeridir 102 | fmt.Println(fInfo.Size(), "bytes") 103 | fmt.Println("File name is ", fInfo.Name()) 104 | fmt.Println("File modes are ", fInfo.Mode().String()) 105 | fmt.Println(fInfo.ModTime(), "Last Changed") 106 | } else { 107 | fmt.Printf("Dosyayı açamadım dostum\n\t%s\n", err.Error()) 108 | } 109 | } 110 | 111 | //bir klasör içeriğini gösterelim 112 | func dir(path string) int { 113 | directory, err := os.Open(path) 114 | var fileCount int = 0 115 | if err == nil { 116 | defer directory.Close() 117 | files, _ := directory.Readdir(-1) 118 | for _, f := range files { 119 | if !f.IsDir() { 120 | fmt.Printf("%s\t\t%d\t%s\n", f.Name(), f.Size(), f.ModTime()) 121 | fileCount++ 122 | } 123 | } 124 | } else { 125 | fmt.Printf("Klasör okumada sorun oluştu\n\t%s\n", err.Error()) 126 | } 127 | return fileCount 128 | } 129 | -------------------------------------------------------------------------------- /Lesson_21.go: -------------------------------------------------------------------------------- 1 | /* 2 | Lesson_21 3 | net/http ve io/util paketine ait bir kaç örnek 4 | */ 5 | package main 6 | 7 | import ( 8 | "fmt" 9 | "io/ioutil" //io stream'lerini rahat okumak için kullandık 10 | "net/http" //Http tabanlı istemci sunucu kabiliyetlerini sunar. Web sunucusu yapmak, HTTP Get,Post,Put,Delete gibi talepler yapmak ve daha pek çok operasyon sunar. 11 | "os" //web içeriklerini yazacağımız dosyanın oluşumu için kullandık 12 | ) 13 | 14 | func main() { 15 | // getWebPageContent("https://golang.org/pkg/net/http/", "net.http.pkg.html") 16 | 17 | // ListenAndServer fonksiyonuna verdiğimiz ilk parametre ile 4567 nolu porttan 18 | // Lesson_21.go'nun olduğu klasördeki docs dizinini kullanıma açtık 19 | // kodu çalıştırdıktan sonra makinenizden http://localhost:4567 ile içeriği görmeyi deneyin 20 | // (Tabii docs isimli klasörü açıp içerisine bir kaç dosya koymayı unutmayalım) 21 | err := http.ListenAndServe(":4567", http.FileServer(http.Dir("docs"))) 22 | if err != nil { 23 | fmt.Println(err.Error()) 24 | } 25 | } 26 | 27 | func getWebPageContent(page string, fileName string) { 28 | response, err := http.Get(page) //parametre olarak gelen sayfaya Get talebi yolluyoruz 29 | if err == nil { 30 | defer response.Body.Close() //defer ettiğimiz şey Body'nin kapatılması 31 | // Header'dan Status, StatusCode, Content Length gibi bilgileri alıyoruz 32 | fmt.Printf("Response Status\t:\t%s\nResponse Code\t:\t%d\nContent Length\t:\t%d\n", response.Status, response.StatusCode, response.ContentLength) 33 | 34 | //Normalde Header bir map olarak geriye dönmektedir 35 | fmt.Println(response.Header) 36 | // map üzerinden dolaşarak da Header bilgilerini yakalayabiliriz. 37 | for k, v := range response.Header { 38 | fmt.Println(k) 39 | for _, vv := range v { 40 | fmt.Println("\t", vv) 41 | } 42 | } 43 | 44 | if response.StatusCode == 200 { // Durum kodumuz HTTP 200 OK ise 45 | content, _ := ioutil.ReadAll(response.Body) //Gövdeyi okuyoruz. ReadAll metodu içeriğin byte array olarak elde edilmesini sağlıyor 46 | f, _ := os.Create(fileName) //içeriği kaydedeceğimiz dosyayı oluşturuyoruz 47 | f.WriteString(string(content)) //içeriğini yazıyoruz 48 | f.Close() // dosyayı kapatıyoruz 49 | fmt.Println("İçerik kaydedildi") 50 | } 51 | 52 | } else { 53 | fmt.Printf("Bir hata oluştu dostum yaa :|\n\t%s\n", err.Error()) 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /Lesson_22.go: -------------------------------------------------------------------------------- 1 | /* 2 | Lesson_22 3 | Bu sefer basit bir web sunucusu yapıyoruz 4 | */ 5 | package main 6 | 7 | import ( 8 | "encoding/json" 9 | "fmt" 10 | "io" 11 | "io/ioutil" 12 | "log" 13 | "net/http" 14 | "time" 15 | ) 16 | 17 | func main() { 18 | fmt.Println("Sunucu dinlemede.") 19 | // Routingleri yapmak oldukça kolay. HandleFunc bunun için kullanılıyor diyebiliriz. 20 | http.HandleFunc("/", mainPage) //root talepleri ele alan fonksiyon ikinci parametrede 21 | http.HandleFunc("/players", getPlayers) // /players şeklinde gelen talepleri alan fonksiyon getPlayers 22 | log.Fatal(http.ListenAndServe(":4501", nil)) //http://localhost:4501 üzerinden dinlemede 23 | } 24 | 25 | // sunucunun ana sayfasına gelen talepleri karşılayacak fonksiyon 26 | func mainPage(response http.ResponseWriter, request *http.Request) { 27 | fmt.Printf("[%s]\t%s:%s\n", request.Method, time.Now(), request.URL) //Request ile ilgili bir log atıyoruz ekrana(http metodu, zaman ve talep olarak gelen URL) 28 | response.Header().Set("Content-Type", "text/html") //Çıktının içeriğini belirliyoruz. HTML basacağız 29 | f, _ := ioutil.ReadFile("mainPage.html") //sistemde kayıtlı html dosyasını okuyoruz 30 | io.WriteString(response, string(f)) //içeriğ responseWriter üzerinden basıyoruz 31 | } 32 | 33 | //Bu sefer slice içerisindeki tüm üyeleri JSON formatında yolluyoruz. 34 | func getPlayers(response http.ResponseWriter, request *http.Request) { 35 | fmt.Printf("[%s]\t%s:%s\n", request.Method, time.Now(), request.URL) //log basıyoruz 36 | players := []Player{ //Örnek bir slice oluşturuyoruz 37 | Player{1, "Con Doo", 100}, 38 | Player{2, "Wolfy", 89}, 39 | Player{3, "Red Sonia", 71}, 40 | Player{4, "Dam Klause", 54}, 41 | Player{5, "Turko", 99}, 42 | } 43 | json.NewEncoder(response).Encode(players) //json encoder ile players'ı responseWriter üzerinden yolluyoruz 44 | } 45 | 46 | type Player struct { 47 | Id int "json:`ID`" 48 | Nickname string "json:`Nickname`" 49 | Level float32 "json:`Level`" 50 | } 51 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # GoLangSamples Kodlarının Amacı 2 | Çalıştığım kitaplardan uyguladığım GO kod örneklerini içerir. Birinci dersten itibaren başlandığı takdirde orta seviyede GO bilgisine sahip olununcaya kadar ilerlenebilir. Yeni dersleri fırsat buldukça eklemekteyim. 3 | 4 | # Çalıştırırken 5 | 6 | Örnek kod dosyalarını indirdikten sonra go derleyicisi ile çalıştırmak gerekiyor. Sistemde Go yüklü olduğunu varsayarsak 7 | 8 | ```bash 9 | go run Lesson_01.go 10 | ``` 11 | 12 | gibi ilerlenebilir. İşleri kolaylaştırmak adına LiteIDE kullanılabilir. Ancak dikkat edilmesi gereken bir konu var. Tüm ders kodları içerisinde main fonksiyonu bulunuyor. Bu nedenle tüm dosyaları aynı klasöre indirirsek LiteIDE o klasörde birden fazla main fonksiyonu göreceği için hata verecektir. Dolayısıyla aynı klasöre indirirseniz komut satırından çalıştırıp sonuçları görebilirsiniz. Ya da tüm dersleri kendi özerk klasörleri içerisinde ayrıca tutabilirsiniz. 13 | 14 | # Kaynaklar 15 | 16 | GO diline çalışırken kullandığım kaynaklar aşağıdaki gibidir. 17 | 18 | Murat Özalp'in Go Programlama Kitabı 19 | 20 | [Go By Example - Örneklerle Go](https://gobyexample.com) 21 | 22 | [Golang Official Pakages-Paketler ile ilgili bilgiler](https://golang.org/pkg/) 23 | 24 | [Bir Tutorial Serisiz](https://golangbot.com/learn-golang-series/) 25 | 26 | [Kendi bloğumdaki bir kaç yazı](http://www.buraksenyurt.com/category/GoLang) 27 | -------------------------------------------------------------------------------- /Web Programming/Lesson_23/Server.go: -------------------------------------------------------------------------------- 1 | // Server 2 | package main 3 | 4 | import ( 5 | "log" 6 | "net/http" 7 | ) 8 | 9 | func main() { 10 | http.Handle("/", http.FileServer(http.Dir("static"))) 11 | log.Println("Web server is online at 8044") 12 | http.ListenAndServe(":8044", nil) 13 | } 14 | -------------------------------------------------------------------------------- /Web Programming/Lesson_23/static/go_rocks.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/buraksenyurt/golangsamples/0d02cb4e3b9673ccf6100526772d17ebee78bc5a/Web Programming/Lesson_23/static/go_rocks.jpg -------------------------------------------------------------------------------- /Web Programming/Lesson_23/static/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Go Gophy Go! 6 | 7 | 8 | 9 |

Ahoy! Go Lovers

10 |

This language is awesome!

11 | 12 |

We can develop any web application with Go Lang something like that web sites,web services,rest APIs...

13 | 14 | -------------------------------------------------------------------------------- /Web Programming/Lesson_23/static/main.css: -------------------------------------------------------------------------------- 1 | body{ 2 | border:3px solid brown; 3 | border-radius: 20px; 4 | border-width: 5px; 5 | text-align: center; 6 | width: 400px; 7 | height: 500px; 8 | margin: auto; 9 | } -------------------------------------------------------------------------------- /Web Programming/Lesson_24/pages/common.css: -------------------------------------------------------------------------------- 1 | body{ 2 | border:3px solid cyan; 3 | border-radius: 24px; 4 | border-width: 20px; 5 | text-align: center; 6 | width: 400px; 7 | height: 400px; 8 | margin: auto; 9 | font-family:Tahoma, sans-serif; 10 | font-size:16px; 11 | color:541460; 12 | } 13 | table.gridtable { 14 | font-family: verdana,arial,sans-serif; 15 | font-size:16px; 16 | color:#581845; 17 | border-width: 1px; 18 | border-color: #666666; 19 | border-collapse: collapse; 20 | } 21 | table.gridtable th { 22 | border-width: 3px; 23 | padding: 8px; 24 | border-style: solid; 25 | border-color: #666666; 26 | background-color: #FF80E8; 27 | } 28 | table.gridtable td { 29 | border-width: 3px; 30 | padding: 8px; 31 | border-style: solid; 32 | border-color: #666666; 33 | background-color: #98A1FC; 34 | } -------------------------------------------------------------------------------- /Web Programming/Lesson_24/pages/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | Blizert World Game Entertienment 4 | 5 | 6 | 7 |

Wellcome to BliZerT

8 |

The World's best card players are here.
9 | Want to learn some more details?
10 | What are you waiting for. Go Go Go...

11 | 12 |

Famous Hearthstone Players

13 | 14 | -------------------------------------------------------------------------------- /Web Programming/Lesson_24/pages/players.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | Gold Players 4 | 5 | 6 | 7 |

Gold Players

8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 19 | {{ range $index,$player := . }} 20 | 21 | 22 | 23 | 24 | 25 | 26 | {{end}} 27 |
IdPlayer NoNicknameLevel
{{$index}}{{$player.Id}}{{$player.Nickname}}{{$player.Level}}
28 |
29 | Go Back 30 | -------------------------------------------------------------------------------- /Web Programming/Lesson_24/pages/stronger.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/buraksenyurt/golangsamples/0d02cb4e3b9673ccf6100526772d17ebee78bc5a/Web Programming/Lesson_24/pages/stronger.gif -------------------------------------------------------------------------------- /Web Programming/Lesson_24/server.go: -------------------------------------------------------------------------------- 1 | // Server 2 | package main 3 | 4 | import ( 5 | "html/template" 6 | "log" 7 | "net/http" 8 | ) 9 | 10 | func main() { 11 | // http://localhost:8045/players şeklindeki talepler getPlayers fonksiyonuna yönlendiriliyor 12 | http.Handle("/", http.FileServer(http.Dir("pages"))) 13 | http.HandleFunc("/players", getPlayers) 14 | log.Println("Web server is active at port 8045") 15 | http.ListenAndServe(":8045", nil) 16 | 17 | } 18 | 19 | func getPlayers(response http.ResponseWriter, request *http.Request) { 20 | log.Println("Get Request for Players") 21 | players := loadPlayers() 22 | log.Println("Players loaded") 23 | //template içerisindeki ParseFiles fonksiyonu ile players.html içeriğini yakalıyoruz 24 | t, err := template.ParseFiles("pages/players.html") 25 | // Execute fonksiyonu ikinci parametre ile Player yapısı tipinden olan slice'ı gönderiyor 26 | // Player içeriği html dosyasında işlenecek 27 | if err == nil { 28 | t.Execute(response, players) 29 | } else { 30 | log.Println(err.Error()) 31 | } 32 | } 33 | 34 | type Player struct { 35 | Id int 36 | Nickname string 37 | Level int 38 | } 39 | 40 | func loadPlayers() []Player { 41 | return []Player{ 42 | Player{1001, "Molfiryin", 2}, 43 | Player{1002, "Gul'dan", 21}, 44 | Player{1003, "Anduin", 12}, 45 | Player{1004, "Lexar", 5}, 46 | Player{1005, "Turol", 34}, 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /Web Programming/Lesson_25/server.go: -------------------------------------------------------------------------------- 1 | /* 2 | Lesson 25 3 | HttpRouter isimli yönlendirici yardımıyla bir web sayfası geliştiriyoruz. 4 | 5 | */ 6 | package main 7 | 8 | import ( 9 | "fmt" 10 | "net/http" 11 | "strings" 12 | 13 | "github.com/julienschmidt/httprouter" // Kodu LiteIDE'de bu şekilde yazdıktan sonra Debug menüsünden Get dersek, github'daki ilgili paket otomatik olarak sisteme yüklenir 14 | ) 15 | 16 | func main() { 17 | router := httprouter.New() // Önce Router nesnesini örnekliyoruz. 18 | router.GET("/", Index) // root adrese gelecek olan HTTP Get taleplerini Index isimli fonksiyona yönlendiriyoruz. 19 | router.GET("/planets", GetPlanets) // root adresten /planets şeklinde gelecek talepleri GetPlanets fonksiyonuna yönlendiriyoruz. 20 | router.GET("/planets/:name", GetCities) //bu sefer planets arkasına bir de parametre aldık. Bu parametre tahmin edileceği gibi URL'den gelecek 21 | http.ListenAndServe(":4568", router) // 4568 nolu porttan yapacağımız dinlemelerde, gelen tüm talepleri httpRouter nesne örneğinin ele alacağını belirtiyoruz. 22 | } 23 | 24 | // Bu sefer bir gezegendeki şehirleri listeyeceğiz 25 | // params üzerinden gezegen adını yakalayıp slice'dan onun şehirlerini bulacağız 26 | func GetCities(response http.ResponseWriter, request *http.Request, params httprouter.Params) { 27 | planetName := params.ByName("name") 28 | planets := LoadSomeData() 29 | fmt.Fprintf(response, `%s

%s

`, planetName, planetName) 30 | for _, planet := range planets { 31 | if strings.ToLower(planet.Name) == strings.ToLower(planetName) { 32 | for _, city := range planet.Cities { 33 | fmt.Fprintf(response, `

%s-%s

`, city.Name, city.Affiliation) 34 | } 35 | break 36 | } 37 | } 38 | fmt.Fprintf(response, ``) 39 | } 40 | 41 | func GetPlanets(response http.ResponseWriter, request *http.Request, params httprouter.Params) { 42 | planets := LoadSomeData() //Star Wars'dan bir kaç gezegen ve şehir adı yüklenir 43 | fmt.Fprintf(response, `Planets

Planets

`) 44 | for _, planet := range planets { 45 | fmt.Fprintf(response, `

%s-%s (%d)

`, planet.Name, planet.Name, planet.Sector, planet.Population) 46 | } 47 | fmt.Fprintf(response, ``) 48 | } 49 | 50 | // builtin kullandığımız http.HandleFunc'dan farklı olarak 3ncü bir parametremiz var. 51 | // httpRouter.Params ile talep ile birlikte gelen parametreleri yakalayabiliriz 52 | func Index(response http.ResponseWriter, request *http.Request, params httprouter.Params) { 53 | fmt.Fprintf(response, ` 54 | 55 | 56 | Star Wars Planets 57 | 58 | 59 |

Star Wars Planets

60 | Planets
61 |

Planet list updates every morning with new planets

62 | 63 | `) 64 | //HTML içeriğini bir dosyadan okutursak daha güzel olur. Ama dinamik olarak da üretilebilir 65 | } 66 | 67 | // Örnek verileri yüklemek için kullanacağımız fonksiyon 68 | // Geriye bir slice döndürecek 69 | func LoadSomeData() []Planet { 70 | var planets []Planet 71 | 72 | planets = append(planets, Planet{Name: "Naboo", Sector: "Chommel", Population: 4500000, 73 | Cities: []City{ 74 | City{Id: 1, Name: "Theed", Affiliation: "Galactic Empire"}, 75 | City{Id: 2, Name: "Umberbool City", Affiliation: "Gungan Grand Army"}, 76 | City{Id: 3, Name: "Spinnaker", Affiliation: "Galactic Empire"}, 77 | City{Id: 4, Name: "Otoh Gunga", Affiliation: "Trade Federation"}, 78 | }}) 79 | 80 | planets = append(planets, Planet{Name: "Coruscant", Sector: "Corusca", Population: 1000000000, 81 | Cities: []City{ 82 | City{Id: 1, Name: "Galactic City", Affiliation: "Rebellian"}, 83 | }}) 84 | 85 | planets = append(planets, Planet{Name: "Mustafar", Sector: "Atravis", Population: 20000, 86 | Cities: []City{ 87 | City{Id: 1, Name: "Fralideja", Affiliation: "Rise of Empire"}, 88 | }}) 89 | 90 | return planets 91 | } 92 | 93 | type Planet struct { 94 | Name string 95 | Sector string 96 | Population int64 97 | Cities []City 98 | } 99 | 100 | type City struct { 101 | Id int 102 | Name string 103 | Affiliation string 104 | } 105 | -------------------------------------------------------------------------------- /Web Programming/Lesson_26/Server.go: -------------------------------------------------------------------------------- 1 | /* 2 | Lesson 26 3 | Bu sefer JSON çıktı veren REST tadından bir servis yazıyoruz 4 | sistemde paket olarak oluşturulan entity/starwars içerisindeki 5 | Category ve Model yapılarının çıktıları JSON formatında basılıyor 6 | Router için httpRouter paketini kullanıyoruz 7 | */ 8 | package main 9 | 10 | import ( 11 | "encoding/json" 12 | "entity/starwars" // bu paket C:\Go Works\Samples\src\entity\starwars altında yer alıyor 13 | "fmt" 14 | "net/http" 15 | "strings" 16 | 17 | "github.com/julienschmidt/httprouter" 18 | ) 19 | 20 | func main() { 21 | router := httprouter.New() //router nesnesi oluşturuluyor 22 | 23 | // static sayfaları bir sub-path'e yönlendiriyoruz. Eğer / kullanırsak *filepath bildirimi diğer Get bildirimlerini de kapsayacağından derleme hatası alırız. 24 | router.ServeFiles("/static/*filepath", http.Dir("static")) 25 | router.GET("/category", GetCategories) // /category taleplerini GetCategories fonksiyonu karşılayacak 26 | router.GET("/category/:name", GetModelsByCategoryName) // /category/fighter gibi talepleri de GetModelsByCategoryName karşılayacak 27 | 28 | http.ListenAndServe(":4569", router) // 4569 nolu porttan dinleme yapıyoruz. İstekleri Router nesnemize yönlendiriyoruz 29 | } 30 | 31 | func GetCategories(response http.ResponseWriter, request *http.Request, params httprouter.Params) { 32 | c, _ := loadDataSet() // örnek veri setini yüklüyoruz 33 | cJson, _ := json.Marshal(c) // kategorileri json formatına dönüştürüyoruz 34 | response.Header().Set("Content-Type", "application/json") // çıktının json olarak yorumlanması gerektiğini ifade ediyoruz 35 | response.WriteHeader(200) // HTTP 200 OK bildirimini ekliyoruz 36 | fmt.Fprintf(response, "%s", cJson) //içeriği basıyoruz 37 | } 38 | 39 | func GetModelsByCategoryName(response http.ResponseWriter, request *http.Request, params httprouter.Params) { 40 | _, models := loadDataSet() 41 | var result []starwars.Model // istenen kategoriye bağlı modelleri tutacağımız slice 42 | for _, m := range models { 43 | if strings.ToLower(m.Category.Name) == strings.ToLower(params.ByName("name")) { //kategori adına uyan bir modelse ekliyoruz 44 | result = append(result, m) 45 | } 46 | } 47 | cJson, _ := json.Marshal(result) // bulunan sonuç kümesini json formatına çeviriyoruz 48 | response.Header().Set("Content-Type", "application/json") 49 | response.WriteHeader(200) 50 | fmt.Fprintf(response, "%s", cJson) 51 | } 52 | 53 | func loadDataSet() (categories []starwars.Category, models []starwars.Model) { 54 | fighter := starwars.Category{Id: 1, Name: "Fighter"} 55 | cruiser := starwars.Category{Id: 2, Name: "Cruiser"} 56 | 57 | vwing := starwars.Model{Id: 1, Title: "V-Wing Fighter", Price: 45.50, Category: fighter} 58 | n1 := starwars.Model{Id: 2, Title: "Naboo N-1 Starfighter", Price: 250.45, Category: fighter} 59 | republicCruiser := starwars.Model{Id: 3, Title: "Republic Cruiser", Price: 450.00, Category: cruiser} 60 | attackCruiser := starwars.Model{Id: 4, Title: "Republic Attack Cruiser", Price: 950.00, Category: cruiser} 61 | eta2 := starwars.Model{Id: 5, Title: "ETA-2 Jedi Starfighter", Price: 650.50, Category: fighter} 62 | delta7 := starwars.Model{Id: 6, Title: "Delta-7 Jedi Starfighter", Price: 250.35, Category: fighter} 63 | bwing := starwars.Model{Id: 7, Title: "B-Wing", Price: 195.50, Category: fighter} 64 | ywing := starwars.Model{Id: 8, Title: "Y-Wing", Price: 45.50, Category: fighter} 65 | monCalamari := starwars.Model{Id: 9, Title: "Mon Calamari Star Crusier", Price: 1500.00, Category: cruiser} 66 | 67 | categories = append(categories, fighter, cruiser) 68 | models = append(models, vwing, n1, republicCruiser, attackCruiser, eta2, delta7, bwing, ywing, monCalamari) 69 | 70 | return categories, models 71 | } 72 | -------------------------------------------------------------------------------- /Web Programming/Lesson_26/entity/starwars/starwars.go: -------------------------------------------------------------------------------- 1 | //Bu dosyayi GOPATH'in ya da GOROOT'un kuruldugu yere gore 2 | // src altinda 3 | // -entity 4 | // -entity/starwars 5 | // -entity/starwars/starwars.go 6 | // seklinde olusturup derlemeliyiz. 7 | package starwars 8 | 9 | type model struct { 10 | Id int 11 | Title string 12 | Price float32 13 | Category category 14 | } 15 | 16 | type category struct { 17 | Id int 18 | Name string 19 | } 20 | -------------------------------------------------------------------------------- /Web Programming/Lesson_26/static/common.css: -------------------------------------------------------------------------------- 1 | body{ 2 | border:3px solid #BA4A00; 3 | border-radius: 16px; 4 | border-width: 10px; 5 | text-align: center; 6 | width: 420px; 7 | height: 500px; 8 | margin: auto; 9 | font-family:Tahoma, sans-serif; 10 | font-size:18px; 11 | color:#212F3D; 12 | } -------------------------------------------------------------------------------- /Web Programming/Lesson_26/static/cover.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/buraksenyurt/golangsamples/0d02cb4e3b9673ccf6100526772d17ebee78bc5a/Web Programming/Lesson_26/static/cover.gif -------------------------------------------------------------------------------- /Web Programming/Lesson_26/static/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | Starwars Models 4 | 5 | 6 | 7 |

My Starwars Collection

8 | 9 |

This is a JSON based data service
Try this url : category/fighter

10 | All Categories 11 | -------------------------------------------------------------------------------- /Web Programming/Lesson_27/server.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "database/sql" 5 | "encoding/json" //JSON Serileştirmeler için 6 | "entity/starwars" //Entity paketimiz 7 | "fmt" 8 | "log" //gerekli yerlerde log atmak için 9 | "net/http" 10 | "strconv" 11 | 12 | "github.com/julienschmidt/httprouter" // Yönlendirme işlemleri için kullandığımız paket 13 | _ "github.com/mattn/go-sqlite3" // SQLite veritabanı işlemlerimizi kolaylaştıran paket 14 | ) 15 | 16 | func main() { 17 | router := httprouter.New() 18 | 19 | // yönlendiriciyi oluşturduk 20 | router.GET("/", home) //root 21 | router.GET("/categories", getCategories) //Tüm kategoriler 22 | router.GET("/categories/:categoryId", getModelsByCategoryId) //belli bir kateogori id'ye bağlı modeller 23 | router.GET("/models/:firstLetter", getModelsByFirstLetter) // Baş harfine göre modeller 24 | router.POST("/newCategory", createCategory) // Yeni bir kategori eklemek için kullanılan fonksiyon 25 | 26 | http.ListenAndServe(":4571", router) //localhost:4571 adresinden host ediyoruz 27 | } 28 | 29 | func createCategory(w http.ResponseWriter, r *http.Request, _ httprouter.Params) { 30 | category := starwars.Category{} 31 | json.NewDecoder(r.Body).Decode(&category) //Body üstünden gelen JSON içeriğini ayrıştır ve category nesnesi al 32 | log.Printf("Insert request. %d,%s\n", category.Id, category.Name) 33 | conn, _ := sql.Open("sqlite3", "starwars.sdb") // DB Bağlantısını aç 34 | defer conn.Close() // fonksiyondan çıkarken bağlantıyı kapat 35 | _, err := conn.Exec("Insert into Category values (?,?)", category.Id, category.Name) //Insert sorgusunu çalıştır. ? ile parametreler veriliyor 36 | if err == nil { 37 | render(w, category) // render fonksiyonu ile category içeriğini bastır 38 | } else { 39 | log.Println(err.Error()) 40 | //404 basılabilir 41 | } 42 | } 43 | 44 | func getCategories(w http.ResponseWriter, r *http.Request, _ httprouter.Params) { 45 | conn, _ := sql.Open("sqlite3", "starwars.sdb") //bağlantıyı aç 46 | defer conn.Close() 47 | rows, _ := conn.Query("Select Id,Name from Category order by Name") //select sorgu sonuçlarını rows değişkenine al 48 | defer rows.Close() //çıkarken bağlantıyı kapat 49 | categories := make([]*starwars.Category, 0) 50 | for rows.Next() { //tüm sonuç kümesinde dön 51 | category := new(starwars.Category) 52 | rows.Scan(&category.Id, &category.Name) //Sorgu sonuçlarındaki alanları category nesnesindeki alanlar ile eşleştir 53 | categories = append(categories, category) //slice'a ekle 54 | } 55 | render(w, categories) //slice içeriğini JSON formatından istemciye basacak fonksiyonu çağır 56 | } 57 | 58 | func getModelsByCategoryId(w http.ResponseWriter, r *http.Request, params httprouter.Params) { 59 | conn, _ := sql.Open("sqlite3", "starwars.sdb") 60 | defer conn.Close() 61 | id, _ := strconv.Atoi(params.ByName("categoryId")) 62 | cRow := conn.QueryRow("Select * from Category Where Id=?", id) 63 | ctgry := new(starwars.Category) 64 | if cRow != nil { 65 | cRow.Scan(&ctgry.Id, &ctgry.Name) 66 | rows, _ := conn.Query("Select Id,Title,ListPrice from Model where CategoryId=?", id) 67 | defer rows.Close() 68 | models := make([]*starwars.Model, 0) 69 | for rows.Next() { 70 | model := new(starwars.Model) 71 | model.Category = starwars.Category{Id: ctgry.Id, Name: ctgry.Name} 72 | rows.Scan(&model.Id, &model.Title, &model.Price) 73 | models = append(models, model) 74 | } 75 | render(w, models) 76 | } 77 | } 78 | 79 | func getModelsByFirstLetter(w http.ResponseWriter, r *http.Request, params httprouter.Params) { 80 | conn, _ := sql.Open("sqlite3", "starwars.sdb") 81 | defer conn.Close() 82 | // Like kullanımındaki 'A%' için önce Sprintf ile sorgu metni oluşturuldu 83 | statement := fmt.Sprintf("Select Id,Title,ListPrice from Model where Title like '%s%%'", params.ByName("firstLetter")) 84 | rows, _ := conn.Query(statement) // Sorguyu çalıştır ve sonuçları rows setine aktar 85 | defer rows.Close() 86 | models := make([]*starwars.Model, 0) 87 | for rows.Next() { 88 | model := new(starwars.Model) 89 | rows.Scan(&model.Id, &model.Title, &model.Price) 90 | models = append(models, model) 91 | } 92 | render(w, models) 93 | } 94 | 95 | func home(rWriter http.ResponseWriter, request *http.Request, _ httprouter.Params) { 96 | fmt.Fprintf(rWriter, "Star Wars universe!") 97 | } 98 | 99 | // İkinci parametre göre bu fonksiyona categories, models, category gibi önceki fonksiyonlarda kullandığımız tüm nesneleri aktarabiliriz 100 | func render(w http.ResponseWriter, d data) { 101 | // Header içeriğini JSON çıktı verecek şekilde işaretle 102 | w.Header().Set("Content-Type", "application/json") 103 | // İstmeciye HTTP 200 OK mesajını ver 104 | w.WriteHeader(200) 105 | // gelen d içeriğini JSON olarak serileştir 106 | jContent, _ := json.Marshal(d) 107 | // Serileşen içeriği ResponseWriter üzerinden istemciye bas 108 | fmt.Fprintf(w, "%s", jContent) 109 | } 110 | 111 | type data interface { 112 | } 113 | -------------------------------------------------------------------------------- /Web Programming/Lesson_27/starwars.sdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/buraksenyurt/golangsamples/0d02cb4e3b9673ccf6100526772d17ebee78bc5a/Web Programming/Lesson_27/starwars.sdb -------------------------------------------------------------------------------- /Web Programming/Lesson_28/db/southwind.sdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/buraksenyurt/golangsamples/0d02cb4e3b9673ccf6100526772d17ebee78bc5a/Web Programming/Lesson_28/db/southwind.sdb -------------------------------------------------------------------------------- /Web Programming/Lesson_28/server.go: -------------------------------------------------------------------------------- 1 | /* 2 | Temel bir ORM aracını nasıl kullanabileceğimizi öğrenmeye çalışıyoruz. 3 | */ 4 | package main 5 | 6 | import ( 7 | "fmt" 8 | 9 | "entity/southwind" 10 | 11 | "github.com/jinzhu/gorm" 12 | _ "github.com/mattn/go-sqlite3" 13 | ) 14 | 15 | func main() { 16 | db, err := gorm.Open("sqlite3", "db\\southwind.sdb") 17 | db.LogMode(true) 18 | defer db.Close() 19 | if err == nil { 20 | //db.SingularTable(true) 21 | db.AutoMigrate(&Southwind.Employee{}, &Southwind.Email{}) 22 | db.Model(&Southwind.Employee{}).Related(&Southwind.Email{}) 23 | 24 | burakMails := []Southwind.Email{ 25 | Southwind.Email{Mail: "selim@buraksenyurt.com", IsActive: true}, 26 | Southwind.Email{Mail: "burak.senyurt@southwind.com", IsActive: false}, 27 | Southwind.Email{Mail: "burakselimsenyurt@gmail.com", IsActive: true}, 28 | } 29 | 30 | burak := Southwind.Employee{FirstName: "burak", LastName: "senyurt", Emails: burakMails} 31 | db.Create(&burak) 32 | 33 | loraMails := []Southwind.Email{ 34 | Southwind.Email{Mail: "lora@kimbilll.moon", IsActive: true}, 35 | Southwind.Email{Mail: "kimbill.the.black.lora@southwind.com", IsActive: true}, 36 | } 37 | lora := Southwind.Employee{FirstName: "Lora", LastName: "Kimbılll", Emails: loraMails} 38 | db.Create(&lora) 39 | 40 | WriteToScreen(burak) 41 | WriteToScreen(lora) 42 | 43 | var burki Southwind.Employee 44 | db.Find(&burki, "ID=?", 1) //Önce 45 | db.Model(&burki).Update("LastName", "Selim Senyurt") 46 | WriteToScreen(burki) 47 | 48 | var buffon Southwind.Employee 49 | 50 | db.Model(&buffon).Where("ID=?", 2).Updates(map[string]interface{}{"FirstName": "Cianluici", "LastName": "Buffon"}) 51 | db.First(&buffon, 2) //Direkt primary key üstünden(varsayılan olarak ID) arama yapar 52 | WriteToScreen(buffon) 53 | } else { 54 | fmt.Println(err.Error()) 55 | } 56 | } 57 | 58 | func WriteToScreen(e Southwind.Employee) { 59 | fmt.Printf("%d\t%s,%s,%s\n", e.ID, e.FirstName, e.LastName, e.CreatedAt) 60 | for _, email := range e.Emails { 61 | fmt.Printf("\t%d:%s\n", email.ID, email.Mail) 62 | } 63 | } 64 | -------------------------------------------------------------------------------- /Web Programming/Lesson_28/southwind/southwind.go: -------------------------------------------------------------------------------- 1 | package Southwind 2 | 3 | import ( 4 | "github.com/jinzhu/gorm" 5 | ) 6 | 7 | type Employee struct { 8 | gorm.Model 9 | FirstName string `gorm:"not null;size:30"` 10 | LastName string `gorm:"not null;size:30"` 11 | Emails []Email 12 | } 13 | 14 | type Email struct { 15 | gorm.Model 16 | EmployeeID int `gorm:"index"` 17 | Mail string `gorm:"type:varchar(50);unique_index"` 18 | IsActive bool 19 | } 20 | -------------------------------------------------------------------------------- /Web Programming/Lesson_29/NewsRoom/conf/app.conf: -------------------------------------------------------------------------------- 1 | appname = NewsRoom 2 | httpport = 8080 3 | runmode = dev 4 | -------------------------------------------------------------------------------- /Web Programming/Lesson_29/NewsRoom/controllers/default.go: -------------------------------------------------------------------------------- 1 | package controllers 2 | 3 | import ( 4 | "github.com/astaxie/beego" 5 | ) 6 | 7 | type MainController struct { 8 | beego.Controller 9 | } 10 | 11 | func (c *MainController) Get() { 12 | c.Data["Website"] = "beego.me" 13 | c.Data["Email"] = "astaxie@gmail.com" 14 | c.TplName = "index.tpl" 15 | } 16 | 17 | func (c *MainController) Wellcome() { 18 | 19 | c.Data["Id"] = c.Ctx.Input.Param(":id") 20 | c.Data["Website"] = "News Room" 21 | c.Data["Email"] = "selim@buraksenyurt.com" 22 | c.Data["EmailName"] = "Burak Selim Senyurt" 23 | c.TplName = "default/hello-newsroom.tpl" 24 | } 25 | -------------------------------------------------------------------------------- /Web Programming/Lesson_29/NewsRoom/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | _ "NewsRoom/routers" 5 | 6 | "github.com/astaxie/beego" 7 | ) 8 | 9 | func main() { 10 | beego.Run() 11 | } 12 | -------------------------------------------------------------------------------- /Web Programming/Lesson_29/NewsRoom/routers/router.go: -------------------------------------------------------------------------------- 1 | package routers 2 | 3 | import ( 4 | "NewsRoom/controllers" 5 | 6 | "github.com/astaxie/beego" 7 | ) 8 | 9 | func init() { 10 | beego.Router("/", &controllers.MainController{}) 11 | beego.Router("/wellcome/:id([0-9]+)", &controllers.MainController{}, "get:Wellcome") 12 | } 13 | -------------------------------------------------------------------------------- /Web Programming/Lesson_29/NewsRoom/static/js/reload.min.js: -------------------------------------------------------------------------------- 1 | function b(a){var c=new WebSocket(a);c.onclose=function(){setTimeout(function(){b(a)},2E3)};c.onmessage=function(){location.reload()}}try{if(window.WebSocket)try{b("ws://localhost:12450/reload")}catch(a){console.error(a)}else console.log("Your browser does not support WebSockets.")}catch(a){console.error("Exception during connecting to Reload:",a)}; 2 | -------------------------------------------------------------------------------- /Web Programming/Lesson_29/NewsRoom/tests/default_test.go: -------------------------------------------------------------------------------- 1 | package test 2 | 3 | import ( 4 | "net/http" 5 | "net/http/httptest" 6 | "testing" 7 | "runtime" 8 | "path/filepath" 9 | _ "NewsRoom/routers" 10 | 11 | "github.com/astaxie/beego" 12 | . "github.com/smartystreets/goconvey/convey" 13 | ) 14 | 15 | func init() { 16 | _, file, _, _ := runtime.Caller(1) 17 | apppath, _ := filepath.Abs(filepath.Dir(filepath.Join(file, ".." + string(filepath.Separator)))) 18 | beego.TestBeegoInit(apppath) 19 | } 20 | 21 | 22 | // TestBeego is a sample to run an endpoint test 23 | func TestBeego(t *testing.T) { 24 | r, _ := http.NewRequest("GET", "/", nil) 25 | w := httptest.NewRecorder() 26 | beego.BeeApp.Handlers.ServeHTTP(w, r) 27 | 28 | beego.Trace("testing", "TestBeego", "Code[%d]\n%s", w.Code, w.Body.String()) 29 | 30 | Convey("Subject: Test Station Endpoint\n", t, func() { 31 | Convey("Status Code Should Be 200", func() { 32 | So(w.Code, ShouldEqual, 200) 33 | }) 34 | Convey("The Result Should Not Be Empty", func() { 35 | So(w.Body.Len(), ShouldBeGreaterThan, 0) 36 | }) 37 | }) 38 | } 39 | 40 | -------------------------------------------------------------------------------- /Web Programming/Lesson_29/NewsRoom/views/default/hello-newsroom.tpl: -------------------------------------------------------------------------------- 1 |
2 |
3 |
4 |
5 |

News Room sitesine hoşgeldiniz

6 |

This is Beta Version

7 |

{{.Website}} {{.Email}} {{.EmailName}} {{.Id}}

8 |
9 |
10 |
11 |
-------------------------------------------------------------------------------- /Web Programming/Lesson_29/NewsRoom/views/index.tpl: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Beego 6 | 7 | 8 | 9 | 74 | 75 | 76 | 77 |
78 |

Welcome to Beego

79 |
80 | Beego is a simple & powerful Go web framework which is inspired by tornado and sinatra. 81 |
82 |
83 | 91 |
92 | 93 | 94 | 95 | 96 | -------------------------------------------------------------------------------- /Web Programming/Lesson_30/index.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "net/http" 6 | ) 7 | 8 | func main() { 9 | http.HandleFunc("/", Greetings) 10 | http.ListenAndServe(":2456", nil) 11 | } 12 | 13 | // HandleFunc bildirimine göre http://localhost:2456/ adresine gelecek taleplere header 1 formatında Wellcome Back cevabı verilecek 14 | func Greetings(res http.ResponseWriter, req *http.Request) { 15 | fmt.Fprintf(res, "

Wellcome Back

") 16 | } 17 | -------------------------------------------------------------------------------- /Web Programming/Lesson_30/index_test.go: -------------------------------------------------------------------------------- 1 | /* 2 | index.go'yu test edecek bir unit test içeriği 3 | index.go aslında bir web hizmeti sunuyor. 4 | oradaki Greetings fonksiyonunu test ediyoruz. 5 | */ 6 | package main 7 | 8 | import ( 9 | "net/http" 10 | "net/http/httptest" 11 | "testing" //test fonksiyonlarını içeren paket 12 | ) 13 | 14 | func Test_Greetings(t *testing.T) { 15 | newRequest, err := http.NewRequest("GET", "/", nil) //HTTP Get'ten test talebi üretiyoruz. 16 | if err != nil { 17 | t.Fatal(err) //Eğer talep sırasında hata oluştuysa Fatal test sonucu bırakıyoruz. 18 | } 19 | response := httptest.NewRecorder() //http talebi sonucunu tutacak bir kaydedici nesne 20 | Greetings(response, newRequest) //Test edilecek fonksiyon request ve response nesneleri ile çağırlıyor. 21 | // exptected := "

Wellcome Back

" //Beklediğimiz içerik 22 | exptected := "Wellcome Back" //Beklediğimiz içerik(bilerek hatalı ürettik) 23 | incoming := response.Body.String() // Gelen cevaptaki body içeriği 24 | if exptected != incoming { 25 | t.Fatalf("/ için yapılan talebe karşılık beklenen cevap gelmedi.\nBeklenen-> %s\nGelen-> %s", exptected, incoming) 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /_config.yml: -------------------------------------------------------------------------------- 1 | theme: jekyll-theme-minimal -------------------------------------------------------------------------------- /mainPage.html: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/buraksenyurt/golangsamples/0d02cb4e3b9673ccf6100526772d17ebee78bc5a/mainPage.html --------------------------------------------------------------------------------