struct — vad är det, nyckelbegrepp och syntax i Swift

Vad är struct i Swift?

Struct (struktur) — är en sammansatt datatyp i Swift som grupperar relaterade egenskaper och metoder i en enda enhet. Till skillnad från klasser är strukturer value types: vid överföring till en funktion eller tilldelning till en ny variabel skapas en oberoende kopia av strukturen, inte en referens till det ursprungliga objektet.

Swift använder strukturer för alla primitiva typer: Int, Double, String, Bool, Array, Dictionary och Set. Detta innebär att även ett grundläggande tal Int beter sig som en struktur — vid tilldelning skapas en kopia. Utvecklaren kan definiera sin egen struktur med en godtycklig uppsättning egenskaper och metoder.

Enligt Swift Evolution (SE-0143) är beslutet att implementera standardtyper som strukturer motiverat av prestanda och förutsägbarhet. Value types skapar inte referenscykler, kräver inte ARC-referensräkning och garanterar att ändring av kopian inte påverkar originalet — detta är avgörande för datats oföränderlighet i flertrådade scenarier.

Struct som value type

Value type semantics — den viktigaste skillnaden mellan struct och class. När du tilldelar en struktur till en ny variabel eller skickar den till en funktion, skapar Swift en oberoende kopia av all data. Alla ändringar i kopian påverkar inte originalet, vilket eliminerar biverkningar som är typiska för referenstyper.

// Exempel på value type semantik
struct Point {
    var x: Double
    var y: Double
}

var p1 = Point(x: 10, y: 20)
var p2 = p1        // p2 är en oberoende kopia av p1
p2.x = 99            // Endast p2 ändras
print(p1.x)         // 10 — p1 oförändrad
print(p2.x)         // 99

Copy-on-Write optimering

Swift använder Copy-on-Write (COW) för att optimera kopiering. Om flera variabler refererar till samma struktur, men ingen av dem ändrar data, sker ingen faktisk kopiering. Swift delar minnet mellan variablerna fram till den första mutationen — då skapas en riktig kopia. Detta förhindrar onödiga allokeringsoperationer och påskyndar arbete med samlingar.

Föränderlighet och mutating metoder

Som standard kan strukturens metoder inte ändra dess egenskaper — Swift kräver explicit angivelse av mutating för metoder som gör ändringar. Denna begränsning skyddar mot oavsiktlig mutation och gör koden förutsägbar: om en metod inte är markerad som mutating har du garanti att du inte ändrar strukturen.

Mutating i praktiken

När du lägger till nyckelordet mutating före metoden, får Swift möjlighet att skriva nya värden till strukturens egenskaper. Faktum är att metoden till och med helt kan ersätta strukturens instans med en ny via self = . Denna mekanism används till exempel i typerna Option och Result.

// Struct med mutating metod
struct Counter {
    private var value: Int = 0

    // Mutating metod — kan ändra egenskaper
    mutating func increment() {
        value += 1
    }

    // Mutating metod kan helt ersätta self
    mutating func reset() {
        self = Counter()
    }

    // Non-mutating metod — endast läsning
    func currentValue() -> Int {
        return value
    }
}

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

Regler för mutating: strukturen måste deklareras med var, inte let — en konstant struktur kan inte anropa en mutating metod. Kompilatorn kontrollerar detta under kompileringen: ett försök att anropa en mutating metod på en let-konstant leder till ett kompileringsfel.

Struct vs Class: jämförelse

Valet mellan struct och class — ett av de grundläggande besluten i Swift. Båda typerna kan innehålla egenskaper, metoder, initierare och implementera protokoll, men har grundläggande skillnader i minnessemantik, arv och livscykelhantering.

Strukturer är att föredra när data inte kräver arv, inte ska ha delad identitet (till exempel koordinater, dimensioner, konfiguration) och skickas mellan moduler. Klasser väljs för UI-komponenter (UIView, UIViewController), singleton och objekt med delad identitet.

När du ska välja struct

Apple rekommenderar att använda struct som standardtyp för datamodellering i Swift. Strukturer är lämpliga för de flesta scenarier tack vare förutsägbar kopieringssemantik och frånvaro av overhead för referensräkning. Låt oss titta på typiska fall när struct är det optimala valet.

Datamodeller utan arv

Om entiteten innehåller data utan behov av arv (Product, User, Order, Point), använd struct. Kompilatorn genererar automatiskt en memberwise initializer — du behöver inte skriva init manuellt. Equatable och Hashable implementeras också automatiskt för strukturer vars alla egenskaper uppfyller dessa protokoll.

Oföränderlig (immutable) data

För konfigurationer, inställningar och flaggor som inte ändras efter skapande är struct att föredra framför class. En konstant (let) struktur garanterar oföränderlighet för alla nästlade fält — i class gäller detta endast referensen, inte objektets innehåll.

Flertrådad kod

Strukturer är säkra i flertrådade miljöer på grund av value semantics. Varje tråd får en oberoende kopia av data och påverkar inte andra trådar. Race condition mellan trådar är omöjliga för value types, vilket gör struct till det föredragna valet för modeller i SwiftUI (ObservableObject kräver class, men @State använder struct).

// Exempel på struct-användning för datamodell
struct User: Codable, Identifiable {
    let id: UUID
    var name: String
    var email: String
    var isPremium: Bool

    // Beräknad egenskap — non-mutating
    var displayName: String {
        isPremium ? "\(name) ⭐️" : name
    }
}

// Automatisk memberwise initierare
let user = User(
    id: UUID(),
    name: "Alice",
    email: "alice@example.com",
    isPremium: true
)

// Kopiering är säker för flertrådning
var userCopy = user
userCopy.isPremium = false
// user.isPremium förblir true

Använd class när du behöver arv (UIKit/AppKit-komponenter), delad identitet (delegate, observer) eller kontrollerad objektlivscykel (deinit). För allt annat — struct.