Swift Academy · Lección

@Model y ModelContext de SwiftData

Defina modelos con la macro @Model y realice operaciones CRUD mediante ModelContext.

@Model y ModelContext de SwiftData es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 4 lecciones en total.

Introducción a SwiftData

SwiftData (iOS 17 o posterior) es el framework moderno de persistencia de Apple, nativo de Swift y basado internamente en Core Data.

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

Macro @Model

Anote una clase con @Model para convertirla en un modelo de SwiftData persistible. Las propiedades se convierten automáticamente en atributos almacenados.

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

Configuración de ModelContainer

Cree un ModelContainer con sus tipos de modelo e inyéctelo en el entorno de SwiftUI.

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

ModelContext en las vistas

Use @Environment(\.modelContext) para acceder al contexto del modelo en una vista de SwiftUI.

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

Inserción y eliminación

Llame a context.insert para añadir modelos y a context.delete para eliminarlos. De forma predeterminada, los cambios se guardan automáticamente.

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

@Query para realizar búsquedas

@Query en las vistas de SwiftUI obtiene los datos y se actualiza automáticamente cuando cambian los datos subyacentes.

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

Filtrado con predicados

Pase un #Predicate a @Query para filtrar los resultados de forma declarativa.

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

Guardado manual

Llame a try context.save() cuando necesite controlar explícitamente cuándo se persisten los cambios.

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

@Attribute para personalización

Use @Attribute en las propiedades para personalizar el comportamiento de persistencia (por ejemplo, unicidad o almacenamiento externo).

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

Propiedades @Transient

Marque las propiedades con @Transient para excluirlas de la persistencia.

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

Configuración de ModelContainer

Configure el contenedor con un esquema explícito y un plan de migración 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)

Comprobación rápida

¿Qué wrapper de propiedades de SwiftUI obtiene automáticamente los modelos de SwiftData y actualiza la vista cuando cambian los datos?

Repaso de la lección

Anote las clases con @Model para convertirlas en persistibles. Configure ModelContainer en el nivel de la app. Lea y escriba mediante @Environment(\.modelContext). Obtenga los datos de forma reactiva con @Query. Filtre con #Predicate.

Preguntas frecuentes

¿La lección «@Model y ModelContext de SwiftData» es gratis?

Sí — el texto completo de «@Model y ModelContext de SwiftData» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 4 lecciones en total.

¿Qué aprenderé en «@Model y ModelContext de SwiftData»?

Defina modelos con la macro @Model y realice operaciones CRUD mediante ModelContext. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Swift Academy?

No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «@Model y ModelContext de SwiftData»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Swift Academy?

Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Stack de Core Data: configuración de NSPersistentContainer
@Model y ModelContext de SwiftData
Relaciones y descriptores de búsqueda
Migraciones ligeras y sincronización con CloudKit

← Volver a Swift Academy