Swift Academy · Pelajaran

Equatable yang Dihasilkan Otomatis

Dapatkan == secara otomatis dan sesuaikan jika diperlukan.

Equatable yang Dihasilkan Otomatis adalah pelajaran Swift Academy gratis di CoddyKit. Ini adalah pelajaran 1 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.

Apa Itu Kesetaraan?

Equatable adalah protokol yang menyediakan operator == untuk suatu tipe. Dengan menerapkannya, Anda dapat membandingkan kesamaan dua nilai dan menggunakannya bersama contains, firstIndex, dan lainnya.

Penerapan Otomatis

Untuk struktur yang semua properti tersimpannya mendukung kesetaraan, Swift membuat == secara otomatis untuk Anda — cukup nyatakan penerapan protokolnya:

struct Point: Equatable {
    let x: Int
    let y: Int
}
print(Point(x: 1, y: 2) == Point(x: 1, y: 2))  // true
print(Point(x: 1, y: 2) == Point(x: 9, y: 2))  // false

Cara Pembuatan Otomatis Bekerja

== yang dibuat secara otomatis membandingkan setiap pasangan properti tersimpan. Semua properti harus sama agar nilainya dianggap sama:

struct User: Equatable {
    let name: String
    let age: Int
}
let a = User(name: "Ann", age: 30)
let b = User(name: "Ann", age: 31)
print(a == b)  // false  (age differs)

Menggunakan == pada Koleksi

Kesetaraan membuka banyak operasi larik:

struct Tag: Equatable { let name: String }
let tags = [Tag(name: "a"), Tag(name: "b")]
print(tags.contains(Tag(name: "b")))        // true
print(tags.firstIndex(of: Tag(name: "a"))!) // 0

Enumerasi Juga Mendukung Kesetaraan

Enumerasi juga mendapatkan penerapan Equatable secara otomatis. Enumerasi tanpa nilai terkait mendukung kesetaraan meskipun Anda tidak menyatakannya; untuk enumerasi dengan nilai terkait, nyatakan penerapannya agar nilai-nilai tersebut juga dibandingkan.

Enumerasi dengan Nilai Terkait yang Mendukung Kesetaraan

Nilai terkait ikut dibandingkan:

enum Status: Equatable {
    case active
    case error(code: Int)
}
print(Status.error(code: 404) == Status.error(code: 404))  // true
print(Status.error(code: 404) == Status.error(code: 500))  // false

Tipe Bersarang

Pembuatan otomatis dapat tersusun: struktur yang berisi anggota yang mendukung kesetaraan juga dapat dibuatkan penerapannya secara otomatis:

struct Line: Equatable {
    let start: Int
    let end: Int
}
struct Shape: Equatable {
    let lines: [Line]
}
print(Shape(lines: [Line(start: 0, end: 1)]) == Shape(lines: [Line(start: 0, end: 1)]))  // true

Saat Pembuatan Otomatis Gagal

Jika ada properti tersimpan yang tidak mendukung kesetaraan, pembuatan otomatis tidak tersedia dan Anda harus menulis == sendiri (akan dibahas nanti):

struct Box: Equatable {
    let id: Int
    static func == (l: Box, r: Box) -> Bool { l.id == r.id }
}
print(Box(id: 1) == Box(id: 1))  // true

Kelas Tidak Dibuatkan Penerapan Otomatis

Tipe referensi tidak mendapatkan == secara otomatis; Anda harus menerapkannya sendiri (dengan membandingkan identitas atau bidang):

final class Account: Equatable {
    let id: Int
    init(id: Int) { self.id = id }
    static func == (l: Account, r: Account) -> Bool { l.id == r.id }
}
print(Account(id: 7) == Account(id: 7))  // true

!= Tersedia Otomatis

Setelah == tersedia, != otomatis dibuat sebagai negasinya:

struct Color: Equatable { let hex: String }
print(Color(hex: "#fff") != Color(hex: "#000"))  // true

Kesetaraan dalam Kode Generik

Kesetaraan memungkinkan fungsi generik membandingkan elemen — banyak algoritma memerlukannya:

func allSame<T: Equatable>(_ xs: [T]) -> Bool {
    guard let first = xs.first else { return true }
    return xs.allSatisfy { $0 == first }
}
print(allSame([2, 2, 2]))  // true
print(allSame(["a", "b"]))  // false

Pemeriksaan Singkat

Pada tipe mana Swift otomatis membuat == ketika Anda menyatakan dukungan terhadap protokol kesetaraan?

Ringkasan

Anda telah mempelajari kesetaraan:

Equatable menyediakan == (dan != secara otomatis)
Struktur dan enumerasi dengan anggota yang mendukung kesetaraan mendapatkan == secara otomatis
Memungkinkan penggunaan contains, firstIndex(of:), dan sebagainya
Kelas dan anggota yang tidak mendukung kesetaraan memerlukan == manual

Berikutnya: Hashable.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Equatable yang Dihasilkan Otomatis” gratis?

Ya — teks lengkap “Equatable yang Dihasilkan Otomatis” 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 “Equatable yang Dihasilkan Otomatis”?

Dapatkan == secara otomatis dan sesuaikan jika diperlukan. 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 1 dari 4.

Berapa lama pelajaran “Equatable yang Dihasilkan Otomatis” 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

← Kembali ke Swift Academy