Swift: что это, синтаксис и ключевые понятия языка

Что такое Swift?

Swift — мультипарадигмальный язык программирования, разработанный Apple для iOS, macOS, watchOS, tvOS и visionOS. Ключевые цели языка: безопасность, скорость и выразительность синтаксиса. Swift использует компилятор LLVM и генерирует оптимизированный машинный код, сравнимый по производительности с C++.

С момента релиза в 2014 году Swift прошёл через 6 мажорных версий. Swift 6 (2024) представил полную модель data-race safety через строгий контроль изоляции concurrent-кода. По данным 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 и паттерн-матчинг в Swift мощнее, чем в C и Kotlin. Switch поддерживает сопоставление с кортежами, диапазонами, where-условиями и binding-значений. Компилятор проверяет исчерпывающий охват всех 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 — это 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 protocols могут иметь реализации по умолчанию через 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.