0Pricing
Swift Academy · Pelajaran

Persyaratan Self dan Rancangan Equatable

Protokol yang menggunakan Self serta cara Equatable/Comparable memanfaatkannya.

Persyaratan Self dan Rancangan Equatable adalah pelajaran Swift Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Swift Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Swift Academy mencakup 4 pelajaran total.

Selamat Datang

`Self` dalam protokol merujuk pada tipe konkret yang mengikutinya. Ini memungkinkan protokol seperti `Equatable` dan `Comparable` bekerja dengan tipe heterogen secara aman.

Self sebagai Tipe Parameter

```swift protocol Equatable { static func == (lhs: Self, rhs: Self) -> Bool } ``` `Self` berarti kedua parameter harus bertipe konkret yang *sama*. Anda tidak dapat membandingkan `Int` dengan `String` melalui protokol ini.

Menyesuaikan dengan Equatable

```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 ```

Comparable dengan Self

```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 ```

Self sebagai Tipe Kembalian

```swift protocol Clonable { func clone() -> Self } class Animal: Clonable { var name: String = "" required init() {} func clone() -> Self { type(of: self).init() } } ``` `Self` dalam tipe kembalian berarti subkelas mengembalikan tipenya sendiri, bukan `Animal`.

Protokol dengan Persyaratan Self (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` memerlukan `Equatable` — keduanya disintesis secara otomatis untuk struct sederhana.

Protokol dengan Self Tidak Dapat Digunakan Langsung sebagai Eksistensial

```swift // Before Swift 5.7: var shapes: [Equatable] = [] // ❌ Equatable has Self requirement // After Swift 5.7 with 'any': var boxes: [any Equatable] = [] // ⚠️ limited API ``` Kata kunci `any` secara eksplisit memilih penggunaan pembungkusan eksistensial.

Prasyarat Sintesis

Sintesis otomatis `Equatable`/`Hashable`/`Comparable` memerlukan: • Semua properti tersimpan memenuhi protokol yang sama • Kasus enum, termasuk nilai terkait, memenuhi protokol ```swift struct Pair: Equatable { var a, b: T } // Equatable synthesised automatically ```

Penimpaan Equatable Kustom

```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 } } ```

Pemeriksaan Singkat

Dalam protokol, apa yang dimaksud dengan `Self`?

Rangkuman

Hal-hal penting: • `Self` = tipe konkret yang memenuhi protokol • `Equatable`, `Comparable`, `Hashable` semuanya menggunakan `Self` • Swift menyintesisnya secara otomatis untuk struct dan enum sederhana • `Self` dalam tipe kembalian menghasilkan API yang mempertahankan tipe • Protokol dengan persyaratan Self memerlukan `any` untuk eksistensial (Swift 5.7+) Berikutnya: prinsip desain berorientasi protokol.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Persyaratan Self dan Rancangan Equatable” gratis?

Ya — teks lengkap “Persyaratan Self dan Rancangan Equatable” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Swift Academy, upgrade ke CoddyKit PRO. Kursus Swift Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Persyaratan Self dan Rancangan Equatable”?

Protokol yang menggunakan Self serta cara Equatable/Comparable memanfaatkannya. Kamu berlatih Swift Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Swift Academy?

Tidak diperlukan pengalaman sebelumnya. Swift Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Persyaratan Self dan Rancangan Equatable” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Swift Academy ini?

Ya. Setiap pelajaran Swift Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Komposisi Protokol dengan &
  2. Kesesuaian Bersyarat
  3. Persyaratan Self dan Rancangan Equatable
  4. Prinsip Rancangan Berorientasi Protokol
← Kembali ke Swift Academy