body: co to jest, obliczana właściwość View w SwiftUI

Czym jest body w SwiftUI?

body — to obliczana właściwość (computed property), która jest jedynym obowiązkowym wymaganiem protokołu View. Każda struktura zgodna z View musi implementować body. Właściwość zwraca treść, którą SwiftUI wyświetla na ekranie — może to być tekst, obraz, przycisk, kontener z elementami zagnieżdżonymi lub dowolny inny typ zgodny z protokołem View.

Sygnatura body jest zawsze stała: var body: some View { get }. Typ zwracany — some View (nieprzezroczysty typ), a nie konkretny typ. Oznacza to, że różne View mogą zwracać różne konkretne typy w body, ale kompilator Swift ustala konkretny typ dla każdej implementacji na etapie kompilacji.

Według WWDC 2022, body jest punktem wejścia do deklaratywnego opisu interfejsu. W przeciwieństwie do UIKit, gdzie imperatywnie tworzysz i konfigurujesz UIView, w SwiftUI deklaratywnie opisujesz, co ma być wyświetlone, a SwiftUI sam oblicza, jak to zaimplementować.

body jako czysta funkcja

body powinno zachowywać się jak czysta funkcja — przy tych samych danych wejściowych (właściwości struktury i stan) powinno zwracać to samo drzewo View. Jeśli body zależy od zewnętrznego zmiennego stanu (zmiennych globalnych, UserDefaults bez otoczki @AppStorage), zachowanie staje się nieprzewidywalne, a SwiftUI może przerysowywać ekran nieprawidłowo.

Jak działa obliczana właściwość body

Obliczana właściwość body nie przechowuje wartości — jest obliczana za każdym razem przy odczycie. Gdy SwiftUI określi, że stan się zmienił, odtwarza strukturę View i odczytuje nową wartość body, aby uzyskać aktualne drzewo elementów do wyświetlenia.

struct CounterView: View {
    @State private var count = 0

    var body: some View {
        VStack {
            Text("Licznik: \(count)")
                .font(.largeTitle)
            Button("Zwiększ") {
                count += 1
            }
            .padding()
            .background(.blue)
            .foregroundColor(.white)
            .cornerRadius(8)
        }
    }
}

W tym przykładzie body zwraca VStack zawierający Text i przycisk z modyfikatorami. Po naciśnięciu przycisku właściwość @State count zwiększa się, SwiftUI odtwarza strukturę CounterView i ponownie wywołuje body w celu uzyskania zaktualizowanego drzewa z nową wartością Text.

Modyfikatory (.font, .padding, .background, .foregroundColor, .cornerRadius) nie zmieniają oryginalnego View, ale opakowują go w ModifiedContent — nowy typ dodający modyfikację. Każdy modyfikator tworzy kolejny poziom zagnieżdżenia, co należy uwzględnić dla wydajności.

body i nieprzezroczysty typ some View

some View w typie zwracanym body — to nie tylko konwencja, ale obowiązkowe wymaganie kompilatora. Swift wymaga, aby wszystkie ścieżki zwrotu w body miały taki sam konkretny typ. Bez @ViewBuilder nie możesz zwrócić Text w jednej gałęzi i Button w drugiej — kompilator zgłosi błąd.

struct ConditionalView: View {
    var isReady: Bool

    @ViewBuilder
    var body: some View {
        if isReady {
            Text("Gotowe")
                .foregroundColor(.green)
        } else {
            ProgressView()
        }
    }
}

@ViewBuilder na body pozwala na użycie logiki warunkowej (if/else, switch) bez błędów kompilacji. ViewBuilder automatycznie opakowuje różne gałęzie w ConditionalContent — specjalny typ ukrywający różnice konkretnych typów. To kluczowa możliwość do budowania dynamicznych interfejsów.

Bez @ViewBuilder kompilator próbuje wywnioskować jednolity typ dla wszystkich ścieżek zwrotu. Jeśli typy są różne — pojawia się błąd. Dlatego SwiftUI niejawnie stosuje @ViewBuilder do body w deklaracjach View, choć w kodzie użytkownika adnotację należy umieścić jawnie dla niestandardowych metod i właściwości zwracających wiele View.

