Swift: apa itu, sintaksis dan konsep kunci bahasa

Apa itu Swift?

Swift — bahasa pemrograman multi-paradigma yang dikembangkan oleh Apple untuk iOS, macOS, watchOS, tvOS, dan visionOS. Tujuan utama bahasa: keamanan, kecepatan, dan ekspresivitas sintaksis. Swift menggunakan compiler LLVM dan menghasilkan kode mesin yang dioptimalkan, sebanding dalam performa dengan C++.

Sejak dirilis pada 2014, Swift telah melalui 6 versi utama. Swift 6 (2024) memperkenalkan model data-race safety lengkap melalui kontrol isolasi kode konkuren yang ketat. Menurut GitHub Octoverse 2025, Swift masuk dalam 10 besar bahasa dengan pertumbuhan komunitas, melampaui Rust dan Kotlin dalam kecepatan adopsi di platform Apple.

Swift terbuka dan lintas platform — kode sumber dipublikasikan di GitHub (Swift Open Source). Selain platform Apple, Swift digunakan di Linux dan Windows untuk pengembangan server (Vapor, Hummingbird), meskipun area aplikasi utama tetap pengembangan mobile dan desktop di ekosistem Apple.

Mengapa Swift menggantikan Objective-C

Alasan utama transisi: Swift menghilangkan seluruh kelas kesalahan yang mungkin terjadi di Objective-C. Type safety mencegah ketidakcocokan tipe pada tahap kompilasi. Optionals mengecualikan dereferensi nil. ARC sudah terintegrasi sejak hari pertama, tidak seperti MRC/ARC di Objective-C. Sintaksis Swift lebih pendek dan lebih mudah dibaca — penelitian menunjukkan pengurangan volume kode sebesar 30-40% dibandingkan Objective-C untuk tugas serupa.

Sintaksis dan konstruksi dasar

Sintaksis dasar Swift menggabungkan konstruksi mirip C yang familiar dengan elemen bahasa fungsional. Variabel dideklarasikan melalui var, konstanta melalui let. Compiler menggunakan type inference, jadi penentuan tipe secara eksplisit hanya diperlukan saat ambiguitas.

import Foundation

// Konstanta dan variabel
let name = "Swift"
var version = 6.0
var count: Int = 42

// Fungsi dengan parameter default
func greet(person: String, greeting: String = "Hello") -> String {
    return "\(greeting), \(person)!"
}

// Guard-let untuk keluar awal
func parse(input: String?) -> Int {
    guard let value = input, let number = Int(value) else {
        return 0
    }
    return number
}

Switch dan pattern matching di Swift lebih kuat daripada di C dan Kotlin. Switch mendukung pencocokan dengan tuple, rentang, kondisi where, dan binding nilai. Compiler memeriksa cakupan menyeluruh semua case — tidak adanya default bukan kesalahan jika semua nilai yang mungkin sudah tercakup.

let point = (x: 3, y: -1)

switch point {
case (0, 0):
    print("Titik asal")
case let (x, y) where x == y:
    print("X sama dengan Y")
case let (x, y) where abs(y) > x:
    print("Y lebih besar dari X modulo")
default:
    print("Titik (\(point.x), \(point.y))")
}

Optionals dan bekerja aman dengan nil

Optionals — konsep sentral Swift, yang memecahkan masalah referensi null pada level sistem tipe. Optional<Wrapped> adalah enum dengan dua case: .none (nil) dan .some(Wrapped). Compiler melarang penggunaan Optional tanpa pemeriksaan eksplisit, yang mengecualikan seluruh kelas kesalahan runtime.

var optionalString: String? = "Hello"
optionalString = nil  // diizinkan

// Optional Binding — ekstraksi aman
if let text = optionalString {
    print("Teks: \(text)")
} else {
    print("Nilai tidak ada")
}

// Optional Chaining — akses aman ke properti
let length = optionalString?.count ?? 0

// Operator Nil-coalescing
let greeting = optionalString ?? "Default"

