0Pricing
Swift Academy · Aula

SwiftData @Model e ModelContext

Defina modelos com a macro @Model e execute operações CRUD por meio de ModelContext.

SwiftData @Model e ModelContext é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Introdução ao SwiftData

SwiftData (iOS 17+) é a estrutura moderna de persistência da Apple, nativa do Swift e construída sobre o Core Data internamente.

import SwiftData
// Main concepts: @Model, ModelContainer, ModelContext

Macro @Model

Anote uma classe com @Model para transformá-la em um modelo SwiftData persistível. As propriedades se tornam atributos armazenados automaticamente.

@Model
class Item {
  var name: String
  var createdAt: Date
  init(name: String) {
    self.name = name
    self.createdAt = Date()
  }
}

Configurando o ModelContainer

Crie um ModelContainer com os tipos do seu modelo e injete-o no ambiente do SwiftUI.

@main
struct MyApp: App {
  var body: some Scene {
    WindowGroup {
      ContentView()
    }
    .modelContainer(for: Item.self)
  }
}

ModelContext nas visualizações

Use @Environment(\.modelContext) para acessar o contexto do modelo em uma visualização SwiftUI.

struct AddItemView: View {
  @Environment(\.modelContext) private var context
  func addItem() {
    context.insert(Item(name: "New Item"))
  }
}

Inserindo e excluindo

Chame context.insert para adicionar modelos e context.delete para removê-los. As alterações são salvas automaticamente por padrão.

let item = Item(name: "Coffee")
context.insert(item)   // add
context.delete(item)   // remove
// Auto-saved on next run loop

@Query para buscar dados

@Query nas visualizações SwiftUI busca dados e atualiza a interface automaticamente quando os dados subjacentes mudam.

struct ItemList: View {
  @Query(sort: \Item.createdAt, order: .reverse) var items: [Item]
  var body: some View {
    List(items) { item in Text(item.name) }
  }
}

Filtrando com predicados

Passe um #Predicate para @Query a fim de filtrar os resultados de forma declarativa.

@Query(filter: #Predicate<Item> { $0.name.contains("Swift") })
var swiftItems: [Item]

Salvamento manual

Chame try context.save() quando precisar controlar explicitamente quando as alterações serão persistidas.

do {
  try context.save()
} catch {
  print("Save error: \(error)")
}

@Attribute para personalização

Use @Attribute nas propriedades para personalizar o comportamento da persistência (por exemplo, exclusividade e armazenamento externo).

@Model
class User {
  @Attribute(.unique) var email: String
  @Attribute(.externalStorage) var avatar: Data?
  init(email: String) { self.email = email }
}

Propriedades @Transient

Marque as propriedades com @Transient para excluí-las da persistência.

@Model
class Session {
  var token: String
  @Transient var isExpired: Bool = false
  init(token: String) { self.token = token }
}

Configuração do ModelContainer

Configure o contêiner com um esquema explícito e um plano de migração para modelos versionados.

let schema = Schema([Item.self, User.self])
let config = ModelConfiguration(schema: schema, isStoredInMemoryOnly: false)
let container = try ModelContainer(for: schema, configurations: config)

Verificação rápida

Qual wrapper de propriedade do SwiftUI busca automaticamente modelos SwiftData e atualiza a visualização quando os dados mudam?

Recapitulação da lição

Anote as classes com @Model para torná-las persistíveis. Configure o ModelContainer no nível do app. Leia e grave dados por meio de @Environment(\.modelContext). Faça buscas reativas com @Query. Filtre com #Predicate.

Perguntas Frequentes

A aula “SwiftData @Model e ModelContext” é grátis?

Sim — o texto completo de “SwiftData @Model e ModelContext” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “SwiftData @Model e ModelContext”?

Defina modelos com a macro @Model e execute operações CRUD por meio de ModelContext. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “SwiftData @Model e ModelContext”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Pilha do Core Data: configuração de NSPersistentContainer
  2. SwiftData @Model e ModelContext
  3. Relacionamentos e Fetch Descriptors
  4. Migrações leves e sincronização com CloudKit
← Voltar para Swift Academy