0Pricing
Swift Academy · Ders

Self Gereksinimleri ve Equatable Tasarımı

Self kullanan protokolleri ve Equatable/Comparable'ın bunlardan nasıl yararlandığını öğrenin.

Self Gereksinimleri ve Equatable Tasarımı, CoddyKit'te ücretsiz bir Swift Academy dersidir. Bu, 4 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Swift Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Swift Academy kursu toplamda 4 dersten oluşur.

Hoş Geldiniz

`Self`, bir protokole uyum sağlayan somut türü ifade eder. Protokollerin, `Equatable` ve `Comparable` gibi, farklı türlerle güvenli biçimde çalışmasını sağlar.

Parametre Türü Olarak Self

```swift protocol Equatable { static func == (lhs: Self, rhs: Self) -> Bool } ``` `Self`, her iki parametrenin de *aynı* somut türde olması gerektiği anlamına gelir. Bu protokol aracılığıyla bir `Int` ile bir `String` değerini karşılaştıramazsınız.

Equatable Protokolüne Uyumluluk

```swift struct Point: Equatable { var x: Double var y: Double // Auto-synthesised: // static func == (lhs: Point, rhs: Point) -> Bool // { lhs.x == rhs.x && lhs.y == rhs.y } } print(Point(x:1,y:2) == Point(x:1,y:2)) // true ```

Self ile Comparable

```swift struct Version: Comparable { let major, minor, patch: Int static func < (lhs: Version, rhs: Version) -> Bool { (lhs.major, lhs.minor, lhs.patch) < (rhs.major, rhs.minor, rhs.patch) } } let v1 = Version(major:1,minor:2,patch:0) let v2 = Version(major:2,minor:0,patch:0) print(v1 < v2) // true ```

Dönüş Türü Olarak Self

```swift protocol Clonable { func clone() -> Self } class Animal: Clonable { var name: String = "" required init() {} func clone() -> Self { type(of: self).init() } } ``` Dönüş türündeki `Self`, alt sınıfların `Animal` yerine kendi türlerini döndürmesi anlamına gelir.

Self Gereksinimi Olan Protokol (PAT)

```swift protocol Scalable { func scaled(by factor: Double) -> Self } struct Size: Scalable { var w, h: Double func scaled(by f: Double) -> Size { Size(w: w*f, h: h*f) } } ```

Hashable: Self + Equatable

```swift struct Color: Hashable { var r, g, b: UInt8 // Auto-synthesised: func hash(into:) and == } var palette: Set = [] palette.insert(Color(r:255,g:0,b:0)) ``` `Hashable`, `Equatable` gerektirir; basit yapı türleri için her ikisi de otomatik olarak oluşturulur.

Self İçeren Protokoller Doğrudan Varoluşsal Türler Olarak Kullanılamaz

```swift // Before Swift 5.7: var shapes: [Equatable] = [] // ❌ Equatable has Self requirement // After Swift 5.7 with 'any': var boxes: [any Equatable] = [] // ⚠️ limited API ``` `any` anahtar sözcüğü, varoluşsal kutulamayı açıkça etkinleştirir.

Otomatik Oluşturma Ön Koşulları

`Equatable`/`Hashable`/`Comparable` için otomatik oluşturma şunları gerektirir: • Saklanan tüm özelliklerin aynı protokole uyumlu olması • İlişkili değerler içerenler de dahil olmak üzere enum durumlarının uyumlu olması ```swift struct Pair: Equatable { var a, b: T } // Equatable synthesised automatically ```

Özel Equatable Geçersiz Kılması

```swift struct Person: Equatable { var id: UUID var name: String // Only compare by id, ignore name: static func == (lhs: Person, rhs: Person) -> Bool { lhs.id == rhs.id } } ```

Hızlı Kontrol

Bir protokolde `Self` neyi ifade eder?

Özet

Temel çıkarımlar: • `Self` = uyum sağlayan somut tür • `Equatable`, `Comparable` ve `Hashable` türlerinin tümü `Self` kullanır • Swift, basit yapı ve enum türleri için bunları otomatik olarak oluşturur • Dönüş türlerindeki `Self`, türü koruyan API'ler sağlar • Self gereksinimleri olan protokoller, varoluşsal türler için `any` gerektirir (Swift 5.7 ve sonrası) Sıradaki konu: protokol odaklı tasarım ilkeleri.

Sıkça Sorulan Sorular

“Self Gereksinimleri ve Equatable Tasarımı” dersi ücretsiz mi?

Evet — “Self Gereksinimleri ve Equatable Tasarımı” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Swift Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Swift Academy kursu toplamda 4 dersten oluşur.

“Self Gereksinimleri ve Equatable Tasarımı” dersinde ne öğreneceğim?

Self kullanan protokolleri ve Equatable/Comparable'ın bunlardan nasıl yararlandığını öğrenin. Swift Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Swift Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Swift Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 3. dersidir.

“Self Gereksinimleri ve Equatable Tasarımı” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Swift Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Swift Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. & ile Protokol Birleştirme
  2. Koşullu Uygunluk
  3. Self Gereksinimleri ve Equatable Tasarımı
  4. Protokol Odaklı Tasarım İlkeleri
← Swift Academy Sayfasına Dön