Swift: mi ez, szintaxis és a nyelv kulcsfogalmai

Mi az a Swift?

Swift — egy többparadigmás programozási nyelv, amelyet az Apple fejlesztett iOS, macOS, watchOS, tvOS és visionOS rendszerekhez. A nyelv fő céljai: biztonság, sebesség és a szintaxis kifejezőereje. A Swift az LLVM fordítót használja és optimalizált gépi kódot generál, amely teljesítményben összehasonlítható a C++-szal.

A 2014-es megjelenés óta a Swift 6 főverzión ment keresztül. A Swift 6 (2024) bevezette a teljes data-race safety modellt a párhuzamos kód szigetelésének szigorú ellenőrzésével. A GitHub Octoverse 2025 szerint a Swift a top-10 nyelv közé tartozik a közösség növekedése alapján, megelőzve a Rustot és a Kotlint az Apple-platformokon való elfogadás sebességében.

A Swift nyílt és többplatformos — a forráskód a GitHubon (Swift Open Source) jelent meg. Az Apple-platformok mellett a Swiftet Linuxon és Windows-on is használják szerverfejlesztésre (Vapor, Hummingbird), bár a fő alkalmazási terület továbbra is a mobil és asztali fejlesztés az Apple ökoszisztémában.

Miért váltotta fel a Swift az Objective-C-t

Az átállás fő okai: a Swift kiküszöböli az Objective-C-ben lehetséges hibák egész osztályait. A Type safety megakadályozza a típus-eltéréseket a fordítási fázisban. Az Optionals kizárja a nil-dereferenciákat. Az ARC az első naptól beépítésre került, ellentétben az Objective-C MRC/ARC rendszerével. A Swift szintaxisa rövidebb és olvashatóbb — a kutatások 30-40%-os kódmennyiség-csökkenést mutatnak az Objective-C-hez képest hasonló feladatok megoldásánál.

Szintaxis és alapvető szerkezetek

A Swift alapszintaxisa az ismert C-szerű szerkezeteket funkcionális nyelvek elemeivel ötvözi. A változókat a var, a konstansokat a let kulcsszóval deklaráljuk. A fordító type inference-t használ, így a típus explicit megadása csak kétértelműség esetén szükséges.

import Foundation

// Konstansok és változók
let name = "Swift"
var version = 6.0
var count: Int = 42

// Függvények alapértelmezett paraméterekkel
func greet(person: String, greeting: String = "Hello") -> String {
    return "\(greeting), \(person)!"
}

// Guard-let korai kilépéshez
func parse(input: String?) -> Int {
    guard let value = input, let number = Int(value) else {
        return 0
    }
    return number
}

Switch és pattern matching Swift-ben erősebb, mint C-ben vagy Kotlin-ban. A Switch támogatja az illesztést tuple-ökkel, tartományokkal, where feltételekkel és értékek bindingjával. A fordító ellenőrzi az összes case kimerítő lefedését — a default hiánya nem hiba, ha az összes lehetséges érték le van fedve.

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

switch point {
case (0, 0):
    print("Kiindulópont")
case let (x, y) where x == y:
    print("X egyenlő Y-nal")
case let (x, y) where abs(y) > x:
    print("Y nagyobb mint X modulo")
default:
    print("Pont (\(point.x), \(point.y))")
}

Optionals és biztonságos munka nil-lel

Optionals — a Swift központi fogalma, amely a null-referenciák problémáját oldja meg a típusrendszer szintjén. Az Optional<Wrapped> egy enum két case-szel: .none (nil) és .some(Wrapped). A fordító megtiltja az Optional használatát explicit ellenőrzés nélkül, ami kizárja a futásidejű hibák egész osztályát.

var optionalString: String? = "Hello"
optionalString = nil  // engedélyezett

// Optional Binding — biztonságos kinyerés
if let text = optionalString {
    print("Szöveg: \(text)")
} else {
    print("Érték hiányzik")
}

// Optional Chaining — biztonságos hozzáférés tulajdonságokhoz
let length = optionalString?.count ?? 0

