Swift: co to je, syntaxe a klíčové pojmy jazyka

Co je Swift?

Swift — multiparadigmatický programovací jazyk vyvinutý společností Apple pro iOS, macOS, watchOS, tvOS a visionOS. Klíčové cíle jazyka: bezpečnost, rychlost a výraznost syntaxe. Swift používá kompilátor LLVM a generuje optimalizovaný strojový kód, srovnatelný výkonem s C++.

Od vydání v roce 2014 prošel Swift 6 hlavními verzemi. Swift 6 (2024) představil kompletní model data-race safety prostřednictvím přísné kontroly izolace souběžného kódu. Podle GitHub Octoverse 2025 patří Swift mezi top-10 jazyků v růstu komunity a předčí Rust a Kotlin v rychlosti přijetí na platformách Apple.

Swift je otevřený a multiplatformní — zdrojový kód je publikován na GitHubu (Swift Open Source). Kromě platforem Apple se Swift používá na Linuxu a Windows pro serverový vývoj (Vapor, Hummingbird), ačkoli hlavní oblastí použití zůstává vývoj mobilních a desktopových aplikací v ekosystému Apple.

Proč Swift nahradil Objective-C

Hlavní důvody přechodu: Swift odstraňuje celé třídy chyb možných v Objective-C. Type safety zabraňuje neshodě typů ve fázi kompilace. Optionals vylučují nil-reference. ARC je integrován od prvního dne, na rozdíl od MRC/ARC v Objective-C. Syntaxe Swifta je kratší a čitelnější — výzkumy ukazují snížení objemu kódu o 30-40% ve srovnání s Objective-C při řešení podobných úloh.

Syntaxe a základní konstrukce

Základní syntaxe Swifta kombinuje známé konstrukce podobné C s prvky funkcionálních jazyků. Proměnné se deklarují pomocí var, konstanty pomocí let. Kompilátor používá type inference, takže explicitní uvedení typu je vyžadováno pouze při nejednoznačnosti.

import Foundation

// Konstanty a proměnné
let name = "Swift"
var version = 6.0
var count: Int = 42

// Funkce s výchozími parametry
func greet(person: String, greeting: String = "Hello") -> String {
    return "\(greeting), \(person)!"
}

// Guard-let pro předčasný výstup
func parse(input: String?) -> Int {
    guard let value = input, let number = Int(value) else {
        return 0
    }
    return number
}

Switch a pattern matching ve Swiftu jsou mocnější než v C a Kotlinu. Switch podporuje porovnávání s tuple, rozsahy, where podmínkami a binding hodnot. Kompilátor kontroluje vyčerpávající pokrytí všech case — absence default není chyba, pokud jsou pokryty všechny možné hodnoty.

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

switch point {
case (0, 0):
    print("Počátek souřadnic")
case let (x, y) where x == y:
    print("X se rovná Y")
case let (x, y) where abs(y) > x:
    print("Y je větší než X modulo")
default:
    print("Bod (\(point.x), \(point.y))")
}

Optionals a bezpečná práce s nil

Optionals — ústřední koncept Swifta, řešící problém null-referencí na úrovni typového systému. Optional<Wrapped> je enum se dvěma case: .none (nil) a .some(Wrapped). Kompilátor zakazuje použití Optional bez explicitní kontroly, což vylučuje celou třídu runtime chyb.

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

// Optional Binding — bezpečné vyjmutí
if let text = optionalString {
    print("Text: \( text)")
} else {
    print("Hodnota chybí")
}

// Optional Chaining — bezpečný přístup k vlastnostem
let length = optionalString?.count ?? 0

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

Optional Chaining s operátorem ?. umožňuje bezpečné volání metod a přístup k vlastnostem volitelné hodnoty. Pokud je řetězec přerušen nil, výsledkem celého výrazu je nil. Nil-coalescing (??) poskytuje výchozí hodnotu a je široce používán v UI kódu pro zobrazení placeholder textu.

Protokoly a rozšíření

Protocols ve Swiftu definují kontrakt — sadu vlastností a metod. Na rozdíl od Java rozhraní mohou mít Swift protokoly výchozí implementace prostřednictvím protocol extensions. To je základ Protocol-Oriented Programming, doporučeného přístupu Apple místo dědičnosti tříd.

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

// Výchozí implementace přes extension
extension NamedEntity {
    func description() -> String {
        return "Entity: \(name)"
    }
}

// Konformita přes extension
extension String: NamedEntity {
    var name: String { return self }
}

Protocol Extensions umožňují přidávat metody k protokolu bez úpravy každého vyhovujícího typu. To je zvláště užitečné pro přidávání společných nástrojů: map, filter, reduce pro Sequence, nebo Codable pro JSON serializaci. Apple postavil mnoho frameworků (SwiftUI, Combine) na prototypech s rozšířeními.

Closures a funkční řetězce

Closures ve Swiftu — anonymní funkce zachycující proměnné z vnějšího kontextu. Syntakticky jsou closures podobné lambdám v Kotlinu, ale s flexibilnější syntaxí: trailing closure, shorthand argument names ($0, $1) a autoclosures.

// Closure se zachycením kontextu
let numbers = [5, 3, 8, 1, 9]

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

// Funkční řetězec
let result = numbers
    .filter { $0 > 3 }
    .map { $0 * 2 }
    .reduce(0, +)

// Closure jako parametr funkce
func performAsync(completion: @escaping (Result<Data, Error>) -> Void) { }

@escaping closures se používají, když se closure provádí po návratu z funkce — typicky pro síťové požadavky a asynchronní operace. @autoclosure automaticky zabalí výraz do closure, což se používá v assert a short-circuit logice.

Struktury a třídy: srovnání

Volba mezi struct a class — jedno z prvních rozhodnutí při navrhování Swift modelu. Apple doporučuje používat struct jako výchozí (value-typ) a přejít na class (reference-typ) pouze při potřebě dědičnosti nebo identifikace podle reference.

Value-typy (struct) jsou bezpečnější ve vícevláknovém prostředí — každé vlákno dostává nezávislou kopii. Reference-typy (class) jsou nezbytné pro práci s UIKit (UIView, UIViewController), kde je vyžadována identita reference a dědičnost od systémových tříd.

Správa paměti ARC

ARC (Automatic Reference Counting) — systém správy paměti Swifta pro reference-typy. Kompilátor vkládá retain/release za běhu, sleduje počet silných referencí na objekt. Když počítadlo dosáhne nuly, objekt je okamžitě uvolněn.

Hlavní problém ARC — retain cycles (cyklické reference). Když dva objekty drží silné reference jeden na druhého, paměť se neuvolňuje. Řešením jsou slabé reference weak (automaticky se stanou nil při uvolnění) a unowned reference (zaručují, že objekt žije).

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

Pro zabránění retain cycles v closures používejte [weak self] s guard let self = self else { return }. Toto pravidlo je zvláště důležité v UIKit, kde ViewController drží silné reference na své vlastnosti a closures uvnitř těchto vlastností odkazují na ViewController.