From 482665079a3f508ddabc0c0af441245cd33afca3 Mon Sep 17 00:00:00 2001 From: Bora Kaplan Date: Sat, 3 Sep 2016 20:25:39 +0300 Subject: [PATCH] Translated code examples for 02.3.md to Turkish --- tr/02.3.md | 262 ++++++++++++++++++++++++++--------------------------- 1 file changed, 131 insertions(+), 131 deletions(-) diff --git a/tr/02.3.md b/tr/02.3.md index e0dc8a1c..fa1a0fc0 100644 --- a/tr/02.3.md +++ b/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 { - fmt.Println("x is greater than 10") + if x := islenenDeger(); x > 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 { - fmt.Println("The integer is equal to 3") + if sayı == 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 - for ; sum < 1000; { - sum += sum + toplam := 1 + for ; toplam < 1000; { + toplam += toplam } Hatta `;` bile çıkarılabilir. Tanıdık geldi mi? Evet, tamamen `while` gibi oldu. - sum := 1 - for sum < 1000 { - sum += sum + toplam := 1 + for toplam < 1000 { + 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 - // continue prints 10、9、8、7、6、4、3、2、1 + // break varsa yazılanlar: 10、9、8、7、6 + // 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's val:",v) + fmt.Println("map'in k anahtarı:", k) + 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 { - case expr1: - some instructions - case expr2: - some other instructions - case expr3: - some other instructions + switch anaIfade { + case ifade1: + // eşleşme olursa işlenecek kod + case ifade2: + // eşleşme olursa işlenecek kod + case ifade3: + // 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 - switch integer { + sayı := 6 + 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 - integer <= 7 - integer <= 8 - default case +Programın sonucu şu olacaktır. -## 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) { - // function body - // multi-value return - return value1, value2 + func fonksiyonAdı(parametre1 tür1, parametre2 tür2) (çıkış1 tür1, çıkış2 tür2) { + // fonksiyon gövdesi + // birden fazla return + 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_xz := max(x, z) // call function max(x, z) + max_xy := max(x, y) // max(x, y) fonskiyonunu çağır + 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 - func SumAndProduct(A, B int) (int, int) { + // A+B ve A*B nin sonuçlarını döndür + 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, xTIMESy) + fmt.Printf("%d + %d = %d\n", x, y, xARTIy) + 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) { - add = A+B - multiplied = A*B + func ToplaVeCarp(A, B int) (toplanan int, carpılan int) { + toplanan = 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 - func add1(a int) int { - a = a+1 // we change value of a - return a // return new value of a + // a ya 1 eklemek için basit bir fonksiyon + func birEkle(a int) int { + a = a+1 // a'nın değeri değişti + 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 = ", x) // should print "x = 3" + fmt.Println("x+1 = ", x1) // sonuç "x+1 = 4" olmalı + 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 - func add1(a *int) int { - *a = *a+1 // we changed value of a - return *a // return new value of a + // a ya 1 eklemek için basit bir fonksiyon + func birEkle(a *int) int { + *a = *a+1 // a'nın değeri değişti + 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 = ", x) // should print "x = 4" + fmt.Println("x+1 = ", x1) // sonuç "x+1 = 4" olmalı + 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 { - file.Open("file") - // Do some work - if failureX { + func OkuYaz() bool { + file.Open("dosya") + // Kod + 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 { - file.Open("file") + func OkuYaz() bool { + 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 { - if integer%2 == 0 { + func tekMi(sayı int) bool { + if sayı%2 == 0 { return false } return true } - func isEven(integer int) bool { - if integer%2 == 0 { + func çiftMi(sayı int) bool { + 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 { - var result []int - for _, value := range slice { - if f(value) { - result = append(result, value) + func filtre(slice []int, f testInt) []int { + var sonuc []int + for _, deger := range slice { + if f(deger) { + 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 - fmt.Println("Odd elements of slice are: ", odd) - even := filter(slice, isEven) - fmt.Println("Even elements of slice are: ", even) + tek := filtre(slice, tekMi) // fonksiyonu değer olarak kullan + fmt.Println("Slice'daki tek sayılar: ", tek) + çift := filtre(slice, çiftMi) + 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 == "" { - panic("no value for $USER") + if kullanıcı == "" { + 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) -- Önceki bölüm: [Go foundation](02.2.md) +- [Rehber](preface.md) +- Önceki bölüm: [Go temelleri](02.2.md) - Sonraki bölüm: [struct](02.4.md)