- verinin 2. veriden büyüklüğü
- verinin 2. veriden küçüklüğü
- verinin 2. veriden büyük veya eşitliği
- verinin 2. veriden küçük veya eşitliği
Cobra CLI logo
Merhaba Dünya!
``` {% endcode %} **main.go** dosyamız ise aşağıdaki gibi olsun. {% code title="main.go" %} ```go package main import ( "net/http" "github.com/webview/webview" ) //sunucu başlatan fonksiyonumuz //aslında bunu main fonksiyonuna da // "go http.ListenAndServe(":5555", nil)" //şeklinde yazabilirsiniz. func serverOlustur() { //dinlecek portu belirttik (5555) http.ListenAndServe(":5555", nil) } func main() { //Sunucumuzun hangi klasörden oluşacağını //belirtiyoruz. (klasor isimli klasörümüzden) klasor := http.FileServer(http.Dir("klasor/")) //anasayfayı klasor'e bağlayalım. http.Handle("/", http.StripPrefix("/", klasor)) //eşzamanlı olarak sunucuyu başlatalım. go serverOlustur() //debug açık şekilde webview nesnesi oluşturalım. pencere := webview.New(true) //pencere başlığını girelim. pencere.SetTitle("Uygulamam") //pencere boyutunu ve normal pencere olacağını belirtelim. pencere.SetSize(600, 400, webview.HintNone) //Yukarıda başlattığımız sunucunun adresini girelim. pencere.Navigate("http://localhost:5555") //penceremizi başlatalım. pencere.Run() } ``` {% endcode %} Sıra geldi Backend (Golang) ve Frontend (Javascript) arasındaki iletişimi sağlamaya. Aşağıdaki işlemleri yukarıdaki klasör yapısında göre yapacağız. Yani bu şekilde: {% code title="Proje yapımız" %} ```bash . ├── klasor │ └── index.html └── main.go ``` {% endcode %} ## **Frontend’den Backend’e Veri Gönderme (JavaScript ===> Go)** Bu işlemi gerçekleştirebilmemiz için webview tarayıcısının frontend’deki sinyalleri dinlemesi gerekir. Golang tarafından dinlemek için **Bind()** fonksiyonunu kullanıyoruz. Örnek bir **main.go** dosyası oluşturalım. {% code title="main.go" %} ```go package main import ( "fmt" "net/http" "github.com/webview/webview" ) func serverOlustur() { http.ListenAndServe(":5555", nil) } func main() { klasor := http.FileServer(http.Dir("klasor/")) http.Handle("/", http.StripPrefix("/", klasor)) go serverOlustur() pencere := webview.New(true) pencere.SetTitle("Uygulamam") pencere.SetSize(600, 400, webview.HintNone) pencere.Navigate("http://localhost:5555") //Bind fonksiyonu ile dinleyici oluşturduk pencere.Bind("merhaba", func(isim string) { //Javascript'teki merhaba fonksiyonunu dinliyoruz. //Javascript'teki bu fonksiyona string bir değer girilecek. //Bu değeri de aşağıdaki gibi ekrana bastıracağız. fmt.Println("merhaba", isim) }) pencere.Run() } ``` {% endcode %} `Bind()` fonksiyonunu `pencere.Run()`'dan önce yazmalıyız. Eğer sonra yazarsak, çalışma zamanı `Run()` fonksiyonu kapatılmadan `Bind()` fonksiyonuna gelmeyeceği için yazmamızın bir mantığı olmaz. Sıra geldi websayfamızdaki kodları yazmaya. klasor klasörümüzün içerisine **uygulama.js** dosyası oluşturalım. {% code title="Proje yapımız" %} ```bash . ├── klasor │ ├── index.html │ └── uygulama.js << burada └── main.go ``` {% endcode %} **index.html** dosyamıza ise bir yazı kutusu ve buton ekleyelim. Ek olarak da **uygulama.js** dosyamızı html etiketi olarak ekleyelim. {% code title="index.html" %} ```markupMerhaba Dünya!
``` {% endcode %} Oluşturduğumuz HTML elementlerine id'ler vererek, bunları Javascript'te kullanacağız. **uygulama.js** dosyamızun içeriği ise aşağıdaki gibi olsun. {% code title="uygulama.js" %} ```javascript var yaziKutusu = document.querySelector("#isim") //yazı kutusunun id'sini belirttik var gonderButonu = document.querySelector("#gonder") //Gönder butonunun id'sini belirttik //Gönder butonuna tıklandığı zaman gerçekleşecek olaylar gonderButonu.addEventListener("click",() => { //yazı kutusunun içindeki değeri isim değişkeni olarak belirledik. var isim = yaziKutusu.value; //merhaba fonksiyonuna isim değişkeninin değerini yolladık. merhaba(isim) //Farkettiyseniz javascript tarafında merhaba adında bir fonksiyon //oluşturmadık. Normalde tarayıcı buna hata verecektir. //Ama biz golang tarafındaki webview'e merhaba fonksiyonunu bildirdik //ve dinleyici olarak tanıttık. }) ``` {% endcode %} Bu işlemler sonucunda uygulamamızı projemizin ana dizinindeyken `go run .` şeklinde başlatalım. **Yazı kutusu**na isim girip **Gönder** butonuna baştığımızda konsol tarafında `merhaba isim` şeklinde bir çıktı görürüz. ## **Backend’den Frontend’e Veri Gönderme (Go ===> JavaScript)** Aslında burada yapacağımız olay bir JavaScript kodu çalıştırmak veya tetiklemek de denebilir. Tıpkı Developer Console'dan yaptığımız gibi.. Bu işlem için `Eval()` fonksiyonundan faydalanıyoruz. Örnek için yukarıdaki kodlarımıza devam edelim. `merhaba` fonksiyonunu dinliyoruz demiştik. `Bind()` içerisinde komut satırına isim bastırmak yerine JavaScript konsoluna ismi bastıralım. `Bind()` fonksiyonumuzun içeriği şöyle olsun. ```go pencere.Bind("merhaba", func(isim string) { //Eval ile gönderilecek js kodumuzu oluşturalım. jsKodumuz := fmt.Sprintf("console.log('Merhaba, %s!')", isim) //isim değişkeni %s yerinde gösterilecek. pencere.Eval(jsKodumuz) }) ``` Uygulamamızı çalıştırıp yazı kutusuna bir isim girdiğimizde Komut satırından şöyle bir çıktı alabiliriz: > [http://localhost:5555/:1:12](http://localhost:5555/:1:12): CONSOLE LOG Merhaba, Kaan! İsterseniz Webview içerisindeki Developer Tool ile de bakabiliriz. Sayfaya sağ tıklayalım ve Inspect Element'e tıklayalım. Açılan bölümde **Console** sekmesine geçelim. All şeçeneğinin şeçili olduğundan emin olalım. Ve işte! log çıktımızın burada.  Bu işlemler ile kolay bir şekilde Backend-Frontend arası iletişimi sağlayabilirsiniz. ## Golang ile Webview'a Asenkron Müdahale Etme Go tarafında asenkron işlemler için **Goroutine**'leri kullandığımızı belirtmiştik. Backend tarafında zaman alan bir işlemi goroutine ile asenkron bir işlem parçacığı haline getirmezsek. İşlem tamamlanana kadar webview penceremiz yanıt vermez. Yani herhangi bir şeye tıklayamayız. Bu yüzden uzun sürecek arkaplan işlemlerini **Webview**'e aseknron şekilde çalıştırmamız gerekir. Örnek bir `Bind()` fonksiyonunda aseknron bir işlemi inceleyelim. ```go pencere.Bind("merhaba", func(isim string) { //asenkron çalışan bir anonim fonksiyon oluşturalım go func(){ //3 saniye beklesin time.Sleep(3*time.Second) //ve ekrana JavaScript tarafından gelen //isim değişkenini bastırsın. fmt.Println(isim) }() }) ``` Yukarıdaki örnekte JavaScript tarafından çalıştırılacak merhaba fonksiyonunu dinliyoruz. Bu fonksiyon bize string tipinde bir değer iletiyor. Asenkron olarak anonim bir fonksiyon oluşturuyoruz ve içeriğinde 3 saniye beklemesini istiyoruz. Son olarak ekrana isim değişkenindeki değeri bastırıyoruz. Eğer bu kodları asenkron olarak çalıştırmasaydık, Webview penceremiz 3 saniye boyunca yaptığımız hiçbir işleme tepki vermeyecekti. Şimdi buraya kadar karışık bir olay yok aslında. Asıl asenkron mantığı 3 saniye bekleyip çıktımızı JavaScript konsoluna bastırmak olacaktır. Aralarındaki asenkron olayı bu şekilde sağlancaktır. Normalde asenkron iki işlemin birinden diğerine ait olan bir işlemi yapmak için işaretçileri _(pointer)_ kullanabiliriz. Fakat Webview nesnesine bir işaretçi atayamayız. Çünkü webview ile oluşturulan nesnemiz bir interface'tir. Örnek bir deneme girişimi 😀 {% code title="main.go" %} ```go package main import ( "fmt" "net/http" "time" "github.com/webview/webview" ) func serverOlustur() { http.ListenAndServe(":5555", nil) } func main() { klasor := http.FileServer(http.Dir("klasor/")) http.Handle("/", http.StripPrefix("/", klasor)) go serverOlustur() pencere := webview.New(true) pencere.SetTitle("Uygulamam") pencere.SetSize(600, 400, webview.HintNone) pencere.Navigate("http://localhost:5555") pencere.Bind("merhaba", func(isim string) { //fonksiyonumuzu asenkron olarak başlatıyoruz go fonksiyonumuz(&pencere, isim) //parametre olarak pencere nesnesinin adresini verdik //aynı şekilde isim değişkenini de }) pencere.Run() } func fonksiyonumuz(p *webview.WebView, isim string) { //3 saniye beklemesini istedik time.Sleep(3 * time.Second) //Eval ile gönderilecek JS kodumuzu hazırlayalım jsKodumuz := fmt.Sprintf("alert('%s')", isim) //İşte geldik Zurnanın zırt dediği yere (kullandığım deyime takılmayın 😀) p.Eval(jsKodumuz) //Bu kısımda böyle bir kullanım yapamayacağımızı söylüyor olacak. } ``` {% endcode %}  Şuana kadar gösterdiğim şeyler bir yanlış yapmayın diyeydi. Yukarıdaki yöntemi doğru değildir. Doğrusu `Dispatch()` fonksiyonunu kullanmaktır. Go kodlarımızın tamamını görecek şekilde bir örnek verelim. Örnek kullanımı: {% code title="main.go" %} ```go package main import ( "fmt" "net/http" "time" "github.com/webview/webview" ) func serverOlustur() { http.ListenAndServe(":5555", nil) } func main() { klasor := http.FileServer(http.Dir("klasor/")) http.Handle("/", http.StripPrefix("/", klasor)) go serverOlustur() pencere := webview.New(true) pencere.SetTitle("Uygulamam") pencere.SetSize(600, 400, webview.HintNone) pencere.Navigate("http://localhost:5555") pencere.Bind("merhaba", func(isim string) { //fonksiyonumuzu asenkron olarak başlatıyoruz go fonksiyonumuz(pencere, isim) //parametre olarak pencere nesnesini & olmadan verdik }) pencere.Run() } func fonksiyonumuz(p webview.WebView, isim string) { //3 saniye beklemesini istedik time.Sleep(3 * time.Second) //Eval ile gönderilecek JS kodumuzu hazırlayalım jsKodumuz := fmt.Sprintf("alert('%s')", isim) //Dispatch fonksiyonu ile ana iş parçacığındaki webview //nesnesi ile işlem yapabiliriz. p.Dispatch(func() { p.Eval(jsKodumuz) }) } ``` {% endcode %} ## Webview Kütüphanesindeki Diğer Fonksiyonlar ### Destroy() Webview penceremizi sonlandırır. ```go pencere.Destroy() ``` ### Terminate() Pencerenin çalışmasını keser. ```go pencere.Terminate() ``` ### Eval() Pencerede JavaScript kodu çalıştırmamızı sağlar. ```go pencere.Eval("alert('Merhaba!')") ``` ### Init() Pencereye JavaScript kodu iliştirir. `Eval()` fonksiyonundan farkı ise sayfa değişse bile JavaScript kodu sayfada kalır. `Eval()` ile bir kere mahsus JavaScript kodu çalıştırılır. `Init()` fonksiyonunda sayfa yenilenince bile kod çalışırır. ```go pencere.Init("alert('Merhaba!')") ``` ### Navigate() Webview penceresinin belirtilen adresi yüklemesini sağlar. ```go pencere.Navigate("https://www.google.com.tr") ``` ### Run() Pencereyi başlatır. ```go pencere.Run() ``` ### SetSize() Pencerenin boyutunu ve etkileşimini ayarlar. ```go //Genişlik, Uzunluk, Etkileşim pencere.SetSize(800, 600, webview.HintNone) //webview.HintNone ile normal, //webview.HintFixed ile boyutu değiştirilemeyen, //webview.HintMax ile en fazla solundaki büyüklükte, //webview.HintMin ile en az solundaki küçüklükte //bir pencere oluşturabiliriz. ``` ### SetTitle() Pencerenin başlığını değiştirmemizi sağlar. ```go pencere.SetTitle("Uygulama Başlığım") ``` ================================================ FILE: kitap-hakkinda/katkida-bulunanlar.md ================================================ --- description: Değerli vaktini ayırıp, dökümanın geliştirilmesine katkıda bulunan kişiler --- # Katkıda Bulunanlar \*Liste harf sıralamasına göre yapılmıştır. | PP | Kişi | Github | | ----------------------------------------------------------------------------------------------------------------- | -------------------- | --------------------------------------------------- | |
| Adem Ali Durmuş | [@ademalidurmus](https://github.com/ademalidurmus) |
| 
| Adem İlter | [@ademilter](https://github.com/ademilter) |
| 
| Aykut Kardaş | [@aykutkardas](https://github.com/aykutkardas) |
| 
| Berkay Çoban | [@berkaycoban](https://github.com/berkaycoban) |
| 
| Emre Önal | [@emmreonal](https://github.com/emmreonal) |
| 
| Erhan Yakut | [@yakuter](https://github.com/yakuter) |
| 
| Hazarek | [@hazerek](https://github.com/hazarek) |
| 
| Latif Uluman | [@latif70427517](https://twitter.com/latif70427517) |
| 
| Mert Şimşek | [@mertingen](https://github.com/mertingen) |
| 
| Murat Mirgün Ercan | [@muratmirgun](https://github.com/muratmirgun) |
| 
| Yunus Emre Geldegül | [@emregeldegul](https://github.com/emregeldegul) |
| 
| Yusuf Dündar | [@yusufdundar](https://github.com/yusufdundar) |
| 
| Yusuf Turhan Papurcu | [@yusufpapurcu](https://github.com/yusufpapurcu) |
================================================
FILE: mikro-denetleyiciler/gobot-ile-arduino-yanip-soenen-led-yapimi.md
================================================
# Gobot ile Arduino Yanıp-Sönen LED Yapımı
Bu yazımda sizlere Golang için Robotik kütüphanesi olan **Gobot**‘tan bir örnek göstereceğim. Bu örneğimizde Arduino’da yanıp sönen LED yapacağız.\
İlk olarak Gobot kütüphanesini indiriyoruz.
> go get -d -u gobot.io/x/gobot/...
Daha sonra Arduino’muzla iletişim kurabilmemiz için **Gort**‘u yüklememiz gerekiyor.\
[https://gort.io/documentation/getting\_started/downloads/](https://gort.io/documentation/getting\_started/downloads/)\
Bu örnekte **Arduino Uno** kullanacağız. Arduino’muzun bilgisayarımıza bağlıyoruz ve hangi porta bağlı olduğunu öğrenmek için komut satırına aşağıdakileri yazıyoruz.
> gort scan serial
Windows’ta **\
Tablo görünümü
{{ .başlık }}
``` Burada `{{ .başlık }}` yerine Go'dan değer göndereceğiz. `main.go` dosyamız ise aşağıdaki gibi olsun. ```go package main import ( "github.com/gin-gonic/gin" ) func main() { router := gin.Default() //Burada templates klasörünün içindeki tüm şablonları //yüklemesini isteyelim. router.LoadHTMLGlob("templates/*") router.GET("/", index) router.Run() } func index(c *gin.Context) { //HTML şablonunu almak için //HTML fonksiyonunu kullanıyoruz. c.HTML(200, "index.html", gin.H{ //Şablondaki başlık yerine Anasayfa yazısını yollayalım. "başlık": "Anasayfa", }) } ``` Web sunucumuza bağlandığımızda ise **Anasayfa** yazdığını görebiliriz. ## 🔘 Statik Dosyaları Yayınlama Web sunucumuzda kullanacağımız Css, JS vb. statik dosyalarımız olabilir. Bunun için `Static` fonksiyonunu kullanabiliriz. Statik dosyalarımızı projemizin ana dizindeki `statik` klasöründe barındırdığımızı varsayalım. ```go func main() { router := gin.Default() //(yönlendirme, klasör-ismi) router.Static("/static", "./statik") router.GET("/", index) router.Run(":9000") } ``` `statik` klasörümüzün içerisinde `index.js` adında bir dosya olduğunu varsayarsak `http://localhost:9000/static/index.js` adresinden ulaşabiliriz. ## 🔘 Bağlantı Metodları Örnek bağlantı oluştururken GET metoduna değindik. Metodları test ediyorken **Postman**'i kullanabilirsiniz. Ben bu konuda **curl** komut satırı aracını kullanacağım. Detaylarına bakacak olursak: ### ➡️ GET Metodu `GET` metodu web sunucumuza normal bağlantı yapılırken kullanılır. Hazır bir kaynağı yüklemek için kullanılır. ```go router.GET("/", index) ``` `index` fonksiyonu ile `GET` metodlu anasayfayı yakalayabilirsiniz. ### ➡️ POST Metodu POST metodu genellikle form gönderimlerinde kullanılır. Yeni bir kaynak oluşturmak için kullanılır. (Yeni kayıt oluşturma, yeni gönderi oluşturma vb...) Örnek kullanımını görelim. ```go package main import ( "github.com/gin-gonic/gin" ) func main() { router := gin.Default() //Burada templates klasörünün içindeki tüm şablonları //yüklemesini isteyelim. router.LoadHTMLGlob("templates/*") router.GET("/", getIndex) router.POST("/", postIndex) router.Run(":9000") } func getIndex(c *gin.Context) { c.String(200, "GET metodu ile bağlanıldı.") } func postIndex(c *gin.Context) { c.String(200, "POST metodu ile bağlanıldı.") } ``` Yukarıdaki örnekte anasayfa `GET` ile bağlanıldığında `getIndex`, `POST` ile bağlanıldığında `postIndex` fonksiyonu çalışacak. Tarayıcımızdan girdiğimizde "_GET metodu ile bağlanıldı._" yazısını görürüz. `POST` metodu ile bağlanmak için komut satırına şu komutları yazalım. > curl -X POST http://localhost:9000 Çıktısı "_POST metodu ile bağlanıldı._" olacaktır. POST metodu üzerinden değer almayı görelim. ```go //json verisi için yapımız type kişi struct { Ad string `json:"ad"` Soyad string `json:"soyad"` } func postIndex(c *gin.Context) { //posttan gelen json'ın kaydedileceği değişken var postkişi kişi //postan gelen json'ı postkişi'ye atayalım c.BindJSON(&postkişi) c.String(200, "JSON Veri:") //json'ı tekrar post ile gösterelim c.JSON(200, postkişi) } ``` Komut satırına aşağıdaki komutu yazarak çıktısını görebilirsiniz. > curl -X POST -H "Content-Type: application/json" -d '{"ad":"kaan","soyad":"kuşcu"}' [http://localhost:9000](http://localhost:9000) ### ➡️ Diğer Metodlar Diğer metodlardan kısaca bahsedelim: * **PATCH metodu:** Bir kaynak üzerindeki belirli bir alanı değiştirmek için kullanılır. * **DELETE metodu:** Sunucudaki bir kaynağı silmeye yarar. * **PUT metodu:** Bir kaynağın yerine başka bir kaynağı koymaya yarar. (Komple değiştirme) * **HEAD metodu:** Sunucuya tıpkı GET metodu gibi fakat sadece başlığı olan bir istek gönderir. * **OPTIONS metodu:** Sunucunun desteklediği metodları kontrol etmek için kullanılır. ## 🔘 Adreslendirme ### ➡️ Parametre ile Adreslendirme Örneğin:  ```go package main import ( "github.com/gin-gonic/gin" ) func main() { router := gin.Default() router.GET("/blog/:yazı", blog) //Buradaki :yazı bizim parametremiz //Bu parametre ile hangi blog yazısını //göstereceğimizi belirleyeceğiz. router.Run(":9000") } func blog(c *gin.Context) { //yazı parametresininde geleni sayfaİsmi değişkenine atayalım. sayfaİsmi := c.Param("yazı") c.String(200, "Şuanda "+sayfaİsmi+" blogunu okuyorsunuz.") } ``` Yukarıdaki örneğe göre [http://localhost:9000/blog/gin%20ile%20sunucu%20geli%C5%9Ftirme](http://localhost:9000/blog/gin%20ile%20sunucu%20geli%C5%9Ftirme) adresine gittiğimizde "_Şuanda gin ile sunucu geliştirme blogunu okuyorsunuz._" yazısı ile karşılacağız. Tabi ki birden fazla parametre ekleyebilirsiniz. ```go package main import ( "github.com/gin-gonic/gin" ) func main() { router := gin.Default() router.GET("/blog/:yazar/:yazı", blog) router.Run(":9000") } func blog(c *gin.Context) { yazar := c.Param("yazar") yazı := c.Param("yazı") c.String(200, "Yazar: "+yazar+" Yazı: "+yazı) } ``` ### ➡️ Querystring (Sorgu dizesi) ile Adreslendirme Örneğin:  ```go package main import ( "github.com/gin-gonic/gin" ) func main() { router := gin.Default() router.GET("/arama", arama) router.Run(":9000") } func arama(c *gin.Context) { tür := c.Query("tur") sıralama := c.Query("siralama") c.String(200, tür+" türünden filmler "+sıralama+" olarak sıralanıyor.") } ``` Yukarıdaki örneğe göre [http://localhost:9000/arama?tur=bilim-kurgu\&siralama=imdb](http://localhost:9000/arama?tur=bilim-kurgu\&siralama=imdb) adresine girdiğimizde "_bilim-kurgu türünden filmler imdb olarak sıralanıyor._" yazılı bir sonuç elde edeceğiz. ### Göz atmanızı önerdiğim yazı: {% embed url="https://kaanksc.com/go-web-sunucuda-kullanici-girisi-sistemi" %} ================================================ FILE: web-sunucu-server-ag-istemleri/gin-web-kuetuephanesi/gin-dosya-yuekleme.md ================================================ # Gin Dosya Yükleme Bu yazıda Gin kütüphanesinden `POST` isteği ile nasıl dosya yükleyeceğimizi göreceğiz. Aşağıda projemizin dizin/dosya yapısı bulunuyor. ``` . ├── main.go └── public └── index.html ``` İlk olarak `index.html` dosyamızı görelim. ```markupYüklemek için 1 adet dosya seçin
``` Detaylıca değinmiyorum. `input` elementlerinin `name` özelliğinde ne isim verdiğimizi dikkat etmemiz yeterli. `form` elementinin action özelliğine `/yukle` adresini verdik. `main.go` dosyamız ise aşağıdaki gibi olacaktır. Detaylarına yorum satırlarında değindim. ```go package main import ( "fmt" "path/filepath" "github.com/gin-gonic/gin" ) func main() { router := gin.Default() //Yükleme yapacağımız dosyanın maksimum boyutunu //ayarlayalım. router.MaxMultipartMemory = 8 << 20 // 8 MiB //index.html dosyamızın bulunduğu klasörü static olarak //ekliyoruz ki index.html dosyamızı kullanabilelim. router.Static("/", "./website") //yukleme işlemini yapacak olduğumuz yönlendirmeyi //buradan ayarlıyoruz. router.POST("/yukle", func(c *gin.Context) { //form içerisindeki dosya hariç verilerimizi //atayalım isim := c.PostForm("isim") eposta := c.PostForm("email") // Dosyamızı ise özel fonksiyon ile atıyoruz dosya, hata := c.FormFile("dosya") //Hata kontrolü yapmayı unutmayalım. if hata != nil { c.String(400, fmt.Sprintf("Form Hatası: %s", hata.Error())) return } //yüklenecek olan dosyanın ismini alalım. dosyaismi := filepath.Base(dosya.Filename) //yüklenen dosyanın kaydedileceği konum // dizin + dosyaismi kayıtYeri := "./website/" + dosyaismi //dosyayı kaydedelim ve hata kontrolü yapalım. if hata := c.SaveUploadedFile(dosya, kayıtYeri); hata != nil { c.String(400, fmt.Sprintf("Dosya Yükleme Hatası: %s", hata.Error())) return } //Şuana kadar herhangi bir sıkıntı ile //karşılaşmadıysak, olumlu mesajımızı gösterelim. c.String(200, fmt.Sprintf("%s isimli dosya başarıyla yüklendi \nİsim: %s\nE-posta: %s", dosya.Filename, isim, eposta)) }) router.Run(":8080") } ``` ================================================ FILE: web-sunucu-server-ag-istemleri/grpc.md ================================================ # gRPC ## gRPC Nedir? gRPC, Google tarafından geliştirilen, açık kaynaklı uzaktan prosedür çağırma (rpc) kütüphanesi (sistemi)'dir. Aktarım için `HTTP/2` kullanır. Arayüz tanımlama dili olarak `protokol tamponları (buffers)` kullanır. Kimlik doğrulama, Çift yönlü akış, engelleme ve engelleme olmayan bağlantılar, iptal ve zaman aşımı işlemleri için kullanılır. JSON ve HTTP API'larının aksine, daha katı bir spesifikasyona sahiptirler. Tek bir spesifikasyona sahip olduğu için, gRPC tartışmalarını ortadan kaldırır ve geliştiriciye zaman kazandırır. Çünkü gRPC, platformlar ve uygulamalar arasında tutarlıdır. Özet olarak, uzaktan prosedür çağırarak client (müşteri) ve server (sunucu) programları arasındaki iletişimi sağlayan bir kütüphanedir. ## Protokol Tamponları (Buffers) Nedir? İki uygulama arasındaki iletişimin nasıl olacağını belirleyen sözleşmedir. ## Örnek Uygulama Yapalım Bu örneğimizde sunucuya mesaj gönderip, karşılığında mesaj alan bir uygulama yazacağız. Bir nevi chat uygulaması olacak. Öncelikle, iletişim protokülünü Go koduna dönüştürebilmemiz (generating) için `protoc`'yi bilgisayarımıza kuralım. İndirmek için [buradaki](https://github.com/protocolbuffers/protobuf/releases/tag/v3.13.0) adrese gidin. Buradaki versiyon v3.13.0 versiyonu. Daha güncel versiyonlar için [buradaki](https://github.com/protocolbuffers/protobuf/releases/) sayfayı kontrol etmeyi unutmayın.  GNU/Linux İS kullanan arkadaşlarımız uygulama depolarından protobuf adıyla yükleyebilirler. Böylece PATH olarak eklemelerine gerek kalmaz. ## Sisteme Yol Olarak Ekleme Eğer GitHub sayfasından indirdiyseniz, sisteminize dosya yolunu tanıtmanız gerekir. Bunun için örnek olarak; ### Windows üzerinde Örnek olarak `protoc.exe` dosyamız `C:\\protoc\bin` klasörü içerisinde olsun. Başlar menüsünde _"Ortam değişkenleri"_ yazarak aratalım. Açılan pencerede _Gelişmiş_ sekmesinde alt tarafta _Ortam Değişkenleri_ butonuna basalım. _PATH_ seçeneğini _Düzenle_ diyerek `protoc.exe`'nin konumunu ekleyelim. ### GNU/Linux, MacOS vs. Bash Kullanan Sistemler Üzerinde `protoc` çalıştırılabilir dosyamızı örnek olarak `Home (Ev)` dizinine atmış olalım. **Örnek:** `~/protoc/bin` olsun. Ev dizinimizdeki `.bashrc` dosyamızın en altına şunları ekleyelim. ``` export PATH="~/protoc/bin:$PATH" ``` `.bashrc` dosyasını kaydettikten sonra komut satırına `source ~/.bashrc` yazarak dosyada yaptığımız değişimi onaylayalım. #### Protoc'yi kontrol edelim Komut satırına aşağıdakileri yazarak `protoc`'nin versiyonuna bakalım. ``` protoc --version ``` `Protoc`'ye Golang desteğini eklemek için aşağıdaki paketleri kuralım. ``` go get google.golang.org/protobuf/cmd/protoc-gen-go go get google.golang.org/protobuf/cmd/protoc-gen-go-grpc ``` Aynı şekilde Windows üzerinde `C:\\Users\isim\go\bin` klasörünü ekli değilse ortam değişkenlerine ekleyelim. Unix-like sistemler için `~/go/bin`'i path'e ekleyelim. Yukarıda belirttiğimiz örnek `chat` uygulamasını yazmak için aşağıdaki gibi bir proje yapımız olacak. ``` . ├── chat │ └── chat.go ├── chat.proto ├── client.go └── server.go ``` Client ve Server arasındaki iletişim protokolünü belirleyelim. `chat.proto` dosyamız şöyle olsun. ```groovy //Söz dizimi için proto3'ü kullanacağız syntax = "proto3"; //Go paketi için ayarlarımız package chat; option go_package=".;chat"; //iletişimde kullanılacak mesajın yapısı message Message { string body = 1; //buradaki 1 sıra numarasıdır. Değer ataması değildir. } //rpc servisimiz service ChatService { rpc SayHello(Message) returns (Message) {} } ``` Yukarıdaki `chat.proto` dosyasını Go koduna dönüştürelim. Bunun için proje dizinindeyken aşağıdaki komutu yazalım. > protoc --go\_out=plugins=grpc:chat chat.proto Bu işlem sonucunda chat klasörümüzüm içerisinde `chat.pb.go` dosyamız oluşacak. Bu dosyanın en başında yorum olarak düzenleme yapmamızın uygun olamayacağı yazıyor. O yüzden bu dosyayla çok uğraşmamakta fayda var. ## Server (Sunucu) Oluşturalım `chat` klasörümüzdeki `chat.go` dosyasını oluşturalım. ```go package chat import ( "log" "golang.org/x/net/context" ) type Server struct { //Burası şuanlık boş olacak } //server nesnemize iliştirilecek fonksiyonumuz func (s *Server) SayHello(ctx context.Context, message *Message) (*Message, error) { //Client'ten gelen mesajı ekrana bastıralım log.Printf("Clientten mesaj alındı: %s", message.Body) //mesaj gelince değer döndürelim (mesaj ve hata) return &Message{Body: "Server'dan merhaba!"}, nil //hata nil olsun } ``` Go modules'tan faydalanarak chat paketini diğer paketlerde kullanabiliriz. Bunun için proje dizinindeyken komut satırına: > go mod init github.com/ksckaan1/grpcOrnek yazalım. Buradaki yaptığımız şey, GitHub'a paket yüklemeden sanal olarak yazdığımız `chat` paketini kullanabileceğiz. Bu komuttan sonra proje dizinimizde `go.mod` dosyası oluşacak. Böylece chat klasörünü paket olarak diğer yerlerde de kullanabileceğiz. `server.go` dosyamızı oluşturalım. ```go package main import ( "log" "net" "github.com/ksckaan1/grpcExample/chat" "google.golang.org/grpc" ) func main() { //tcp dinleyelim lis, err := net.Listen("tcp", ":9080") //hata kontrolü yapalım if err != nil { log.Fatalf("9080 portu dinlenirken hata oluştu: %v \n", err) } //chat server nesnesi oluşturalım s := chat.Server{} //grpc server'ı oluşturalım. grpcServer := grpc.NewServer() //tcp sunucu ile grpc'yi bağlayalım. chat.RegisterChatServiceServer(grpcServer, &s) //hata kontrolü if err := grpcServer.Serve(lis); err != nil { log.Fatalf("grpcServer oluşturulurken hata : %v", err) } } ``` `go run server.go` komutunu yazarak test edelim. Eğer çıktı vermiyorsa ve program kapanmıyorsa server dinleniyor demektir. Yani şuana kadar başarılıyız. ## Client (Müşteri) Oluşturalım Şimdi de Server'a mesaj yollayabilmek için Client'i oluşturalım. `client.go` dosyamız aşağıdaki gibi olsun. ```go package main import ( "log" //chat klasörünü kullanacağımız için //go mod init üzerinde belirlediğimiz deponun //sonuna /chat ekliyoruz. "github.com/ksckaan1/grpcExample/chat" "golang.org/x/net/context" //grpc kütüphanemiz "google.golang.org/grpc" ) func main() { //grpc client bağlantı nesnesi var conn *grpc.ClientConn //grpc ye 9080 portunu dinlemesini söyleyelim conn, err := grpc.Dial(":9080", grpc.WithInsecure()) if err != nil { log.Fatalf("9080 portu dinlenirken hata oluştu: %v", err) } //bağlantığı kapatmayı unutmayalım defer conn.Close() //Client nesnesi oluşturalım c := chat.NewChatServiceClient(conn) //server'a gönderilecek mesajı belirleyelim message := chat.Message{ Body: "Client'ten merhabalar!", } //Server'dan dönen cevabı alalım response, err := c.SayHello(context.Background(), &message) //hata kontrolü yapalım. if err != nil { log.Fatalf("SayHello fonksiyonu çağırılıken hata oluştu: %v", err) } //server'dan gelen mesajı ekrana bastıralım log.Printf("Server'dan gelen cevap: %s", response.Body) } ``` Yukarıda yazdığımız kodların çalışma mantığını açıklayacak olursak: 1. Server `9080` portunu belirlediğimiz protokol sözleşmesine (_chat.proto_) göre dinliyor. 2. `Client.go` dosyamız çalıştırılınca server'a mesaj yolluyor. 3. Client'ten gelen mesajı server ekrana bastırıyor ve bunun karşılığında server client'e cevap veriyor. 4. Server'dan gelen cevabı da client ekrana bastırıyor. 5. Son olarak client programımız sonlanıyor (kapanıyor). Gif olarak sonucu göstermek gerekirse:  ================================================ FILE: web-sunucu-server-ag-istemleri/herokuda-go-uygulamasi-yayinlama.md ================================================ # Heroku'da Go Uygulaması Yayınlama ## Öncelikle Bilmeyenler İçin Heroku Nedir? Kısaca Heroku, JavaScript, Go, Ruby, Python, Scala, PHP, Java, Clojure ile geliştirdiğimiz sunucu uygulamalarını ücretsiz barındırabileceğimiz bir platformdur. Aşağıdaki bağlantıdaki blog yazısını okumanızı tavsiye ederim. {% embed url="https://ceaksan.com/tr/heroku-nedir" %} ## Projemizi Planlayalım Bu örneğimizde bir web sunucu oluşturacağız. Öncelikle `Go modules` kullanacağımız için projemizi kullanıcının go dizinine oluştumalıyız. Komut satırını açalım ve aşağıdaki komutu yazarak bahsettiğimiz dizine geçelim. Windows'ta: > cd C:\\\Users\\%username%\go\src GNU/Linux ve MacOS'te: > cd \~/go/src Bu konuma proje dizinimizi oluşturalım > mkdir heroku-app `heroku-app` klasörü projemizin ana dizini olacak. Aşağıdaki komut ile proje ana dizinimize girelim. > cd heroku-app Daha sonra bu dizini `code .` komutu ile VSCode üzerinde açalım. `main.go` dosyamızı oluşturalım ve aşağıdaki gibi olsun. ```go package main import ( "fmt" "net/http" "os" ) func main() { port := os.Getenv("PORT") http.HandleFunc("/", anaSayfa) http.ListenAndServe(":"+port, nil) } func anaSayfa(w http.ResponseWriter, r *http.Request) { port := os.Getenv("PORT") fmt.Fprintf(w, "Merhaba Dünya!\nKullanılan Port: "+port) } ``` Yukarıda normal web sunucu oluşturma kodlarından biraz farklı işlemler var. Bunları açıklamak gerekir ise: `port` değişkenimiz sistemden `string` tipinde `PORT` ortam değişkenini alıyor. Yani `port` değişkeni sunucumuzun hangi portta çalışacağını belirliyor. Uygulamamızı Heroku'ya yükledikten sonra sistemimiz Heroku olduğu için port ortam değişkenini Heroku'dan almış olacağız. Sunucunun çalışacağı portu Heroku belirlediği için portu kendimiz kodlar içinde belirleyemiyoruz. `http.ListenAndServe()` fonksiyonuna da parametre olarak `":"+port` vererek devam ediyoruz. Sunucumuzun ana dizinini yakalacak olan anaSayfa fonksiyonumuza bakalım. Yine burada sistemden portu istedik. Hemen aşağısında "Merhaba Dünya!" ve kullanılan portun çıktısını vermesini sağladık. Kodlarımız artık hazır. Bu projemizde dışarıdan bir pakete ihtiyacımız olmadı. Hepsi Go'nun hazır paketlerinden. Eğer dışarıdan paketler olsa ne yapacaktık? Hadi hemen görelim. Komut satırına go modules için aşağıdaki komutu yazalım. > go mod init {% hint style="warning" %} Eğer projenizi go/src klasörü içinde oluşturmazsanız bu komut hata verecektir. {% endhint %}  Böylece go.mod dosyamızı oluşturduk. Dışarıdan paket bağımlılıklarını yüklemek için aşağıdaki komutu yazalım. > go mod vendor Bu komutu yazdığınızda paket bağımlılığınız yoksa aşağıdaki gibi bir çıktı alacaksınız.  Eğer paket bağımlılığınız varsa projenizin ana dizininde vendor adında bir klasör oluşacak ve bu klasörün içinde dış paketlerin kaynak kodları bulunanacak. ## Versiyon sistemli hale getirelim Heroku platformu versiyon kontrol sistemi ile çalıştığı için, öncelikle git projemizi oluşturalım. Projemizin ana dizinindeyken komut satırına: > git init Daha sonra oluşturduğumuz projeyi staging'e almak için: > git add . yazalım. Commit oluşturmak için ise: > git commit -m "Heroku uygulamamı oluşturdum." ## Heroku'da Yayınlama Öncelikle Heroku'nun komut satırı uygulamasını bilgisayarımıza kuralım. Windows, MacOS ve Ubuntu için [bu adresten](https://devcenter.heroku.com/articles/heroku-cli#download-and-install) kurabilirsiniz. Arch Linux ve türevleri için kolaylık açısından AUR üzerinden `heroku-cli-bin` aratarak kurabilirsiniz. Uygulamayı kurduktan sonra Heroku Hesabımıza bağlayalım. Komut satırına aşağıdakileri yazalım. > heroku login Şöyle bir çıktı verecek:  q tuşuna basınca giriş yapmayı iptal eder. O yüzden giriş yapmak için herhangi bir tuşa başabilirsiniz. (Lütfen bilgisayarınızın güç tuşuna basmayın 🙂) Daha sonra varsayılan tarayıcınız üzerinden giriş yapma sayfası açılacak. Heroku hesabınıza girdikdek sonra tarayıcınızda girişin başarılı olduğunu söylecek.  Komut satırında da aşağıdaki gibi bir çıktı göreceksiniz. Kendi bilgilerim olduğu için birazını sansürledim.  Böylece başarıyla giriş yapmış olduk. Heroku projemizi oluşturalım. > heroku create Şöyle bir çıktı alacağız.  Yazdığımız kodları Heroku uygulamamıza yükleyelim. > git push heroku master Bu komut sonrasında aşağıdakine benzer bir sonuç almanız gerekir. ```go [kaanksc@KAANHP heroku-app]$ git push heroku master Enumerating objects: 4, done. Counting objects: 100% (4/4), done. Delta compression using up to 4 threads Compressing objects: 100% (3/3), done. Writing objects: 100% (4/4), 477 bytes | 477.00 KiB/s, done. Total 4 (delta 0), reused 0 (delta 0), pack-reused 0 remote: Compressing source files... done. remote: Building source: remote: remote: -----> Go app detected remote: -----> Fetching jq... done remote: -----> Fetching stdlib.sh.v8... done remote: -----> remote: Detected go modules via go.mod remote: -----> remote: Detected Module Name: heroku-app remote: -----> remote: !! The go.mod file for this project does not specify a Go version remote: !! remote: !! Defaulting to go1.12.17 remote: !! remote: !! For more details see: https://devcenter.heroku.com/articles/go-apps-with-modules#build-configuration remote: !! remote: -----> New Go Version, clearing old cache remote: -----> Installing go1.12.17 remote: -----> Fetching go1.12.17.linux-amd64.tar.gz... done remote: -----> Determining packages to install remote: remote: Detected the following main packages to install: remote: heroku-app remote: remote: -----> Running: go install -v -tags heroku heroku-app remote: heroku-app remote: remote: Installed the following binaries: remote: ./bin/heroku-app remote: remote: Created a Procfile with the following entries: remote: web: bin/heroku-app remote: remote: If these entries look incomplete or incorrect please create a Procfile with the required entries. remote: See https://devcenter.heroku.com/articles/procfile for more details about Procfiles remote: remote: -----> Discovering process types remote: Procfile declares types -> web remote: remote: -----> Compressing... remote: Done: 3.6M remote: -----> Launching... remote: Released v3 remote: https://obscure-ocean-33068.herokuapp.com/ deployed to Heroku remote: remote: Verifying deploy... done. To https://git.heroku.com/obscure-ocean-33068.git * [new branch] master -> master ``` Yukarıdaki çıktıya göre aşağıdaki işaretlediğim yerde uygulamamızın adresi olacak.  Bu adres tabiki de sizde farlı olacak. Buradan girip uygulamanızı kontrol edebilirsiniz. Benim sonucum ise şu şekilde:  ================================================ FILE: web-sunucu-server-ag-istemleri/html-sablonlar-templates.md ================================================ # HTML Şablonlar (Templates) HTML Şablonlar, Golang üzerinde web sayfalarının dinamikliği için kullanılır. Yani şablonlar kullanarak web sayfalarımızın belirlediğimiz bölümlerini Go üzerinden değişikliğe uğratabiliriz. Bu yazımızda HTML şablonların nasıl oluşturulacağına bakacağız. Çalışma mantığı çok basit. Şablon olarak kullanacağımız html dosyasınında sadece tasarımı yapıyoruz ve dinamik olacak kısımlara ise bir nevi işaretler koyuyoruz. Daha sonra Go bu şablon dosyasını işliyor ve işaret koyduğumuz yerlere gelecek değerleri yerleştiriyor. Düz mantık olarak bu işi yapıyor. ## ✨ Örnek Kullanım ```markup Merhaba, {{ . }} ``` Yukarıdaki örnekte `{{ }}` süslü parantezler içerisinde . (nokta) yazıyor. Bu da Go şablon işlenirken bu kısma Go tarafından vereceğimiz değerin geleceği anlamına geliyor. Şimdi yukarıdaki örneğimizi `sablon.html` adı ile kaydedelim. Gelelim Go kodlarımıza; `main.go` dosyamız aşağıdaki gibi olsun. {% code title="main.go" %} ```go package main import ( "fmt" "html/template" "net/http" ) // yakalayıcı fonksiyonumuz func anasayfa(w http.ResponseWriter, r *http.Request) { //isim değişkenimiz isim := "Kaan" //burada şablon oluşturuyoruz şablon, _ := template.ParseFiles("sablon.html") //Burada da şablonu çalıştırmasını ve isim //değişkenini kullanmasını istiyoruz. şablon.Execute(w, isim) } func main() { fmt.Println("Sunucu Başladı") //ana dizini anasayfa fonksiyonu ile yakalayalım http.HandleFunc("/", anasayfa) //portu 8000 yapalım ve sunucuyu başlatalım http.ListenAndServe(":8000", nil) } ``` {% endcode %} Açıklamaları üstte yazıyor. Sayfamıza bakmak için [http://localhost:8000](http://localhost:8000) adresine gittiğimizde, şöyle bir sonuç ile karşılaşacağız.  Tabi ki burada bir terslik var. b etiketleri gözüküyor. Bunun sebebi tarayıcımızın sayfayı `html` olarak değil de metin dosyası olarak göstermesi. Çözüm için `sablon.html` dosyamızın başına `` ekleyelim. Yani şöyle olacak: {% code title="sablon.html" %} ```go Merhaba, {{ . }} ``` {% endcode %} {% hint style="info" %} Eğer sadece şablon dosyasında değişiklik yaptıysanız, sunucuyu yeniden başlatmanıza gerek yoktur. Şablon dosyalarındaki değişiklik sunucu açıkken de güncellenir. {% endhint %} Sayfayı yenileyerek değişikliğe bakalım. Çıktımız şöyle olacaktır:  Bu sefer doğru bir çıktı üretmiş olduk. Bu yöntemler ile sayfamızda istediğimiz bölüme istediğimiz tipte değerler gönderebiliriz. ## ✨ HTML Kodu Gönderme Bu örneğimizde `sablon.html` dosyamız aşağıdaki gibi olsun. {% code title="sablon.html" %} ```go {{ . }} ``` {% endcode %} `main.go` dosyamız da aşağıdaki gibi olsun. {% code title="main.go" %} ```go package main import ( "fmt" "html/template" "net/http" ) func anasayfa(w http.ResponseWriter, r *http.Request) { //html kodumuz htmlKodu := "Merhaba
" şablon, _ := template.ParseFiles("sablon.html") şablon.Execute(w, htmlKodu) } func main() { fmt.Println("Sunucu Başladı") http.HandleFunc("/", anasayfa) http.ListenAndServe(":8000", nil) } ``` {% endcode %} Yukarıdaki örnekte sayfamıza bu sefer html kodu yolluyoruz. Çıktımıza bakalım.  Burada yine bir şeyler dönüyor. Çıktı yine istediğimiz gibi değil. "Niye bana yanlış kodları gösteriyorsun Kaan?" dediğinizi duyar gibiyim. Çünkü ilk önce yapmamamız gereken şeyleri gösteriyorum ki daha akılda kalıcı olsun. Yukarıdaki olayın sebebi şudur: Go tarafından gönderdiğimiz html kodunun aslında `html` tipinde değil de `string` tipinde olması. Bu yüzden html kodumuz düz bir şekilde görünüyor. Çözüm olarak da Go tarafındaki değişkenimizin tipini `template.HTML` yapacağız. `main.go` dosyamızda `htmlKodu` değişkenimizin tipini değiştirelim. ```go var htmlKodu template.HTML = "Merhaba
" ``` veya burada değişkenin tipini değiştirmek yerine `şablon.Execute()` fonksiyonunda değişiklik yapabilirsiniz. (Hangisi kolayınıza geliyorsa) ```go şablon.Execute(w, template.HTML(htmlKodu)) ``` ## ✨ Şablona Struct Gönderme Buraya kadar şablon dosyamıza hep bir tane değer gönderdik. Birden fazla değer göndermek için ne yapmalıyız? Bu konuda da struct'lardan faydalanabiliriz. Örnek olarak `main.go` dosyamız aşağıdaki gibi olsun. ```go package main import ( "fmt" "html/template" "net/http" ) type bilgi struct { Başlık string İçerik template.HTML } func anasayfa(w http.ResponseWriter, r *http.Request) { sayfaBilgi := bilgi{ Başlık: "Sayfa Başlığı", İçerik: "sayfa içeriği", } şablon, _ := template.ParseFiles("sablon.html") şablon.Execute(w, sayfaBilgi) } func main() { fmt.Println("Sunucu Başladı") http.HandleFunc("/", anasayfa) http.ListenAndServe(":8000", nil) } ``` Yukarıda `bilgi` isminde bir struct oluşturduk. Bu struct'ımız `Başlık` ve `İçerik` adında alt değişkenlere sahip. Struct'ın elemanlarını isimlendirirken baş harflerinin büyük olmasına dikkat edelim. Çünkü Şablonlar struct değişkenlerini dışa aktarma mantığı ile kullanır. Bu yüzden baş harflerini büyük yazmazsak değişkenleri sayfaya ulaştıramayız. Daha sonra `anasayfa` fonksiyonumuz içerisinde `sayfaBilgi` adında `bilgi` struct'ı oluşturduk ve değişkenlerimizin değerlerini girdik. Son olarak `sayfaBilgi`'yi şablona gönderdik. `sablon.html` dosyamız içerisinde ise `sayfaBilg`i'den gelen değişkenleri yerleştirelim. {% code title="sablon.html" %} ```go{{ .Başlık }}
{{.İçerik}} ``` {% endcode %} Yukarıdaki kodlarda dikkat edeceğimiz nokta, tanımlama yaparken noktadan sonra, bilgi struct'ının alt değişkenlerinin ismi ile çağırıyor olmamız. Çıktımızı görelim:  Buraya kadar şablon mantığını az çok anladığınıza inanıyorum. Buradan sonrasını konu çok uzun olmasın diye hızlıca anlatmaya çalışacağım. Yani buradan sonra çıktıların resimlerini göstermeyeceğim. ## ✨ Şablon İçinde Değişken Atama Şablon içerisinde oluşturduğumuz değişkenleri tıpkı PHP'deki gibi `$` işareti ile kullanırız. Öncelikle `main.go` dosyamız aşağıdaki gibi olsun. {% code title="main.go" %} ```go package main import ( "fmt" "html/template" "net/http" ) func anasayfa(w http.ResponseWriter, r *http.Request) { şablon, _ := template.ParseFiles("sablon.html") //şablona değer göndermeyeceğimiz için burası nil olsun. şablon.Execute(w, nil) } func main() { fmt.Println("Sunucu Başladı") http.HandleFunc("/", anasayfa) http.ListenAndServe(":8000", nil) } ``` {% endcode %} `sablon.html` dosyamız da aşağıdaki gibi olsun. {% code title="sablon.html" %} ```go {{ $isim := "kaan"}} {{ $isim }} ``` {% endcode %} Yukarıda gördüğünüz gibi değişkeni tanımlarken ve kullanırken başına `$` işareti koyduk. Çıktımızda _"kaan"_ yazacaktır. ## ✨ Şablonda If-Else Kullanımı ```go {{if .Reşit}} Bu kişi reşittir. {{else}} Bu kişi reşit değildir. {{end}} ``` Yukarıda dikkat etmemiz gereken şey `if-else`'in sonuna `end` eklememiz gerekiyor. Sadece `if` olsaydı bile `end` eklememiz gerekir. Bu kodları yazdıktan sonra çıkan sonuçta boşluklar (boşluk tuşunun boşluğu gibi) oluşabilir. Bunu engellemek için ise aşağıdaki gibi yapabiliriz. ```go {{if .Reşit}} Bu kişi reşittir. {{- else}} Bu kişi reşit değildir. {{- end}} ``` Yani boşluk oluşan bölgeniz başına `- tire` ekliyoruz. ## ✨ Şablonda Range Döngüsü Kullanımı Range döngüsü ile web sayfamızın içerisinde bir listenin sıralanmasını sağlayabiliriz. ```go
-
{{range .Liste}}
{{.}}
{{end}}
.png)
Viper logo