struct — какво е това, ключови понятия и синтаксис в Swift

Какво е struct в Swift?

Struct (структура) — съставен тип данни в Swift, който групира свързани свойства и методи в една цялост. За разлика от класовете, структурите са value types: при предаване на функция или присвояване на нова променлива се създава независимо копие на структурата, а не референция към оригиналния обект.

Swift използва структури за всички примитивни типове: Int, Double, String, Bool, Array, Dictionary и Set. Това означава, че дори основното число Int се държи като структура — при присвояване се създава копие. Разработчикът може да дефинира собствена структура с произволен набор от свойства и методи.

Според Swift Evolution (SE-0143), решението да се имплементират стандартните типове като структури е мотивирано от производителност и предвидимост. Value types не създават референтни цикли, не изискват броене на референции ARC и гарантират, че промяната на копието няма да засегне оригинала — това е критично за неизменяемостта на данни в многонишкови сценарии.

Struct като value type

Value type semantics — ключовата разлика между struct и class. Когато присвоите структура на нова променлива или я предадете на функция, Swift създава независимо копие на всички данни. Всякакви промени в копието не засягат оригинала, което елиминира страничните ефекти, характерни за референтните типове.

// Пример за семантика на value type
struct Point {
    var x: Double
    var y: Double
}

var p1 = Point(x: 10, y: 20)
var p2 = p1        // p2 е независимо копие на p1
p2.x = 99            // Само p2 се променя
print(p1.x)         // 10 — p1 непроменен
print(p2.x)         // 99

Copy-on-Write оптимизация

Swift използва Copy-on-Write (COW) за оптимизиране на копирането. Ако няколко променливи се отнасят към една и съща структура, но никоя не променя данните, действително копиране не се извършва. Swift споделя паметта между променливите до първата мутация — тогава се създава истинско копие. Това предотвратява излишни операции по заделяне и ускорява работата с колекции.

Променливост и mutating методи

По подразбиране методите на структурата не могат да променят нейните свойства — Swift изисква изрично посочване на mutating за методи, които правят промени. Това ограничение предпазва от случайна мутация и прави кода предвидим: ако метод не е маркиран като mutating, гарантирано няма да промените структурата.

Mutating в действие

Когато добавите ключовата дума mutating преди метода, Swift получава възможност да запише нови стойности в свойствата на структурата. Всъщност методът може дори напълно да замени инстанцията на структурата с нова чрез self = . Този механизъм се използва например в типовете Option и Result.

// Struct с mutating метод
struct Counter {
    private var value: Int = 0

    // Mutating метод — може да променя свойства
    mutating func increment() {
        value += 1
    }

    // Mutating метод може напълно да замени self
    mutating func reset() {
        self = Counter()
    }

    // Non-mutating метод — само за четене
    func currentValue() -> Int {
        return value
    }
}

var counter = Counter()
counter.increment()
print(counter.currentValue())  // 1
counter.reset()
print(counter.currentValue())  // 0

Правила за mutating: структурата трябва да бъде декларирана чрез var, а не let — на константна структура не може да се извика mutating метод. Компилаторът проверява това на етапа на компилиране: опит за извикване на mutating метод върху let константа ще доведе до грешка при компилиране.

Struct vs Class: сравнение

Изборът между struct и class — едно от фундаменталните решения в Swift. И двата типа могат да съдържат свойства, методи, инициализатори и да имплементират протоколи, но имат принципни разлики в семантиката на паметта, наследяването и управлението на жизнения цикъл.

Структурите са предпочитани, когато данните не изискват наследяване, не трябва да имат обща идентичност (например координати, размери, конфигурация) и се предават между модули. Класовете се избират за UI компоненти (UIView, UIViewController), singleton и обекти с обща идентичност.

Кога да изберете struct

Apple препоръчва използването на struct като тип по подразбиране за моделиране на данни в Swift. Структурите са подходящи за повечето сценарии благодарение на предвидимата семантика на копиране и липсата на допълнителни разходи за броене на референции. Нека разгледаме типичните случаи, когато struct е оптималният избор.

Модели от данни без наследяване

Ако обектът съдържа данни без необходимост от наследяване (Product, User, Order, Point), използвайте struct. Компилаторът автоматично генерира memberwise initializer — не е нужно да пишете init ръчно. Equatable и Hashable също се имплементират автоматично за структури, чиито всички свойства отговарят на тези протоколи.

Неизменяеми (immutable) данни

За конфигурации, настройки и флагове, които не се променят след създаване, struct е за предпочитане пред class. Константна (let) структура гарантира неизменяемост на всички вложени полета — в class това се отнася само до референцията, а не до съдържанието на обекта.

Многонишков код

Структурите са безопасни в многонишкова среда поради value semantics. Всяка нишка получава независимо копие на данните и не влияе на други нишки. Състезателни условия между нишки са невъзможни за value types, което прави struct предпочитания избор за модели в SwiftUI (ObservableObject изисква class, но @State използва struct).

// Пример за използване на struct за модел от данни
struct User: Codable, Identifiable {
    let id: UUID
    var name: String
    var email: String
    var isPremium: Bool

    // Изчисляемо свойство — non-mutating
    var displayName: String {
        isPremium ? "\(name) ⭐️" : name
    }
}

// Автоматичен memberwise инициализатор
let user = User(
    id: UUID(),
    name: "Alice",
    email: "alice@example.com",
    isPremium: true
)

// Копирането е безопасно за многонишковост
var userCopy = user
userCopy.isPremium = false
// user.isPremium остава true

Използвайте class, когато имате нужда от наследяване (UIKit/AppKit компоненти), обща идентичност (delegate, observer) или контролиран жизнен цикъл на обекти (deinit). За всичко останало — struct.