Segredos e Segurança de Tipos
Trate valores sensíveis sem expô-los nos tipos.
Segredos e Segurança de Tipos é uma aula grátis de TypeScript 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 TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 4 aulas no total.
Segredos exigem atenção especial
Chaves de API, senhas e tokens também são configurações, mas expô-los em registros ou mensagens de erro é perigoso. A segurança de tipos pode ajudar a impedir que valores secretos sejam expostos acidentalmente.
O problema do registro acidental
Um segredo representado por um texto comum pode ser registrado acidentalmente em qualquer lugar, por exemplo por meio de console.log(config) ou de um despejo de erro que serialize todo o objeto de configuração.
const config = { dbPassword: "hunter2" };
console.log(config); // leaks the passwordTipos Secret marcados
Um tipo marcado identifica um texto como secreto em tempo de compilação, permitindo que o sistema de tipos diferencie um Secret de um texto comum e exija um tratamento deliberado.
type Secret = string & { readonly __brand: "Secret" };
function secret(s: string): Secret { return s as Secret; }Por que marcar ajuda
Como um Secret não pode ser atribuído a um string comum sem uma intenção explícita, as funções podem exigir um Secret quando apropriado, e você não pode passá-lo por engano a um local inseguro.
function connect(pw: Secret) { /* uses pw */ }
// connect("plain") -> type error; must wrap with secret()Uma classe invólucro para segredos
Uma alternativa envolve o valor em uma classe cujo toString e cuja serialização são redigidos, de modo que até mesmo um registro descuidado mostre um marcador.
class Secret {
constructor(private readonly value: string) {}
expose(): string { return this.value; }
toString() { return "[REDACTED]"; }
}Redigindo durante a serialização
Personalizar toJSON garante que o segredo nunca apareça quando um objeto for serializado com JSON.stringify, o caminho mais comum para vazamentos acidentais.
class Secret {
constructor(private readonly value: string) {}
expose() { return this.value; }
toJSON() { return "[REDACTED]"; }
}
// JSON.stringify({ pw: new Secret("x") }) -> {"pw":"[REDACTED]"}Exposição somente explícita
O valor real só pode ser acessado por meio de um método explícito, como expose(). Isso torna visível e auditável no código cada ponto que lê um segredo.
const pw = new Secret("hunter2");
console.log(String(pw)); // [REDACTED]
connectToDb(pw.expose()); // deliberate accessMantenha segredos fora de tipos abrangentes
Evite colocar textos secretos brutos em interfaces de configuração abrangentes que sejam registradas por inteiro. Use o tipo Secret para que eles sejam redigidos por padrão sempre que a configuração for impressa.
interface Config {
host: string;
dbPassword: Secret; // not a plain string
}Carregando segredos com segurança
Envolva os valores secretos de env ao lê-los, para que sejam marcados ou encapsulados desde o primeiro momento e nunca circulem como textos comuns.
const config = {
host: process.env.DB_HOST!,
dbPassword: new Secret(process.env.DB_PASSWORD!),
};Defesa em profundidade
Segredos no nível de tipos reduzem vazamentos acidentais, mas não substituem boas práticas operacionais: restrinja quem pode ler env, evite registrar corpos de solicitações e limpe os dados enviados aos sistemas de relatório de erros.
Resumo das técnicas
Use tipos com marca para exigir um tratamento deliberado, uma classe de encapsulamento com toString/toJSON que oculte dados e uma chamada explícita a expose() para ler o valor, mantendo segredos fora dos registros e da saída serializada.
Verificação rápida
Faça uma verificação rápida desta lição.
Recapitulação
Proteja segredos com tipos com marca (que exigem um tratamento deliberado) ou com uma classe de encapsulamento cujo toString/toJSON retorne [REDACTED], expondo o valor real somente por meio de uma chamada explícita a expose(). Isso mantém os segredos fora dos registros e da configuração serializada.
Aprenda TypeScript com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 101
- Aulas
- 352
Perguntas Frequentes
A aula “Segredos e Segurança de Tipos” é grátis?
Sim — o texto completo de “Segredos e Segurança de Tipos” é 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 TypeScript Academy, atualize para CoddyKit PRO. O curso de TypeScript Academy inclui 4 aulas no total.
O que vou aprender em “Segredos e Segurança de Tipos”?
Trate valores sensíveis sem expô-los nos tipos. Você pratica TypeScript 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 TypeScript Academy?
Nenhuma experiência prévia é necessária. TypeScript 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 “Segredos e Segurança de Tipos”?
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 TypeScript Academy?
Sim. Cada aula de TypeScript 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
- Definindo Tipos de Variáveis de Ambiente
- Configuração Validada por Esquema
- Camadas e Valores Padrão de Configuração
- Segredos e Segurança de Tipos