summaryrefslogtreecommitdiffhomepage
path: root/tr-tr/swift-tr.html.markdown
diff options
context:
space:
mode:
authorozgur sahin <ozgursahin555@gmail.com>2015-08-22 18:31:39 +0300
committerozgur sahin <ozgursahin555@gmail.com>2015-08-22 18:31:39 +0300
commit036577916e76fe4df512da1b6c9253e1f51a5175 (patch)
tree2fc9d4f34fc6246e1a3ac2b0e5d17b418a7fc125 /tr-tr/swift-tr.html.markdown
parent3dff16785fbbeeabc994e4074c04a9a725d7c041 (diff)
[Swift/tr] Turkish For Swift
Diffstat (limited to 'tr-tr/swift-tr.html.markdown')
-rw-r--r--tr-tr/swift-tr.html.markdown590
1 files changed, 590 insertions, 0 deletions
diff --git a/tr-tr/swift-tr.html.markdown b/tr-tr/swift-tr.html.markdown
new file mode 100644
index 00000000..41835e13
--- /dev/null
+++ b/tr-tr/swift-tr.html.markdown
@@ -0,0 +1,590 @@
+---
+language: swift
+contributors:
+ - ["Özgür Şahin", "https://github.com/ozgurshn/"]
+filename: learnswift.swift
+---
+
+Swift iOS ve OSX platformlarında geliştirme yapmak için Apple tarafından oluşturulan yeni bir programlama dilidir. Objective - C ile beraber kullanılabilecek ve de hatalı kodlara karşı daha esnek bir yapı sunacak bir şekilde tasarlanmıştır. Swift 2014 yılında Apple'ın geliştirici konferansı WWDC de tanıtıldı. Xcode 6+'a dahil edilen LLVM derleyici ile geliştirildi.
+
+The official [Swift Programming Language](https://itunes.apple.com/us/book/swift-programming-language/id881256329) book from Apple is now available via iBooks.
+
+Apple'ın resmi [Swift Programlama Dili](https://itunes.apple.com/us/book/swift-programming-language/id881256329) kitabı iBooks'ta yerini aldı.
+
+See also Apple's [getting started guide](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html), which has a complete tutorial on Swift.
+
+Ayrıca Swift ile gelen tüm özellikleri görmek için Apple'ın [başlangıç kılavuzu](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html)na bakmanızda yarar var.
+
+
+
+```swift
+// modülü import etme
+import UIKit
+
+//
+// MARK: Temeller
+//
+
+
+//XCode işaretlemelerle kodunuzu bölümlere ayırmanızı ve sağ üstteki metot
+ listesinde gruplama yapmanıza olanak sağlıyor
+// MARK: Bölüm işareti
+// TODO: Daha sonra yapılacak
+// FIXME: Bu kodu düzelt
+
+
+//Swift 2 de, println ve print metotları print komutunda birleştirildi. Print
+ otomatik olarak yeni satır ekliyor.
+print("Merhaba dünya") // println print olarak kullanılıyor.
+print("Merhaba dünya", appendNewLine: false) // yeni bir satır eklemeden yazar.
+
+// variables (var) değer atandıktan sonra değiştirilebilir.
+// constants (let) değer atndıktan sonra değiştirilemez.
+
+var degiskenim = 42
+let øπΩ = "deger" // unicode degişken adları
+let π = 3.1415926
+let convenience = "keyword" // bağlamsal değişken adı
+let isim = "ahmet"; let soyad = "un" // farklı ifadeler noktalı virgül
+kullanılarak ayrılabilir.
+let `class` = "keyword" // rezerve edilmiş keywordler tek tırnak içerisine
+alınarak değişken adı olarak kullanılabilir
+let doubleOlduguBelli: Double = 70
+let intDegisken = 0007 // 7
+let largeIntDegisken = 77_000 // 77000
+let etiket = "birseyler " + String(degiskenim) // Cast etme
+let piYazi = "Pi = \(π), Pi 2 = \(π * 2)" // String içerisine değiken yazdırma
+
+
+// Builde özel değişkenler
+// -D build ayarını kullanır.
+#if false
+ print("yazılmadı")
+ let buildDegiskeni= 3
+#else
+ let buildDegiskeni = 7
+#endif
+print("Build degiskeni: \(buildDegiskeni)") // Build degeri: 7
+
+/*
+ Optionals Swift dilinde bazı değerleri veya yokluğu (None) bir değişkende
+ tutmanıza olanak sağlar.
+
+ Swift'te her bir degişkeninin bir değeri olması gerektiğinden, nil değeri
+ bile Optional değer olarak saklanır.
+
+ Optional<T> bir enum'dır.
+*/
+var baziOptionalString: String? = "optional" // nil olabilir.
+// yukarıdakiyle aynı ama ? bir postfix (sona eklenir) operatördür. (kolay
+okunabilir)
+var someOptionalString2: Optional<String> = "optional"
+
+
+if baziOptionalString != nil {
+ // ben nil değilim
+ if baziOptionalString!.hasPrefix("opt") {
+ print("ön eki var")
+ }
+
+ let bos = baziOptionalString?.isEmpty
+}
+baziOptionalString = nil
+
+// belirgin olarak acilan(unwrap) opsiyonel (optional) değer
+var acilanString: String! = "Değer bekleniliyor"
+//yukarıdakiyle aynı ama ! bir postfix operatördür (kolay okunabilir)
+var acilanString2: ImplicitlyUnwrappedOptional<String> = "Değer bekleniliyor."
+
+if let baziOpsiyonelSabitString = baziOptionalString {
+ // eğer bir değeri varsa, nil değilse
+ if ! baziOpsiyonelSabitString("tamam") {
+ // ön eke sahip değil
+ }
+}
+
+// Swift değişkenlerde herhangi bir tip saklanabilir.
+// AnyObject == id
+// Objective-C deki `id` den farklı olarak, AnyObject tüm değişkenlerle
+ çalışabilir (Class, Int, struct, etc)
+var herhangiBirObject: AnyObject = 7
+herhangiBirObject = "Değer string olarak değişti, iyi bir yöntem değil ama mümkün"
+
+/*
+ Yorumlar buraya
+
+ /*
+ İç içe yorum yazılması da mümkün
+ */
+*/
+
+//
+// MARK: Koleksiyonlar
+//
+
+/*
+ Array ve Dictionary tipleri aslında structdırlar. Bu yüzden `let` ve `var`
+ ayrıca bu tipleri tanımlarken değişebilir(var) veya değişemez(let)
+ olduğunu belirtir.
+
+*/
+
+// Diziler
+var liste = ["balik", "su", "limon"]
+liste[1] = "şişe su"
+let bosDizi = [String]() // let == değiştirilemez
+let bosDizi2 = Array<String>() // yukarıdakiyle aynı
+var bosDegistirilebilirDizi = [String]() // var == değişebilir
+
+
+// Dictionary
+var meslekler = [
+ "Kamil": "Kaptan",
+ "Ayse": "Analist"
+]
+meslekler["Cansu"] = "Halkla İlişkiler"
+let bosDictionary = [String: Float]() // let == değiştirilemez
+let bosDictionary2 = Dictionary<String, Float>() // yukarıdakiyle aynı
+var bosDegistirilebirDictionary = [String: Float]() // var == değiştirilebilir
+
+
+//
+// MARK: Kontroller
+//
+
+// for döngüsü (dizi)
+let dizi = [1, 1, 2, 3, 5]
+for deger in dizi {
+ if deger == 1 {
+ print("Bir!")
+ } else {
+ print("Bir degil!")
+ }
+}
+
+// for döngüsü (dictionary)
+var dict = ["one": 1, "two": 2]
+for (key, value) in dict {
+ print("\(key): \(value)")
+}
+
+// for döngüsü (aralık)
+for i in -1...liste.count {
+ print(i)
+}
+liste[1...2] = ["et", "yogurt"]
+// ..< kullanarak son elemanı çıkartabilirsiniz
+
+// while döngüsü
+var i = 1
+while i < 1000 {
+ i *= 2
+}
+
+// do-while döngüsü
+do {
+ print("merhaba")
+} while 1 == 2
+
+// Switch
+// Çok güçlü, `if` ifadesenin daha kolay okunabilir hali olarak düşünün
+// String, object örnekleri, ve primitif tipleri (Int, Double, vs) destekler.
+let sebze = "kırmızı biber"
+switch sebze {
+case "sogan":
+ let sebzeYorumu = "Biraz da domates ekle"
+case "domates", "salata":
+ let sebzeYorumu = "İyi bir sandviç olur"
+case let lokalScopeDegeri where lokalScopeDegeri.hasSuffix("biber"):
+ let sebzeYorumu = "Acı bir \(lokalScopeDegeri)?"
+default: // zorunludur (tüm olasılıkları yakalamak icin)
+ let sebzeYorumu = "Corbadaki herseyin tadı güzel"
+}
+
+
+//
+// MARK: Fonksiyonlar
+//
+
+// Fonksiyonlar first-class tiplerdir, yani başka fonksiyon içine konabilir
+// ve parametre olarak geçirilebilirler.
+
+// Swift dökümanlarıylaa birlikte Fonksiyonlar (format as reStructedText)
+
+/**
+ selamlama işlemi
+
+ :param: isim e isim
+ :param: gun e A gun
+ :returns: isim ve gunu iceren bir String
+*/
+func selam(isim: String, gun: String) -> String {
+ return "Merhaba \(isim), bugün \(gun)."
+}
+selam("Can", "Salı")
+
+// fonksiyon parametre davranışı hariç yukarıdakine benzer
+func selam2(#gerekliIsim: String, disParametreIsmi lokalParamtreIsmi: String) -> String {
+ return "Merhaba \(gerekliIsim), bugün \(lokalParamtreIsmi)"
+}
+selam2(gerekliIsim:"Can", disParametreIsmi: "Salı")
+
+// Bir tuple ile birden fazla deger dönen fonksiyon
+func fiyatlariGetir() -> (Double, Double, Double) {
+ return (3.59, 3.69, 3.79)
+}
+let fiyatTuple = fiyatlariGetir()
+let fiyat = fiyatTuple.2 // 3.79
+// _ (alt çizgi) kullanımı Tuple degerlerini veya diğer değerleri görmezden
+gelir
+let (_, fiyat1, _) = fiyatTuple // fiyat1 == 3.69
+print(fiyat1 == fiyatTuple.1) // true
+print("Benzin fiyatı: \(fiyat)")
+
+// Çeşitli Argümanlar
+func ayarla(sayilar: Int...) {
+ // its an array
+ let sayi = sayilar[0]
+ let argumanSAyisi = sayilar.count
+}
+
+// fonksiyonu parametre olarak geçirme veya döndürme
+func arttirmaIslemi() -> (Int -> Int) {
+ func birEkle(sayi: Int) -> Int {
+ return 1 + sayi
+ }
+ return birEkle
+}
+var arttir = arttirmaIslemi()
+arttir(7)
+
+// referans geçirme
+func yerDegistir(inout a: Int, inout b: Int) {
+ let tempA = a
+ a = b
+ b = tempA
+}
+var someIntA = 7
+var someIntB = 3
+yerDegistir(&someIntA, &someIntB)
+print(someIntB) // 7
+
+
+//
+// MARK: Closurelar
+//
+var sayilar = [1, 2, 6]
+
+// Fonksiyonlar özelleştirilmiş closurelardır. ({})
+
+// Closure örneği.
+// `->` parametrelerle dönüş tipini birbirinden ayırır
+// `in` closure başlığını closure bodysinden ayırır.
+sayilar.map({
+ (sayi: Int) -> Int in
+ let sonuc = 3 * sayi
+ return sonuc
+})
+
+// eger tip biliniyorsa, yukarıdaki gibi, şöyle yapabiliriz
+sayilar = sayilar.map({ sayi in 3 * sayi })
+// Hatta bunu
+//sayilar = sayilar.map({ $0 * 3 })
+
+print(sayilar) // [3, 6, 18]
+
+// Trailing closure
+sayilar = sorted(sayilar) { $0 > $1 }
+
+print(sayilar) // [18, 6, 3]
+
+// Super kısa hali ise, < operatörü tipleri çıkartabildiği için
+
+sayilar = sorted(sayilar, < )
+
+print(sayilar) // [3, 6, 18]
+
+//
+// MARK: Yapılar
+//
+
+// Structurelar ve sınıflar birçok aynı özelliğe sahiptir.
+struct IsimTablosu {
+ let isimler = [String]()
+
+ // Özelleştirilmiş dizi erişimi
+ subscript(index: Int) -> String {
+ return isimler[index]
+ }
+}
+
+// Structurelar otomatik oluşturulmuş kurucu metoda sahiptir.
+let isimTablosu = IsimTablosu(isimler: ["Ben", "Onlar"])
+let isim = isimTablosu[1]
+print("İsim \(name)") // İsim Onlar
+
+//
+// MARK: Sınıflar
+//
+
+// Sınıflar, structurelar ve üyeleri 3 seviye erişime sahiptir.
+// Bunlar: internal (default), public, private
+
+public class Sekil {
+ public func alaniGetir() -> Int {
+ return 0;
+ }
+}
+
+// Sınıfın tüm değişkenleri ve metotları publictir.
+// Eğer sadece veriyi yapılandırılmış bir objede
+// saklamak istiyorsanız, `struct` kullanmalısınız.
+
+internal class Rect: Sekil {
+ var yanUzunluk: Int = 1
+
+ // Özelleştirilmiş getter ve setter propertyleri
+ private var cevre: Int {
+ get {
+ return 4 * yanUzunluk
+ }
+ set {
+ // `newValue ` setterlarda yeni değere erişimi sağlar
+ yanUzunluk = newValue / 4
+ }
+ }
+
+ // Bir değişkene geç atama(lazy load) yapmak
+ // altSekil getter cağrılana dek nil (oluşturulmamış) olarak kalır
+ lazy var altSekil = Rect(yanUzunluk: 4)
+
+ // Eğer özelleştirilmiş getter ve setter a ihtiyacınız yoksa,
+ // ama bir değişkene get veya set yapıldıktan sonra bir işlem yapmak
+ // istiyorsanız, `willSet` ve `didSet` metotlarını kullanabilirsiniz
+ var identifier: String = "defaultID" {
+ // `willSet` argümanı yeni değer için değişkenin adı olacaktır.
+ willSet(someIdentifier) {
+ print(someIdentifier)
+ }
+ }
+
+ init(yanUzunluk: Int) {
+ self. yanUzunluk = yanUzunluk
+ // super.init i her zaman özelleştirilmiş değerleri oluşturduktan sonra
+ çağırın
+ super.init()
+ }
+
+ func kisalt() {
+ if yanUzunluk > 0 {
+ --yanUzunluk
+ }
+ }
+
+ override func alaniGetir() -> Int {
+ return yanUzunluk * yanUzunluk
+ }
+}
+
+// Basit `Kare` sınıfI `Rect` sınıfını extend ediyor.
+class Kare: Rect {
+ convenience init() {
+ self.init(yanUzunluk: 5)
+ }
+}
+
+var benimKarem = Kare()
+print(m benimKarem.alaniGetir()) // 25
+benimKarem.kisalt()
+print(benimKarem.yanUzunluk) // 4
+
+// sınıf örneğini cast etme
+let birSekil = benimKarem as Sekil
+
+// örnekleri karşılaştır, objeleri karşılaştıran == (equal to) ile aynı değil
+if benimKarem === benimKarem {
+ print("Evet, bu benimKarem")
+}
+
+// Opsiyonel init
+class Daire: Sekil {
+ var yaricap: Int
+ override func alaniGetir() -> Int {
+ return 3 * yaricap * yaricap
+ }
+
+ // Eğer init opsiyonelse (nil dönebilir) `init` den sonra soru işareti
+ // son eki ekle.
+ init?(yaricap: Int) {
+ self.yaricap = yaricap
+ super.init()
+
+ if yaricap <= 0 {
+ return nil
+ }
+ }
+}
+
+var benimDairem = Daire(radius: 1)
+print(benimDairem?.alaniGetir()) // Optional(3)
+print(benimDairem!. alaniGetir()) // 3
+var benimBosDairem = Daire(yaricap: -1)
+print(benimBosDairem?. alaniGetir()) // "nil"
+if let daire = benimBosDairem {
+ // benimBosDairem nil olduğu için çalışmayacak
+ print("circle is not nil")
+}
+
+
+//
+// MARK: Enumlar
+//
+
+// Enumlar opsiyonel olarak özel bir tip veya kendi tiplerinde olabilirler.
+// Sınıflar gibi metotlar içerebilirler.
+
+enum Kart {
+ case Kupa, Maca, Sinek, Karo
+ func getIcon() -> String {
+ switch self {
+ case .Maca: return "♤"
+ case .Kupa: return "♡"
+ case .Karo: return "♢"
+ case .Sinek: return "♧"
+ }
+ }
+}
+
+// Enum değerleri kısayol syntaxa izin verir. Eğer değişken tipi açık olarak belirtildiyse enum tipini yazmaya gerek kalmaz.
+var kartTipi: Kart = .Kupa
+
+// Integer olmayan enumlar direk değer (rawValue) atama gerektirir.
+enum KitapAdi: String {
+ case John = "John"
+ case Luke = "Luke"
+}
+print("Name: \(KitapAdi.John.rawValue)")
+
+// Değerlerle ilişkilendirilmiş Enum
+enum Mobilya {
+ // Int ile ilişkilendirilmiş
+ case Masa(yukseklik: Int)
+ // String ve Int ile ilişkilendirilmiş
+ case Sandalye(String, Int)
+
+ func aciklama() -> String {
+ switch self {
+ case .Masa(let yukseklik):
+ return "Masa boyu \(yukseklik) cm"
+ case .Sandalye(let marka, let yukseklik):
+ return "\(brand) marka sandalyenin boyu \(yukseklik) cm"
+ }
+ }
+}
+
+var masa: Mobilya = .Masa(yukseklik: 80)
+print(masa.aciklama()) // "Masa boyu 80 cm"
+var sandalye = Mobilya.Sandalye("Foo", 40)
+print(sandalye.aciklama()) // "Foo marka sandalyenin boyu 40 cm"
+
+
+//
+// MARK: Protokoller
+//
+
+// `protocol` onu kullanan tiplerin bazı özel değişkenleri, metotları,
+// tip metotlarını,opertörleri ve alt indisleri (subscripts) içermesini
+// zorunlu hale getirebilir.
+
+protocol SekilUretici {
+ var aktif: Bool { get set }
+ func sekilOlustur() -> Sekil
+}
+
+// @objc ile tanımlanan protokoller, uygunluğu kontrol edebilmenizi sağlayacak
+// şekilde opsiyonel fonksiyonlara izin verir
+@objc protocol SekliDondur {
+ optional func sekillendirilmis()
+ optional func sekillendirilebilir() -> Bool
+}
+
+class BenimSeklim: Rect {
+ var delegate: SekliDondur?
+
+ func buyut() {
+ yanUzlunluk += 2
+
+ // Bir çalışma zamanı hatası("optional chaining") fırlatmak yerine nil
+ //değeri görmezden gelerek nil dönmek için opsiyonel değişken, metot veya
+ // altindisten sonra soru işareti koyabilirsiniz.
+ if let izinVeriyormu = self.delegate?.sekillendirilebilir?() {
+ // önce delegate i sonra metodu test edin
+ self.delegate?.sekillendirilmis?()
+ }
+ }
+}
+
+
+//
+// MARK: Diğerleri
+//
+
+// `extension`lar: Var olan tiplere ekstra özellikler ekleyin
+
+// Kare artık `Printable` protokolüne uyuyor.
+extension Kare: Printable {
+ var description: String {
+ return "Alan: \(alaniGetir()) - ID: \(self.identifier)"
+ }
+}
+
+print("Kare: \(benimKarem)")
+
+// Dahili tipleri de yeni özellikler ekleyebilirsiniz
+extension Int {
+ var customProperty: String {
+ return "Bu sayı \(self)"
+ }
+
+ func carp(num: Int) -> Int {
+ return num * self
+ }
+}
+
+print(7.customProperty) // "Bu sayı 7"
+print(14.carp(3)) // 42
+
+// Genericler: Java ve C#'a benzer şekilde. `where` anahtar kelimesini
+// kullanarak genericlerin özelliklerini belirleyin
+
+func indexiBul<T: Equatable>(dizi: [T], bulunacakDeger: T) -> Int? {
+ for (index, deger) in enumerate(dizi) {
+ if deger == bulunacakDeger {
+ return index
+ }
+ }
+ return nil
+}
+let bulunanIndex = indexiBul([1, 2, 3, 4], 3)
+print(bulunanIndex == 2) // true
+
+// Operatorler:
+// Özel operatorler şu karakterlerle başlayabilir:
+// / = - + * % < > ! & | ^ . ~
+// veya
+// Unicode math, symbol, arrow, dingbat, ve line/box karakterleri.
+prefix operator !!! {}
+
+// Yan uzunluğu 3 katına çıkartan prefix operatörü
+prefix func !!! (inout sekil: Kare) -> Kare {
+ sekil.YanUzunluk *= 3
+ return sekil
+}
+
+// güncel deger
+print(benimKarem.YanUzunluk) // 4
+
+// yan uzunluğu !!! operatorü kullanarak 3 katına çıkar
+!!!benimKarem
+print(benimKarem.YanUzunluk) // 12
+```