Optional Chaining dengan operator ?. memungkinkan pemanggilan metode yang aman dan akses ke properti nilai opsional. Jika rantai terputus oleh nil, hasil seluruh ekspresi adalah nil. Nil-coalescing (??) menyediakan nilai default dan banyak digunakan dalam kode UI untuk menampilkan teks placeholder.

Protokol dan ekstensi

Protocols di Swift mendefinisikan kontrak — sekumpulan properti dan metode. Tidak seperti antarmuka Java, protokol Swift dapat memiliki implementasi default melalui protocol extensions. Ini adalah dasar dari Protocol-Oriented Programming, pendekatan yang direkomendasikan Apple sebagai pengganti pewarisan kelas.

protocol NamedEntity {
    var name: String { get }
    func description() -> String
}

// Implementasi default melalui extension
extension NamedEntity {
    func description() -> String {
        return "Entity: \(name)"
    }
}

// Konformitas melalui extension
extension String: NamedEntity {
    var name: String { return self }
}

Protocol Extensions memungkinkan penambahan metode ke protokol tanpa memodifikasi setiap tipe yang sesuai. Ini sangat berguna untuk menambahkan utilitas umum: map, filter, reduce untuk Sequence, atau Codable untuk serialisasi JSON. Apple membangun banyak framework (SwiftUI, Combine) di atas protokol dengan ekstensi.

Closures dan rantai fungsional

Closures di Swift — fungsi anonim yang menangkap variabel dari konteks eksternal. Secara sintaksis, closures mirip dengan lambda di Kotlin, tetapi dengan sintaksis yang lebih fleksibel: trailing closure, shorthand argument names ($0, $1), dan autoclosures.

// Closure dengan penangkapan konteks
let numbers = [5, 3, 8, 1, 9]

// Trailing closure syntax
let sorted = numbers.sorted { $0 < $1 }

// Rantai fungsional
let result = numbers
    .filter { $0 > 3 }
    .map { $0 * 2 }
    .reduce(0, +)

// Closure sebagai parameter fungsi
func performAsync(completion: @escaping (Result<Data, Error>) -> Void) { }

@escaping closures digunakan ketika closure dijalankan setelah kembali dari fungsi — biasanya untuk permintaan jaringan dan operasi asinkron. @autoclosure secara otomatis membungkus ekspresi dalam closure, yang digunakan dalam assert dan logika short-circuit.

Struct dan Class: perbandingan

Pilihan antara struct dan class — salah satu keputusan pertama saat merancang model Swift. Apple merekomendasikan menggunakan struct secara default (value-type) dan beralih ke class (reference-type) hanya jika diperlukan pewarisan atau identifikasi berdasarkan referensi.

Value-tipe (struct) lebih aman di lingkungan multi-thread — setiap thread mendapatkan salinan independen. Reference-tipe (class) diperlukan untuk bekerja dengan UIKit (UIView, UIViewController), di mana identitas referensi dan pewarisan dari kelas sistem diperlukan.

Manajemen memori ARC

ARC (Automatic Reference Counting) — sistem manajemen memori Swift untuk reference-tipe. Compiler menyisipkan retain/release saat runtime, melacak jumlah referensi kuat ke objek. Ketika penghitung mencapai nol, objek segera dibebaskan.

Masalah utama ARC — retain cycles (referensi siklik). Ketika dua objek memegang referensi kuat satu sama lain, memori tidak dibebaskan. Solusinya — referensi weak (secara otomatis menjadi nil saat dibebaskan) dan referensi unowned (menjamin objek hidup).

class ProfileViewController: UIViewController {
    var onLogout: (() -> Void)?
    
    func setupHandler() {
        // [weak self] mencegah retain cycle
        onLogout = { [weak self] in
            guard let self else { return }
            self.dismiss(animated: true)
        }
    }
}

Untuk mencegah retain cycles di closures, gunakan [weak self] dengan guard let self = self else { return }. Aturan ini sangat penting di UIKit, di mana ViewController memegang referensi kuat ke propertinya, dan closures di dalam properti ini merujuk ke ViewController.