Wydajność some View

Używanie some View zamiast konkretnego typu nie obniża wydajności — kompilator na etapie kompilacji zna dokładny typ i generuje bezpośredni kod bez dynamicznego dysponowania. AnyView natomiast używa wymazywania typu (type erasure) z narzutem na pakowanie w kontener egzystencjalny.

Cykl życia body: kiedy i jak jest wywoływane

body jest wywoływane przez SwiftUI w trzech głównych scenariuszach: przy pierwszym wyświetleniu View, przy zmianie @State/@Binding/@ObservedObject/@StateObject oraz przy zmianie rodzica przekazującego nowe wartości przez inicjalizator. SwiftUI może również wywołać body przy zmianie wartości środowiska (@Environment).

Częstotliwość wywołania body nie powinna Cię martwić — SwiftUI optymalizuje przerysowanie poprzez mechanizm tożsamości. Każdy View w hierarchii ma unikalny identyfikator. Jeśli tożsamość i dane wejściowe się nie zmieniły — body nie jest wywoływane, nawet jeśli rodzic się przerysował. Osiąga się to przez porównanie Equatable i stabilność struktur.

struct ParentView: View {
    var body: some View {
        ChildView(name: "Alice") // Stabilna tożsamość
    }
}

struct ChildView: View {
    let name: String
    var body: some View {
        Text("Witaj, \(name)!")
    }
}

W tym przykładzie, jeśli ParentView przerysowuje się, ale przekazuje tę samą wartość name — ChildView.body nie jest wywoływane. SwiftUI porównuje dane wejściowe struktury i, jeśli się nie zmieniły, pomija przerysowanie komponentu potomnego. To mechanizm różnicowania widoku (view differentiation).

Kiedy body jest wywoływane nieoczekiwanie

Istnieje kilka pułapek prowadzących do nieoczekiwanego wywołania body: używanie klas bez ObservableObject, przekazywanie domknięć tworzonych wewnątrz body (każde utworzenie domknięcia daje nową tożsamość) oraz nieprawidłowe używanie EquatableView. Jeśli body jest wywoływane zbyt często — sprawdź stabilność tożsamości wszystkich komponentów potomnych.

Najlepsze praktyki pracy z body

Pierwsza zasada: body powinno być minimalne. Wyodrębniaj złożoną logikę do osobnych obliczanych właściwości lub metod zwracających View. Poprawia to czytelność i pozwala SwiftUI dokładniej określać, które części hierarchii się zmieniły. Dziel duże body na podkomponenty z wyraźnymi granicami odpowiedzialności.

Druga zasada: nie używaj body do wykonywania pracy. Ładowanie danych, praca z siecią, zapis do bazy danych — wszystko to powinno odbywać się poza body, w zadaniach (task), modyfikatorach onChange lub przez ObservableObject. body jest przeznaczone wyłącznie do deklaracji interfejsu.

Trzecia zasada: używaj właściwości EquatableView lub niestandardowego protokołu Equatable dla View, jeśli standardowe porównanie struktur jest niewystarczające. Pozwala to jawnie wskazać SwiftUI, kiedy komponent potomny wymaga przerysowania i uniknąć zbędnych wywołań body.

Czwarta zasada: jeśli body zawiera złożone obliczenia (formatowanie, filtrowanie, sortowanie) — używaj @State do buforowania wyniku lub wyodrębniaj obliczenia do osobnej metody wywoływanej z onChange. Ponowne obliczenia w body przy każdej aktualizacji stanu — częsta przyczyna spowolnienia animacji.

Piąta zasada: dla list (List, ForEach) zapewniaj stabilne identyfikatory przez parametr id. Bez stabilnej tożsamości ForEach odtwarza wszystkie elementy przy każdej zmianie, wywołując body dla każdego z nich, nawet jeśli zmienił się tylko jeden element.