Swift-specifiek in mobiele ontwikkeling: wat het is, belangrijkste functies en hoe het werkt

Struct vs Class in Swift: waardetypen en referentietypen

In Swift is struct een waardetype, terwijl class een referentietype is. Dit fundamentele verschil bepaalt het gedrag bij toewijzing, doorgeven aan functies en geheugenbeheer. Struct wordt bij elke toewijzing volledig gekopieerd, class wordt door verwijzing doorgegeven — alleen de verwijzing naar het heap-object wordt gekopieerd.

Waardesemantiek van Struct

Struct implementeert automatisch waardesemantiek — elk exemplaar is onafhankelijk. Mutatie van een struct-eigenschap is alleen mogelijk via var en methoden die eigenschappen wijzigen moeten als mutating worden gemarkeerd. Struct ondersteunt geen overerving, maar kan wel voldoen aan protocollen. De Swift-standaardbibliotheek gebruikt struct voor String, Array, Dictionary, Int, Bool — alle fundamentele typen zijn waardetypen.

struct User {
    let id: Int
    var name: String

    mutating func updateName(_ newName: String) {
        name = newName
    }
}

var user1 = User(id: 1, name: "Alice")
var user2 = user1
user2.updateName("Bob")
// user1.name === "Alice", user2.name === "Bob"
// Volledige kopie — onafhankelijke exemplaren

Referentiesemantiek van Class

Class wordt opgeslagen in de heap en ondersteunt referentiegelijkheid. Meerdere variabelen kunnen naar hetzelfde object verwijzen, wijzigingen via één verwijzing zijn zichtbaar via alle andere. Class ondersteunt overerving, staat methodeoverschrijving (override) toe, heeft deinit voor het opruimen van bronnen. In Swift wordt class minder vaak gebruikt dan struct — Apple raadt aan te beginnen met struct en alleen over te stappen op class wanneer overerving of referentiesemantiek nodig is.

class Car {
    let model: String
    var speed: Int

    init(model: String, speed: Int) {
        self.model = model
        self.speed = speed
    }

    func accelerate(_ amount: Int) {
        speed += amount
    }
}

let car1 = Car(model: "Tesla", speed: 0)
let car2 = car1
car2.accelerate(50)
// car1.speed === 50, car2.speed === 50
// Dezelfde verwijzing — wijzigingen overal zichtbaar

De keuze tussen struct en class hangt af van de gegevenssemantiek. Gebruik struct voor configuraties, gegevensmodellen en toestanden — kopiëren is veiliger en voorspelbaarder. Gebruik class voor objecten met identiteit (gebruikerssessie, databaseverbinding) en wanneer overerving nodig is.

Actor — threadveiligheid in Swift

Actor is een referentietype dat zijn veranderlijke toestand beschermt tegen gelijktijdige toegang. De Swift-compiler garandeert dat actorvariabelen alleen toegankelijk zijn vanuit dezelfde actorcontext — elke externe toegang veroorzaakt een compilatiefout. Dit voorkomt dataraces op taalniveau, zonder handmatige vergrendelingen.

Actorisolatie

Alle actoreigenschappen en -methoden zijn standaard geïsoleerd. Het aanroepen van een actormethode van buitenaf vereist await — Swift schakelt de uitvoering naar de actor en terug. De actor synchroniseert toegang sequentieel: verzoeken van verschillende taken worden in een wachtrij geplaatst. Dit garandeert een consistente toestand binnen de actor. Niet-geïsoleerde methoden (nonisolated) kunnen zonder await worden aangeroepen, maar hebben geen toegang tot veranderlijke eigenschappen.

actor BankAccount {
    private var balance: Double

    init(initialBalance: Double) {
        balance = initialBalance
    }

    func deposit(amount: Double) {
        balance += amount
    }

    func withdraw(amount: Double) throws {
        guard balance >= amount else {
            throw BankError.insufficientFunds
        }
        balance -= amount
    }

    nonisolated func accountInfo() -> String {
        return "Bankrekening"
    }
}

let account = BankAccount(initialBalance: 1000)
await account.deposit(amount: 500)
// balance = 1500 — atomair, zonder raceconditie

Actor is nuttig voor toestandsbeheerders, caches en netwerkdiensten waar meerdere taken gelijktijdig gegevens lezen en schrijven. In tegenstelling tot handmatige synchronisatie via NSLock of DispatchQueue, wordt actor gecontroleerd tijdens het compileren — een fout maken is onmogelijk. Isolatiefouten verschijnen tijdens het compileren, niet tijdens runtime.

