Natuurlijk! In TypeScript kun je interfaces gebruiken om de structuur en de eisen voor objecten te definiëren, inclusief strikte eigenschapsbeperkingen voor bijvoorbeeld een Gebruiker. Hier volgt een uitleg en voorbeelden: ### 1. Een interface definiëren voor Gebruiker Je kunt een interface maken die bepaalt welke eigenschappen een Gebruiker moet hebben. Bijvoorbeeld: ```typescript interface Gebruiker { naam: string; leeftijd: number; email: string; isActief: boolean; } ``` Hiermee geef je aan dat elk object dat voldoet aan deze interface minimaal deze eigenschappen met de juiste types moet bezitten. ### 2. Gebruiker implementeren in een klasse Je kunt een klasse maken die deze interface implementeert: ```typescript class PotentiëleGebruiker implements Gebruiker { naam: string; leeftijd: number; email: string; isActief: boolean; constructor(naam: string, leeftijd: number, email: string) { this.naam = naam; this.leeftijd = leeftijd; this.email = email; this.isActief = false; // standaardwaarde } activeer() { this.isActief = true; } } ``` Omdat de klasse `PotentiëleGebruiker` de interface `Gebruiker` implementeert, moet hij alle eigenschappen en types naleven. ### 3. Functie met interface als parameter Je kunt functies schrijven die alleen objecten accepteren die voldoen aan de interface: ```typescript function registreerGebruiker(g: Gebruiker): void { console.log(`Gebruiker ${g.naam} is geregistreerd met email ${g.email}.`); } ``` En gebruiken: ```typescript const nieuweGebruiker: Gebruiker = { naam: "Jan Jansen", leeftijd: 30, email: "jan@example.com", isActief: false }; registreerGebruiker(nieuweGebruiker); ``` ### 4. Strikte eigenschapsbeperkingen afdwingen TypeScript controleert op compile-tijd of objecten aan de interface voldoen. Als je bijvoorbeeld een object mist een verplichte eigenschap of een verkeerde type, krijg je een fout: ```typescript const onvolledigeGebruiker = { naam: "Piet Pieters", email: "piet@example.com" // ontbreekt leeftijd en isActief } as Gebruiker; // TypeScript geeft hier waarschuwing of fout ``` Of bij het ontbreken van verplichte eigenschappen: ```typescript const foutGebruiker: Gebruiker = { naam: "Fout", email: "fout@example.com" // fout: ontbreekt leeftijd en isActief }; // compile-fout ``` ### Samenvatting - Maak een interface `Gebruiker` met de vereiste eigenschappen. - Implementeer deze interface in klassen of objecten. - TypeScript controleert dat objecten voldoen aan de interface bij compile-tijd. - Dit zorgt voor strikte eigenschapsbeperkingen en helpt fouten voorkomen. Heeft u nog verdere vragen of wilt u een specifiek voorbeeld?

