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 по модул")
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 и функционални вериги

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

// Closure с улавяне на контекст
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, +)

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

@escaping closures се използват, когато closure се изпълнява след връщане от функция — типично за мрежови заявки и асинхронни операции. @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 в closures използвайте [weak self] с guard let self = self else { return }. Това правило е особено важно в UIKit, където ViewController държи силни референции към своите свойства, а closures вътре в тези свойства реферират към ViewController.