Swift: шта је то, синтакса и кључни концепти језика

Шта је Swift?

Swift — вишепарадигматски програмски језик развијен од стране Apple-а за iOS, macOS, watchOS, tvOS и visionOS. Кључни циљеви језика: безбедност, брзина и изражајност синтаксе. Swift користи LLVM компајлер и генерише оптимизовани машински код, упоредив по перформансама са C++.

Од издања 2014. године, Swift је прошао кроз 6 главних верзија. Swift 6 (2024) је представио потпуни модел data-race safety кроз строгу контролу изолације конкурентног кода. Према GitHub Octoverse 2025, Swift је у топ-10 језика по расту заједнице, престижући Rust и Kotlin по брзини усвајања на Apple платформама.

Swift је отворен и вишеплатформски — изворни код је објављен на GitHub-у (Swift Open Source). Поред Apple платформи, Swift се користи на Linux-у и Windows-у за серверски развој (Vapor, Hummingbird), иако главна област примене остаје мобилни и десктоп развој у Apple екосистему.

Зашто је Swift заменио Objective-C

Главни разлози преласка: Swift елиминише читаве класе грешака које су могуће у Objective-C. Type safety спречава неусаглашеност типова у фази компајлације. Optionals искључују nil-разреференцирања. ARC је уграђен од првог дана, за разлику од MRC/ARC у Objective-C. Синтакса Swift-а је краћа и читљивија — истраживања показују смањење обима кода за 30-40% у поређењу са Objective-C при решавању сличних задатака.

Синтакса и основне конструкције

Основна синтакса Swift-а комбинује познате C-сличне конструкције са елементима функционалних језика. Променљиве се декларишу кроз var, константе — кроз let. Компајлер користи type inference, па је експлицитно навођење типа потребно само при нејасноћи.

import Foundation

// Константе и променљиве
let name = "Swift"
var version = 6.0
var count: Int = 42

// Функције са подразумеваним параметрима
func greet(person: String, greeting: String = "Hello") -> String {
    return "\(greeting), \(person)!"
}

// Guard-let за рани излаз
func parse(input: String?) -> Int {
    guard let value = input, let number = Int(value) else {
        return 0
    }
    return number
}

Switch и pattern matching у Swift-у су моћнији него у C и Kotlin-у. Switch подржава поклапање са торкама, опсезима, where условима и везивањем вредности. Компајлер проверава исцрпну покривеност свих case-ова — одсуство default није грешка ако су све могуће вредности покривене.

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

switch point {
case (0, 0):
    print("Почетак координата")
case let (x, y) where x == y:
    print("X је једнако Y")
case let (x, y) where abs(y) > x:
    print("Y је веће од X modulo")
default:
    print("Точка (\(point.x), \(point.y))")
}

Optionals и безбедан рад са nil-ом

Optionals — централни концепт Swift-а, који решава проблем null-референци на нивоу система типова. Optional<Wrapped> је enum са два case-а: .none (nil) и .some(Wrapped). Компајлер забрањује коришћење Optional-а без експлицитне провере, што искључује читаву класу runtime грешака.

var optionalString: String? = "Hello"
optionalString = nil  // дозвољено

// Optional Binding — безбедно издвајање
if let text = optionalString {
    print("Текст: \(text)")
} else {
    print("Вредност недостаје")
}

// Optional Chaining — безбедан приступ својствима
let length = optionalString?.count ?? 0

// Nil-coalescing оператор
let greeting = optionalString ?? "Default"

Optional Chaining са оператором ?. омогућава безбедно позивање метода и приступ својствима опционе вредности. Ако се ланац прекине nil-ом, резултат целог израза је nil. Nil-coalescing (??) обезбеђује подразумевану вредност и широко се користи у UI коду за приказ placeholder текста.

Протоколи и проширења

Protocols у Swift-у дефинишу уговор — скуп својстава и метода. За разлику од Java интерфејса, Swift протоколи могу имати подразумеване имплементације кроз protocol extensions. То је основа Protocol-Oriented Programming, препорученог Apple-овог приступа уместо наслеђивања класа.

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

// Подразумевана имплементација кроз extension
extension NamedEntity {
    func description() -> String {
        return "Entity: \(name)"
    }
}

// Конформизам кроз extension
extension String: NamedEntity {
    var name: String { return self }
}

Protocol Extensions омогућавају додавање метода протоколу без модификације сваког типа који га имплементира. Ово је посебно корисно за додавање заједничких алата: map, filter, reduce за Sequence, или Codable за JSON серијализацију. Apple је изградио многе фрејмворке (SwiftUI, Combine) на протоколима са проширењима.

Затварања и функционални ланци

Closures у Swift-у — анонимне функције које хватају променљиве из спољашњег контекста. Синтаксно, closures су слични ламбда изразима у Kotlin-у, али са флексибилнијом синтаксом: trailing closure, shorthand argument names ($0, $1) и autoclosures.

// Затварање са хватањем контекста
let numbers = [5, 3, 8, 1, 9]

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

// Функционални ланац
let result = numbers
    .filter { $0 > 3 }
    .map { $0 * 2 }
    .reduce(0, +)

// Затварање као параметар функције
func performAsync(completion: @escaping (Result<Data, Error>) -> Void) { }

@escaping closures се користе када се затварање извршава након повратка из функције — типично за мрежне захтеве и асинхроне операције. @autoclosure аутоматски умотава израз у closure, што се користи у assert и short-circuit логици.

Структуре и класе: поређење

Избор између struct и class — једна од првих одлука при пројектовању Swift модела. Apple препоручује коришћење struct подразумевано (value-тип) и прелазак на class (reference-тип) само када је потребно наслеђивање или идентификација по референци.

Value-типови (struct) су безбеднији у вишеструком окружењу — свака нит добија независну копију. Reference-типови (class) су неопходни за рад са UIKit (UIView, UIViewController), где је потребан идентитет референце и наслеђивање од системских класа.

ARC управљање меморијом

ARC (Automatic Reference Counting) — систем управљања меморијом Swift-а за reference-типове. Компајлер убацује retain/release у runtime, пратећи број јаких референци на објекат. Када бројач достигне нулу, објекат се одмах ослобађа.

Главни проблем ARC-а — retain cycles (цикличне референце). Када два објекта држе јаке референце један на другог, меморија се не ослобађа. Решење — слабе референце weak (аутоматски постају nil при ослобађању) и unowned референце (гарантују да је објекат жив).

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

За спречавање retain cycles у затварањима користите [weak self] са guard let self = self else { return }. Ово правило је посебно важно у UIKit-у, где ViewController држи јаке референце на своја својства, а затварања унутар ових својстава референцирају ViewController.