.task { } — шта је то, модификатор async и учитавање података у View

Шта је .task { } у SwiftUI

.task { } — је модификатор View који креира Task у async контексту при појављивању View на екрану. SwiftUI покреће прослеђени closure у позадини, док главна нит остаје слободна за UI операције. Када View нестане, SwiftUI аутоматски отказује Task кроз механизам Structured Concurrency — ово гарантује да се асинхрона операција неће наставити након што њен резултат више никоме није потребан.

Према Apple — Swift Programming Language (2025), .task користи концепт Structured Concurrency, уведен у Swift 5.5. Сваки .task креира подређени задатак у оквиру задатка родитељског View. Ако је родитељски задатак отказан (View нестане), сви подређени задаци се такође аутоматски отказују. Ово радикално поједностављује управљање животним циклусом асинхроних операција у поређењу са ручним чувањем референци на DispatchWorkItem или AnyCancellable.

За разлику од традиционалног приступа са @State + ручним позивом у .onAppear, .task не захтева чување референце на Task за касније отказивање. SwiftUI то ради аутоматски, што смањује количину boilerplate кода и елиминише ризик заборава отказивања задатка.

struct ArticlesView: View {
    @State var articles: [Article] = []
    @State var error: Error?
    
    var body: some View {
        List(articles) { article in
            Text(article.title)
        }
        .task {
            do {
                articles = await APIClient().fetchArticles()
            } catch {
                self.error = error
            }
        }
    }
}

.task vs .onAppear: кључне разлике

Многи програмери су навикли да учитавају податке у .onAppear, али са појавом async/await и .task овај приступ је застарео. .onAppear извршава код синхроно — за асинхроне операције унутар .onAppear потребно је умотати позив у Task { } и ручно чувати референцу на њега за евентуално отказивање. .task то ради аутоматски.

.onAppear је и даље користан за синхроне операције — на пример, логирање или почетно подешавање UI. Али за асинхроно учитавање података, мрежне захтеве, рад са базом података или системом датотека користи .task. Ово је сигурније и чистије са архитектуралне тачке гледишта.

// ❌ Стари приступ: Task у .onAppear без отказивања
var loadTask: Task<Void, Never>?
func body() { var body: some View { Text("") }
    .onAppear {
        loadTask = Task { await loadData() }
    }
    .onDisappear { loadTask?.cancel() }

// ✅ Модерни приступ: .task управља отказивањем
func body() { var body: some View { Text("") }
    .task { await loadData() }

.task(id:) — поновно покретање при промени података

Модификатор .task(id:) прима додатни параметар — идентификатор. Када се вредност идентификатора промени, SwiftUI отказује тренутни задатак и покреће нови са новим идентификатором. Ово је идеално за екране где подаци зависе од изабраног параметра — на пример, листа чланака по категорији или детаљи производа по ID-у.

struct CategoryView: View {
    let categoryId: Int
    @State var items: [Item] = []
    
    var body: some View {
        List(items) { item in
            Text(item.name)
        }
        .task(id: categoryId) {
            await loadItems(for: categoryId)
        }
    }
    
    func loadItems(for id: Int) async {
        do {
            items = await APIClient().fetchItems(categoryId: id)
        } catch {
            // обради грешку
        }
    }
}

Када се categoryId промени, SwiftUI отказује претходни захтев и покреће нови. Ово је посебно важно при брзом пребацивању категорија — стари захтеви се неће такмичити са новим за ажурирање стања. Без .task(id:) морали би ручно да пратите промене кроз .onChange и ручно управљате Task-ом.

Отказивање задатака и провера isCancelled

Иако .task аутоматски отказује задатак при нестанку View, сама асинхрона операција мора кооперативно да проверава отказивање. Swift користи кооперативни модел отказивања — Task.cancel() не зауставља извршење присилно, већ само поставља флаг isCancelled. Код унутар задатка треба периодично да проверава овај флаг.

struct LoadingView: View {
    @State var progress: Double = 0
    
    var body: some View {
        ProgressView(value: progress)
            .task {
                for i in 0..<100 {
                    // Провери отказивање
                    try Task.checkCancellation()
                    
                    await Task.sleep(nanoseconds: 50_000_000)
                    progress = Double(i + 1) / 100.0
                }
            }
    }
}

Task.checkCancellation() баца CancellationError ако је задатак отказан. Ово је најједноставнији начин провере — ради у било ком async контексту. Алтернатива — ручна провера Task.isCancelled пре скупих операција. За URLSession мрежни захтеви се аутоматски отказују при отказивању задатка, јер URLSession подржава Structured Concurrency из корена.

Практични примери .task

.task је погодан за мноштво сценарија: од једноставног учитавања JSON до сложених паралелних операција са TaskGroup. Размотримо три типична примера употребе.

Учитавање са обрадом грешака

struct ProfileView: View {
    @State var profile: Profile?
    @State var isLoading = true
    
    var body: some View {
        Group {
            if isLoading {
                ProgressView()
            } else if let profile {
                Text(profile.name)
            } else {
                Text("Није успело учитавање")
            }
        }
        .task {
            defer { isLoading = false }
            do {
                profile = await APIClient().fetchProfile()
            } catch {
                // профил остаје nil
            }
        }
    }
}

Паралелно учитавање са TaskGroup

struct DashboardView: View {
    @State var stats: DashboardStats?
    
    var body: some View {
        Text("Командна табла")
            .task {
                stats = await Task {
                    await withThrowingTaskGroup { group in
                        group.addTask { await API().fetchUsers() }
                        group.addTask { await API().fetchOrders() }
                        group.addTask { await API().fetchRevenue() }
                        
                        return DashboardStats(
                            users: try await group.next(),
                            orders: try await group.next(),
                            revenue: try await group.next()
                        )
                    }
                }.value
            }
    }
}

Типичне грешке са .task

Најчешћа грешка — мутација UI својстава унутар .task без пребацивања на главну нит. Иако SwiftUI аутоматски враћа ажурирања на главну нит при промени @State у async контексту, директне манипулације UIKit елементима унутар .task могу изазвати crash.

• Заборавио си try/catch — .task не обрађује грешке аутоматски. Све функције које бацају изузетке унутар морају бити умотане у do/catch, иначе ће апликација пасти.
• Race condition — ако је неколико .task(id:) покренуто са различитим id-овима и ажурирају исто стање, могуће су трке. Користи одвојена својства за различите изворе података.
• Дуге синхроне операције — .task не чини синхрони код асинхроним. Ако унутар .task постоји тежак синхрони посао, умотај га у Task.detached или премести у посебан async метод.
• Игнорисање CancellationError — при провери Task.checkCancellation() грешка CancellationError треба да се пропагира навише, а не да се потискује. Потискивање отказивања може довести до цурења меморије.

// ❌ Грешка: без обраде грешака
.task {
    let data = await fetchData() // пада при грешци!
    items = data
}

// ✅ Исправно: do/catch
.task {
    do {
        items = await fetchData()
    } catch {
        errorMessage = error.localizedDescription
    }
}