Swift Academy · Lección

Vistas Equatable y ámbito de @State

Restrinja el estado para limitar la invalidación.

Vistas Equatable y ámbito de @State es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 3 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.

La igualdad puede evitar trabajo

Si SwiftUI puede demostrar que las entradas de una vista no han cambiado, puede omitir volver a renderizarla. Hacer que una vista sea Equatable le proporciona a SwiftUI una forma precisa de decidirlo.

Adoptar la conformidad con Equatable

Declare la conformidad de su vista con Equatable para que SwiftUI compare los valores antiguos y nuevos. Si son iguales, omite el body.

struct Badge: View, Equatable {
    let count: Int
    var body: some View { Text("\(count)") }
    static func == (a: Badge, b: Badge) -> Bool {
        a.count == b.count
    }
}

EquatableView

También puede envolver cualquier vista Equatable con .equatable() para solicitar que se omita basándose en la comparación, sin cambiar los lugares donde se usa el tipo.

Badge(count: total)
    .equatable()

Cuándo ayuda Equatable

Equatable resulta especialmente útil en vistas con entradas baratas de comparar pero cuyos cuerpos son costosos. El coste de la comparación debe ser muy inferior al del renderizado para que compense.

La trampa del coste de comparación

Si su == también es costoso, como al comparar profundamente matrices grandes, puede costar más que el renderizado que intenta omitir. Compare únicamente campos baratos y decisivos.

static func == (a: Self, b: Self) -> Bool {
    a.id == b.id && a.version == b.version // cheap fields
}

Equatable sintetizado de forma predeterminada

Si todas las propiedades almacenadas son Equatable, Swift puede sintetizar ==. Sin embargo, los cierres y algunos tipos no son Equatable, por lo que quizá necesite una implementación personalizada que los ignore.

struct Card: View, Equatable {
    let title: String
    let onTap: () -> Void // not Equatable
    static func == (a: Card, b: Card) -> Bool { a.title == b.title }
    var body: some View { Text(title) }
}

Reducir el ámbito de @State

Colocar el estado demasiado arriba hace que todo lo que está debajo se vuelva a renderizar. Lleve @State hasta la vista más pequeña que lo posee, para que los cambios afecten a la menor cantidad posible de interfaz.

// Move toggle state into the row that uses it
struct Row: View {
    @State private var expanded = false
    var body: some View { /* only this row re-renders */ Text("Row") }
}

Elevar el estado solo cuando se comparte

Eleve el estado únicamente cuando varias vistas realmente lo necesiten. De lo contrario, el estado local mantiene reducido el alcance de la re-renderización.

Extraer subvistas para localizar las actualizaciones

Extraer una parte que cambia con frecuencia a su propia vista confina la reevaluación a esa vista y deja intactas las vistas hermanas.

struct LiveClock: View {
    @State private var now = Date()
    var body: some View { Text(now, style: .time) }
}

Enlaces y ámbito

Un @Binding conecta una vista hija con el estado de su vista padre. Pasar un enlace específico, correspondiente a un solo campo, en lugar del objeto completo limita los cambios que se propagan.

struct NameField: View {
    @Binding var name: String // narrow binding
    var body: some View { TextField("Name", text: $name) }
}

Combinar Equatable con el ámbito

Los mejores resultados se obtienen al combinar técnicas: colocar el estado en un ámbito reducido para disminuir los activadores y usar Equatable para omitir los renderizados que aun así se produzcan.

Comprobación rápida: vistas Equatable

Compruebe su comprensión de las vistas Equatable y del ámbito del estado.

Resumen: vistas Equatable y ámbito del estado

Hacer que una vista sea Equatable (o usar .equatable()) permite que SwiftUI omita los renderizados sin cambios; resulta útil cuando comparar es mucho más barato que renderizar y se usan únicamente campos decisivos.

Reduzca @State a la vista más pequeña que posee el estado, pase enlaces específicos y extraiga las partes variables a sus propias vistas. Combinar un ámbito de estado reducido con Equatable produce menos re-renderizaciones y de menor coste.

Preguntas frecuentes

¿La lección «Vistas Equatable y ámbito de @State» es gratis?

Sí — el texto completo de «Vistas Equatable y ámbito de @State» 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 «Vistas Equatable y ámbito de @State»?

Restrinja el estado para limitar la invalidación. 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 3 de 4.

¿Cuánto tiempo toma la lección «Vistas Equatable y ámbito de @State»?

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