O Padrão MVVM
Separe as responsabilidades da view, do modelo de view e do modelo.
O Padrão MVVM é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 1 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.
O que é MVVM?
MVVM significa Modelo-Visualização-ViewModel. É um padrão arquitetural que separa seu aplicativo em três camadas, cada uma com uma responsabilidade clara e única.
- Modelo — dados e regras de negócio
- Visualização — o que o usuário vê
- ViewModel — a ponte que prepara os dados do Modelo para a Visualização
O objetivo é a separação de responsabilidades: cada camada muda por seu próprio motivo, independentemente das outras.
A camada Modelo
O Modelo contém seus dados brutos e as regras que os governam. Ele não sabe nada sobre a tela nem sobre como as coisas são exibidas.
Os modelos geralmente são estruturas simples ou objetos de domínio. São fáceis de testar porque não têm dependências da interface.
struct User {
let id: UUID
let firstName: String
let lastName: String
let isPremium: Bool
}
struct Order {
let items: [String]
let total: Decimal
}A camada de visualização
A Visualização é puramente voltada à apresentação. No SwiftUI, ela corresponde às suas estruturas View; no UIKit, ao seu UIViewController e às suas subvisualizações.
Uma boa visualização não contém lógica de negócio. Ela apenas renderiza o state e encaminha as ações do usuário ao ViewModel.
struct ProfileView: View {
@StateObject var viewModel: ProfileViewModel
var body: some View {
VStack {
Text(viewModel.displayName)
if viewModel.showBadge {
Text("Premium")
}
}
}
}A camada ViewModel
O ViewModel fica entre o Modelo e a Visualização. Ele recebe dados brutos do Modelo e os transforma em valores prontos para apresentação que a Visualização pode exibir diretamente.
Ele também expõe intenções (métodos) que a Visualização chama quando o usuário interage.
final class ProfileViewModel: ObservableObject {
@Published var displayName: String
@Published var showBadge: Bool
init(user: User) {
displayName = user.firstName + " " + user.lastName
showBadge = user.isPremium
}
}Por que separar responsabilidades?
Quando formatação, comunicação de rede e renderização ficam todas misturadas dentro de um controlador de visualização, esse arquivo se torna um bloco enorme e impossível de testar.
Ao dividir as responsabilidades:
- O Modelo pode ser reutilizado em várias telas
- O ViewModel pode ser testado unitariamente sem uma interface
- A Visualização permanece pequena e declarativa
O que pertence ao Modelo
Coloque no Modelo:
- Entidades de domínio (
User,Product) - Regras de validação de negócio
- Abstrações de persistência e comunicação de rede (geralmente por meio de serviços que o ViewModel chama)
Nunca coloque textos da interface, cores ou formatação no Modelo.
O que pertence ao ViewModel
O ViewModel cuida da lógica de apresentação:
- Formatar datas, moedas e nomes em textos para exibição
- Decidir quais estados da interface estão visíveis (carregando, erro, vazio)
- Coordenar chamadas a serviços e expor resultados
final class CartViewModel: ObservableObject {
@Published var totalText: String = ""
func update(with order: Order) {
let formatter = NumberFormatter()
formatter.numberStyle = .currency
totalText = formatter.string(from: order.total as NSNumber) ?? "-"
}
}O que pertence à visualização
A visualização deve apenas:
- Organizar e renderizar elementos da interface
- Ler o state publicado do ViewModel
- Encaminhar toques e gestos chamando métodos do ViewModel
Se você encontrar um if decidindo regras de negócio dentro de uma visualização, essa lógica provavelmente pertence ao ViewModel.
Fluxo de dados no MVVM
O fluxo segue uma direção para os dados e a direção inversa para as ações:
- Modelo -> ViewModel -> Visualização para dados
- Visualização -> ViewModel para intenções do usuário
A Visualização nunca se comunica diretamente com o Modelo. Isso mantém as dependências apontando para dentro, em direção ao seu domínio.
MVVM versus MVC
No MVC clássico, o controlador costuma crescer demais porque reúne formatação, comunicação de rede e conexão com a visualização de uma só vez.
O MVVM extrai essa lógica de apresentação para o ViewModel, deixando o controlador (ou a visualização do SwiftUI) enxuto. O ViewModel não depende do framework de interface, portanto é muito mais fácil de testar.
Uma parte completa
Aqui está uma parte pequena, mas completa, de MVVM que conecta as camadas.
struct Account { let balance: Decimal }
final class AccountViewModel: ObservableObject {
@Published var balanceText: String
init(account: Account) {
balanceText = "$" + "\(account.balance)"
}
}
struct AccountView: View {
@StateObject var viewModel: AccountViewModel
var body: some View { Text(viewModel.balanceText) }
}Verificação rápida
Teste sua compreensão das responsabilidades do MVVM.
Recapitulação
Você aprendeu as três camadas do MVVM e seus limites:
- Modelo — dados brutos e regras de negócio, sem interface
- ViewModel — lógica de apresentação e intenções
- Visualização — renderização pura do state do ViewModel
Manter essas responsabilidades separadas torna seu código testável, reutilizável e fácil de compreender. A seguir, conectaremos um ViewModel a uma Visualização com vinculações.
Perguntas Frequentes
A aula “O Padrão MVVM” é grátis?
Sim — o texto completo de “O Padrão MVVM” é 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 “O Padrão MVVM”?
Separe as responsabilidades da view, do modelo de view e do modelo. 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 1 de 4.
Quanto tempo leva a aula “O Padrão MVVM”?
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.