Swift-specifikumok a mobilfejlesztésben: mi ez, kulcsfontosságú funkciók és hogyan működik

Struct vs Class a Swift-ben: értéktípusok és referenciatípusok

A Swift-ben a struct egy értéktípus, míg a class egy referenciatípus. Ez az alapvető különbség határozza meg a viselkedést hozzárendelés, függvényeknek való átadás és memóriakezelés során. A struct minden hozzárendeléskor teljes egészében másolódik, a class referencia szerint adódik át — csak a mutató a heap-objektumra másolódik.

A Struct értékszemantikája

A struct automatikusan megvalósítja az értékszemantikát — minden példány független. A struct tulajdonságának megváltoztatása csak var-on keresztül lehetséges, és a tulajdonságokat módosító metódusokat muting-ként kell megjelölni. A struct nem támogatja az öröklődést, de megfelelhet protokolloknak. A Swift szabványos könyvtára struct-ot használ a String, Array, Dictionary, Int, Bool típusokhoz — minden alapvető típus értéktípus.

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"
// Teljes másolat — független példányok

A Class referenciaszemantikája

A class a heap-ben tárolódik és támogatja a referencia-egyenlőséget. Több változó is hivatkozhat ugyanarra az objektumra, az egyik referencián keresztüli változtatások az összes többin keresztül láthatóak. A class támogatja az öröklődést, lehetővé teszi a metódusok felülírását (override), rendelkezik deinit-tel az erőforrások tisztításához. A Swift-ben a class ritkábban használatos, mint a struct — az Apple azt ajánlja, hogy struct-tal kezdjünk, és csak akkor váltsunk class-ra, ha öröklődésre vagy referenciaszemantikára van szükség.

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
// Ugyanaz a referencia — a változtatások mindenhol láthatóak

A struct és class közötti választás az adatszemantikától függ. Konfigurációkhoz, adatmodellekhez és állapotokhoz használjon struct-ot — a másolás biztonságosabb és kiszámíthatóbb. Azonosítóval rendelkező objektumokhoz (felhasználói munkamenet, adatbázis-kapcsolat) és ha öröklődésre van szükség, használjon class-t.

Actor — szálbiztonság a Swift-ben

Actor egy referenciatípus, amely megvédi változtatható állapotát a párhuzamos hozzáféréstől. A Swift fordítóprogram garantálja, hogy az actor változói csak ugyanabból az actor kontextusból érhetők el — bármilyen külső hozzáférés fordítási hibát okoz. Ez megakadályozza az adatversenyeket nyelvi szinten, kézi zárolások nélkül.

Actor-elkülönítés

Minden actor tulajdonság és metódus alapértelmezetten elkülönített. Egy actor metódusának kívülről történő meghívásához await szükséges — a Swift átkapcsolja a végrehajtást az actor-ba és vissza. Az actor szekvenciálisan szinkronizálja a hozzáférést: a különböző feladatoktól érkező kérések sorba kerülnek. Ez konzisztens állapotot garantál az actor-on belül. A nem elkülönített metódusok (nonisolated) await nélkül is meghívhatók, de nem férhetnek hozzá a változtatható tulajdonságokhoz.

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 "Bankszámla"
    }
}

let account = BankAccount(initialBalance: 1000)
await account.deposit(amount: 500)
// balance = 1500 — atomi, versenyfeltétel nélkül

Az actor hasznos állapotkezelők, gyorsítótárak és hálózati szolgáltatások számára, ahol több feladat párhuzamosan olvas és ír adatokat. A kézi szinkronizációval (NSLock vagy DispatchQueue) ellentétben az actor fordításkor ellenőrzött — lehetetlen hibázni. Az elkülönítési hibák fordításkor jelennek meg, nem futásidőben.

Property Wrappers: @Published, @State, @Binding

Property Wrapper egy annotáció, amely viselkedést ad egy tulajdonsághoz anélkül, hogy megváltoztatná a deklarációját. A SwiftUI és a Combine beépített wrapper-eket biztosít a nézetek állapotának kezeléséhez. A fordítóprogram olyan kódot generál, amely becsomagolja a tulajdonságelérést, megfigyelési, szinkronizációs vagy átalakítási logikát hozzáadva.

@Published és @State

@Published az ObservableObject-nek megfelelő osztályokban használatos a változtatások automatikus közzétételéhez. A Combine feliratkozók értesítéseket kapnak minden frissítéskor. @State egy SwiftUI nézet helyi állapota. A SwiftUI automatikusan újrarajzolja a nézetet, amikor a @State megváltozik. @Binding kétirányú kapcsolatot hoz létre egy szülő és gyermek nézet között anélkül, hogy birtokolná az adatokat.

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 = "Szia"
    @StateObject private var viewModel = CounterViewModel()

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

struct CounterDisplay: View {
    @Binding var count: Int

    var body: some View {
        Text("Számláló: \(count)")
    }
}

