Como você otimiza o desempenho de um app Flutter?

Question

Accepted Answer

Embora Flutter seja performático por padrão, otimizar o desempenho envolve minimizar **rebuilds desnecessários**, **renderização eficiente de listas**, uso apropriado de **const**, evitar trabalho custoso na build e fazer profiling. Entender isso mantém apps suaves (60/120 fps).

## Minimizar rebuilds desnecessários

```text
✓ Use CONST constructors where possible → const widgets aren't rebuilt (huge win)
  const Text('Static')   // not rebuilt unnecessarily
✓ Keep setState/rebuild scope SMALL → rebuild only what changed (extract widgets so
  state changes rebuild a small subtree, not the whole screen)
✓ Use targeted state management (rebuild only widgets that depend on changed state)
✓ Don't rebuild large trees for small changes
```

## Listas eficientes

```text
✓ Use ListView.BUILDER (not ListView with all children) for long/infinite lists →
  builds only VISIBLE items lazily (not all at once) — critical for long lists
✓ Same for GridView.builder; use keys appropriately; avoid heavy item widgets
```

## Evitar trabalho custoso em build()

```text
✓ build() runs OFTEN → keep it cheap; don't do heavy computation, I/O, or allocations there
✓ Cache/precompute expensive results; move work out of build
✓ Heavy computation → use ISOLATES (run on a separate thread, off the UI thread) to
  avoid jank (the UI thread must stay free for smooth 60fps rendering)
```

## Profiling e outras otimizações

```text
✓ Use Flutter DEVTOOLS → performance overlay, widget rebuild profiler, timeline →
  FIND the actual bottlenecks (measure, don't guess)
✓ Optimize images (sizes, caching); avoid unnecessary opacity/clipping (expensive)
✓ Test in PROFILE/RELEASE mode (debug mode is slower — don't judge perf in debug)
✓ Reduce overdraw; use RepaintBoundary to isolate repaints
```

## Por que isso importa

Entender a otimização de desempenho do Flutter é conhecimento valioso em nível sênior porque **desempenho suave é essencial para uma boa experiência do usuário**, e embora Flutter seja performático por padrão, apps reais podem desenvolver problemas de desempenho (jank, frames perdidos) que precisam ser tratados.

A maior alavanca é **minimizar rebuilds desnecessários**: usando **const constructors** (para que widgets const não sejam reconstruídos — uma vitória significativa e fácil), mantendo **escopo de setState/rebuild pequeno** (extraindo widgets para que mudanças de estado reconstruam apenas uma pequena subárvore em vez de toda a tela), e usando state management direcionado (reconstruindo apenas widgets que dependem do estado alterado) — já que rebuilds desnecessários são um problema de desempenho comum. **Renderização eficiente de listas** é crítica: usar **`ListView.builder`** (que constrói preguiçosamente apenas os itens visíveis) em vez de construir todos os filhos de uma vez é essencial para listas longas — uma otimização comum e importante. **Evitar trabalho custoso em `build()`** importa porque build é executada frequentemente (então deve ser barata, com computação pesada movida para fora ou executada em **isolates** fora da thread UI para evitar jank, já que a thread UI deve permanecer livre para renderização suave). **Profiling com Flutter DevTools** (o overlay de desempenho, profiler de rebuild e timeline para encontrar gargalos reais) é a disciplina-chave — medir em vez de adivinhar — juntamente com testes em modo profile/release (não debug, que é mais lento) e otimização de imagens e repaints.

Desempenho suave de 60/120fps é o que torna os apps polidos, e jank é perceptível e frustrante, portanto essas otimizações afetam diretamente a experiência do usuário.

Já que desempenho suave é essencial para boa UX e apps Flutter reais podem desenvolver problemas de desempenho que otimização apropriada (const, rebuilds mínimos, listas eficientes, builds baratas, isolates, profiling) aborda, entender otimização de desempenho do Flutter é conhecimento valioso em nível sênior para construir apps suaves e polidos — uma habilidade-chave para desenvolvimento Flutter profissional que garante que apps permaneçam responsivos e livres de jank, refletindo a consciência de desempenho esperada para papéis sênior.