Swift: ce este, sintaxa și conceptele cheie ale limbajului

Ce este Swift?

Swift — un limbaj de programare multiparadigmă dezvoltat de Apple pentru iOS, macOS, watchOS, tvOS și visionOS. Obiectivele cheie ale limbajului: siguranță, viteză și expresivitate a sintaxei. Swift utilizează compilatorul LLVM și generează cod mașină optimizat, comparabil ca performanță cu C++.

De la lansarea din 2014, Swift a trecut prin 6 versiuni majore. Swift 6 (2024) a introdus un model complet de data-race safety prin controlul strict al izolării codului concurent. Conform GitHub Octoverse 2025, Swift se află în top-10 limbi după creșterea comunității, depășind Rust și Kotlin în ritmul de adopție pe platformele Apple.

Swift este deschis și cross-platformă — codul sursă este publicat pe GitHub (Swift Open Source). Pe lângă platformele Apple, Swift este utilizat pe Linux și Windows pentru dezvoltare server (Vapor, Hummingbird), deși domeniul principal de aplicare rămâne dezvoltarea mobilă și desktop în ecosistemul Apple.

De ce Swift a înlocuit Objective-C

Principalele motive ale tranziției: Swift elimină clase întregi de erori posibile în Objective-C. Type safety previne nepotrivirea tipurilor în faza de compilare. Optionals exclud dereferențierile nil. ARC este încorporat din prima zi, spre deosebire de MRC/ARC în Objective-C. Sintaxa Swift este mai scurtă și mai lizibilă — cercetările arată o reducere a volumului de cod cu 30-40% comparativ cu Objective-C pentru sarcini similare.

Sintaxa și construcțiile de bază

Sintaxa de bază Swift combină construcții familiare asemănătoare C cu elemente ale limbajelor funcționale. Variabilele se declară prin var, constantele — prin let. Compilatorul utilizează type inference, deci specificarea explicită a tipului este necesară doar la ambiguitate.

import Foundation

// Constante și variabile
let name = "Swift"
var version = 6.0
var count: Int = 42

// Funcții cu parametri impliciți
func greet(person: String, greeting: String = "Hello") -> String {
    return "\(greeting), \(person)!"
}

// Guard-let pentru ieșire timpurie
func parse(input: String?) -> Int {
    guard let value = input, let number = Int(value) else {
        return 0
    }
    return number
}

Switch și pattern matching în Swift sunt mai puternice decât în C și Kotlin. Switch suportă potrivirea cu tupluri, intervale, condiții where și binding de valori. Compilatorul verifică acoperirea exhaustivă a tuturor case-urilor — absența default nu este o eroare dacă toate valorile posibile sunt acoperite.

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

switch point {
case (0, 0):
    print("Originea coordonatelor")
case let (x, y) where x == y:
    print("X este egal cu Y")
case let (x, y) where abs(y) > x:
    print("Y este mai mare decât X modulo")
default:
    print("Punct (\(point.x), \(point.y))")
}

Optionals și lucrul sigur cu nil

Optionals — conceptul central al Swift, rezolvând problema referințelor null la nivelul sistemului de tipuri. Optional<Wrapped> este un enum cu două case: .none (nil) și .some(Wrapped). Compilatorul interzice utilizarea Optional fără verificare explicită, ceea ce exclude o întreagă clasă de erori de runtime.

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

// Optional Binding — extragere sigură
if let text = optionalString {
    print("Text: \(text)")
} else {
    print("Valoare absentă")
}

// Optional Chaining — acces sigur la proprietăți
let length = optionalString?.count ?? 0

// Operatorul nil-coalescing
let greeting = optionalString ?? "Default"

Optional Chaining cu operatorul ?. permite apelarea sigură a metodelor și accesarea proprietăților unei valori opționale. Dacă lanțul este întrerupt de nil, rezultatul întregii expresii este nil. Nil-coalescing (??) oferă o valoare implicită și este utilizat pe scară largă în codul UI pentru afișarea textului placeholder.

Protocoale și extensii

Protocols în Swift definesc un contract — un set de proprietăți și metode. Spre deosebire de interfețele Java, protocoalele Swift pot avea implementări implicite prin protocol extensions. Aceasta este baza Protocol-Oriented Programming, abordarea recomandată de Apple în locul moștenirii de clase.

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

// Implementare implicită prin extension
extension NamedEntity {
    func description() -> String {
        return "Entity: \(name)"
    }
}

// Conformitate prin extension
extension String: NamedEntity {
    var name: String { return self }
}

Protocol Extensions permit adăugarea de metode la un protocol fără modificarea fiecărui tip conform. Acest lucru este util în special pentru adăugarea de utilități comune: map, filter, reduce pentru Sequence, sau Codable pentru serializare JSON. Apple a construit multe framework-uri (SwiftUI, Combine) pe protocoale cu extensii.

Closures și lanțuri funcționale

Closures în Swift — funcții anonime care capturează variabile din contextul extern. Sintactic, closures sunt similare cu lambda-urile din Kotlin, dar cu o sintaxă mai flexibilă: trailing closure, shorthand argument names ($0, $1) și autoclosures.

// Closure cu captarea contextului
let numbers = [5, 3, 8, 1, 9]

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

// Lanț funcțional
let result = numbers
    .filter { $0 > 3 }
    .map { $0 * 2 }
    .reduce(0, +)

// Closure ca parametru al funcției
func performAsync(completion: @escaping (Result<Data, Error>) -> Void) { }

@escaping closures sunt utilizate când closure-ul se execută după returnarea din funcție — tipic pentru cereri de rețea și operații asincrone. @autoclosure împachetează automat o expresie într-un closure, fiind utilizat în assert și logica short-circuit.

Structuri și clase: comparație

Alegerea între struct și class — una dintre primele decizii la proiectarea unui model în Swift. Apple recomandă utilizarea implicită a struct (value-tip) și trecerea la class (reference-tip) doar când este necesară moștenirea sau identificarea prin referință.

Value-tipuri (struct) sunt mai sigure în medii multi-thread — fiecare fir primește o copie independentă. Reference-tipuri (class) sunt necesare pentru lucrul cu UIKit (UIView, UIViewController), unde este necesară identitatea referinței și moștenirea de la clasele sistemului.

Gestionarea memoriei ARC

ARC (Automatic Reference Counting) — sistemul de gestionare a memoriei Swift pentru reference-tipuri. Compilatorul inserează retain/release în runtime, urmărind numărul de referințe puternice către un obiect. Când contorul ajunge la zero, obiectul este eliberat imediat.

Problema principală a ARC — retain cycles (referințe ciclice). Când două obiecte dețin referințe puternice unul către celălalt, memoria nu este eliberată. Soluția — referințe weak (devin automat nil la eliberare) și referințe unowned (garantează că obiectul este viu).

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

Pentru a preveni retain cycles în closures, utilizați [weak self] cu guard let self = self else { return }. Această regulă este deosebit de importantă în UIKit, unde ViewController deține referințe puternice la proprietățile sale, iar closures din interiorul acestor proprietăți fac referire la ViewController.