Swift Academy · Aula

Cache de Layout e Desempenho

Use o cache de layout para obter eficiência.

Cache de Layout e Desempenho é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 4 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.

Por Que Usar um Cache de Layout

O SwiftUI pode chamar sizeThatFits e placeSubviews muitas vezes durante uma única passagem de layout.

Se seus cálculos forem caros, um cache permite calcular uma vez e reutilizar o resultado, evitando trabalho repetido.

O Tipo Associado Cache

O protocolo Layout tem um tipo associado Cache, cujo padrão é Void. Defina sua própria estrutura para armazenar resultados pré-calculados.

struct FlowLayout: Layout {
    struct CacheData {
        var sizes: [CGSize] = []
    }
    typealias Cache = CacheData
}

makeCache

Implemente makeCache(subviews:) para criar o cache inicial. O SwiftUI o chama uma vez antes dos métodos de layout, oferecendo um local para fazer medições antecipadas.

func makeCache(subviews: Subviews) -> CacheData {
    let sizes = subviews.map { $0.sizeThatFits(.unspecified) }
    return CacheData(sizes: sizes)
}

Lendo o Cache

Agora, os métodos de layout recebem cache como um parâmetro inout. Leia os valores pré-calculados em vez de medir novamente cada elemento filho.

func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout CacheData) -> CGSize {
    let height = cache.sizes.map(\.height).max() ?? 0
    let width = cache.sizes.reduce(0) { $0 + $1.width }
    return CGSize(width: width, height: height)
}

updateCache

Quando o conjunto de subvisualizações muda, o SwiftUI chama updateCache(_:subviews:). A implementação padrão recria o cache por meio de makeCache, mas você pode substituí-la para fazer atualizações incrementais.

func updateCache(_ cache: inout CacheData, subviews: Subviews) {
    cache.sizes = subviews.map { $0.sizeThatFits(.unspecified) }
}

Quando updateCache É Executado

updateCache é executado quando a quantidade ou a identidade das subvisualizações muda — não a cada ajuste de geometria. Armazene em cache apenas dados que dependem das subvisualizações, não do tamanho proposto.

Armazene em Cache Apenas Dados Independentes da Proposta

Um erro comum é armazenar resultados que dependem do tamanho proposto. A proposta pode mudar entre as chamadas, portanto os resultados dependentes do tamanho devem ser recalculados, não armazenados cegamente em cache.

// OK to cache: intrinsic child sizes
// NOT OK to cache: row breaks (depend on proposed width)

Armazenando Tamanhos Intrínsecos em Cache

O padrão seguro é armazenar em cache os resultados dispendiosos de sizeThatFits(.unspecified) e executar a aritmética barata da quebra de linha a cada chamada usando a proposta atual.

struct CacheData { var intrinsic: [CGSize] = [] }
// wrapping uses cache.intrinsic + current maxWidth

Evite a Otimização Prematura

Para alguns elementos filhos simples, a medição é barata e um cache adiciona complexidade. Analise o desempenho primeiro; use um cache somente quando a medição realmente for dispendiosa (texto, imagens e layouts aninhados).

Cache e Semântica de Valor

O cache pertence ao SwiftUI e é passado como inout. Mantenha-o como um tipo de valor simples, sem referências a visualizações, para que o SwiftUI possa gerenciar seu ciclo de vida com segurança.

struct CacheData {
    var sizes: [CGSize] // value types only
}

Medindo o Ganho

Use o Instrumento do SwiftUI ou contadores simples para confirmar que o cache realmente reduz as chamadas de medição. Otimizar sem medir é trabalhar com suposições.

Verificação Rápida: Cache de Layout

Teste sua compreensão do armazenamento em cache do layout.

Recapitulação: Cache de Layout e Desempenho

O tipo associado Cache do protocolo Layout, criado por makeCache e atualizado por updateCache, armazena trabalho dispendioso e independente da proposta, como os tamanhos intrínsecos dos elementos filhos.

Execute a aritmética barata e dependente da proposta a cada chamada. Mantenha o cache como um tipo de valor sem referências, evite armazenar dados prematuramente em cache e verifique o benefício com análise de desempenho antes de adicionar complexidade.

Perguntas Frequentes

A aula “Cache de Layout e Desempenho” é grátis?

Sim — o texto completo de “Cache de Layout e Desempenho” é 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 “Cache de Layout e Desempenho”?

Use o cache de layout para obter eficiência. 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 4 de 4.

Quanto tempo leva a aula “Cache de Layout e Desempenho”?

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

← Voltar para Swift Academy