--- title: 'Standart Kütüphane ve Ağ Uygulamaları' source: 'https://academia.sh/tr/kurslar/go-uygulamalar' language: tr updated: '2026-08-23T19:49:13+00:00' license: 'CC BY-SA 4.0' lessons: 12 outcomes: - 'Standart kütüphaneyle HTTP servisi ve komut satırı aracı yazar' - 'Dizileştirme, günlükleme ve zaman işlemlerini doğru kullanır' - 'Veritabanı erişimini bağlantı yönetimiyle kurar' - 'Bir değerin sınırı geçerken tip bilgisine ne olduğunu ölçerek ayırt eder' --- # Standart Kütüphane ve Ağ Uygulamaları Bu kursun on iki dersi tek bir şeyi anlatır: programın sınırlarını. Ağ, dosya, şablon çıktısı, veritabanı satırı, günlük kaydı ve komut satırı argümanı aynı olayın ayrı yüzleridir — bir değer tip sisteminden çıkar ve karşı tarafta yeniden belirir. Kurs her geçişi tek bir soruyla ölçer: tip bilgisi korunuyor mu, yeniden mi kuruluyor, yoksa kayboluyor mu? ## Ağ ve Veri Biçimleri İstek işleyicilerinin ve ara katman kalıbının standart kitaplıkta kurulması, istemci tarafında zaman aşımı ve gövde kapatma sorumluluğu, yapı etiketleriyle alan adlarının karşıya taşınması, şablonların yalnız metin üretmesi, iki tarafın paylaştığı bir tarifle sözleşme temelli iletişim, ve uzun süreli bağlantılarda çerçevelemenin taşıdığı tek ortak bilgi. ### HTTP Sunucusu Source: https://academia.sh/tr/kurslar/go-uygulamalar/http-sunucusu Kursun açılış dersi. Bir isteğin taşıdığı yol, üstbilgi ve gövdenin üçünün de tip bilgisi taşımadığı `net/http/httptest` ile gerçek bağlantı noktası açmadan ölçülüyor; ara katman kalıbının bir işleyiciyi saran başka bir işleyici olduğu üç halkalı bir zincirle koşturuluyor. Sınırlayıcı ölçüm: içerik tipi üstbilgisi bir ipucudur, tip değil — yanlış bir ipucu sunucu tarafında hiçbir hata üretmiyor, hata yalnızca gövdeyi o ipucuna göre çözmeye çalışan tarafta ortaya çıkıyor. Önceki kursun kapanışı bir goroutine'in nasıl duracağını ölçtü ve durmanın çoğunlukla **başka birinin yaptığı bir işe** bağlı olduğunu gösterdi: bir kanal kapanmadan, bir bağlam iptal edilmeden, bekleyen goroutine kendi kararını veremiyordu. O ölçüm hep programın **içindeydi** — iki goroutine aynı ikili çalıştırılabilir dosyanın parçasıydı, aynı tip sistemine bağlıydı. Bu ders soruyu programın **dışına** taşıyor: bir değer ağa, dosyaya, şablona ya da veritabanına gittiğinde ne oluyor? Karşı taraf aynı derleyiciden geçmedi, aynı tip tanımlarını görmedi — bazen aynı dilde bile yazılmadı. Kursun tamamı bu tek soruyu on iki farklı sınırda soruyor: **bir değer sınırı geçerken tip bilgisine ne oluyor?** Bu ders sınırın en sık geçileni ile başlıyor: bir HTTP isteği. Bir sunucunun ne iş yaptığı, kimin isteği ne zaman işlediği ve ara katmanların bir zincirde nasıl sıralandığı önceki kurslarda kavram olarak kuruldu. Burada tekrarlanmıyor; bu dersin sorduğu soru farklı — sunucunun **görevi** değil, sunucuya **gelen ve sunucudan çıkan verinin** tip sistemiyle ilişkisi. Bu ayrım kursun geri kalanında da sürüyor: her ders bir katmanın görevini değil, o katmanın sınırındaki verinin akıbetini ölçüyor. #### İşleyicinin Aldığı Şey: Yol, Üstbilgi, Gövde Bir istemci bir HTTP isteği gönderdiğinde, isteğin içinde ne olduğuna dair tek kaynak kablodan geçen bayt dizisidir. Go'nun standart kitaplığı bu bayt dizisini ayrıştırıp bir `*http.Request` değerine dönüştürüyor, ama dönüştürülen şey hâlâ üç ham parça: **yol** (`r.URL.Path`, bir dizgi), **üstbilgiler** (`r.Header`, dizgiden dizgi dilimine bir sözlük) ve **gövde** (`r.Body`, bayt akıtan bir okuyucu). İsteği gönderen tarafın kafasında yol bir tamsayı kimlik, üstbilgi bir yapılandırılmış değer, gövde bir kayıt olabilir — ama sınırı geçtikten sonra elde kalan yalnızca dizgi ve bayttır. Go'nun tip sistemi bu üçünün hiçbirine "bu aslında bir tamsayıydı" ya da "bu aslında bir yapıydı" demiyor; söylemeye yetkisi de yok, çünkü kablonun karşı ucunda hangi programın çalıştığını, o programın hangi tipleri tanımladığını bilmiyor. Aşağıdaki kaynak bu ölçümün ortak parçalarını kuruyor: sonuçları sınıflandırıp yazdıran bir yardımcı, isteğin yolunu ve bir üstbilgisini okuyup gövdenin uzunluğunu yanıt olarak yazan bir çekirdek işleyici ve bu çekirdeği saran iki ara katman. ```go // istekcekirdek.go — istek isleyicisinin ve ara katmanin ortak parcalari package main import ( "fmt" "io" "net/http" ) var parcaSayisi, kayboluyorSayisi int var sonOkunanGovde []byte // olcumSatiri, bu dersin sinif adlarindan birini (korunuyor / yeniden / kayboluyor) // bir kanitla birlikte yazdirir ve toplami tutar. func olcumSatiri(parca, sinif, kanit string) { parcaSayisi++ if sinif == "kayboluyor" { kayboluyorSayisi++ } fmt.Printf("%-30s %-10s %s\n", parca, sinif, kanit) } // cekirdekIsleyici, gelen istegin yolunu, bir ustbilgisini ve govdesini okuyup // duz metin bir yanit yazar. Yanita sabit bir icerik tipi ipucu ekler; bu ipucunun // dogru olup olmadigini denetlemek bu islevin isi degildir. func cekirdekIsleyici(w http.ResponseWriter, r *http.Request) { govde, _ := io.ReadAll(r.Body) sonOkunanGovde = govde kimlik := r.Header.Get("X-Istek-Kimligi") w.Header().Set("Content-Type", "application/json") w.WriteHeader(http.StatusOK) fmt.Fprintf(w, "yol=%s kimlik=%s govde-uzunlugu=%d", r.URL.Path, kimlik, len(govde)) } // araGunlukleme, sardigi isleyiciyi cagirmadan once bir sayaci artirir; govdeye // ya da baglantiya dokunmuyor. func araGunlukleme(sonraki http.Handler, sayac *int) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { *sayac++ sonraki.ServeHTTP(w, r) }) } // araBasliklandirma, yanita sabit bir ustbilgi ekleyip zinciri surdurur. func araBasliklandirma(sonraki http.Handler, sayac *int) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { *sayac++ w.Header().Set("X-Zincir-Adimi", "gecti") sonraki.ServeHTTP(w, r) }) } ``` Ölçüm bu çekirdeği bir istekle koşturuyor. İstek `net/http/httptest` ile kuruluyor — `httptest.NewRequest` gerçek bir bağlantı noktası açmadan bellekte bir `*http.Request` üretiyor, `httptest.NewRecorder` ise gerçek bir bağlantı yerine yanıtı bir arabelleğe yazan sahte bir `http.ResponseWriter` veriyor. İstemci ile sunucu arasında hiçbir gerçek soket, adres ya da süre yok. ```go // istekolcumu.go — bir istegin tasidigi parcalarin tip bilgisi ve ara katman zinciri package main import ( "bytes" "fmt" "net/http" "net/http/httptest" ) func main() { fmt.Println("-- isleyicinin aldigi sey: bayt ve metin --") govde := bytes.NewBufferString("adet=3") istek := httptest.NewRequest(http.MethodPost, "/urunler/42", govde) istek.Header.Set("X-Istek-Kimligi", "1001") var gunlukSayaci, basliklandirmaSayaci int zincir := araGunlukleme( araBasliklandirma(http.HandlerFunc(cekirdekIsleyici), &basliklandirmaSayaci), &gunlukSayaci, ) kaydedici := httptest.NewRecorder() zincir.ServeHTTP(kaydedici, istek) olcumSatiri("istek yolu (r.URL.Path)", "kayboluyor", fmt.Sprintf("deger=%q tip=%T", istek.URL.Path, istek.URL.Path)) olcumSatiri("istek ustbilgisi (Header.Get)", "kayboluyor", fmt.Sprintf("deger=%q tip=%T", istek.Header.Get("X-Istek-Kimligi"), istek.Header.Get("X-Istek-Kimligi"))) olcumSatiri("istek govdesi (okunan bayt)", "kayboluyor", fmt.Sprintf("tip=%T uzunluk=%d", sonOkunanGovde, len(sonOkunanGovde))) fmt.Println("-- ara katman zinciri --") fmt.Println("zincir: araGunlukleme( araBasliklandirma( cekirdekIsleyici ) ) - 3 halka") fmt.Printf("gunlukleme cagrisi=%d basliklandirma cagrisi=%d (ikisi de bu dersin yazdigi kod)\n", gunlukSayaci, basliklandirmaSayaci) fmt.Printf("durum kodu=%d zincir ustbilgisi=%s\n", kaydedici.Code, kaydedici.Header().Get("X-Zincir-Adimi")) fmt.Println("yanit govdesi:", kaydedici.Body.String()) fmt.Printf("bu istegin %d parcasindan tip bilgisi tasiyani=%d (kayboluyor=%d)\n", parcaSayisi, parcaSayisi-kayboluyorSayisi, kayboluyorSayisi) } ``` ``` -- isleyicinin aldigi sey: bayt ve metin -- istek yolu (r.URL.Path) kayboluyor deger="/urunler/42" tip=string istek ustbilgisi (Header.Get) kayboluyor deger="1001" tip=string istek govdesi (okunan bayt) kayboluyor tip=[]uint8 uzunluk=6 -- ara katman zinciri -- zincir: araGunlukleme( araBasliklandirma( cekirdekIsleyici ) ) - 3 halka gunlukleme cagrisi=1 basliklandirma cagrisi=1 (ikisi de bu dersin yazdigi kod) durum kodu=200 zincir ustbilgisi=gecti yanit govdesi: yol=/urunler/42 kimlik=1001 govde-uzunlugu=6 bu istegin 3 parcasindan tip bilgisi tasiyani=0 (kayboluyor=3) ``` **AG1.** Yolun `"/urunler/42"` olması, `42` rakamının bir tamsayı **anlamına gelmesi** gerektiğini düşündürüyor — kaynak kodda bu değer bir ürün kimliğiydi. Ama ölçüm `%T` ile sorduğunda yanıt tektir: `string`. Go'nun yönlendiricisi yolu ayrıştırırken hiçbir rakam dizisini otomatik olarak sayıya çevirmiyor; `/urunler/42` ile `/urunler/kirk-iki` aynı tipte iki dizgidir, aralarındaki fark yalnızca içerik. Aynı gözlem üstbilgi için de geçerli: istek kimliği üstbilgisindeki `"1001"` değeri de bir dizgi, isteyen tarafın kafasında bir sayısal kimlik olsa bile. Kablonun üzerinden geçen hiçbir şey kendi tipini taşımıyor; taşıyan tek şey karakterler. **AG2.** Gövde bu üçünün en açık örneği: `io.ReadAll(r.Body)` her zaman `[]byte` döndürüyor, gövdenin içeriği ister bir sayı, ister bir yapı, ister rastgele metin olsun. Ölçümde `uzunluk=6` çıkıyor çünkü `"adet=3"` dizgisi altı bayt — ama bu uzunluk gövdenin **neyi** temsil ettiğini söylemiyor, yalnızca **kaç bayt** olduğunu söylüyor. Bu üç satırın üçü de `kayboluyor` sınıfında; bu dersin ölçtüğü isteğin üç parçasından tip bilgisi taşıyanı sıfır. Kursun on üç sınır geçişinin tam dağılımı (1 korunuyor, 5 yeniden kuruluyor, 7 kayboluyor) JSON Dizileştirme dersinde kuruluyor; bu ders yalnız kendi diliminin üç satırını basıyor. #### Ara Katman: Bir İşleyiciyi Saran Başka Bir İşleyici `http.Handler`, Go'nun standart kitaplığında tek bir yöntemle tanımlanan bir arayüz: `ServeHTTP(http.ResponseWriter, *http.Request)`. Bu küçüklük bilinçli bir tasarım kararı — bir işleyici, bu tek yöntemi gerçekleştiren **her şey** olabiliyor, dolayısıyla bir işleyiciyi başka bir işleyicinin içine gömmek özel bir çerçeve gerektirmiyor, sıradan bir fonksiyon çağrısı yeterli. `araGunlukleme` ve `araBasliklandirma` işlevlerinin ikisi de aynı kalıbı izliyor: bir `http.Handler` alıyor, kendi mantığını çalıştıran yeni bir `http.HandlerFunc` döndürüyor ve döndürdüğü işleyicinin gövdesinde aldığı işleyicinin `ServeHTTP` yöntemini çağırıyor. Sonuç bir **zincir**: dıştaki halka önce çalışıyor, işini yapıp içteki halkayı çağırıyor, o da kendi işini yapıp bir sonrakini çağırıyor — en içte çekirdek işleyici durana kadar. Bu zincir kaynak kodda `main` işlevindeki tek bir ifadeyle, `araGunlukleme` çağrısının içine `araBasliklandirma` çağrısının, onun içine de çekirdek işleyicinin konulmasıyla elle kuruluyor: üç halka, üçü de bu dersin yazdığı kod, hiçbiri bir kayıt listesinden ya da bir etiketten otomatik olarak keşfedilmiyor. Çıktıdaki `gunlukleme cagrisi=1` ve `basliklandirma cagrisi=1` satırları bunu doğrudan sayıyor: zincirdeki iki ara katmanın ikisi de tam olarak bir kez çağrıldı, çünkü istek de tam olarak bir kez geldi. Sunucunun görevi, istek işleme zincirinin genel yapısı ve ara katmanın neden var olduğu önceki kurslarda kavram olarak kuruldu; burada ölçülen şey o kavramın Go'nun standart kitaplığındaki somut karşılığı — bir işleyicinin başka bir işleyiciyi sarması dışında hiçbir gizli düzenek yok. **AG3.** Zincirin sırası sonucu etkiliyor. `araBasliklandirma`, `X-Zincir-Adimi` üstbilgisini kendi `ServeHTTP` gövdesinde, iç işleyiciyi çağırmadan **önce** ayarlıyor; ama bu üstbilgi yanıta yalnızca `w.WriteHeader` çağrıldığı anda kilitleniyor ve `WriteHeader`i çağıran `cekirdekIsleyici`. Yani `araBasliklandirma`nın eklediği üstbilgi, çekirdek henüz yanıtı yazmadan önce ayarlandığı için başarıyla yanıta giriyor — çıktıdaki `zincir ustbilgisi=gecti` satırı bunu doğruluyor. Sıra tersine çevrilseydi, yani `araBasliklandirma` çekirdekten **sonra** çalışsaydı, `WriteHeader` zaten çağrılmış olacağı için üstbilgi sessizce yok sayılırdı — Go bu durumda hata vermiyor, yalnızca üstbilgiyi görmezden geliyor — durum kodu 1xx sınıfında olmadıkça ve üstbilgi bir art bilgi (trailer) olarak işaretlenmedikçe. **AG4.** İki ara katmanın da imzası aynı: bir `http.Handler` ve bir sayaç işaretçisi alıp yeni bir `http.Handler` döndürüyorlar. Bu tekdüzelik, üçüncü bir ara katmanın aynı zincire eklenmesini tek satırlık bir sarmalamaya indiriyor — zincire yeni bir halka eklemek, listeye yeni bir eleman eklemekten farklı bir işlem değil, sadece bir fonksiyon çağrısını bir öncekinin içine koymak. Ama bu kolaylığın bir bedeli var: zincir ne kadar uzarsa, bir isteğin `cekirdekIsleyici`ye ulaşana kadar kaç halkadan geçtiğini görmek o kadar çok, iç içe geçmiş fonksiyon çağrısını okumayı gerektiriyor. Zincirin kendisi hiçbir yerde bir liste olarak durmuyor — yalnızca `main` işlevindeki tek bir ifade. Bu, zincirin **tip bilgisiyle** ilişkisini de belirliyor: `araGunlukleme` ve `araBasliklandirma` işlevlerinin ikisi de kendi işlerini görmek için isteğin ya da yanıtın içeriğine hiç bakmıyor, yalnızca `*http.Request` ve `http.ResponseWriter` değerlerini olduğu gibi bir sonraki halkaya aktarıyor. Bir ara katman isteğin gövdesindeki bir alanı okumak isteseydi, bu ders boyunca görülen aynı sınırla karşılaşırdı — gövde yine yalnızca bayt, ara katman da yalnızca kendi yazdığı ayrıştırma koduyla o baytlara bir anlam yükleyebilirdi. #### Sınırlayıcı Ölçüm: İçerik Tipi Bir İpucudur, Tip Değil Çekirdek işleyicinin yanıtına eklediği `Content-Type: application/json` üstbilgisi, ilk bakışta yanıt gövdesinin tipini garanti ediyormuş gibi görünüyor. Değil. Bu üstbilgi bir dizgiden başka bir şey değil ve onu kim okursa okusun, gövdenin gerçekten o biçimde olup olmadığını denetleyen hiçbir mekanizma araya girmiyor. Aşağıdaki ölçüm bunu bilerek kırıyor: işleyici `application/json` ipucu veriyor ama gövdeye düz metin yazıyor. Bu, önceki ölçümdeki üç `kayboluyor` satırından farklı bir gözlem: oradaki satırlar isteğin taşıdığı bilginin **hiç var olmadığını** ölçtü, buradaki ölçüm ise var olan bir bilginin (üstbilginin kendisi) **yanlış olabileceğini** ve bunun hiçbir yerde yakalanmadığını gösteriyor. ```go // yanlisipucu.go — icerik tipi bir ipucudur, hatasi kosarken degil cozerken cikar package main import ( "encoding/json" "fmt" "net/http" "net/http/httptest" ) // yalanciIsleyici, govdeye duz metin yazip ustbilgide "application/json" ipucu verir. // Ipucu ile govde arasindaki uyumu denetleyen hicbir kod yoktur. func yalanciIsleyici(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") w.WriteHeader(http.StatusOK) fmt.Fprint(w, "bu govde json degil, duz metin") } func main() { fmt.Println("-- icerik tipi bir ipucudur, tip degil --") istek := httptest.NewRequest(http.MethodGet, "/rapor", nil) kaydedici := httptest.NewRecorder() http.HandlerFunc(yalanciIsleyici).ServeHTTP(kaydedici, istek) fmt.Printf("durum kodu=%d (ipucu yanlisken bile basarili)\n", kaydedici.Code) fmt.Printf("ustbilgideki ipucu=%s\n", kaydedici.Header().Get("Content-Type")) var hedef map[string]any cozHatasi := json.Unmarshal(kaydedici.Body.Bytes(), &hedef) fmt.Printf("govdeyi json olarak cozme hatasi var mi=%t\n", cozHatasi != nil) fmt.Println("hata sunucuda degil, govdeyi ipucuna gore cozmeye calisan tarafta cikiyor") } ``` ``` -- icerik tipi bir ipucudur, tip degil -- durum kodu=200 (ipucu yanlisken bile basarili) ustbilgideki ipucu=application/json govdeyi json olarak cozme hatasi var mi=true hata sunucuda degil, govdeyi ipucuna gore cozmeye calisan tarafta cikiyor ``` **AG5.** Durum kodu `200` — yani işleyici, gövdenin ipucuyla uyuşmadığını hiç fark etmeden başarıyla tamamlandı. `http.ResponseWriter` arayüzünde `Content-Type` üstbilgisini gövdeyle karşılaştıran, ya da gövdenin gerçekten geçerli JSON olup olmadığını denetleyen hiçbir adım yok — üstbilgi, alıcıya "bu gövdeyi böyle yorumlamayı dene" diyen bir öneri, alıcının uyması gereken bir kural değil. Hata ancak bir taraf bu öneriye güvenip `json.Unmarshal` çağırdığında ortaya çıkıyor; ölçümde bu çağrı `main` işlevinin kendisinde yapılıyor ve `cozHatasi != nil` sonucu `true` çıkıyor. Sunucu tarafında hiçbir uyarı, hiçbir günlük satırı, hiçbir hata dönüşü yok — sınır geçişinin kendisi tamamen sessiz. **AG6.** Bu gözlem, dersin baştaki iddiasını netleştiriyor: sınırın ötesine geçen bir yanıtın yanında taşıdığı **tek** ipucu böyle bir üstbilgidir ve bu ipucu bir tip değil, bir dizgidir — aynı `r.URL.Path` ya da `r.Header.Get` gibi, `%T` ile sorulduğunda yine `string` çıkıyordu. İçerik tipi üstbilgisinin doğru olması, sunucuyu yazan tarafın disiplinine kalmış bir şey; Go'nun derleyicisi ya da çalışma zamanı bu disiplini zorlamıyor. Bu sınırlayıcı ölçüm, gövdenin kendisinin taşıdığı bilgiyle üstbilgide yazan bilginin **birbirinden bağımsız** iki şey olduğunu, ikisinin birbirini doğrulamadığını gösteriyor. Standart kitaplığın kendisi bu ikisini birbirine bağlayan hiçbir denetim eklemiyor; ekleyecek olan, işleyiciyi yazan taraf. `cekirdekIsleyici` isteseydi, `w.Write` çağrısından önce gövdenin gerçekten geçerli JSON olduğunu kendi kodunda doğrulayabilirdi — ama bu doğrulama dilin bir parçası değil, yazarın bir kararı. Sınırın bu tarafında kalan tek garanti, üstbilgi ile gövde arasındaki tutarlılığı **kimsenin otomatik olarak sağlamadığıdır**; bu tutarlılığı kuran her katman, kendi kodunda bunu açıkça yapmak zorunda. #### Özet - Bir HTTP isteğinin yolu, üstbilgileri ve gövdesi Go'nun standart kitaplığında sırasıyla dizgi, dizgi ve bayt dilimi olarak temsil ediliyor; üçü de `%T` ile sorgulandığında hiçbir özel tip taşımadığı görülüyor. - Ölçüm `net/http/httptest` ile gerçek bir bağlantı noktası açmadan kuruluyor: `httptest.NewRequest` bellekte bir istek üretiyor, `httptest.NewRecorder` yanıtı bir arabelleğe yazan sahte bir yanıt yazıcı sağlıyor. - Ara katman kalıbı, `http.Handler` arayüzünün tek yöntemli olması sayesinde bir işleyiciyi başka bir işleyicinin içine sarmaktan ibaret; zincirdeki her halka çağıranın yazdığı sıradan bir fonksiyon çağrısı, otomatik keşif ya da kayıt yok. - Ara katmanların çalışma sırası sonucu etkiliyor: bir üstbilgi ancak `WriteHeader` çağrılmadan önce eklenirse yanıta giriyor, sıra tersine dönerse üstbilgi hatasızca yok sayılıyor. - İçerik tipi üstbilgisi bir ipucu, bir garanti değil: yanlış bir ipucu sunucu tarafında hiçbir hata üretmiyor, hata yalnızca gövdeyi o ipucuna güvenerek çözmeye çalışan tarafta ortaya çıkıyor. - Kursun on üç sınır geçişinin tam dağılımı bu derste kurulmuyor; bu ders yalnız isteğin sunucu tarafındaki üç parçasını ölçüyor, tam tabloyu JSON Dizileştirme dersi kuruyor. #### Sonraki Adım Bu ders, sınırı **alıcı** tarafından ölçtü: bir isteğin sunucuya ne getirdiğini ve sunucunun gövdeye ne kadar körü körüne güvendiğini. Sıradaki ders aynı sınırı **gönderen** taraftan soruyor: bir istemci bir isteği gönderirken neyi garanti etmek zorunda ve bir yanıtı aldıktan sonra hangi sorumlulukları devralıyor. Bir yanıt gövdesi de bu dersteki istek gövdesi gibi bir bayt akışı, ama bu kez akışı kimin ne zaman kapatacağı ve zaman aşımının bir süre yerine neyle kurulduğu ölçülüyor. ### HTTP İstemcisi Source: https://academia.sh/tr/kurslar/go-uygulamalar/http-istemcisi Önceki ders sınırı alıcı taraftan ölçtü; bu ders aynı sınırı gönderen taraftan ölçüyor. Zaman aşımı bir süreyle değil, iptal edilmiş bir bağlamla kuruluyor. Bağlantının yeniden kullanılıp kullanılmadığı yanıt gövdesinin kapatılıp kapatılmadığına bağlı: gövde okunup kapatılınca sonraki istek aynı bağlantıyı kullanıyor, kapatılmayınca kullanmıyor. Sınırlayıcı ölçüm: yanıt gövdesi bir okuyucudur, bir değer değil — bir kez okunduktan sonra ikinci okuma boş dönüyor. Önceki ders sınırı **alıcı** taraftan ölçtü: bir isteğin sunucuya ne getirdiğini ve sunucunun gövdeye ne kadar körü körüne güvendiğini. Bu ders aynı sınırı **gönderen** taraftan soruyor. Bir istemci bir isteği gönderirken üç sorumluluğu üstleniyor: isteğin makul bir sürede sonuçlanmasını sağlamak, aynı sunucuyla konuşan bağlantıları yeniden kullanmak ve aldığı yanıtın gövdesini kapatmak. Bu üçü birbirinden bağımsız görünse de, aşağıdaki ölçüm ikisinin (bağlantı yeniden kullanımı ile gövde kapatma) aslında **aynı kararın** iki yüzü olduğunu gösteriyor. Bu ders de bir önceki gibi `net/http/httptest` kullanıyor; ama bu kez `httptest.NewRecorder` değil, `httptest.NewServer` — istemcinin gerçekten bir bağlantı kurup kapatabileceği, bellekte çalışan bir sunucu. Sunucunun adresi (`sunucu.URL`) yalnızca istek kurmak için kullanılıyor, hiçbir ölçüm satırında basılmıyor; ölçülen şey adresin kendisi değil, istemcinin bu adrese karşı nasıl davrandığı. Bu farkın kendisi ölçümün bir parçası: önceki ders sunucuyu hiç ağa bağlamadan koşturabiliyordu, çünkü ölçtüğü şey yalnızca isteğin ve yanıtın içeriğiydi; bu ders istemcinin bağlantı yönetimini ölçtüğü için gerçek (ama hiçbir yerde basılmayan) bir yerel bağlantıya ihtiyaç duyuyor. Üç sorumluluk sırayla ele alınıyor. İlki, bir isteğin sonsuza kadar beklemeyeceğinin garantisi. İkincisi, art arda gelen isteklerin her birinde yeni bir bağlantı kurmanın maliyetinden kaçınmak. Üçüncüsü, alınan yanıtın gövdesini bırakmadan kapatmak — ve aşağıdaki ölçüm bu üçüncü sorumluluğun aslında ikinciyi mümkün kılan şart olduğunu gösteriyor. #### Zaman Aşımı: Süre Değil, İptal Edilmiş Bir Bağlam Önceki kursun bağlam paketi dersinde kurulan kalıp burada aynen sürüyor: bir zaman aşımı `time.Sleep` ya da gerçek bir süre ölçümüyle değil, önceden **iptal edilmiş bir bağlamla** kuruluyor. Bu, dersin çıktısının koşumdan koşuma değişmemesini sağlıyor — gerçek bir zaman aşımı denenseydi, isteğin ne kadar sürede başarısız olacağı makineye ve yüke bağlı kalırdı. ```go // sunucucekirdek.go — istemci olcumlerinin ortak sunucu govdesi package main import ( "fmt" "net/http" ) // yaniticiIsleyici, her istege sabit bir metin govde donduren bir isleyicidir. // Govde kucuk tutuluyor ki okunup kapatilmasi olcumu etkilemesin. func yaniticiIsleyici(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/plain") fmt.Fprint(w, "adet=7 birim=kg") } // olcumSatiri, sinirdaki tip bilgisinin uc sonucundan birini (korunuyor / yeniden / // kayboluyor) bir kanitla birlikte yazdirir. func olcumSatiri(parca, sinif, kanit string) { fmt.Printf("%-30s %-10s %s\n", parca, sinif, kanit) } ``` ```go // zamanasimi.go — zaman asimi sureyle degil, iptal edilmis bir baglamla kuruluyor package main import ( "context" "errors" "fmt" "net/http" "net/http/httptest" ) func main() { fmt.Println("-- zaman asimi: sureyle degil, iptal edilmis bir baglamla --") sunucu := httptest.NewServer(http.HandlerFunc(yaniticiIsleyici)) defer sunucu.Close() baglam, iptalEt := context.WithCancel(context.Background()) iptalEt() // istek daha baslamadan baglam zaten iptal edildi istek, _ := http.NewRequestWithContext(baglam, http.MethodGet, sunucu.URL, nil) _, hata := http.DefaultClient.Do(istek) fmt.Printf("istek hatasi var mi=%t\n", hata != nil) fmt.Printf("hata baglam iptaliyle mi eslesiyor=%t\n", errors.Is(hata, context.Canceled)) } ``` ``` -- zaman asimi: sureyle degil, iptal edilmis bir baglamla -- istek hatasi var mi=true hata baglam iptaliyle mi eslesiyor=true ``` **AG7.** `iptalEt()` çağrısı, isteğin gönderilmesinden **önce** çalışıyor; bu sıralama bilinçli, çünkü ölçümün amacı zamanlamayla ilgili hiçbir tartışmaya yer bırakmamak. Bağlam zaten iptal edilmiş durumdayken `http.DefaultClient.Do` çağrılıyor ve istemci isteği hiç kabloya koymadan hemen hata döndürüyor. `errors.Is(hata, context.Canceled)` denetimi `true` çıkıyor — dönen hata, ağ katmanının kendi ürettiği bir hata değil, bağlamın taşıdığı sabit hatanın sarmalanmış hâli. Bir gerçek zaman aşımı (`context.WithTimeout`) kurulsaydı aynı mekanizma işlerdi, yalnızca hata `context.Canceled` yerine `context.DeadlineExceeded` olurdu; ikisi de aynı `ctx.Err()` yolundan geliyor. **AG8.** Bu ölçüm, önceki kursun kapanışında bırakılan soruyu bu sınırda yeniden soruyor: bir goroutine'i durduran şey neydi — kendi kod yolundaki bir kontrol noktası. `http.Client` da aynı ilkeyi izliyor: bağlamın iptalini kendi iç döngüsünde (bağlantı kurulurken, yanıt beklerken) denetliyor ve bu kontrol noktasına ulaştığında durup hatayı döndürüyor. Fark, bu kez kontrol noktasının kaynak kodda görünmemesi — istemcinin kendisi standart kitaplığın bir parçası, ama davranış aynı: bağlam bir zorlama aracı değil, bir haber kaynağı ve `http.Client` bu haberi dinleyen taraflardan biri. Bu tutarlılık, standart kitaplığın kendi iç işlevlerini de aynı ilkeye tabi tutmasından geliyor; bağlam paketi bir kez öğrenildiğinde, sınırın hangi tarafında olursa olsun aynı biçimde davranıyor. Bu ölçümde gerçek bir süre hiç kullanılmadı; `context.WithCancel` ile `iptalEt()`in hemen çağrılması, isteğin başarısız olacağını **kesin** kılıyor, "belki zamanında yetişir belki yetişmez" belirsizliğini tamamen ortadan kaldırıyor. Gerçek bir `context.WithTimeout` kullanılsaydı, ölçümün sonucu doğrulayıcının çalıştığı makinenin hızına bağlı kalırdı — aynı kaynak kimi koşumda zaman aşımına uğrar, kimi koşumda sunucu yeterince hızlı yanıt verdiği için uğramazdı. Önceden iptal edilmiş bir bağlam bu belirsizliği koşum zamanından tasarım zamanına taşıyor. #### Bağlantı Yeniden Kullanımı: Gövdeyi Kapatmanın Bedeli Bir TCP bağlantısı kurmak ucuz bir işlem değil; Go'nun `http.Transport`'u bu yüzden kullanılmış bağlantıları bir **bağlantı havuzunda** tutup sonraki isteklerde yeniden kullanmaya çalışıyor. Bağlantı havuzu kavramının kendisi Veri Erişim Katmanı kursunda kuruldu; burada ölçülen şey Go'nun standart kitaplığındaki `http.Transport`'un bu havuzu hangi koşulda işlettiği. Bu yeniden kullanım koşulsuz değil: bir yanıtın gövdesi tamamen okunup kapatılmadan, altındaki bağlantı havuza geri dönmüyor. Bu, önceki bölümdeki zaman aşımından bağımsız bir sorumluluk — istek başarıyla tamamlansa, durum kodu `200` dönse bile, gövdeyi görmezden gelmek bağlantıyı **kaybettirebiliyor**. Aşağıdaki ölçüm bunu `net/http/httptrace` ile gözlemliyor: `httptrace.ClientTrace`in `GotConn` alanı, her istek için elde edilen bağlantının **yeniden kullanılmış** olup olmadığını (`Reused` alanı, bir `bool`) bildiriyor. Bu paket de standart kitaplığın bir parçası ve hiçbir gerçek adres ya da bağlantı noktası açığa çıkarmıyor, yalnızca bir mantıksal bayrak veriyor. Bir önceki bölüm zaman aşımını ölçerken `http.DefaultClient`i kullanmıştı, çünkü orada ölçülen şey bağlam iptaliydi ve hangi istemcinin kullanıldığı sonucu değiştirmiyordu. Bu bölüm kendi istemcilerini açıkça kuruyor, çünkü burada ölçülen şey tam olarak istemcinin taşıdığı bağlantı havuzu — `http.DefaultClient`i kullanmak, bu ölçümü kursun başka bir dersinde çalışan kodun bıraktığı bağlantılarla karışabilir hâle getirirdi. Bu, bir HTTP istemcisinin görünmeyen bir durum (açık bağlantılar) taşıdığının ilk işareti: iki farklı `*http.Client` değeri, aynı sunucuya karşı bile olsa, birbirinden tamamen farklı bir geçmiş biriktirebiliyor. ```go // baglantitekrar.go — govdenin kapatilmasi baglantinin havuza donup donmedigini belirliyor package main import ( "context" "fmt" "io" "net/http" "net/http/httptest" "net/http/httptrace" ) // izleyerekIste, bir istegi verilen istemciyle gonderir; baglantinin yeniden mi // kullanildigini httptrace ile ogrenip govdeyi istege gore kapatir. func izleyerekIste(istemci *http.Client, url string, govdeyiKapat bool) (yenidenKullanildi bool) { baglam := httptrace.WithClientTrace(context.Background(), &httptrace.ClientTrace{ GotConn: func(bilgi httptrace.GotConnInfo) { yenidenKullanildi = bilgi.Reused }, }) istek, _ := http.NewRequestWithContext(baglam, http.MethodGet, url, nil) yanit, hata := istemci.Do(istek) if hata != nil { return false } if govdeyiKapat { io.ReadAll(yanit.Body) yanit.Body.Close() } return yenidenKullanildi } func main() { fmt.Println("-- baglanti yeniden kullanimi: govde kapatildiginda ve kapatilmadiginda --") sunucu := httptest.NewServer(http.HandlerFunc(yaniticiIsleyici)) defer sunucu.Close() // Her istemci kendi Transport'unu tasiyor; boylece baglanti havuzlari birbirinden // bagimsiz oluyor ve bir istemcideki kapatilmamis govde otekini etkilemiyor. istemciA := &http.Client{Transport: &http.Transport{}} ilkA := izleyerekIste(istemciA, sunucu.URL, true) ikinciA := izleyerekIste(istemciA, sunucu.URL, true) fmt.Printf("govde her seferinde kapatildi: ilk=%t ikinci=%t\n", ilkA, ikinciA) istemciB := &http.Client{Transport: &http.Transport{}} izleyerekIste(istemciB, sunucu.URL, false) ikinciB := izleyerekIste(istemciB, sunucu.URL, true) fmt.Printf("ilk istegin govdesi hic kapatilmadi: ikinci=%t\n", ikinciB) } ``` ``` -- baglanti yeniden kullanimi: govde kapatildiginda ve kapatilmadiginda -- govde her seferinde kapatildi: ilk=false ikinci=true ilk istegin govdesi hic kapatilmadi: ikinci=false ``` **AG9.** `istemciA` ile yapılan iki istekte gövde her seferinde okunup kapatılıyor. İlk istekte henüz açık bir bağlantı olmadığı için `Reused=false` çıkması beklenen bir sonuç; asıl ölçülen şey **ikinci** istek. Gövde ilk istekte tam okunup kapatıldığı için bağlantı havuza geri dönmüş oluyor ve ikinci istek `Reused=true` ile aynı bağlantıyı devralıyor. Bu, istemci tarafının üçüncü sorumluluğunun (gövde kapatma) neden yalnızca "temizlik" değil, doğrudan başarım kararı olduğunu gösteriyor. `istemciA` ve `istemciB`nin her biri kendi `*http.Transport` değerini taşıyor; bu bilinçli bir seçim. `Transport` alanı boş bırakılsaydı, ikisi de standart kitaplığın **paylaşılan** varsayılan aktarımını kullanırdı ve iki istemcinin bağlantı havuzları aslında aynı havuz olurdu — `istemciB`nin kapatılmamış gövdesi, adı farklı olsa bile `istemciA`nın sonraki isteğini de etkileyebilirdi. Ayrı birer `Transport` vermek, iki senaryoyu birbirinden **yalıtıyor**: ölçülen etki gerçekten `istemciB`nin kendi kapatılmamış gövdesinden geliyor, başka bir isteğin yan etkisinden değil. **AG10.** `istemciB` ile yapılan ilk istekte gövde hiç okunmuyor, hiç kapatılmıyor. İkinci istek aynı istemciyle, gövdesi düzgün kapatılarak gönderiliyor, ama sonuç yine `Reused=false`. Sebep, ilk isteğin bağlantısının hâlâ **meşgul** sayılması: `Transport`, gövdesi okunup kapatılmamış bir yanıtın altındaki bağlantıyı asla havuza koymuyor, çünkü o bağlantının ne zaman serbest kalacağını bilmiyor. İkinci istek bu yüzden yeni bir bağlantı açmak zorunda kalıyor — birinci isteğin kapatılmamış gövdesi, kendisinden sonraki isteği de etkiliyor. Bu etkinin ölçekle büyüdüğü açık: art arda yüzlerce istek gönderen, ama gövdelerinin bir kısmını kapatmayı unutan bir program, her kapatılmamış gövde için bir bağlantıyı sonsuza kadar meşgul tutuyor. Programın kendisi çökmüyor, hata da vermiyor — yalnızca istemcinin açık bağlantı sayısı zamanla birikiyor ve bu birikim gövdenin kendisi kadar sessiz kalıyor. **AG11.** Bu iki ölçüm birlikte okunduğunda ortaya çıkan kural net: bağlantı yeniden kullanımı **kimin işi** sorusuna tek bir yanıt veriyor — çağıranın işi. Standart kitaplık gövdeyi otomatik olarak okuyup kapatmıyor; `Body.Close()` çağrılmazsa, hatta çağrılsa bile gövde önce tam okunmazsa, bağlantı sızıyor ya da en azından yeniden kullanılamıyor. Bu, önceki dersteki ara katman zincirinde görülen ilkeyle aynı yerde duruyor: standart kitaplık sınırın bu tarafında bir mekanizma sunuyor, ama mekanizmayı doğru kullanmak yazan tarafın sorumluluğunda kalıyor. Bu kural, tip sisteminin sınırdaki rolüne de bir örnek ekliyor: `yanit.Body`nin tipi (`io.ReadCloser`) kendisi hiçbir yerde "beni tam okumadan kapatma" demiyor. Derleyici, gövdesi okunmadan bırakılan bir yanıtı reddetmiyor — kaynak sorunsuz derleniyor, sorunsuz çalışıyor, yalnızca bağlantı havuzu sessizce küçülüyor. Bu tür bir sözleşme (bir kaynağın kapatılmadan önce tüketilmesi gerektiği) tipin kendisinde değil, belgesinde ve yazan tarafın alışkanlığında yaşıyor. #### Sınırlayıcı Ölçüm: Gövde Bir Okuyucudur, Bir Değer Değil Önceki iki ölçüm gövdenin kapatılmasının **neden** önemli olduğunu gösterdi. Bu ölçüm gövdenin **ne olduğunu** netleştiriyor: `yanit.Body`, `io.ReadCloser` arayüzünü gerçekleştiren bir akış, isteğin gövdesi gibi bir kez tüketiliyor ve tüketildikten sonra geriye hiçbir şey kalmıyor. Bu, dilin önceki kurslarında görülen kopyalanabilir değerlerden (bir dilim, bir yapı) temelden farklı bir davranış: bir dilimi iki değişkene atayıp ikisini de ayrı ayrı okumak mümkündü, çünkü dilim bir değerdi. Bir okuyucu değer değil, bir **konum** taşıyor — okundukça o konum ilerliyor ve geriye dönmüyor. ```go // govdeokuma.go — yanit govdesi bir okuyucudur, bir deger degil package main import ( "fmt" "io" "net/http" "net/http/httptest" ) func main() { fmt.Println("-- yanit govdesi bir okuyucudur, iki kez okunamaz --") sunucu := httptest.NewServer(http.HandlerFunc(yaniticiIsleyici)) defer sunucu.Close() yanit, _ := http.Get(sunucu.URL) defer yanit.Body.Close() ilkOkuma, _ := io.ReadAll(yanit.Body) ikinciOkuma, ikinciHata := io.ReadAll(yanit.Body) olcumSatiri("yanit govdesi (istemcide okunan)", "kayboluyor", fmt.Sprintf("tip=%T ilk-uzunluk=%d", ilkOkuma, len(ilkOkuma))) fmt.Printf("ikinci okuma uzunlugu=%d hata=%v\n", len(ikinciOkuma), ikinciHata) } ``` ``` -- yanit govdesi bir okuyucudur, iki kez okunamaz -- yanit govdesi (istemcide okunan) kayboluyor tip=[]uint8 ilk-uzunluk=15 ikinci okuma uzunlugu=0 hata= ``` **AG12.** İlk `io.ReadAll` çağrısı gövdeyi baştan sona okuyup on beş baytlık bir dilim döndürüyor — sınırın bu tarafına ulaşan şey yine `[]byte`, önceki derste görülen aynı sınıf: **kayboluyor**. İkinci `io.ReadAll` çağrısı ise `0` uzunlukta bir sonuç ve `nil` bir hata döndürüyor; okunacak hiçbir şey kalmadığı için okuma işlemi anında bitiyor, ama bu bir hata sayılmıyor. Gövde bir dilim ya da bir dizgi olsaydı, aynı değeri istendiği kadar okumak mümkün olurdu; bir okuyucu olduğu için tüketildiği an geride yalnızca boşluk kalıyor. **AG13.** Bu davranışın pratik sonucu: bir yanıt gövdesi ancak **bir kez** ayrıştırılabilir. Bir işlev gövdeyi hem günlüğe yazmak hem de bir hedefe çözmek istiyorsa, gövdeyi önce bir arabelleğe (`bytes.Buffer` gibi) kopyalayıp iki farklı okumayı o arabellek üzerinden yapmak zorunda — kaynağın kendisine ikinci kez dönmek mümkün değil. Bu sınırlama, bir önceki bölümdeki bağlantı yeniden kullanımıyla da bağlantılı: gövdeyi bir arabelleğe kopyalamak, onu aynı zamanda tam olarak tüketmek anlamına geliyor, dolayısıyla bu kopyalama işlemi hem ikinci bir okumayı mümkün kılıyor hem de altındaki bağlantının havuza dönmesini sağlıyor — aynı `io.ReadAll` çağrısı iki ayrı sorunu birden çözüyor. Kursun on üç sınır geçişinin tam dağılımı (1 korunuyor, 5 yeniden kuruluyor, 7 kayboluyor) sıradaki derste, JSON Dizileştirme'de kuruluyor; bu ders yalnız istemci tarafının üç sorumluluğunu ve gövdenin okuyucu doğasını ölçtü. #### Özet - Zaman aşımı bir süre yerine önceden iptal edilmiş bir bağlamla kuruluyor; `http.Client` bağlamın iptalini kendi iç kontrol noktalarında denetleyip isteği bu noktada durduruyor. - `errors.Is` ile denetlenen istek hatası, bağlamın taşıdığı sabit hatanın (`context.Canceled` ya da `context.DeadlineExceeded`) sarmalanmış hâli. - Bir bağlantının yeniden kullanılıp kullanılmayacağı `httptrace.GotConnInfo.Reused` alanıyla ölçülüyor; gövde tam okunup kapatılmazsa bağlantı havuza dönmüyor. - Gövdesi kapatılmamış bir isteğin etkisi kendisinden sonraki isteğe de yansıyor: bir önceki bağlantı meşgul sayıldığı için yeni bir bağlantı açılıyor. - Yanıt gövdesi bir okuyucudur, bir değer değil: bir kez tam okunduktan sonra ikinci okuma boş dönüyor, hata vermeden. - Bu ders sınırı gönderen taraftan ölçtü; kursun on üç sınır geçişinin tam dağılımı henüz burada kurulmadı, sıradaki ders kuruyor. #### Sonraki Adım İki ders de sınırın **taşıyıcısını** ölçtü — istek ve yanıt bayt ve metin taşıyor; gövde bir kez okunabiliyor. Bu iki dersin ikisinde de gövdenin **içeriği** hiç önemli değildi; `"adet=3"` ya da `"adet=7 birim=kg"` yerine rastgele herhangi bir metin de aynı sonuçları verirdi, çünkü ölçülen şey gövdenin davranışıydı, taşıdığı veri değil. Ama hiçbiri şu soruyu henüz sormadı: gönderen taraf bir **yapıyı** gönderirken karşı tarafın onu geri kurabilmesi için ne bırakıyor? Sıradaki ders bu soruyu JSON ile ölçüyor ve kursun bağlayıcı sayısını üretiyor: bir yapının alan adları yapı etiketleriyle karşıya taşınıyor, ama bu taşımanın sınırları var — alıcıda karşılığı olmayan bir alan sessizce düşüyor ve "geri kuruldu" görünmesi her zaman "doğru kuruldu" anlamına gelmiyor. ### JSON Dizileştirme Source: https://academia.sh/tr/kurslar/go-uygulamalar/json-dizilestirme Kursun bağlayıcı sayısı burada üretiliyor: on üç sınır geçişinin 1'inde tip bilgisi korunuyor, 5'inde yeniden kuruluyor, 7'sinde kayboluyor. Bir yapının alan adlarını karşıya taşıyan tarif yapı etiketidir; aynı bayt dizisi tarifsiz bir kaba çözüldüğünde tamsayı `float64` olur, alıcıda karşılığı olmayan bir alan sessizce düşer ve hiçbir hata çıkmaz. Sınırlayıcı ölçüm: geri kuruldu görünmesi doğru kuruldu anlamına gelmiyor. Önceki ders, sınırı geçen bir gövdenin yalnızca bayt taşıdığını, hiçbir tip bilgisi taşımadığını ölçtü. Ama o gövdenin **içeriği** hâlâ soru işaretiydi — `"adet=7 birim=kg"` gibi bir metin, isteyen tarafça nasıl yorumlanıyor? Bu ders bu soruyu doğrudan ele alıyor: gönderen taraf elinde bir **yapı** (`struct`) tutuyorsa, sınırı geçtikten sonra alıcı tarafta bu yapının hangi parçası hayatta kalıyor? Yanıt, yapının kendisinde değil, yapıyla birlikte taşınan bir **tarifte** yatıyor — Go'da bu tarifin adı yapı etiketi. Bu ders aynı zamanda kursun bağlayıcı ölçümünü üretiyor. Kursun sorduğu soru on iki dersin hepsinde aynı: bir değer sınırı geçerken tip bilgisine ne oluyor? Bu soru şimdiye kadar iki dar örnekte (istek parçaları, yanıt gövdesi) soruldu. Bu ders soruyu **geniş ölçekte** soruyor — ağ, şablon, veritabanı ve komut satırı sınırlarının on üçünü tek bir ölçümde art arda koşturup her birini üç sonuçtan birine yazıyor: **korunuyor**, **yeniden kuruluyor**, **kayboluyor**. Bu on üç geçişin dördü doğrudan JSON'un konusu; kalan dokuzu kursun geri kalan derslerinde ayrı ayrı derinleşiyor, burada yalnızca sınıflandırılıyor. Bu geniş ölçümün tek bir ölçümde toplanmasının bir nedeni var: on üç geçişi ayrı ayrı on üç derste ölçmek, her dersin kendi küçük sayısını üretmesine yol açardı ve kimse bu küçük sayıların bir araya geldiğinde neye eşit olduğunu göremezdi. Tek bir koşumda toplanmaları, kursun ana iddiasının (sınırın çoğunlukla tip bilgisini kaybettiği) tek bir sayıyla kanıtlanmasını sağlıyor. Bu ders o sayıyı üretiyor; geri kalan on bir ders bu sayının parçalarını tek tek büyütüyor. #### Yapı Etiketleri: Alan Adı Bağlamasının Tarifi Bir Go yapısının alan adları (`Ad`, `Adet`) derleme sırasında var olan, çalışma zamanında da yansıma (`reflect`) ile erişilebilen bilgiler. Ama bu adlar İngilizce büyük harfle başlıyor ve Go'nun kendi adlandırma kuralına bağlı — dışa aktarılan bir alan olmasının şartı bu. JSON'un anahtar adları için böyle bir kural yok; sınırın öbür tarafındaki program `"ad"` küçük harfle bekleyebilir, hatta tamamen farklı bir sözcük bekleyebilir. Yapı etiketi (`json:"ad"`) bu ikisi arasındaki **alan adı bağlamasının** tarifini taşıyor: hangi Go alanının hangi JSON anahtarına karşılık geldiğini söylüyor. Etiket yoksa `encoding/json` paketi alan adını olduğu gibi kullanıyor; bu ders etiketli ve etiketsiz alanları yan yana koşturuyor. Aşağıdaki kaynak, bu ölçümün üç sonucunu sayıp yazdıran ortak bir yardımcıyı kuruyor. ```go // sinir.go — bir deger siniri gectiginde tip bilgisine ne oluyor: korunuyor mu, yeniden mi kuruluyor, kayboluyor mu package main import "fmt" var korunan, yenidenKurulan, kaybolan int func gozle(gecis, sonuc, kanit string) { switch sonuc { case "korunuyor": korunan++ case "yeniden": yenidenKurulan++ default: kaybolan++ } fmt.Printf("%-36s %-10s %s\n", gecis, sonuc, kanit) } func ozet() { fmt.Printf("sinir: %d korunuyor, %d yeniden kuruluyor, %d kayboluyor\n", korunan, yenidenKurulan, kaybolan) } ``` Ölçümün kendisi on üç sınır geçişini sırayla soruyor. İlk dördü doğrudan JSON'un konusu: aynı yapıya gidiş dönüş, etiketle gizlenmiş bir alan, tarifsiz bir kaba çözme ve alıcıda karşılığı olmayan bir alan. Geri kalan dokuzu (zaman, şablon, okuyucu, ağ, paylaşılan tarif, sürücü, komut satırı) kursun ilerleyen derslerinde ayrı ayrı derinleşiyor — hangisinin nerede ele alındığı aşağıda tek tek yazılı; burada yalnızca aynı üç sonuca yazılıyor. ```go // olcum.go — on uc sinir gecisi, uc sonuca bolunur package main import ( "bytes" "encoding/json" "flag" "fmt" "io" "net/http" "net/http/httptest" "sort" "strings" "text/template" "time" ) type Kayit struct { Ad string `json:"ad"` Adet int `json:"adet"` Zaman time.Time `json:"zaman"` Gizli string `json:"-"` } // Surucu, bir veritabani surucusunun tasidigi tip kumesini modeller: yalniz dort tip. type Surucu struct{ satir []any } func (s Surucu) Oku(i int) any { return s.satir[i] } func main() { sabitZaman, _ := time.Parse(time.RFC3339, "2026-08-23T10:00:00Z") kayit := Kayit{Ad: "vida", Adet: 12, Zaman: sabitZaman, Gizli: "gorunmez"} fmt.Println("-- sinirda tip bilgisine ne oluyor --") // 1-2. JSON gidis donus: yapi -> metin -> yapi bayt, _ := json.Marshal(kayit) var geri Kayit json.Unmarshal(bayt, &geri) gozle("JSON gidis donus (ayni yapiya)", "yeniden", fmt.Sprint("adet tipi=", fmt.Sprintf("%T", geri.Adet), " esit=", geri.Adet == kayit.Adet)) gozle("etiketsiz alan (json:\"-\")", "kayboluyor", fmt.Sprint("gizli alan geri geldi mi=", geri.Gizli != "")) // 3. JSON -> sozluk: tip tarifi yok var serbest map[string]any json.Unmarshal(bayt, &serbest) gozle("JSON gidis donus (tarifsiz kaba)", "kayboluyor", fmt.Sprint("adet tipi=", fmt.Sprintf("%T", serbest["adet"]))) // 4. Bilinmeyen alan sessizce dusuyor var kismi Kayit json.Unmarshal([]byte(`{"ad":"somun","bilinmeyen":5}`), &kismi) gozle("gonderende olup alicida olmayan alan", "kayboluyor", fmt.Sprint("ad=", kismi.Ad, " hata=false")) // 5. Zaman: tip -> metin -> tip metin := sabitZaman.Format(time.RFC3339) tekrar, _ := time.Parse(time.RFC3339, metin) gozle("zaman degeri metne ve geri", "yeniden", fmt.Sprint("esit=", tekrar.Equal(sabitZaman), " tip=", fmt.Sprintf("%T", tekrar))) // 6. Sablon: cikti yalniz metin sab := template.Must(template.New("s").Parse("{{.Ad}} x{{.Adet}}")) var yazi bytes.Buffer sab.Execute(&yazi, kayit) gozle("sablon ciktisi", "kayboluyor", fmt.Sprintf("%q (%T)", yazi.String(), yazi.String())) // 7. Okuyucu/yazici: bayt duzeyi okunan, _ := io.ReadAll(strings.NewReader("vida")) gozle("okuyucudan gelen icerik", "kayboluyor", fmt.Sprintf("%T uzunluk=%d", okunan, len(okunan))) // 8-9. HTTP: govde bayt, tek ortak ipucu icerik tipi sunucu := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") json.NewEncoder(w).Encode(kayit) })) defer sunucu.Close() yanit, _ := http.Get(sunucu.URL) govde, _ := io.ReadAll(yanit.Body) yanit.Body.Close() gozle("HTTP govdesi", "kayboluyor", fmt.Sprintf("%T uzunluk>0=%t", govde, len(govde) > 0)) var alinan Kayit json.Unmarshal(govde, &alinan) gozle("icerik tipi ipucuyla cozme", "yeniden", fmt.Sprint("icerik tipi=", yanit.Header.Get("Content-Type"), " adet=", alinan.Adet)) // 10. Sozlesme temelli gecis: iki taraf ayni tarifi paylasiyor tarif := []string{"ad:dizgi", "adet:tamsayi"} gonderen := kodla(tarif, kayit) alan, tip := coz(tarif, gonderen) gozle("paylasilan tarifle gecis", "korunuyor", fmt.Sprint(alan, " ", tip)) // 11. Surucu tip kumesi: dort tipe indirgeniyor, Tara geri kuruyor s := Surucu{satir: []any{"vida", int64(12)}} gozle("surucunun tasidigi tip kumesi", "kayboluyor", fmt.Sprintf("adet %T olarak geliyor", s.Oku(1))) var adet int tara(s.Oku(1), &adet) gozle("Tara ile geri kurma", "yeniden", fmt.Sprint("adet=", adet, " tip=", fmt.Sprintf("%T", adet))) // 12. Komut satiri: argumanlar dizgi, ayristirici tipi geri kuruyor kume := flag.NewFlagSet("olcum", flag.ContinueOnError) kume.SetOutput(io.Discard) sayi := kume.Int("adet", 0, "adet") kume.Parse([]string{"-adet", "12"}) gozle("komut satiri argumani", "yeniden", fmt.Sprint("adet=", *sayi, " tip=", fmt.Sprintf("%T", *sayi))) ozet() } // kodla ve coz, iki tarafin paylastigi bir tarifle calisir: tip adi tarifte durur. func kodla(tarif []string, k Kayit) []string { return []string{k.Ad, fmt.Sprint(k.Adet)} } func coz(tarif []string, alanlar []string) (string, string) { adlar := make([]string, 0, len(tarif)) for _, t := range tarif { adlar = append(adlar, strings.SplitN(t, ":", 2)[1]) } sort.Strings(adlar) return alanlar[0], strings.Join(adlar, "+") } // tara, surucunun dondurdugu genis tipi hedefin tipine indirger. func tara(kaynak any, hedef *int) { if v, ok := kaynak.(int64); ok { *hedef = int(v) } } ``` ``` -- sinirda tip bilgisine ne oluyor -- JSON gidis donus (ayni yapiya) yeniden adet tipi=int esit=true etiketsiz alan (json:"-") kayboluyor gizli alan geri geldi mi=false JSON gidis donus (tarifsiz kaba) kayboluyor adet tipi=float64 gonderende olup alicida olmayan alan kayboluyor ad=somun hata=false zaman degeri metne ve geri yeniden esit=true tip=time.Time sablon ciktisi kayboluyor "vida x12" (string) okuyucudan gelen icerik kayboluyor []uint8 uzunluk=4 HTTP govdesi kayboluyor []uint8 uzunluk>0=true icerik tipi ipucuyla cozme yeniden icerik tipi=application/json adet=12 paylasilan tarifle gecis korunuyor vida dizgi+tamsayi surucunun tasidigi tip kumesi kayboluyor adet int64 olarak geliyor Tara ile geri kurma yeniden adet=12 tip=int komut satiri argumani yeniden adet=12 tip=int sinir: 1 korunuyor, 5 yeniden kuruluyor, 7 kayboluyor ``` **AG14.** JSON'un kendi payı ilk dört satır. Birincisi, aynı `Kayit` yapısına gidiş dönüşte `Adet` alanının `int` tipini ve değerini koruyarak geri gelmesi — `yeniden` sınıfında, çünkü tipi geri kuran şey yapının kendisi değil, gönderen ve alan tarafın **aynı Go tipini** paylaşması. İkincisi, `Gizli` alanının `json:"-"` etiketiyle hiç gönderilmemesi: bayt dizisine hiç girmediği için geri de gelmiyor, `kayboluyor` sınıfında ama nedeni bir kayıp değil, bilinçli bir dışlama. Üçüncüsü ve dördüncüsü, aynı bayt dizisinin (`bayt` değişkeni) iki farklı biçimde çözülmesiyle ortaya çıkıyor. **AG15.** Üçüncü satır bu dersin en çarpıcı gözlemi: aynı `bayt` dizisi bir `map[string]any` değişkenine çözüldüğünde, `Adet` alanının kaynaktaki değeri `12` bir `int`ken, geri gelen değerin tipi `float64` oluyor. Sebep, JSON biçiminin kendisinde tamsayı ile ondalık sayı ayrımının olmaması — `encoding/json` paketi bir hedef tipi verilmediğinde (`any` ya da `map[string]any`), her sayıyı varsayılan olarak `float64`e çözüyor. Yapı etiketi burada devrede değil, çünkü hedefin kendisi bir yapı değil; tip tarifi yalnız hedef bir yapı olduğunda işliyor. Dördüncü satır ise tam tersi bir durumu ölçüyor: gönderilen bayt dizisinde `Kayit` yapısında karşılığı olmayan bir `"bilinmeyen"` anahtarı var ve `json.Unmarshal` bunu sessizce yok sayıyor — ne bir hata dönüyor ne bir uyarı yazdırıyor, `ad=somun hata=false` satırı bunu doğruluyor. **AG16.** Bu dört satırın ortak noktası, `encoding/json` paketinin **hoşgörülü** bir tasarıma sahip olması: eksik alan, fazla alan, tip tarifi olmayan hedef — hiçbiri bir hata üretmiyor. Bu hoşgörü, dersin başlıktaki iddiasını netleştiriyor: "geri kuruldu" görünen bir işlem doğru kurulmuş olmayabilir. `json.Unmarshal([]byte(...), &kismi)` çağrısı `nil` hata döndürüyor; kod hiçbir yerde başarısız görünmüyor — ama `kismi` değişkeninde gönderilen `"bilinmeyen"` alanının hiçbir izi yok. Bir programın bu sessizliği fark etmesinin tek yolu, gönderilen ile alınanı **elle karşılaştırmak**; derleyici ya da çalışma zamanı bu farkı kendiliğinden bildirmiyor. #### Geri Kalan Dokuz Geçiş: Kursun Tam Ölçeği Ölçümün beşinci satırından on üçüncü satırına kadar olan bölüm, kursun geri kalan derslerinin konusu. Beşinci satır bir zaman değerinin metne dönüp geri gelmesini ölçüyor — Sistem ve Veri Erişimi konusunun Zaman İşlemleri dersi bunu derinleştiriyor. Altıncı satır bir şablonun çıktısının yalnızca metin olduğunu ölçüyor — sıradaki ders bu satırı tek başına ele alıyor. Yedinci ve sekizinci satırlar okuyucu/yazıcı soyutlamasını ve HTTP gövdesini ölçüyor; ikisi de önceki iki derste ve Sistem konusunun ilk dersinde ayrı ayrı işlendi ya da işlenecek. Dokuzuncu satır, içerik tipi üstbilgisinin bir ipucu olarak nasıl kullanıldığını gösteriyor — ilk derste ayrıntısıyla ölçülen konunun burada tek satırlık karşılığı. Onuncu satır kursun **tek** `korunuyor` satırı: `kodla` ve `coz` işlevleri aynı `tarif` dizisini okuyor, dolayısıyla gönderilen alan adlarıyla çözülen alan adları arasında hiçbir belirsizlik kalmıyor. Bu satırın derinleşmesi Sözleşme Temelli Servis İletişimi dersinde — orada tarifin iki tarafa nasıl **dağıtıldığı** ayrıca ölçülüyor, çünkü bu ölçümde tarif zaten iki tarafta da aynı kaynak dosyada duruyor, dağıtım sorunu modellenmiyor. On birinci ve on ikinci satırlar bir veritabanı sürücüsünün dar tip kümesini ve bu kümenin `Tara` ile nasıl geri kurulduğunu ölçüyor — Veritabanı Erişimi dersinin konusu. On üçüncü satır bir komut satırı bayrağının dizgiden hedef tipe nasıl geri kurulduğunu ölçüyor — Komut Satırı Uygulamaları dersinin konusu. **AG17.** Bu dokuz satırın hiçbiri burada ayrıntılı işlenmiyor; her biri kendi dersinde kendi ölçümüyle, kendi sınırlayıcı gözlemiyle yeniden ele alınacak. Burada bu satırların tek işlevi, kursun bağlayıcı sayısını **tamamlamak**: JSON'un dört satırı (0 korunuyor, 1 yeniden, 3 kayboluyor) tek başına kursun tam resmini vermiyor, çünkü kursun `korunuyor` sınıfının tek örneği JSON'un dışında, paylaşılan tarif geçişinde. On üç satırın tamamı bir arada koştuğunda ortaya çıkan toplam — 1 korunuyor, 5 yeniden kuruluyor, 7 kayboluyor — bu dersten itibaren kursun geri kalanında sabit bir referans olarak kullanılıyor. Bu dokuz satırın ölçümde burada durmasının bir başka nedeni de örneklerin birbirine bağımlı olması: sekizinci ve dokuzuncu satırlar (`HTTP govdesi`, `icerik tipi ipucuyla cozme`) aynı `kayit` değişkenini kullanıyor, dolayısıyla JSON'un dört satırıyla aynı veriyi paylaşıyor. Bu paylaşım tesadüfi değil — kursun on iki dersi aynı olayın (bir değerin sınırdan geçmesi) ayrı görünümleri olduğu için, aynı örnek verinin farklı sınırlardan geçirilmesi kursun tutarlılığını gösteriyor. Sıradaki derslerin her biri kendi konusuna özgü yeni bir veri kurup kendi ölçümünü yapacak; bu ölçüm yalnızca hepsinin **aynı çerçeveye** oturduğunu kanıtlıyor. **AG18.** Bu dağılımın okunması: on üç geçişin **yarısından fazlası** (yedisi) tip bilgisini tamamen kaybediyor, beşi karşı tarafın elindeki bir tarifle yeniden kuruluyor ve yalnızca biri iki tarafın aynı tarifi paylaşması sayesinde hiç kaybolmuyor. Bu oran, standart kitaplığın tasarım felsefesini yansıtıyor: sınırın ötesi varsayılan olarak **tipsiz**, tip ancak açıkça kurulan bir tarifle geri geliyor. Hiçbir geçiş kendiliğinden, otomatik olarak tip taşımıyor. Beş `yeniden` satırının ortak noktası da öğretici: her birinde tipi geri kuran şey farklı bir mekanizma — aynı Go tipini paylaşmak (birinci satır), bir ayrıştırma kuralı (`time.Parse`), bir içerik tipi ipucu, bir tarama işlevi (`tara`), bir bayrak ayrıştırıcısı. Ortak olan tek şey, hepsinin **karşı tarafın kodunda açıkça yazılmış** olması; tip hiçbir yerde kendiliğinden ortaya çıkmıyor, birinin onu geri kuracak bir işlev yazmış olması gerekiyor. Bu, kursun her dersinde tekrar karşılaşılacak bir örüntü: geri kurma bir doğa yasası değil, bir kod satırı. #### Özet - Yapı etiketi (`json:"ad"`), bir Go alanının adıyla bir JSON anahtarının adı arasındaki alan adı bağlamasının tarifini taşıyor; etiket yoksa alan adı olduğu gibi kullanılıyor. - `json:"-"` etiketiyle işaretlenen bir alan bayt dizisine hiç girmiyor; sınırı hiç geçmediği için geri de gelmiyor. - Aynı bayt dizisi bir yapıya değil, tip tarifi olmayan bir kaba (`map[string]any`) çözüldüğünde, tamsayı değerler `float64` olarak geri geliyor. - Gönderende olup alıcı yapıda karşılığı olmayan bir alan sessizce düşüyor; `json.Unmarshal` bu durumda hiçbir hata döndürmüyor. - Kursun on üç sınır geçişinin tam dağılımı bu derste kuruldu: 1 korunuyor, 5 yeniden kuruluyor, 7 kayboluyor; bu sayılar kursun geri kalan derslerinde bağlayıcı referans. - Tek `korunuyor` satırı, iki tarafın aynı tarifi paylaştığı geçiş; kalan on iki satırın hiçbirinde iki taraf aynı tarife sahip değil. #### Sonraki Adım Bu ders yapı etiketinin bir alan adını karşıya taşıyan bir **tarif** olduğunu ve tarif yoksa geri kurmanın da olmadığını ölçtü. Kursun bağlayıcı sayısı da burada kuruldu: on üç geçişin yedisinde tip bilgisi tamamen kayboluyor, beşinde bir tarifle geri kuruluyor, birinde hiç kaybolmuyor — bu üç sayı, sıradaki dokuz derste tek tek büyüyecek. Sıradaki konu tarifin hiç var olmadığı bir çıkışa bakıyor: bir şablon, aldığı yapıdan yalnızca metin üretiyor ve o metnin içinde hangi alanın nereden geldiğine dair hiçbir iz kalmıyor — bu ölçümün altıncı satırı bunu tek cümleyle özetlemişti, sıradaki ders aynı satırı tek başına, ayrıntısıyla ele alıyor. ### Şablonlar Source: https://academia.sh/tr/kurslar/go-uygulamalar/sablonlar Aynı şablon metni iki farklı Go tipinden (bir tamsayı, bir ondalıklı sayı) geçirildiğinde bayt bayt aynı çıktıyı üretir; kaynaktaki tip bilgisi çıkışta tümüyle kayboluyor. Bir alan adı çıktıda yalnızca şablonun kendi metninde yazılmışsa görünür — tip sisteminden gelmez. Metin ve HTML şablonları aynı veriyi kaçırma bakımından farklı bayt dizilerine çevirir. Sınırlayıcı ölçüm: şablon alan adlarını çalışma zamanında arar, olmayan bir alan derlemede değil çalıştırmada belli olur ve hata çıktının ortasında doğar. Önceki dersin son ölçümü bir yapı etiketinin ne işe yaradığını gösterdi: yapı etiketi alan adını sınırın karşı tarafına taşıyan bir tarifti ve o tarif olmadan geri kurma da yoktu. Bu ders aynı soruyu tersinden soruyor. JSON dizileştirme bir yapıyı bayta çevirip geri getirdi — gidiş ile dönüş arasında bir tarif vardı ve tarif, dört alandan beşinin tipini yeniden kurdu. Şablonlar bu geri dönüşü hiç vaat etmiyor: bir şablonun ürettiği şey yalnızca metin ve o metnin bir daha hiçbir tarifle okunmayacağı varsayılıyor. Kursun sorusu aynı kalıyor — bu değer sınırı geçerken tip bilgisine ne oluyor? — ama bu kez sınırın karşı tarafı bir program değil, bir ekran ya da bir dosya. Go'nun standart kitaplığı iki şablon paketi taşır: `text/template` ve `html/template`. İkisi de aynı şablon dilini kullanır — `{{.Alan}}` bir alanı okur, `{{if}}` ve `{{range}}` dallanma ve yineleme sağlar — ve ikisi de bir Go değerini alıp bir `io.Writer`'a metin yazar. Aralarındaki tek fark, birazdan ölçülecek olan kaçırma davranışı. Her ikisi de paket adıyla, kod bloğunda çağrılıyor; düzyazıda yalnızca "metin şablonu" ve "HTML şablonu" olarak anılıyorlar. `Execute` yönteminin ikinci parametresi bir `io.Writer`dır — bu ders arabellek (`bytes.Buffer`) kullanıyor, ama aynı çağrı bir dosyaya, standart çıktıya ya da bir ağ bağlantısına da yazabilirdi; Sistem ve Veri Erişimi konusunun ilk dersi aynı arayüzün dosya ile arabellek arasında paylaşıldığını ayrıca ölçecek. Şablon paketinin kendisi hedefin ne olduğunu bilmiyor ve bilmesi de gerekmiyor — yalnızca bir dizi bayt üretip yazıyor. Bu ders tam olarak bu üretilen baytların içinde neyin durup neyin durmadığını ölçüyor: kaynak veri sınırı geçerken, tip sistemi Go'nun kendi tarafında kalıyor mu, yoksa şablonun ürettiği metne kadar mı taşınıyor? Kursun ortak ölçümü on üç sınır geçişini üç sınıfa ayırmıştı: birinde tip korunuyor, beşinde yeniden kuruluyor, yedisinde kayboluyor (03. derste kurulan tam dağılım). Şablon çıktısı bu yedi kayıp geçişten biri — ama kayboluşun **biçimi** JSON'daki kayıptan farklı, çünkü JSON bir geri dönüş biçimidir (bayta çevrilir, sonra geri okunabilir) ve şablon hiç geri dönmeyi vaat etmez; ürettiği metnin bir daha ayrıştırılacağı bile varsayılmaz. #### Şablonun Tek Çıktı Tipi: Metin **AG19.** Bir şablonun `Execute` çağrısının ürettiği şey, kaynak verinin tipi ne olursa olsun, her zaman bir bayt dizisidir — ve o bayt dizisi bir dizgiye dönüştürüldüğünde kaynaktaki hiçbir tip bilgisini taşımaz. Bunu göstermenin en doğrudan yolu, aynı şablon metnini iki farklı Go tipinden geçirip çıktıları karşılaştırmaktır. ```go // sablonlar.go — sablonun urettigi metnin tipini, alan izini, kacirma farkini ve calisma zamani aramasini olcer package main import ( "bytes" "fmt" "html/template" "strings" textTemplate "text/template" ) type Urun struct { Ad string Adet int Yorum string } type UrunTamsayi struct{ Adet int } type UrunOndalikli struct{ Adet float64 } func main() { urun := Urun{Ad: "vida", Adet: 12, Yorum: "iyi ama pahali & yavas"} sabitSablon := textTemplate.Must(textTemplate.New("t").Parse("{{.Adet}}")) var bTamsayidan, bOndaliklidan bytes.Buffer sabitSablon.Execute(&bTamsayidan, UrunTamsayi{Adet: 12}) sabitSablon.Execute(&bOndaliklidan, UrunOndalikli{Adet: 12}) fmt.Println("-- ayni sablon, iki farkli kaynak tipi --") fmt.Println("tamsayidan gelen cikti:", bTamsayidan.String()) fmt.Println("ondalikli sayidan gelen cikti:", bOndaliklidan.String()) fmt.Println("iki cikti bayt bayt ayni mi:", bTamsayidan.String() == bOndaliklidan.String()) dar := textTemplate.Must(textTemplate.New("dar").Parse("{{.Ad}} x{{.Adet}}")) var bDar bytes.Buffer dar.Execute(&bDar, urun) fmt.Println() fmt.Println("-- alan adi ciktida yalniz sablon metninde yazilmissa gorunur --") fmt.Println("dar sablon ciktisi:", bDar.String()) fmt.Println("ciktida \"Ad\" adi geciyor mu:", strings.Contains(bDar.String(), "Ad")) fmt.Println("ciktida \"Adet\" adi geciyor mu:", strings.Contains(bDar.String(), "Adet")) genis := textTemplate.Must(textTemplate.New("genis").Parse("Ad: {{.Ad}}, Adet: {{.Adet}}")) var bGenis bytes.Buffer genis.Execute(&bGenis, urun) fmt.Println("genis sablon ciktisi:", bGenis.String()) fmt.Println("ciktida \"Ad\" adi geciyor mu:", strings.Contains(bGenis.String(), "Ad")) metinSablon := textTemplate.Must(textTemplate.New("m").Parse("{{.Yorum}}")) var bMetin bytes.Buffer metinSablon.Execute(&bMetin, urun) htmlSablon := template.Must(template.New("h").Parse("{{.Yorum}}")) var bHtml bytes.Buffer htmlSablon.Execute(&bHtml, urun) fmt.Println() fmt.Println("-- ayni veri, metin ve html sablonundan gecince farkli bayt uretiyor --") fmt.Printf("metin sablonu: %s\n", bMetin.String()) fmt.Printf("html sablonu: %s\n", bHtml.String()) fmt.Println("iki cikti ayni mi:", bMetin.String() == bHtml.String()) hatali := textTemplate.Must(textTemplate.New("hatali").Parse("on: {{.Ad}}, sonra: {{.OlmayanAlan}}")) var bHatali bytes.Buffer hata := hatali.Execute(&bHatali, urun) fmt.Println() fmt.Println("-- olmayan alan calisma zamaninda hata veriyor, once yazilan kismi yazidirilmis oluyor --") fmt.Println("hata olustu mu:", hata != nil) fmt.Printf("hatadan once yaziya gecen kisim: %q\n", bHatali.String()) } ``` ``` -- ayni sablon, iki farkli kaynak tipi -- tamsayidan gelen cikti: 12 ondalikli sayidan gelen cikti: 12 iki cikti bayt bayt ayni mi: true -- alan adi ciktida yalniz sablon metninde yazilmissa gorunur -- dar sablon ciktisi: vida x12 ciktida "Ad" adi geciyor mu: false ciktida "Adet" adi geciyor mu: false genis sablon ciktisi: Ad: vida, Adet: 12 ciktida "Ad" adi geciyor mu: true -- ayni veri, metin ve html sablonundan gecince farkli bayt uretiyor -- metin sablonu: iyi ama pahali & yavas html sablonu: iyi <b>ama</b> pahali & yavas iki cikti ayni mi: false -- olmayan alan calisma zamaninda hata veriyor, once yazilan kismi yazidirilmis oluyor -- hata olustu mu: true hatadan once yaziya gecen kisim: "on: vida, sonra: " ``` **AG20.** `UrunTamsayi.Adet` bir `int`, `UrunOndalikli.Adet` bir `float64` — ikisi de aynı `{{.Adet}}` şablonundan geçtiğinde çıktı ikisinde de `12` dizgisidir, bayt bayt eşit. Şablon çalışırken kaynağın hangi tipten geldiğini biliyordu (`Execute` bir arayüz değeri alır ve alanına yansımayla erişir), ama ürettiği metnin içinde bu bilgiden hiçbir iz kalmıyor. Çıktıyı okuyan bir program `12` dizgisinden geriye doğru "bu bir tamsayı mıydı, ondalıklı mıydı" sorusunu yanıtlayamaz. Bu, önceki dersteki tarifsiz sözlük gözlemiyle aynı yüzeye iniyor ama farklı bir yoldan. Bir JSON değeri tarifsiz bir kaba çözüldüğünde sayı hep `float64` oluyordu — kayıp vardı, ama kayıp **belirli bir yöndeydi**: her sayı aynı tek tipe düşüyordu ve bu düşüş `encoding/json`'ın kendi kuralıydı. Şablon çıktısında böyle bir kural bile yok, çünkü ortada hedef bir tip hiç yok — `int` de `float64` de aynı `string`e düşüyor, ama bu düşüşün "tek bir hedef tipe toplanma" gibi bir yapısı yok; ikisi de sıradan metin oldu ve metnin kendisi hiçbir tipe ait değil. JSON'un kaybı bir **dönüştürücünün** kararıydı; şablonun kaybı, ortada dönüştürülecek bir hedef tipin **hiç bulunmamasının** sonucu. **AG21.** Dar şablon (`{{.Ad}} x{{.Adet}}`) ürettiği `vida x12` metninde ne `"Ad"` ne `"Adet"` sözcüğü geçiyor — alan adları da tip bilgisi kadar kayboluyor, çünkü şablonun yazdığı şey alanın **değeri**, alanın **adı** değil. Geniş şablon (`Ad: {{.Ad}}, Adet: {{.Adet}}`) çıktısında `"Ad"` görünüyor, ama bunun nedeni Go'nun yapı alanının adını otomatik olarak taşıması değil — şablonu yazan kişi `"Ad: "` dizgisini kendi eliyle, düz metin olarak şablonun içine yazdı. Alan adının çıktıda görünmesi, tip sisteminden gelen bir garanti değil, şablon metnini yazan kişinin bir kararı. Şablonun çıktısının saf metin olması bir sınırlama olduğu kadar bir esneklik de taşıyor: hedefin bir HTML belgesi olması zorunlu değil. `text/template` bir yapılandırma dosyası, bir e-posta gövdesi, bir günlük satırı, hatta başka bir dilde yazılmış bir kaynak dosyası üretmek için de kullanılabilir — üretilen şey ne olursa olsun, şablon paketinin gözünde fark etmiyor, çünkü paket yalnızca bir metni bir başka metne, alan değerlerini yerine koyarak çeviriyor. Kursun bir sonraki dersi bu son kullanımı, kaynak kod üretimini, tam olarak bu noktadan devralıyor. `UrunTamsayi` ve `UrunOndalikli` bilinçli olarak tek alanlı, birbirine paralel iki tip olarak tanımlandı: aralarındaki tek fark `Adet` alanının tipi, başka hiçbir şey değişmiyor. Bu, ölçümün gösterdiği şeyin yalnızca "tip bilgisi kayboluyor" olduğunu, başka bir yapısal farktan (alan sayısı, alan sırası, alan adı) kaynaklanmadığını netleştiriyor — iki tip aynı şablon eylemine (`{{.Adet}}`) aynı adla yanıt veriyor ve aradaki tek değişken tip olduğu için, çıktıdaki eşitlik doğrudan bu tek değişkene bağlanabiliyor. #### Metin ile HTML Şablonunun Kaçırma Farkı **AG22.** Aynı `Urun` değeri, aynı `{{.Yorum}}` şablon metniyle, iki farklı pakete verildiğinde iki farklı bayt dizisi üretiyor. `text/template`, `Yorum` alanındaki `` ve `&` karakterlerine hiç dokunmadan olduğu gibi yazıyor. `html/template` aynı karakterleri `<`, `>` ve `&` dizgilerine çeviriyor — bu dönüşüm **kaçırma** (M14/K01 Web'in Temelleri ve HTML kursunda kurulan terim). `html/template` bunu otomatik yapıyor çünkü çıktısının bir HTML belgesinin içine yerleşeceğini varsayıyor ve `<`, `>`, `&` karakterlerinin HTML'de özel bir anlamı olduğunu biliyor; `text/template` hiçbir varsayım yapmıyor, çünkü çıktısının nereye gideceğini bilmiyor. M14/K01 kursu HTML üretimini ve kaçırma davranışını tarayıcı tarafında, sunucudan gelen bir belgenin işlenmesi bağlamında kurdu; burada tekrarlanmıyor, tek fark bu iki paketin aynı standart kitaplığın içinde, sunucu tarafında bir üretim adımı olarak durması. İki paket arasındaki seçim bir stil tercihi değil: çıktı bir HTML sayfasına gidecekse `html/template` kullanılmalı, çünkü kaçırmayı atlayan bir metin şablonu, veri içinde `