Property Wrappers: @Published, @State, @Binding

Property Wrapper is een annotatie die gedrag toevoegt aan een eigenschap zonder de declaratie ervan te wijzigen. SwiftUI en Combine bieden ingebouwde wrappers voor het beheren van de weergavestatus. De compiler genereert code die de toegang tot de eigenschap omhult en observatie-, synchronisatie- of transformatielogica toevoegt.

@Published en @State

@Published wordt gebruikt in klassen die voldoen aan ObservableObject om wijzigingen automatisch te publiceren. Combine-abonnees ontvangen meldingen bij elke update. @State is de lokale status van een SwiftUI-weergave. SwiftUI tekent de weergave automatisch opnieuw wanneer @State verandert. @Binding creëert een bidirectionele verbinding tussen een bovenliggende en onderliggende weergave zonder de gegevens te bezitten.

import SwiftUI
import Combine

@main
struct CounterApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

class CounterViewModel: ObservableObject {
    @Published var count: Int = 0

    func increment() {
        count += 1
    }
}

struct ContentView: View {
    @State private var greeting: String = "Hallo"
    @StateObject private var viewModel = CounterViewModel()

    var body: some View {
        VStack {
            CounterDisplay(count: $viewModel.count)
            Text(greeting)
            Button("Verhoog", action: viewModel.increment)
        }
    }
}

struct CounterDisplay: View {
    @Binding var count: Int

    var body: some View {
        Text("Telling: \(count)")
    }
}

Aangepaste Property Wrappers worden gemaakt met @propertyWrapper en een structuur met een wrappedValue-veld. Dit maakt hergebruik van logica mogelijk: validatie, normalisatie, UserDefaults-opslag. Property Wrappers verminderen boilerplate-code aanzienlijk en maken de bedoeling van de ontwikkelaar expliciet via annotatie.

@propertyWrapper
struct Clamped<T: Comparable> {
    private var value: T
    let range: ClosedRange<T>

    init(wrappedValue: T, range: ClosedRange<T>) {
        self.range = range
        self.value = min(max(wrappedValue, range.lowerBound), range.upperBound)
    }

    var wrappedValue: T {
        get { value }
        set { value = min(max(newValue, range.lowerBound), range.upperBound) }
    }
}

struct Settings {
    @Clamped(range: 0...100) var volume: Int = 50
}

var s = Settings()
s.volume = 150
// s.volume === 100 — waarde automatisch beperkt

Generics en Protocolgericht Programmeren

Generics is een krachtig mechanisme van Swift voor het schrijven van flexibele code zonder verlies van typeveiligheid. Generieke functies en typen werken met elk type dat aan de beperkingen voldoet. Protocolgericht Programmeren (POP) is een Swift-paradigma waarbij protocol + extension de klassieke klasseovererving vervangen en gedragscompositie bieden.

Generieke Beperkingen en Geassocieerde Typen

Swift staat toe generieke parameters te beperken met protocollen (where-clausules). Protocol met geassocieerd type is het generieke equivalent voor protocollen: het concrete type wordt bepaald op het moment van conformiteit. Dit is de basis voor typeveilige verzamelingen en algoritmen. De Swift-standaardbibliotheek gebruikt actief generics: Array, Dictionary, Optional — allemaal generieke typen.

protocol Cacheable {
    associatedtype Key: Hashable
    associatedtype Value

    func get(_ key: Key) -> Value?
    mutating func set(_ value: Value, for key: Key)
}

struct MemoryCache<K: Hashable, V>: Cacheable {
    private var storage: [K: V] = [:]

    typealias Key = K
    typealias Value = V

    func get(_ key: K) -> V? {
        return storage[key]
    }

    mutating func set(_ value: V, for key: K) {
        storage[key] = value
    }
}

func firstMatch<T: Equatable>(in array: [T], target: T) -> Int? {
    for (index, item) in array.enumerated() {
        if item == target {
            return index
        }
    }
    return nil
}

let numbers = [10, 20, 30, 40]
let index = firstMatch(in: numbers, target: 30)
// index === 2 — één generieke methode voor alle Equatable-typen

Protocolextensie en Standaardimplementaties

