@ObservedObject: apa itu, cara kerja dan contoh

Apa itu @ObservedObject di SwiftUI?

@ObservedObject adalah Property Wrapper yang melanggankan view ke perubahan ObservableObject. ObservableObject adalah protokol dari framework Combine yang memerlukan implementasi publisher objectWillChange. Ketika properti apa pun yang ditandai dengan @Published berubah di dalam ObservableObject, publisher mengirim sinyal, dan SwiftUI menggambar ulang semua view yang berlangganan melalui @ObservedObject.

Fitur utama @ObservedObject adalah tidak ada kepemilikan. View tidak bertanggung jawab untuk membuat atau menghancurkan objek. Objek dibuat di view parent (melalui @StateObject) atau disuntikkan melalui @EnvironmentObject. View anak hanya mengamati perubahan dan menerima pembaruan. Jika objek diganti di parent, @ObservedObject beralih ke instance baru.

@ObservedObject cocok untuk skenario berbagi data: model pengguna, pengaturan bersama, status koneksi ke server. Ketika beberapa view di berbagai tingkat hierarki harus menampilkan data yang sama, @ObservedObject di setiap view membuat langganan independen namun terkoordinasi ke satu sumber.

@ObservedObject vs @StateObject: perbedaan utama

Perbedaan antara @ObservedObject dan @StateObject adalah salah satu topik pertanyaan paling umum dalam wawancara SwiftUI. Aturan dasarnya: @StateObject membuat dan memiliki objek, @ObservedObject mengamati objek yang sudah ada. Pelanggaran aturan ini menyebabkan kehilangan data yang tidak terduga atau inisialisasi ganda.

@StateObject menjamin bahwa objek dibuat sekali dan bertahan dari inisialisasi ulang struktur view. @ObservedObject menerima objek dari luar dan dibuat ulang pada setiap inisialisasi struktur parent. Jika parent menggunakan @StateObject untuk objek, view anak dapat dengan aman menerapkan @ObservedObject — objek akan unik di seluruh hierarki.

Bagaimana @ObservedObject melacak perubahan

Mekanisme pelacakan @ObservedObject didasarkan pada Combine dan protokol ObservableObject. Saat inisialisasi, SwiftUI memanggil publisher objectWillChange — objek harus mengirim sinyal sebelum mengubah properti @Published. Combine meneruskan sinyal ke grafik dependensi SwiftUI, yang menandai semua view dependen sebagai memerlukan pembaruan. Ini terjadi secara sinkron sebelum perubahan nilai.

class WeatherService: ObservableObject {
    @Published var temperature: Double = 22.0
    @Published var city: String = "Moscow"
}

struct WeatherView: View {
    @ObservedObject var weather: WeatherService

    var body: some View {
        VStack {
            Text("\\(weather.city)")
            Text("\\(weather.temperature)°C")
        }
    }
}

Dalam listing, WeatherService adalah ObservableObject dengan dua properti @Published. WeatherView mendeklarasikan @ObservedObject var weather: WeatherService, menerima instance dari parent. Saat temperature berubah, objectWillChange terpicu sebelum nilai baru ditetapkan, SwiftUI menggambar ulang WeatherView, dan suhu saat ini ditampilkan. Langganan dikelola secara otomatis oleh SwiftUI — pengembang tidak perlu memanggil sink atau dispose.

Pola penggunaan @ObservedObject

Pola pertama — meneruskan model melalui inisialisator. Parent membuat ObservableObject melalui @StateObject dan meneruskannya ke view anak sebagai @ObservedObject. Ini adalah transmisi data hierarkis standar di mana root view mengelola siklus hidup model, dan semua komponen bersarang berlangganan perubahan.

Pola kedua — EnvironmentObject, versi global dari @ObservedObject melalui SwiftUI Environment. Objek disuntikkan di tingkat scene atau root view dan secara otomatis tersedia untuk semua komponen anak tanpa transmisi eksplisit melalui inisialisator. Di dalam view anak, @EnvironmentObject bekerja mirip dengan @ObservedObject, tetapi mengambil objek dari lingkungan.

Pola ketiga — komposisi beberapa ObservableObject. Dalam aplikasi kompleks, view dapat mengamati beberapa objek: @ObservedObject var user: UserService, @ObservedObject var network: NetworkMonitor. Ini memisahkan tanggung jawab antar layanan dan mempertahankan testabilitas setiap komponen.

struct DashboardView: View {
    @ObservedObject var user: UserViewModel
    @ObservedObject var network: NetworkMonitor

    var body: some View {
        VStack {
            Text("Selamat datang, \\(user.name)")
            HStack {
                Circle()
                    .fill(network.isConnected ? Color.green : Color.red)
                    .frame(width: 10, height: 10)
            }
        }
    }
}

DashboardView mengamati UserViewModel dan NetworkMonitor. Setiap objek bertanggung jawab atas domain datanya sendiri dan secara independen memberi tahu view tentang perubahan. Jika jaringan terputus, NetworkMonitor mengubah isConnected, dan SwiftUI menggambar ulang DashboardView, memperbarui warna indikator. Komposisi ObservableObject adalah cara yang lebih disukai untuk mengatur data di aplikasi SwiftUI.

@Published: hubungan ObservableObject dan SwiftUI

@Published adalah Property Wrapper dari Combine yang secara otomatis menambahkan penerbit ke properti di dalam ObservableObject. Ketika properti @Published berubah, Combine menghasilkan peristiwa melalui publisher objectWillChange. SwiftUI berlangganan publisher ini saat menggunakan @ObservedObject atau @StateObject dan menggambar ulang view pada setiap nilai baru.

@Published mendukung semua tipe, termasuk opsional, koleksi, dan struktur kustom. Namun, untuk koleksi (array, kamus) SwiftUI hanya melacak penggantian referensi, bukan perubahan konten. Untuk mendeteksi penambahan atau penghapusan elemen, Anda perlu menetapkan ulang seluruh koleksi atau menggunakan ObservableObject dengan objectWillChange.send() manual.

Detail penting: @Published harus berada hanya di dalam kelas yang mengimplementasikan ObservableObject. Penggunaan @Published di luar ObservableObject akan menyebabkan kesalahan kompilasi. Juga, @Published tidak dapat diterapkan ke properti inisialisasi malas (lazy var) atau properti terhitung (computed property).

Kesalahan umum dengan @ObservedObject

Kesalahan paling kritis — menggunakan @ObservedObject untuk membuat objek. Jika Anda menulis @ObservedObject var model = UserViewModel() di view parent, instance UserViewModel baru akan dibuat setiap kali render. Data akan hilang, dan langganan @Published akan dibuat ulang. Selalu gunakan @StateObject untuk membuat dan @ObservedObject hanya untuk menerima objek yang sudah jadi.

Kesalahan kedua — mengubah properti @Published di luar thread utama. ObservableObject menggunakan Combine, yang memerlukan pengiriman perubahan di thread utama (main actor). Jika Anda mengubah @Published di antrian latar belakang, SwiftUI dapat menggambar ulang view pada saat yang tidak tepat, menyebabkan race conditions. Gunakan DispatchQueue.main.async atau @MainActor untuk pembaruan.

Masalah ketiga — pembaruan siklik. Jika perubahan @Published menyertakan efek samping yang kembali mengubah @Published, terjadilah loop penggambaran ulang tak terbatas. Solusi: gunakan flag pelindung (isUpdating) atau pisahkan logika ke berbagai ObservableObject dengan batas tanggung jawab yang jelas.