Claro! Vou explicar como criar e usar interfaces em TypeScript para definir restrições rígidas de propriedades de Usuário. ## 1. Interface Básica para Usuário ```typescript // Interface principal com propriedades obrigatórias interface Usuario { id: number; nome: string; email: string; dataNascimento: Date; ativo: boolean; } ``` ## 2. Interfaces Especializadas com Restrições ```typescript // Interface para usuário com propriedades opcionais interface UsuarioOpcional { id?: number; nome?: string; email?: string; dataNascimento?: Date; ativo?: boolean; } // Interface para criação de usuário (sem ID) interface UsuarioCriacao { nome: string; email: string; dataNascimento: Date; ativo: boolean; } // Interface para atualização de usuário (todas as propriedades opcionais) interface UsuarioAtualizacao extends Partial<Usuario> {} // Interface com propriedades readonly interface UsuarioLeitura { readonly id: number; readonly nome: string; readonly email: string; readonly dataCriacao: Date; } ``` ## 3. Implementação em Classes ```typescript class UsuarioImplementado implements Usuario { constructor( public id: number, public nome: string, public email: string, public dataNascimento: Date, public ativo: boolean ) {} // Método que valida o email validarEmail(): boolean { const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/; return regex.test(this.email); } // Método que calcula idade calcularIdade(): number { const hoje = new Date(); const idade = hoje.getFullYear() - this.dataNascimento.getFullYear(); return idade; } } ``` ## 4. Funções que Utilizam as Interfaces ```typescript // Função que cria um usuário function criarUsuario(dados: UsuarioCriacao): Usuario { const id = Math.floor(Math.random() * 1000); return { id, ...dados }; } // Função que atualiza um usuário function atualizarUsuario(usuario: Usuario, atualizacoes: UsuarioAtualizacao): Usuario { return { ...usuario, ...atualizacoes }; } // Função que valida um usuário function validarUsuario(usuario: Usuario): string[] { const erros: string[] = []; if (!usuario.nome || usuario.nome.length < 2) { erros.push('Nome deve ter pelo menos 2 caracteres'); } if (!usuario.email || !usuario.email.includes('@')) { erros.push('Email deve ser válido'); } const idade = new Date().getFullYear() - usuario.dataNascimento.getFullYear(); if (idade < 13) { erros.push('Usuário deve ter pelo menos 13 anos'); } return erros; } ``` ## 5. Interfaces com Propriedades Mais Restritivas ```typescript // Interface com tipos mais específicos interface UsuarioRestrito { readonly id: number; nome: string; email: `${string}@${string}.${string}`; // Template literal type idade: number; tipo: 'admin' | 'usuario' | 'moderador'; // Union type permissoes: readonly string[]; // Array readonly } // Interface com validações avançadas interface UsuarioValidado { id: number; nome: string & { readonly brand: unique symbol }; // Branded type email: string; senha: string; } // Função que cria um usuário validado function criarUsuarioValidado(nome: string, email: string, senha: string): UsuarioValidado { if (nome.length < 2) { throw new Error('Nome muito curto'); } if (senha.length < 8) { throw new Error('Senha deve ter pelo menos 8 caracteres'); } return { id: Date.now(), nome: nome as UsuarioValidado['nome'], email, senha }; } ``` ## 6. Exemplo de Uso Prático ```typescript // Criando um usuário const novoUsuario: UsuarioCriacao = { nome: 'João Silva', email: 'joao@email.com', dataNascimento: new Date('1990-05-15'), ativo: true }; const usuarioCriado = criarUsuario(novoUsuario); console.log('Usuário criado:', usuarioCriado); // Validando o usuário const erros = validarUsuario(usuarioCriado); if (erros.length > 0) { console.log('Erros de validação:', erros); } else { console.log('Usuário válido!'); } // Atualizando o usuário const usuarioAtualizado = atualizarUsuario(usuarioCriado, { nome: 'João Pedro Silva', ativo: false }); console.log('Usuário atualizado:', usuarioAtualizado); // Usando a classe const usuarioClasse = new UsuarioImplementado( 1, 'Maria Santos', 'maria@email.com', new Date('1985-08-20'), true ); console.log('Idade:', usuarioClasse.calcularIdade()); console.log('Email válido:', usuarioClasse.validarEmail()); ``` ## 7. Restrições com Generics ```typescript // Interface genérica para repositório de usuários interface RepositorioUsuario<T extends Usuario> { salvar(usuario: T): void; buscarPorId(id: number): T | undefined; listarTodos(): T[]; deletar(id: number): boolean; } // Implementação do repositório class UsuarioRepositorio implements RepositorioUsuario<Usuario> { private usuarios: Usuario[] = []; salvar(usuario: Usuario): void { const index = this.usuarios.findIndex(u => u.id === usuario.id); if (index !== -1) { this.usuarios[index] = usuario; } else { this.usuarios.push(usuario); } } buscarPorId(id: number): Usuario | undefined { return this.usuarios.find(usuario => usuario.id === id); } listarTodos(): Usuario[] { return [...this.usuarios]; } deletar(id: number): boolean { const index = this.usuarios.findIndex(usuario => usuario.id === id); if (index !== -1) { this.usuarios.splice(index, 1); return true; } return false; } } ``` ## Principais Vantagens das Interfaces: 1. **Type Safety**: O TypeScript verifica em tempo de compilação 2. **Autocompletar**: IDEs fornecem sugestões automáticas 3. **Refatoração Segura**: Mudanças são detectadas em todos os usos 4. **Documentação**: As interfaces servem como documentação do código 5. **Contratos Claros**: Define expectativas claras para objetos Essas interfaces fornecem restrições rígidas que ajudam a prevenir erros e garantem que seus objetos de usuário sempre tenham a estrutura esperada!