Protocolextensie is een belangrijk mechanisme van POP. In een extensie kunnen standaardimplementaties van protocollen worden geleverd. Typen die aan het protocol voldoen, krijgen deze implementatie gratis en kunnen deze indien nodig overschrijven. Dit maakt het mogelijk gedragshiërarchieën op te bouwen zonder klasseovererving — een alternatief voor meervoudige overerving, die niet bestaat in Swift.

protocol Drivable {
    var speed: Double { get set }
    func drive()
}

extension Drivable {
    func drive() {
        if speed > 0 {
            print("Rijden met \(speed) km/u")
        }
    }
}

struct Bicycle: Drivable {
    var speed: Double = 15
}

struct Plane: Drivable {
    var speed: Double = 900

    func drive() {
        print("Vliegen met \(speed) km/u")
    }
}

let bike = Bicycle()
bike.drive() // "Rijden met 15.0 km/u" — standaard

let plane = Plane()
plane.drive() // "Vliegen met 900.0 km/u" — overschreven

POP met extensie maakt compositie via meerdere protocollen mogelijk — een type kan aan meerdere protocollen voldoen en hun implementaties krijgen. Dit is flexibeler dan enkele klasseovererving waar de hele hiërarchie vastligt. De Swift-standaardbibliotheek is gebouwd op POP: CustomStringConvertible, Equatable, Hashable, Codable — allemaal protocollen met extensies.

Enum met geassocieerde waarden en Extension

Enum is in Swift een aanzienlijk krachtigere constructie dan in andere talen. Elk geval kan geassocieerde waarden hebben — een willekeurige set gegevens van elk type. In combinatie met extensie en patroonherkenning wordt enum de basis voor het modelleren van toestanden, bewerkingsresultaten en eindige toestandsmachines.

Geassocieerde Waarden en Patroonherkenning

Geassocieerde waarden stellen elk geval in staat unieke gegevens op te slaan. Het geval loading bevat bijvoorbeeld geen gegevens, success bevat het resultaat, failure bevat een fout. Patroonherkenning via switch haalt de geassocieerde waarden op en verwerkt elk geval. De compiler controleert op volledigheid (exhaustive switch) — dit elimineert vergeten toestanden.

enum NetworkResult<T> {
    case loading
    case success(T)
    case failure(Error)
}

enum MediaFile {
    case image(url: URL, width: Int, height: Int)
    case video(url: URL, duration: Double)
    case audio(url: URL, bitrate: Int)
}

func handle(_ result: NetworkResult<String>) {
    switch result {
    case .loading:
        print("Laden...")
    case .success(let data):
        print("Ontvangen: \(data)")
    case .failure(let error):
        print("Fout: \(error.localizedDescription)")
    }
}

let file = MediaFile.video(url: URL(string: "https://example.com/video.mp4")!, duration: 120)

if case .video(let url, let duration) = file {
    print("Video \(url) duur \(duration)s")
}

Extensie voor Enum

Swift staat toe methoden, berekende eigenschappen en protocolconformiteit toe te voegen via extensie voor enum. Dit vereist geen wijziging van de oorspronkelijke declaratie — de code blijft schoon en modulair. Methoden in een extensie kunnen werken met geassocieerde waarden, afgeleide gegevens berekenen en bedrijfslogica implementeren.

extension MediaFile {
    var fileName: String {
        switch self {
        case .image(let url, _, _),
             .video(let url, _),
             .audio(let url, _):
            return url.lastPathComponent
        }
    }

    var description: String {
        switch self {
        case .image(_, let w, let h):
            return "Afbeelding \(w)x\(h)"
        case .video(_, let d):
            return "Video \(d)s"
        case .audio(_, let b):
            return "Audio \(b) kbps"
        }
    }
}

extension MediaFile: Equatable {
    static func == (lhs: MediaFile, rhs: MediaFile) -> Bool {
        return lhs.fileName == rhs.fileName
    }
}

let files: [MediaFile] = [file]
files.forEach { print($0.description) }
// "Video 120.0s"

Enum met geassocieerde waarden + extensie is de vervanging voor verzegelde klassen uit Kotlin of gediscrimineerde vakbonden uit andere talen. Swift gebruikt deze combinatie voor Result (een standaardtype in de standaardbibliotheek), Optional (Optional is een enum met .none en .some) en statusafhandeling in SwiftUI. Patroonherkenning garandeert dat alle toestanden worden afgehandeld — runtimefouten zijn onmogelijk.