Merge pull request #705 from hebeka/master

Translated code examples for 02.3.md to Turkish

tr/02.3.md

@@ -13,18 +13,18 @@ Akış kontrolü programcılıkta en büyük icattır. Onun sayesinde, basit kon
 `if` şartları için Go da paranteze gerek yoktur.
 
 	if x > 10 {
-    	fmt.Println("x is greater than 10")
+    	fmt.Println("x 10'dan büyüktür")
 	} else {
-    	fmt.Println("x is less than or equal to 10")
+    	fmt.Println("x 10'dan küçük veya eşittir")
 	} 
 	
 Go da çok işe yarar bir `if` kullanımı, şart ifadesinden önce değişken tanımlama yapmaktır. Bu değişkenin kapsamı sadece `if` blok alanı içerisinde geçerlidir.
 
 	// x'i tanımla, ve 10 dan büyük olup olmadığını kontrol et 
-	if x := computedValue(); x > 10 {
+	if x := islenenDeger(); x > 10 {
-    	fmt.Println("x is greater than 10")
+    	fmt.Println("x 10'dan büyüktür")
 	} else {
-    	fmt.Println("x is less than 10")
+    	fmt.Println("x 10'dan küçüktür")
 	}
 
 	// Bu satır derlenemez
@@ -32,12 +32,12 @@ Go da çok işe yarar bir `if` kullanımı, şart ifadesinden önce değişken t
 	
 Birden fazla şart için `if-else` kullanın.	
 
-	if integer == 3 {
+	if sayı == 3 {
-    	fmt.Println("The integer is equal to 3")
+    	fmt.Println("Sayı 3'e eşittir")
 	} else if integer < 3 {
-    	fmt.Println("The integer is less than 3")
+    	fmt.Println("Sayı 3'ten küçüktür")
 	} else {
-    	fmt.Println("The integer is greater than 3")
+    	fmt.Println("Sayı 3'ten büyüktür")
 	}
 	
 ### goto
@@ -46,10 +46,10 @@ Go da `goto` terimi mevcuttur fakat kullanırken dikkatli olun. `goto` programı
 
 	func myFunc() {
     	i := 0
-	Here:   // label ends with ":"
+	Buraya:   // label sonuna ":" koyulur
     	fmt.Println(i)
     	i++
-    	goto Here   // jump to label "Here"
+    	goto Buraya   // "Buraya" labeline git
 	}
 	
 Label'ın adı büyük-küçük harfe duyarlıdır.
@@ -58,11 +58,11 @@ Label'ın adı büyük-küçük harfe duyarlıdır.
 
 `for` Go da bulunan en güçlü kontrol lojiğidir. Datayı döngüsel olarak ve tekrarlı işlemlerle okuyabilir, `while` döngüsü gibi.
 
-	for expression1; expression2; expression3 {
+	for ifade1; ifade2; ifade3 {
     	//...
 	}
 
-`expression1`, `expression2` ve `expression3` birer ifade olmak üzere, `expression1` ve `expression3` değişken tanımlama veya bir fonksiyondan dönen return olabilirken, `expression2` ise kontrol ifadesidir. `expression1` ifadesi döngüye girmeden önce bir kere işlenecektir. `expression3` ise her döngü sonunda işlenir.
+`ifade1`, `ifade2` ve `ifade3` birer ifade olmak üzere, `ifade1` ve `ifade3` değişken tanımlama veya bir fonksiyondan dönen değer olabilirken, `ifade2` ise kontrol ifadesidir. `ifade1` ifadesi döngüye girmeden önce bir kere işlenecektir. `ifade3` ise her döngü sonunda işlenir.
 
 Örnekler düz yazıdan daha yararlı olacaktır.
 
@@ -70,67 +70,67 @@ Label'ın adı büyük-küçük harfe duyarlıdır.
 	import "fmt"
 
 	func main(){
-    	sum := 0;
+    	toplam := 0;
     	for index:=0; index < 10 ; index++ {
-        	sum += index
+        	toplam += index
     	}
-    	fmt.Println("sum is equal to ", sum)
+    	fmt.Println("sayıların toplamı= ", toplam)
 	}
-	// Print：sum is equal to 45
+	// Ekran çıktısı：sayıların toplamı= 45
 
 Bazen birden fazla atama yapmak gerekir fakat Go bunun için kullanılacak bir `,` operatörü yoktur. Biz de `i, j = i + 1, j - 1` gibi paralel atamalar yaparız.
 
-İhtiyacımız yoksa `expression1` ve `expression1` ifadelerini çıkarabiliriz.
+İhtiyaç yoksa `ifade1` ve `ifade3` çıkartılabilir.
 
-	sum := 1
+	toplam := 1
-	for ; sum < 1000;  {
+	for ; toplam < 1000;  {
-    	sum += sum
+    	toplam += toplam
 	}
 
 Hatta `;` bile çıkarılabilir. Tanıdık geldi mi? Evet, tamamen `while` gibi oldu.
 
-	sum := 1
+	toplam := 1
-	for sum < 1000 {
+	for toplam < 1000 {
-    	sum += sum
+    	toplam += toplam
 	}
 
 Döngülerde `break` ve `continue` adında iki önemli işlem vardır. `break` döngüden çıkartır ve `continue` o anki tekrarı atlar ve sonraki tekrara geçer. Eğer birden fazla iç içe döngüleriniz varsa `break` ile labelları kullabilirsiniz.
 
 	for index := 10; index>0; index-- {
     	if index == 5{
-        	break // or continue
+        	break // veya continue
     	}
     	fmt.Println(index)
 	}
-	// break prints 10、9、8、7、6
+	// break varsa yazılanlar: 10、9、8、7、6
-	// continue prints 10、9、8、7、6、4、3、2、1
+	// continue varsa yazılanlar: 10、9、8、7、6、4、3、2、1
 
 `for` döngüsü `range` kullanıldığında `slice` ve `map` de bulunan datayı okuyabilir.
 
 	for k,v:=range map {
-    	fmt.Println("map's key:",k)
+    	fmt.Println("map'in k anahtarı:", k)
-    	fmt.Println("map's val:",v)
+    	fmt.Println("map'in k anahtarındaki değeri:", v)
 	}
 
 Go da birden fazla değer return yapılabildiği ve kullanılmayan bir değişken olduğunda derleyici hata verdiği için, kullanmak istemediğiniz değişkenler için `_` kullanabilirsiniz.
 
 	for _, v := range map{
-    	fmt.Println("map's val:", v)
+    	fmt.Println("map'in değeri:", v)
 	}
 	
 ### switch
 
 Bazı durumlarda çok fazla `if-else` kullandığınızı farkedebilirsiniz. Bu programı okumayı zorlaştırır ve gelecekte bakım yapmayı zorlaştırabilir. Bu durumda problemi çözmek için `switch` kullanmak mükemmeldir. 
 
-	switch sExpr {
+	switch anaIfade {
-	case expr1:
+	case ifade1:
-    	some instructions
+    	// eşleşme olursa işlenecek kod
-	case expr2:
+	case ifade2:
-    	some other instructions
+    	// eşleşme olursa işlenecek kod
-	case expr3:
+	case ifade3:
-    	some other instructions
+    	// eşleşme olursa işlenecek kod
 	default:
-    	other code
+    	// eşleşme olmazsa işlenecek kod
 	}
 
 `sExpr`, `expr1`, `expr2`, ve `expr3` ifadelerinin türleri aynı olmalıdır. `switch` çok esnektir. Şartlar sabit olmak zorunda değildir ve şart sağlanana kadar yukarıdan aşağıya doğru çalışır. Eğer `switch` in ardından bir ifade gelmiyorsa `true` olarak görülür.
@@ -138,61 +138,61 @@ Bazı durumlarda çok fazla `if-else` kullandığınızı farkedebilirsiniz. Bu
 	i := 10
 	switch i {
 	case 1:
-    	fmt.Println("i is equal to 1")
+    	fmt.Println("i 1'e eşittir")
 	case 2, 3, 4:
-    	fmt.Println("i is equal to 2, 3 or 4")
+    	fmt.Println("i 2, 3 veya 4'e eşittir")
 	case 10:
-    	fmt.Println("i is equal to 10")
+    	fmt.Println("i 10'a eşittir")
 	default:
-    	fmt.Println("All I know is that i is an integer")
+    	fmt.Println("Tek bildiğim i nin bir sayi olduğu")
 	}
 
 Beşinci satırdaki gibi `case` içinde birden fazla değer olabilir. `case` sonlarına `break` eklemeye gerek yoktur, şart sağlanıp işlem yapıldıktan sonra çıkacaktır. Eğer çıkmasını istemiyorsanız `fallthrough` ifadesini kullanarak bir sonraki şarta devam edebilirsiniz.
 
-	integer := 6
+	sayı := 6
-	switch integer {
+	switch sayı {
 	case 4:
-		fmt.Println("integer <= 4")
+		fmt.Println("sayı <= 4")
 		fallthrough
 	case 5:
-		fmt.Println("integer <= 5")
+		fmt.Println("sayı <= 5")
 		fallthrough
 	case 6:
-		fmt.Println("integer <= 6")
+		fmt.Println("sayı <= 6")
 		fallthrough
 	case 7:
-		fmt.Println("integer <= 7")
+		fmt.Println("sayı <= 7")
 		fallthrough
 	case 8:
-		fmt.Println("integer <= 8")
+		fmt.Println("sayı <= 8")
 		fallthrough
 	default:
-		fmt.Println("default case")
+		fmt.Println("default durumu")
 	}
-	
-This program prints the following information.
 
-	integer <= 6
+Programın sonucu şu olacaktır.
-	integer <= 7
-	integer <= 8
-	default case
 
-## Functions
+	sayı <= 6
+	sayı <= 7
+	sayı <= 8
+	default durumu
+
+## Fonksiyonlar
 
 `func` terimini kullanarak bir fonksiyon tanımlayın.
 
-	func funcName(input1 type1, input2 type2) (output1 type1, output2 type2) {
+	func fonksiyonAdı(parametre1 tür1, parametre2 tür2) (çıkış1 tür1, çıkış2 tür2) {
-    	// function body
+    	// fonksiyon gövdesi
-    	// multi-value return
+    	// birden fazla return
-    	return value1, value2
+    	return dönüş1, dönüş2
 	}
 
 Yukarıdaki örnekten tahmin edebileceğiniz üzere aşağıda açıklamaları bulunur.
 
-- `funcName` adlı foonksiyonu tanımlamak için `func` terimini kullanın.
+- `fonksiyonAdı` adlı foonksiyonu tanımlamak için `func` terimini kullanın.
 - Fonksiyonlar sıfır veya daha fazla parametreye sahip olabilir. Parametrenin türü adından sonra gelir ve birden fazla parametre varsa `,` ile ayrılır.
 - Fonksiyonlar birden fazla değer döndürebilirler.
-- Bu örnekte `output1` ve `output2` adında iki değer döndürülmüş. Bunlara ad vermek zorunda değilsiniz, türünü yazmanız yeterli.
+- Bu örnekte `çıkış1` ve `çıkış2` adında iki değer döndürülmüş. Bunlara ad vermek zorunda değilsiniz, türünü yazmanız yeterli.
 - Eğer sadece bir değer döndürecekseniz parantez olmadan yazmalısınız.
 - Eğer en az bir değer döndürüyorsanız, fonksiyonun içinde istediğiniz yerde `return` terimini kullanmalısınız.
 
@@ -201,7 +201,7 @@ Yukarıdaki örnekten tahmin edebileceğiniz üzere aşağıda açıklamaları b
 	package main
 	import "fmt"
 
-	// return greater value between a and b
+	// a ile b arasından büyük olanı döndür
 	func max(a, b int) int {
     	if a > b {
         	return a
@@ -214,12 +214,12 @@ Yukarıdaki örnekten tahmin edebileceğiniz üzere aşağıda açıklamaları b
     	y := 4
     	z := 5
 
-    	max_xy := max(x, y) // call function max(x, y)
+    	max_xy := max(x, y) // max(x, y) fonskiyonunu çağır
-    	max_xz := max(x, z) // call function max(x, z)
+    	max_xz := max(x, z) // max(x, z) fonksiyonunu çağır
 
     	fmt.Printf("max(%d, %d) = %d\n", x, y, max_xy)
     	fmt.Printf("max(%d, %d) = %d\n", x, z, max_xz)
-    	fmt.Printf("max(%d, %d) = %d\n", y, z, max(y,z)) // call function here
+    	fmt.Printf("max(%d, %d) = %d\n", y, z, max(y,z)) // burada da fonksiyon çağırıldı
 	}
 
 Yukarıdaki örnek fonksiyon `max` da iki aynı tür parametre `int` olduğu için bir tane yazmak yeterli olur. Yani `a int, b int` yerine `a, b int` kullanılır. Birden fazla parametre için de aynı kural geçerlidir. Farkettiyseniz `max` fonksiyonu sadece bir değer döndürür ve zorunda olmadığımız için o değere bir isim vermedik, bu kısa halini kullandık. 
@@ -233,8 +233,8 @@ Alttaki örnekte bunu kullanalım.
 	package main
 	import "fmt"
 
-	// return results of A + B and A * B
+	// A+B ve A*B nin sonuçlarını döndür
-	func SumAndProduct(A, B int) (int, int) {
+	func toplaVeCarp(A, B int) (int, int) {
     return A+B, A*B
 	}
 
@@ -242,17 +242,17 @@ Alttaki örnekte bunu kullanalım.
     	x := 3
     	y := 4
 
-    	xPLUSy, xTIMESy := SumAndProduct(x, y)
+    	xARTIy, xCARPIy := SumAndProduct(x, y)
 
-    	fmt.Printf("%d + %d = %d\n", x, y, xPLUSy)
+    	fmt.Printf("%d + %d = %d\n", x, y, xARTIy)
-    	fmt.Printf("%d * %d = %d\n", x, y, xTIMESy)
+    	fmt.Printf("%d * %d = %d\n", x, y, xCARPIy)
 	}
 	
 Üstteki fonksiyon isimsiz iki değer döndürür -isterseniz isim verebilirsiniz. Eğer isimlendirseydik, `return` yazıp isimlerini yazmamız yeterdi. Çünkü fonksiyonun içinde tanımlılar. Şuna dikkat etmelisiniz ki eğer fonksiyonu başka bir pakette kullanacaksanız (fonksiyonun ilk harfi büyük harfle başlamalıdır) `return` yapacaklarınızı tam bir ifade olarak yazmanız daha iyi olacaktır. Kodu daha okunur hale getirir. 
 
-	func SumAndProduct(A, B int) (add int, multiplied int) {
+	func ToplaVeCarp(A, B int) (toplanan int, carpılan int) {
-    	add = A+B
+    	toplanan = A+B
-    	multiplied = A*B
+    	carpılan = A*B
     	return
 	}
 
@@ -265,7 +265,7 @@ Go birden fazla argüman alabilen fonksiyonları destekler. Bunlara variadic (be
 `arg …int` kısmı Go ya bu fonksiyonun değişen sayıda argüman aldığını söyler. Bu argümanların türü `int` dir. `arg` fonksiyonun gövdesinde `int` türünde bir `slice` olur.
 
 	for _, n := range arg {
-    	fmt.Printf("And the number is: %d\n", n)
+    	fmt.Printf("Sayı: %d\n", n)
 	}
 	
 ### Değer ile devretmek ve pointerlar
@@ -277,49 +277,49 @@ Bunun kanıtı olarak bir örnek görelim.
 	package main
 	import "fmt"
 
-	// simple function to add 1 to a
+	// a ya 1 eklemek için basit bir fonksiyon
-	func add1(a int) int {
+	func birEkle(a int) int {
-    	a = a+1 // we change value of a 
+    	a = a+1 // a'nın değeri değişti
-    	return a // return new value of a
+    	return a // a'nın yeni değeri döndürülüyor
 	}
 
 	func main() {
     	x := 3
 
-    	fmt.Println("x = ", x)  // should print "x = 3"
+    	fmt.Println("x = ", x)  // sonuç "x = 3" olmalı
 
-    	x1 := add1(x)  // call add1(x)
+    	x1 := birEkle(x)  // birEkle(x) fonksiyonu çağırıldı
 
-    	fmt.Println("x+1 = ", x1) // should print "x+1 = 4"
+    	fmt.Println("x+1 = ", x1) // sonuç "x+1 = 4" olmalı
-    	fmt.Println("x = ", x)    // should print "x = 3"
+    	fmt.Println("x = ", x)    // sonuç "x = 3" olmalı
 	}
 
-Gördünüz mü? `add1` fonksiyonuna `x` i gönderdiğimiz halde asıl değeri değişmedi.
+Gördünüz mü? `birEkle` fonksiyonuna `x` i gönderdiğimiz halde asıl değeri değişmedi.
 
-Sebebi basit: `add1` i çağırdığımızda ona `x` in bir kopyasını gönderdik `x` in kendisini değil.
+Sebebi basit: `birEkle` i çağırdığımızda ona `x` in bir kopyasını gönderdik `x` in kendisini değil.
 
 Şimdi sorabilirsiniz `x` in kendisini nasıl fonksiyona verebilirim diye.
 
-Burada pointer kullanmamız gerekiyor. Biliyoruz ki değişkenler bellekte tutulur ve bir adresleri vardır. Eğer değişkenin aslını değiştirmek istiyorsak onun bellek adresini kullanmalıyız. Böylelikle `add1` fonksiyonu `x` in adresini kullanarak onun değerini değiştirebilir. Parametre türünü `*int` olarak değiştiriyoruz ve değişkenin adresini `&x` ile fonksiyona veriyoruz. Fonksiyona değerin bir kopyasını değil de bir pointer verdiğimize dikkat edin.
+Burada pointer kullanmamız gerekiyor. Biliyoruz ki değişkenler bellekte tutulur ve bir adresleri vardır. Eğer değişkenin aslını değiştirmek istiyorsak onun bellek adresini kullanmalıyız. Böylelikle `birEkle` fonksiyonu `x` in adresini kullanarak onun değerini değiştirebilir. Parametre türünü `*int` olarak değiştiriyoruz ve değişkenin adresini `&x` ile fonksiyona veriyoruz. Fonksiyona değerin bir kopyasını değil de bir pointer verdiğimize dikkat edin.
 
 	package main
 	import "fmt"
 
-	// simple function to add 1 to a
+	// a ya 1 eklemek için basit bir fonksiyon
-	func add1(a *int) int {
+	func birEkle(a *int) int {
-    	*a = *a+1 // we changed value of a
+    	*a = *a+1 // a'nın değeri değişti
-    	return *a // return new value of a
+    	return *a // a'nın yeni değeri döndürülüyor
 	}
 
 	func main() {
     	x := 3
 
-    	fmt.Println("x = ", x)  // should print "x = 3"
+    	fmt.Println("x = ", x)  // sonuç "x = 3" olmalı
 
-    	x1 := add1(&x)  // call add1(&x) pass memory address of x
+    	x1 := add1(&x)  // birEkle(x) fonksiyonu çağırıldı ve x'in adresi verildi
 
-    	fmt.Println("x+1 = ", x1) // should print "x+1 = 4"
+    	fmt.Println("x+1 = ", x1) // sonuç "x+1 = 4" olmalı
-    	fmt.Println("x = ", x)    // should print "x = 4"
+    	fmt.Println("x = ", x)    // sonuç "x = 4" olmalı
 	}
 
 Şimdi `x` in asıl değerini değiştirebiliriz. Neden pointer kullanıyoruz? Avantajı nedir?
@@ -332,15 +332,15 @@ Burada pointer kullanmamız gerekiyor. Biliyoruz ki değişkenler bellekte tutul
 
 Go da iyi tasarlanmış `defer` (ertelemek) adlı bir terim vardır. Bir fonksiyonda birden fazla `defer` ifadesi bulunabilir, program çalıştığında sondan başa sırayla çalışacaklardır. Programın dosya açtığı durumlarda bu dosyaların hata vermeden önce kapatılması gerekir. Örneklere bakalım.
 
-	func ReadWrite() bool {
+	func OkuYaz() bool {
-    	file.Open("file")
+    	file.Open("dosya")
-	// Do some work
+	// Kod
-    	if failureX {
+    	if hataX {
         	file.Close()
         	return false
     	}
 
-    	if failureY {
+    	if hataY {
         	file.Close()
         	return false
         }
@@ -351,13 +351,13 @@ Go da iyi tasarlanmış `defer` (ertelemek) adlı bir terim vardır. Bir fonksiy
 
 Bazı kodların tekrar ettiğini görüyoruz. `defer` bu problemi çok iyi çözer. Daha temiz kod yazmanıza yardım etmekle kalmaz kodunuzu daha okunur yapar.
 
-	func ReadWrite() bool {
+	func OkuYaz() bool {
-    	file.Open("file")
+    	file.Open("dosya")
     	defer file.Close()
-    	if failureX {
+    	if hataX {
         	return false
     	}
-    	if failureY {
+    	if hataY {
         	return false
     	}
     	return true
@@ -373,51 +373,51 @@ Eğer birden fazla `defer` varsa ters sırayla çalışırlar. Sıradaki örnek
 
 Go'da fonksiyonlar aynı zamanda değişken olabilirler. `type` onları kullanarak tanımlayabiliriz. Aynı imzaya sahip fonksiyonlar ayno tür olarak görülebilir.
 
-	type typeName func(input1 inputType1 , input2 inputType2 [, ...]) (result1 resultType1 [, ...])
+	type türAdı func(parametre1 tür1, parametre2 tür2 [, ...]) (çıkış1 tür1 [, ...])
 
 Bunun avantajı nedir? Cevap, fonksiyonları değer olarak verebilmemizi sağlamasıdır.
 
 	package main
 	import "fmt"
 
-	type testInt func(int) bool // define a function type of variable
+	type testInt func(int) bool // değişken olarak fonksiyon tanımlandı
 
-	func isOdd(integer int) bool {
+	func tekMi(sayı int) bool {
-    	if integer%2 == 0 {
+    	if sayı%2 == 0 {
         	return false
     	}
     	return true
 	}
 
-	func isEven(integer int) bool {
+	func çiftMi(sayı int) bool {
-    	if integer%2 == 0 {
+    	if sayı%2 == 0 {
         	return true
     	}
     	return false
 	}
 
-	// pass the function `f` as an argument to another function
+	// 'f' fonksiyonunu bir fonksiyona parametre olarak ata
 
-	func filter(slice []int, f testInt) []int {
+	func filtre(slice []int, f testInt) []int {
-    	var result []int
+    	var sonuc []int
-    	for _, value := range slice {
+    	for _, deger := range slice {
-        	if f(value) {
+        	if f(deger) {
-            	result = append(result, value)
+            	sonuc = append(sonuc, deger)
         	}
     	}
-    	return result
+    	return sonuc
 	}
 
 	func main(){
     	slice := []int {1, 2, 3, 4, 5, 7}
     	fmt.Println("slice = ", slice)
-    	odd := filter(slice, isOdd)    // use function as values
+    	tek := filtre(slice, tekMi)    // fonksiyonu değer olarak kullan
-    	fmt.Println("Odd elements of slice are: ", odd)
+    	fmt.Println("Slice'daki tek sayılar: ", tek)
-    	even := filter(slice, isEven) 
+    	çift := filtre(slice, çiftMi) 
-    	fmt.Println("Even elements of slice are: ", even)
+    	fmt.Println("Slice'daki çift sayılar: ", çift)
 	}
 
-Interface kullanılan durumlarda çok yararlıdır. Gördüğünüz gibi `testInt` fonksiyon türünde bir değişkendir ve `filter` ın döndürdüğü argümanlar ve değerler `testInt` ile aynıdır. Böylelikle programlarımızda karmaşık mantık yürütebilir ve esneklik kazanabiliriz.
+Interface kullanılan durumlarda çok yararlıdır. Gördüğünüz gibi `testInt` fonksiyon türünde bir değişkendir ve `filtre`'nin döndürdüğü argümanlar ve değerler `testInt` ile aynıdır. Böylelikle programlarımızda karmaşık mantık yürütebilir ve esneklik kazanabiliriz.
 
 ### Panic ve Recover
 
@@ -429,23 +429,23 @@ Go da Java gibi `try-catch` yapısı yoktur. Go exception fırlatmak yerine `pan
 
 Aşağıdaki örnekte `panic` nasıl kullanılır gösterilmiştir.
 
-	var user = os.Getenv("USER")
+	var kullanıcı = os.Getenv("KULLANICI")
 
 	func init() {
-    	if user == "" {
+    	if kullanıcı == "" {
-        	panic("no value for $USER")
+        	panic("$KULLANICI için bir değer bulunamadı")
     	}
 	}
 
 Bu örnek de `panic` kontrolü yapılmasını gösterir.	
 
-	func throwsPanic(f func()) (b bool) {
+	func panicYapar(f func()) (b bool) {
     	defer func() {
         	if x := recover(); x != nil {
             	b = true
         	}
     	}()
-    	f() // if f causes panic, it will recover
+    	f() // eğer f() panic yaparsa recover yapılır
     	return
 	}
 	
@@ -459,7 +459,7 @@ Programlar işleme `main` paketinden başlar. Eğer `main` başka paketler dahil
 
 ![](images/2.3.init.png?raw=true)
 
-Figure 2.6 Go da programların parafe edilmesinin akışı
+Şekil 2.6 Go da programların parafe edilmesinin akışı
 
 ### import
 
@@ -510,8 +510,8 @@ Paketler dahil edilirken kullanılan özel operatörler vardır ve bunlar geneld
 	
 	Bu operatör dahil edilen paketin sadece `init` fonksiyonun çağrılıp çalıştırılması için kullanılır. Paketteki diğer fonksiyonları kullanacağınıza emin değilseniz kullanabilirsiniz.
 	
-## Links
+## Linkler
 
-- [Directory](preface.md)
+- [Rehber](preface.md)
-- Önceki bölüm: [Go foundation](02.2.md)
+- Önceki bölüm: [Go temelleri](02.2.md)
 - Sonraki bölüm: [struct](02.4.md)