Programação defensiva e verificações de entrada
Escreva pequenas verificações de entrada, use cláusulas de guarda, análise segura, valores padrão e validação simples de objetos para evitar falhas logo no início
Programação defensiva e verificações de entrada é uma aula grátis de JavaScript Academy no CoddyKit. Esta é a aula 2 de 2. 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 JavaScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de JavaScript Academy inclui 2 aulas no total.
Introdução às verificações defensivas
Objetivo: Interrompa entradas inválidas antecipadamente para que os erros não se espalhem.
- Verificações de tipo e intervalo
- Cláusulas de proteção
- Análise segura
- Valores padrão e validação simples de objetos
Auxiliares de tipo
Crie auxiliares pequenos para reutilizar verificações como número e cadeia não vazia.
// Tiny type helpers
function isNumber(n) {
return typeof n === "number" && Number.isFinite(n);
}
function isNonEmptyString(s) {
return typeof s === "string" && s.trim().length > 0;
}
console.log("isNumber(3):", isNumber(3));
console.log("isNumber(NaN):", isNumber(NaN));
console.log("isNonEmptyString(\"\"):", isNonEmptyString(""));
console.log("isNonEmptyString(\"hi\"):", isNonEmptyString("hi"));
Demonstração de cláusula de proteção
Verifique as entradas primeiro; interrompa antecipadamente em caso de erros para manter o caminho principal limpo.
// Guard clauses: return early if invalid
function buy(quantity) {
if (!isNumber(quantity)) {
console.log("Quantity must be a number");
return;
}
if (quantity <= 0) {
console.log("Quantity must be > 0");
return;
}
console.log("Buying", quantity, "items");
}
buy(3);
buy("3");
buy(0);
Análise com alternativa
Valide os resultados analisados. Se a análise falhar, retorne uma pequena alternativa em vez de causar uma falha.
// Parse safely and use sensible defaults
function toInt(str, fallback = 0) {
const n = parseInt(str, 10);
if (!Number.isFinite(n)) {
return fallback;
}
return n;
}
console.log("toInt(\"42\"):", toInt("42"));
console.log("toInt(\"7px\", -1):", toInt("7px", -1));
console.log("toInt(\"abc\", 0):", toInt("abc", 0));
Valores padrão e intervalos
Use ?? para valores padrão nulos ou indefinidos e, em seguida, limite o valor a um intervalo seguro.
// Defaults with ?? and simple range checks
function clampPercent(value) {
// Use 0 as default when value is null or undefined
const v = (value ?? 0);
if (!isNumber(v)) {
return 0;
}
// Clamp into 0..100
const clamped = Math.min(100, Math.max(0, v));
return clamped;
}
console.log(clampPercent(undefined));
console.log(clampPercent(120));
console.log(clampPercent(-5));
console.log(clampPercent(55));
Verificação da estrutura do objeto
Verifique os campos obrigatórios e os intervalos simples; retorne um pequeno objeto de resultado como { ok, motivo }.
// Simple object validation
function validateUser(u) {
if (u == null || typeof u !== "object") {
return { ok: false, reason: "User must be an object" };
}
if (!isNonEmptyString(u.name)) {
return { ok: false, reason: "name required" };
}
if (!isNumber(u.age) || u.age < 0) {
return { ok: false, reason: "age must be a number >= 0" };
}
return { ok: true };
}
console.log("good:", validateUser({ name: "Ayla", age: 21 }));
console.log("bad:", validateUser({ name: "", age: -1 }));
Questionário sobre verificações defensivas
Verificação rápida: tratamento defensivo de entradas.
Recapitulação
Recapitulação: Use auxiliares de tipo pequenos, cláusulas de proteção, análise segura com alternativas, valores padrão para nulos, limites de intervalo e validação simples de objetos para interromper erros antecipadamente.
Perguntas Frequentes
A aula “Programação defensiva e verificações de entrada” é grátis?
Sim — o texto completo de “Programação defensiva e verificações de entrada” é 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 JavaScript Academy, atualize para CoddyKit PRO. O curso de JavaScript Academy inclui 2 aulas no total.
O que vou aprender em “Programação defensiva e verificações de entrada”?
Escreva pequenas verificações de entrada, use cláusulas de guarda, análise segura, valores padrão e validação simples de objetos para evitar falhas logo no início Você pratica JavaScript 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 JavaScript Academy?
Nenhuma experiência prévia é necessária. JavaScript 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 2 de 2.
Quanto tempo leva a aula “Programação defensiva e verificações de entrada”?
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 JavaScript Academy?
Sim. Cada aula de JavaScript 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
- try/catch/finally, throw e erros personalizados
- Programação defensiva e verificações de entrada