struct — apa itu, konsep kunci dan sintaksis di Swift

Apa itu struct di Swift?

Struct (struktur) — adalah tipe data gabungan di Swift yang mengelompokkan properti dan metode terkait ke dalam satu entitas. Berbeda dengan kelas, struktur adalah value types: saat diteruskan ke fungsi atau ditugaskan ke variabel baru, salinan independen dari struktur dibuat, bukan referensi ke objek asli.

Swift menggunakan struktur untuk semua tipe primitif: Int, Double, String, Bool, Array, Dictionary dan Set. Ini berarti bahkan angka dasar Int berperilaku seperti struktur — saat penugasan, salinan dibuat. Pengembang dapat mendefinisikan struktur sendiri dengan kumpulan properti dan metode yang diinginkan.

Menurut Swift Evolution (SE-0143), keputusan untuk mengimplementasikan tipe standar sebagai struktur didorong oleh kinerja dan prediktabilitas. Value types tidak membuat siklus referensi, tidak memerlukan penghitungan referensi ARC dan menjamin bahwa perubahan salinan tidak akan memengaruhi aslinya — ini sangat penting untuk imutabilitas data dalam skenario multi-thread.

Struct sebagai value type

Value type semantics — perbedaan utama antara struct dan class. Saat Anda menugaskan struktur ke variabel baru atau meneruskannya ke fungsi, Swift membuat salinan independen dari semua data. Setiap perubahan pada salinan tidak memengaruhi aslinya, menghilangkan efek samping yang khas dari tipe referensi.

// Contoh semantik value type
struct Point {
    var x: Double
    var y: Double
}

var p1 = Point(x: 10, y: 20)
var p2 = p1        // p2 adalah salinan independen dari p1
p2.x = 99            // Hanya p2 yang berubah
print(p1.x)         // 10 — p1 tidak berubah
print(p2.x)         // 99

Optimasi Copy-on-Write

Swift menggunakan Copy-on-Write (COW) untuk mengoptimalkan penyalinan. Jika beberapa variabel merujuk ke struktur yang sama, tetapi tidak ada yang mengubah data, penyalinan sebenarnya tidak terjadi. Swift berbagi memori antar variabel hingga mutasi pertama — saat itulah salinan nyata dibuat. Ini mencegah operasi alokasi yang berlebihan dan mempercepat kerja dengan koleksi.

Mutabilitas dan metode mutating

Secara default, metode struktur tidak dapat mengubah propertinya — Swift memerlukan indikasi eksplisit mutating untuk metode yang melakukan perubahan. Pembatasan ini melindungi dari mutasi yang tidak disengaja dan membuat kode dapat diprediksi: jika metode tidak ditandai mutating, Anda dijamin tidak akan mengubah struktur.

Mutating dalam aksi

Saat Anda menambahkan kata kunci mutating sebelum metode, Swift mendapatkan kemampuan untuk menulis nilai baru ke dalam properti struktur. Sebenarnya, metode bahkan dapat sepenuhnya mengganti instance struktur dengan yang baru melalui self = . Mekanisme ini digunakan, misalnya, dalam tipe Option dan Result.

// Struct dengan metode mutating
struct Counter {
    private var value: Int = 0

    // Metode mutating — dapat mengubah properti
    mutating func increment() {
        value += 1
    }

    // Metode mutating dapat mengganti self sepenuhnya
    mutating func reset() {
        self = Counter()
    }

    // Metode non-mutating — hanya baca
    func currentValue() -> Int {
        return value
    }
}

var counter = Counter()
counter.increment()
print(counter.currentValue())  // 1
counter.reset()
print(counter.currentValue())  // 0

Aturan untuk mutating: struktur harus dideklarasikan dengan var, bukan let — struktur konstanta tidak dapat memanggil metode mutating. Kompiler memeriksa ini pada tahap kompilasi: upaya memanggil metode mutating pada konstanta let akan menyebabkan kesalahan kompilasi.

Struct vs Class: perbandingan

Pilihan antara struct dan class — salah satu keputusan fundamental di Swift. Kedua tipe dapat berisi properti, metode, inisialisasi dan mengimplementasikan protokol, tetapi memiliki perbedaan prinsip dalam semantik memori, pewarisan dan manajemen siklus hidup.

Struktur lebih disukai ketika data tidak memerlukan pewarisan, tidak boleh memiliki identitas bersama (misalnya, koordinat, dimensi, konfigurasi) dan diteruskan antar modul. Kelas dipilih untuk komponen UI (UIView, UIViewController), singleton dan objek dengan identitas bersama.

Kapan memilih struct

Apple merekomendasikan penggunaan struct sebagai tipe default untuk pemodelan data di Swift. Struktur cocok untuk sebagian besar skenario berkat semantik penyalinan yang dapat diprediksi dan tidak adanya overhead untuk penghitungan referensi. Mari kita lihat kasus umum ketika struct adalah pilihan optimal.

Model data tanpa pewarisan

Jika entitas berisi data tanpa kebutuhan pewarisan (Product, User, Order, Point), gunakan struct. Kompiler secara otomatis menghasilkan memberwise initializer — Anda tidak perlu menulis init secara manual. Equatable dan Hashable juga diimplementasikan secara otomatis untuk struktur yang semua propertinya memenuhi protokol ini.

Data tidak berubah (immutable)

Untuk konfigurasi, pengaturan dan flag yang tidak berubah setelah pembuatan, struct lebih disukai daripada class. Struktur konstanta (let) menjamin imutabilitas semua bidang bersarang — pada class ini hanya berlaku untuk referensi, bukan untuk konten objek.

Kode multi-thread

Struktur aman di lingkungan multi-thread karena value semantics. Setiap thread menerima salinan data independen dan tidak memengaruhi thread lain. Race condition antar thread tidak mungkin terjadi untuk value types, menjadikan struct pilihan utama untuk model di SwiftUI (ObservableObject memerlukan class, tetapi @State menggunakan struct).

// Contoh penggunaan struct untuk model data
struct User: Codable, Identifiable {
    let id: UUID
    var name: String
    var email: String
    var isPremium: Bool

    // Properti computed — non-mutating
    var displayName: String {
        isPremium ? "\(name) ⭐️" : name
    }
}

// Inisialisasi memberwise otomatis
let user = User(
    id: UUID(),
    name: "Alice",
    email: "alice@example.com",
    isPremium: true
)

// Penyalinan aman untuk multi-threading
var userCopy = user
userCopy.isPremium = false
// user.isPremium tetap true

Gunakan class ketika Anda memerlukan pewarisan (komponen UIKit/AppKit), identitas bersama (delegate, observer) atau siklus hidup objek yang terkontrol (deinit). Untuk yang lainnya — struct.