// Nil-coalescing operátor
let greeting = optionalString ?? "Default"

Optional Chaining a ?. operátorral lehetővé teszi metódusok biztonságos meghívását és egy opcionális érték tulajdonságainak elérését. Ha a lánc nil-lel megszakad, a teljes kifejezés eredménye nil. A Nil-coalescing (??) alapértelmezett értéket biztosít, és széles körben használják UI kódban helyőrző szöveg megjelenítésére.

Protokollok és kiterjesztések

Protocols Swift-ben egy szerződést határoznak meg — tulajdonságok és metódusok halmazát. A Java interfészekkel ellentétben a Swift protokolloknak lehet alapértelmezett implementációjuk protocol extensionökön keresztül. Ez a Protocol-Oriented Programming alapja, az Apple által ajánlott megközelítés az osztályöröklés helyett.

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

// Alapértelmezett implementáció extension segítségével
extension NamedEntity {
    func description() -> String {
        return "Entity: \(name)"
    }
}

// Konformitás extension segítségével
extension String: NamedEntity {
    var name: String { return self }
}

Protocol Extensions lehetővé teszik metódusok hozzáadását egy protokollhoz anélkül, hogy minden megfelelő típust módosítanánk. Ez különösen hasznos közös segédprogramok hozzáadásához: map, filter, reduce a Sequence-hez, vagy Codable a JSON szerializációhoz. Az Apple számos keretrendszert (SwiftUI, Combine) épített protokollokra kiterjesztésekkel.

Closure-ök és funkcionális láncok

Closures Swift-ben — névtelen függvények, amelyek változókat fognak be a külső kontextusból. Szintaxisukban a closure-ök hasonlítanak a Kotlin lambda kifejezéseire, de rugalmasabb szintaxissal: trailing closure, shorthand argument names ($0, $1) és autoclosures.

// Closure kontextusbefogással
let numbers = [5, 3, 8, 1, 9]

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

// Funkcionális lánc
let result = numbers
    .filter { $0 > 3 }
    .map { $0 * 2 }
    .reduce(0, +)

// Closure függvényparaméterként
func performAsync(completion: @escaping (Result<Data, Error>) -> Void) { }

@escaping closure-öket akkor használjuk, amikor a closure a függvényből való visszatérés után hajtódik végre — jellemzően hálózati kéréseknél és aszinkron műveleteknél. Az @autoclosure automatikusan becsomagol egy kifejezést egy closure-be, amelyet assert és short-circuit logikában használnak.

Structok és osztályok: összehasonlítás

A választás a struct és class között — az egyik első döntés a Swift modell tervezésekor. Az Apple alapértelmezés szerint a struct (érték-típus) használatát ajánlja, és csak akkor váltson class (referenciatípus)ra, ha öröklésre vagy referencia szerinti azonosításra van szükség.

Érték-típusok (struct) biztonságosabbak több szálas környezetben — minden szál független másolatot kap. Referenciatípusok (class) szükségesek a UIKit (UIView, UIViewController) használatához, ahol referencia-azonosságra és rendszerosztályoktól való öröklésre van szükség.

ARC memóriakezelés

ARC (Automatic Reference Counting) — a Swift memóriakezelő rendszere referenciatípusokhoz. A fordító retain/release utasításokat szúr be futásidőben, nyomon követve az objektumra mutató erős referenciák számát. Amikor a számláló nullára csökken, az objektum azonnal felszabadul.

Az ARC fő problémája — retain cycle-ök (ciklikus referenciák). Amikor két objektum erős referenciákat tart egymásra, a memória nem szabadul fel. A megoldás — weak referenciák (automatikusan nil-lé válnak felszabadításkor) és unowned referenciák (garantálják, hogy az objektum él).

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

A retain cycle-ök megelőzésére closure-ökben használja a [weak self] paramétert guard let self = self else { return } kifejezéssel. Ez a szabály különösen fontos UIKit-ben, ahol a ViewController erős referenciákat tart a tulajdonságaira, és a tulajdonságokon belüli closure-ök a ViewController-ra hivatkoznak.