Interfaces no TypeScript: Modelagem de Objetos e Contratos de Dados
Inicie o Módulo 2 dominando o coração da modelagem orientada a objetos no TypeScript: aprenda a declarar Interfaces para estabelecer contratos estritos de dados, modele métodos e propriedades aninhadas e reutilize estruturas através de herança com extends.
📑 Índice do Conteúdo
1. O que é uma Interface no TypeScript? (A Filosofia da Tipagem Estrutural)
No desenvolvimento de software corporativo, uma Interface é um contrato formal que define os atributos e comportamentos que um objeto deve possuir. No TypeScript, as interfaces são a ferramenta primária para descrever a “forma” (shape) de entidades de dados.
O TypeScript adota o princípio da Tipagem Estrutural (Structural Typing ou Duck Typing): o compilador não se importa com a árvore genealógica de herança da classe ou qual foi a função construtora utilizada; se um objeto possui todas as propriedades com os tipos exigidos pela interface, ele é considerado compatível e válido.
tsc, todas as interfaces são 100% eliminadas, não gerando nenhum byte adicional no arquivo JavaScript final.
2. Sintaxe Fundamental de uma Interface
A declaração de uma interface utiliza a palavra-chave interface seguida pelo nome da entidade com inicial maiúscula (PascalCase):
TypeScript
interface PerfilUsuario {
id: string;
nomeCompleto: string;
email: string;
nivelAcesso: "admin" | "editor" | "leitor";
ativo: boolean;
}
// Criando um objeto que satisfaz o contrato da interface:
const usuarioLogado: PerfilUsuario = {
id: "USR-9941",
nomeCompleto: "Matheus Silveira",
email: "[email protected]",
nivelAcesso: "admin",
ativo: true
};
// ❌ ERRO TS2741 se faltar qualquer propriedade obrigatória (ex: esquecer "ativo"):
// Property 'ativo' is missing in type '{ ... }' but required in type 'PerfilUsuario'.
3. Modelando Métodos e Funções em Interfaces
Interfaces podem declarar métodos que os objetos implementadores devem fornecer. Existem duas sintaxes equivalentes suportadas pelo compilador:
TypeScript
interface CarrinhoCompras {
codigoCarrinho: string;
totalItens: number;
// Forma 1: Assinatura de Método Tradicional (Mais recomendada)
calcularFrete(cepDestino: string): number;
// Forma 2: Propriedade com Função Arrow
aplicarCupom: (codigoCupom: string) => boolean;
}
4. Herança de Interfaces com a Palavra-Chave extends
Para evitar a repetição de código e modelar hierarquias ricas de dados, uma interface pode estender uma ou mais interfaces existentes utilizando extends:
TypeScript
// 1. Contrato base genérico
interface ProdutoBase {
id: number;
nome: string;
precoBase: number;
}
// 2. Interface derivada herdando propriedades de ProdutoBase
interface ProdutoDigital extends ProdutoBase {
urlDownload: string;
tamanhoMb: number;
expiraEmDias: number;
}
// 3. Herança Múltipla: Uma interface pode estender múltiplas interfaces!
interface Auditavel {
criadoEm: Date;
modificadoPor: string;
}
interface LicencaSoftware extends ProdutoDigital, Auditavel {
chaveAtivacao: string;
}
const licencaIde: LicencaSoftware = {
id: 104,
nome: "Playground Web IDE Pro",
precoBase: 199.90,
urlDownload: "https://webzoneware.com/download/ide",
tamanhoMb: 45.8,
expiraEmDias: 365,
criadoEm: new Date(),
modificadoPor: "admin_sistema",
chaveAtivacao: "WZW-PRO-8899-7711"
};
5. Conectando Interfaces a Classes (implements)
Na Programação Orientada a Objetos (POO), interfaces servem como contratos que as classes devem honrar através da cláusula implements:
TypeScript
interface ServicoNotificacao {
enviarMensagem(destinatario: string, texto: string): Promise<boolean>;
}
// A classe abaixo é OBRIGADA pelo compilador a implementar enviarMensagem:
class NotificadorWhatsApp implements ServicoNotificacao {
async enviarMensagem(destinatario: string, texto: string): Promise<boolean> {
console.log(`[API WHATSAPP] Enviando para ${destinatario}: ${texto}`);
return true;
}
}
6. Exemplo Prático Integrado: Gestão de Assinaturas e Planos SaaS
Veja a aplicação de interfaces, herança com extends e métodos de domínio em um sistema financeiro de assinaturas:
TypeScript
// 1. Contrato de plano de serviço
interface PlanoSaaS {
id: string;
nomePlano: "Starter" | "Professional" | "Enterprise";
mensalidade: number;
limiteRequisicoesMes: number;
}
// 2. Contrato base de cliente cadastrado
interface ClienteBase {
id: string;
razaoSocial: string;
cnpj: string;
emailFinanceiro: string;
}
// 3. Interface especializada estendendo o cliente com dados da assinatura
interface AssinaturaAtiva extends ClienteBase {
plano: PlanoSaaS;
dataInicio: Date;
ativa: boolean;
calcularValorAnualComDesconto(descontoPercentual: number): number;
}
// 4. Instanciação de cliente com contrato validado
const clienteEmpresarial: AssinaturaAtiva = {
id: "CLI-4051",
razaoSocial: "ZoneWare Soluções Tecnológicas Ltda",
cnpj: "12.345.678/0001-90",
emailFinanceiro: "[email protected]",
plano: {
id: "PLN-ENT-01",
nomePlano: "Enterprise",
mensalidade: 890.00,
limiteRequisicoesMes: 10_000_000
},
dataInicio: new Date("2026-01-15"),
ativa: true,
calcularValorAnualComDesconto(descontoPercentual: number): number {
const totalSemDesconto = this.plano.mensalidade * 12;
return totalSemDesconto * (1 - descontoPercentual / 100);
}
};
const totalAnualCom15Off = clienteEmpresarial.calcularValorAnualComDesconto(15);
console.log(`[FATURAMENTO] Cliente: ${clienteEmpresarial.razaoSocial}`);
console.log(`Plano: ${clienteEmpresarial.plano.nomePlano} | Valor Anual com 15% OFF: R$ ${totalAnualCom15Off.toFixed(2)}`);
7. Tabela Didática: Recursos de Modelagem com Interfaces
| Recurso de Interface | Sintaxe no TypeScript | Finalidade Arquitetural |
|---|---|---|
| Propriedades Básicas | chave: Tipo; |
Define os campos obrigatórios do objeto. |
| Assinatura de Método | metodo(arg: Tipo): Retorno; |
Define o comportamento e ações executáveis. |
| Herança Simples | interface B extends A |
Cria subtipos herdando todos os campos do contrato base. |
| Herança Múltipla | interface C extends A, B |
Funde múltiplos contratos em uma única entidade rica. |
| Implementação em Classes | class MeuServico implements MinhaInterface |
Garante que a classe forneça todos os métodos estipulados. |
I em interfaces (como IUsuario ou ICliente). Tanto o time oficial da Microsoft quanto os guias de estilo modernos de TypeScript recomendam usar substantivos limpos (Usuario, Cliente). A filosofia de tipagem estrutural do TypeScript integra tipos e interfaces naturalmente sem necessidade desse prefixo legado do C# ou Java.
?) e o Modificador readonly para imutabilidade profunda.
Aplique o que você aprendeu nesta lição
Utilize nossas ferramentas online gratuitas para experimentar os conceitos ou teste o código ao vivo no Playground IDE.
Editor de Códigos Web Online
Ambiente com destaque de sintaxe para você testar tags, tabelas e scripts na hora.
Abrir Ferramenta OnlinePlayground Web Online
Escreva seu código HTML, CSS ou JavaScript e veja o resultado renderizado ao vivo no navegador com zero configuração.
⚡ Codificar no Playground IDE