Swift Academy · Lección

Minimizar la reevaluación de body

Reduzca los cálculos innecesarios de las vistas.

Minimizar la reevaluación de body 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.

body se recalcula con frecuencia

SwiftUI llama a body de una vista cada vez que cambian sus entradas. Un body pesado o con demasiadas dependencias se recalcula con excesiva frecuencia, lo que perjudica el rendimiento.

Qué activa la reevaluación

Un body vuelve a ejecutarse cuando cambia cualquier @State, @Binding, objeto observado o valor del entorno que lee, o cuando su elemento principal le pasa valores nuevos.

struct Row: View {
    let title: String // changes -> body re-runs
    var body: some View { Text(title) }
}

Limitar lo que observa

Si una vista lee un modelo grande completo, cualquier cambio en ese modelo vuelve a ejecutar su body. Pase únicamente los valores concretos que la vista necesita.

// Instead of passing the whole model:
struct Price: View {
    let amount: Decimal // narrow input
    var body: some View { Text(amount, format: .currency(code: "USD")) }
}

Dividir las vistas grandes

Divida un body enorme en subvistas pequeñas. SwiftUI reevalúa solo las subvistas cuyas entradas han cambiado realmente, no toda la pantalla.

struct Screen: View {
    var body: some View {
        VStack {
            Header()   // re-runs only if its inputs change
            ItemList()
            Footer()
        }
    }
}

Observable y seguimiento a nivel de propiedad

Con la macro @Observable, SwiftUI realiza el seguimiento de las propiedades exactas que lee una vista. Una vista que solo lee model.name ignora los cambios en model.count.

@Observable final class Model {
    var name = ""
    var count = 0
}
// A view reading only name won’t re-run when count changes

Evitar trabajo en body

El body debe describir la interfaz de forma económica. Los cálculos pesados, como ordenar y filtrar, pertenecen al modelo o a una propiedad almacenada en caché, no deben volver a ejecutarse en cada llamada a body.

// Bad: sort inside body (runs every recompute)
// Good: sort once in the model, expose sorted array

Closures y entradas estables

Pasar un array o una closure recién creados en cada renderizado puede impedir las comprobaciones de igualdad de SwiftUI. Eleve los valores estables para que las entradas sean iguales entre los distintos recálculos.

// Hoist constants out of body
private let columns = [GridItem(.flexible())]

Cuidado con los inicializadores costosos

El init de una vista puede ejecutarse muchas veces. Evite realizar trabajo pesado allí; SwiftUI crea valores de vista con frecuencia, incluso cuando no los renderiza.

struct Card: View {
    init(_ item: Item) { /* keep this trivial */ }
    var body: some View { Text("Card") }
}

Leer el entorno tiene un coste de actualización

Leer un valor del entorno suscribe la vista a él. Lea los valores del entorno solo donde sean necesarios, en la subvista más pequeña posible, para limitar el alcance de la reevaluación.

@Environment(\.colorScheme) private var scheme

Contenedores perezosos

Use LazyVStack/LazyHStack y List para que las filas fuera de pantalla no se creen hasta que sean necesarias, reduciendo las llamadas a body en colecciones grandes.

ScrollView {
    LazyVStack {
        ForEach(items) { RowView(item: $0) }
    }
}

Medir y después optimizar

No adivine qué body consume más recursos. Use SwiftUI Instrument para encontrar las vistas con un número elevado de evaluaciones de body y aplique allí estas técnicas.

Comprobación rápida: reevaluación

Compruebe su comprensión de la reevaluación de body.

Resumen: minimizar la reevaluación de body

Los body se vuelven a ejecutar cuando cambian sus entradas, así que pase valores específicos, divida las vistas grandes en subvistas pequeñas y aproveche el seguimiento a nivel de propiedad de @Observable. Mantenga ligeros los body y los inicializadores, eleve las entradas estables, lea los valores del entorno lo mínimo posible y use contenedores perezosos para las colecciones grandes.

Confirme siempre los puntos críticos con SwiftUI Instrument antes de optimizar.

Preguntas frecuentes

¿La lección «Minimizar la reevaluación de body» es gratis?

Sí — el texto completo de «Minimizar la reevaluación de body» 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 «Minimizar la reevaluación de body»?

Reduzca los cálculos innecesarios de las vistas. 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 «Minimizar la reevaluación de body»?

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

← Volver a Swift Academy