Regra
Manusear erros em catch blocos. 
Vazio catch vazios silenciosamente engolir erros, 
tornando a depuração difícil. 
Linguagens suportadas: Java, C, C++, PHP, JavaScript, 
TypeScript, Go, Python

Introdução

Blocos `catch` vazios são um dos anti-padrões mais perigosos em código de produção. Quando exceções são capturadas, mas não tratadas, o erro desaparece sem deixar rastros. A aplicação continua executando com estado corrompido, dados inválidos ou operações falhas que deveriam ter interrompido a execução. Usuários veem falhas silenciosas onde funcionalidades não operam, mas não recebem mensagens de erro. Equipes de operações não têm logs para depurar. A única indicação de que algo está errado surge horas ou dias depois, quando falhas em cascata tornam o sistema inutilizável.

Por que isso importa

Depuração e resposta a incidentes: Blocos `catch` vazios eliminam logs de erro. Engenheiros não têm rastreamento de pilha, mensagem de erro ou indicação de quando ou onde a falha ocorreu, tornando os problemas quase impossíveis de reproduzir.

Corrupção silenciosa de dados: Quando operações de banco de dados ou chamadas de API falham dentro de blocos `catch` vazios, a aplicação continua como se tivessem sido bem-sucedidas. Registros são parcialmente atualizados, transações ficam incompletas e, quando a corrupção é descoberta, o rastro de auditoria já desapareceu.

Vulnerabilidades de segurança: Blocos catch vazios mascaram falhas de segurança como erros de autenticação ou verificações de autorização. Um atacante que aciona uma exceção em um caminho crítico de segurança pode ignorar as proteções completamente se o erro for silenciosamente suprimido.

Falhas em cascata: Quando os erros são suprimidos, a aplicação continua em um estado inválido. Operações subsequentes que dependem do resultado da operação falha também falharão, criando uma cadeia de falhas que desvia os engenheiros da causa raiz real.

Exemplos de código

❌ Não-conforme:

async function updateUserProfile(userId, profileData) {
    try {
        await db.users.update(userId, profileData);
        await cache.invalidate(`user:${userId}`);
        await searchIndex.update(userId, profileData);
    } catch (error) {
        // TODO: handle error
    }

    return { success: true };
}

Por que está errado: Se qualquer operação falhar, o erro é silenciosamente ignorado e a função retorna sucesso. O banco de dados pode ser atualizado, mas a invalidação do cache pode falhar, deixando dados desatualizados. Ou a atualização do índice de busca falha, tornando o usuário inlocalizável, sem nenhum log ou alerta para indicar o problema.

✅ Compatível:

async function updateUserProfile(userId, profileData) {
    try {
        await db.users.update(userId, profileData);
        await cache.invalidate(`user:${userId}`);
        await searchIndex.update(userId, profileData);
        return { success: true };
    } catch (error) {
        logger.error('Failed to update user profile', {
            userId,
            error: error.message,
            stack: error.stack
        });
        throw new ProfileUpdateError(
            'Unable to update profile',
            { cause: error }
        );
    }
}

Por que isso importa: Cada erro é registrado com contexto, fornecendo informações para depuração. O erro se propaga para o chamador, permitindo o tratamento adequado de erros no nível apropriado. Sistemas de monitoramento podem alertar sobre esses erros, e a aplicação falha rapidamente em vez de continuar com um estado inválido.

Conclusão

Blocos `catch` vazios nunca são aceitáveis em código de produção. Toda exceção capturada precisa, no mínimo, ser logada, e a maioria precisa ser propagada para os chamadores ou acionar ações de recuperação específicas. Se você realmente precisar ignorar um erro, documente o motivo com um comentário explicando a justificativa de negócio. O padrão deve ser sempre tratar os erros explicitamente, e não descartá-los silenciosamente.