Az egyedi Property Wrapperek a @propertyWrapper és egy wrappedValue mezővel rendelkező struktúra segítségével hozhatók létre. Ez lehetővé teszi a logika újrafelhasználását: érvényesítés, normalizálás, UserDefaults-tárolás. A Property Wrapperek jelentősen csökkentik a boilerplate kódot, és az annotáción keresztül explicité teszik a fejlesztő szándékát.

@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 — az érték automatikusan korlátozva

Generics és Protokollorientált Programozás

Generics a Swift erőteljes mechanizmusa rugalmas kód írásához a típusbiztonság elvesztése nélkül. A generikus függvények és típusok bármilyen típussal működnek, amely megfelel a megszorításoknak. A Protokollorientált Programozás (POP) egy Swift paradigma, ahol a protocol + extension felváltja a klasszikus osztályöröklődést, viselkedéskompozíciót biztosítva.

Generikus Megszorítások és Kapcsolódó Típusok

A Swift lehetővé teszi a generikus paraméterek protokollokkal való korlátozását (where záradékok). Protokoll kapcsolódó típussal a protokollok generikus megfelelője: a konkrét típus a megfelelés pillanatában kerül meghatározásra. Ez a típusbiztos gyűjtemények és algoritmusok alapja. A Swift szabványos könyvtára aktívan használja a Generics-t: Array, Dictionary, Optional — mind generikus típusok.

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 — egy generikus metódus minden Equatable típushoz

Protokoll Extension és Alapértelmezett Implementációk

A protokoll extension a POP kulcsmechanizmusa. Egy extension-ben alapértelmezett implementáció adható a protokoll metódusaihoz. A protokollnak megfelelő típusok ezt az implementációt ingyen megkapják, és szükség esetén felülírhatják. Ez lehetővé teszi viselkedési hierarchiák építését osztályöröklődés nélkül — alternatíva a többszörös öröklődéshez, amely nem létezik a Swift-ben.

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

extension Drivable {
    func drive() {
        if speed > 0 {
            print("Vezetés \(speed) km/h sebességgel")
        }
    }
}

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

struct Plane: Drivable {
    var speed: Double = 900

    func drive() {
        print("Repülés \(speed) km/h sebességgel")
    }
}

let bike = Bicycle()
bike.drive() // "Vezetés 15.0 km/h sebességgel" — alapértelmezett

let plane = Plane()
plane.drive() // "Repülés 900.0 km/h sebességgel" — felülírva

A POP extension-nel lehetővé teszi a kompozíciót több protokollon keresztül — egy típus több protokollnak is megfelelhet, megszerezve azok implementációit. Ez rugalmasabb, mint az egyetlen osztályöröklődés, ahol a teljes hierarchia rögzített. A Swift szabványos könyvtára POP-ra épül: CustomStringConvertible, Equatable, Hashable, Codable — mind protokollok extension-nel.

Enum kapcsolódó értékekkel és Extension

Enum a Swift-ben jelentősen erősebb konstrukció, mint más nyelvekben. Minden eset rendelkezhet kapcsolódó értékekkel — tetszőleges adatkészlettel bármilyen típusból. Az extension-nel és mintailesztéssel kombinálva az enum az állapotok, műveleti eredmények és véges állapotú gépek modellezésének alapjává válik.

Kapcsolódó Értékek és Mintailesztés

A kapcsolódó értékek lehetővé teszik, hogy minden eset egyedi adatokat tároljon. Például a loading eset nem tartalmaz adatokat, a success tartalmazza az eredményt, a failure tartalmaz egy hibát. A switch-en keresztüli mintailesztés kinyeri a kapcsolódó értékeket és feldolgozza az egyes eseteket. A fordítóprogram ellenőrzi a teljességet (exhaustive switch) — ez kiküszöböli az elfelejtett állapotokat.

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("Betöltés...")
    case .success(let data):
        print("Fogadva: \(data)")
    case .failure(let error):
        print("Hiba: \(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("Videó \(url) időtartam \(duration)s")
}

Extension Enum-hoz

A Swift lehetővé teszi metódusok, számított tulajdonságok és protokollmegfelelés hozzáadását extension-en keresztül enum-hoz. Ehhez nem szükséges az eredeti deklaráció megváltoztatása — a kód tiszta és moduláris marad. Az extension-ben lévő metódusok dolgozhatnak kapcsolódó értékekkel, számíthatnak származtatott adatokat és valósíthatnak meg üzleti logikát.

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 "Kép \(w)x\(h)"
        case .video(_, let d):
            return "Videó \(d)s"
        case .audio(_, let b):
            return "Hang \(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) }
// "Videó 120.0s"

A kapcsolódó értékekkel + extension-nel rendelkező enum a Kotlin-beli sealed osztályok vagy más nyelvek diszkriminált unióinak helyettesítője. A Swift ezt a kombinációt használja a Result (egy szabványos típus a szabványos könyvtárban), az Optional (az Optional egy enum .none és .some értékekkel) és az állapotkezelés a SwiftUI-ben. A mintailesztés garantálja, hogy minden állapot kezelve van — futásidejű hibák lehetetlenek.