Aikido

Perché dovresti rimuovere il codice commentato dal tuo codice sorgente

Leggibilità

Regola
Rimuovi commentato codice blocchi

Codice codice genera rumore, diventa obsoleto, 
e fa parte nella versione di , non il codice sorgente.

Introduzione

Il codice commentato si accumula quando gli sviluppatori non sono sicuri se in futuro avranno bisogno della vecchia logica. Qualcuno commenta una funzione “per ogni evenienza” invece di eliminarla, e questa rimane lì per sempre. Nessuno sa se quel codice funzioni ancora, perché sia stato disabilitato o se sia sicuro rimuoverlo. Il codice si riempie di fantasmi di implementazioni passate che ostacolano la comprensione di ciò che effettivamente viene eseguito in produzione.

Perché è importante

Manutenibilità del codice: il codice commentato costringe i lettori a distinguere mentalmente ciò che è attivo da ciò che è inattivo. Durante la revisione del codice, non è possibile capire se questi blocchi siano esperimenti temporanei, importanti opzioni di rollback o residui dimenticati risalenti a anni fa. Questo “rumore” rende più difficile comprendere la logica effettiva, individuare le sezioni di codice rilevanti e revisionare le modifiche in modo significativo.

Implicazioni per la sicurezza: i controlli di autenticazione, la logica di convalida o le funzionalità di sicurezza commentati rivelano che tali protezioni esistevano ma sono state deliberatamente disabilitate. Se il codice commentato contiene credenziali, chiavi API o URL interni, stai trasmettendo tali dati sensibili in chiaro. Gli aggressori che esaminano il tuo codice possono vedere esattamente quali misure di sicurezza hai preso in considerazione e poi rimosso.

Confusione nel controllo di versione: i diff di Git si riempiono di blocchi commentati che in realtà non subiscono alcuna modifica. Quando è necessario risalire a quando la logica è cambiata o capire perché una funzionalità funziona in un certo modo, le alternative commentate oscurano la cronologia reale. La ricerca nel codice restituisce risultati nel codice inattivo, facendo perdere tempo a indagare su percorsi che non vengono eseguiti.

Esempi di codice

❌ Non conforme:

async function createUser(userData) {
    // const hashedPassword = await bcrypt.hash(userData.password, 10);

    const user = await db.users.create({
        email: userData.email,
        password: userData.password,
        // password: hashedPassword,
        role: userData.role || 'user'
    });

    // await sendWelcomeEmail(user.email);
    // await notifyAdmins(user);

    // Old validation approach
    // if (!isValidEmail(user.email)) {
    //     throw new Error('Invalid email');
    // }

    return user;
}

Perché è sbagliato: il codice relativo all'hashing delle password, che è stato commentato, rivela che le password sono memorizzate in chiaro, il che costituisce una grave vulnerabilità di sicurezza. Non è chiaro se l'email di benvenuto e la notifica all'amministratore debbano essere abilitate, e la vecchia procedura di convalida suggerisce che potrebbe mancare la convalida dell'indirizzo email.

✅ Conforme:

async function createUser(userData) {
    if (!isValidEmail(userData.email)) {
        throw new Error('Invalid email');
    }

    const hashedPassword = await bcrypt.hash(userData.password, 10);

    const user = await db.users.create({
        email: userData.email,
        password: hashedPassword,
        role: userData.role || 'user'
    });

    await sendWelcomeEmail(user.email);
    await notifyAdmins(user);

    return user;
}

Perché è importante: la funzione è chiara ed esaustiva e mostra esattamente cosa viene eseguito in produzione. La convalida dell'indirizzo e-mail viene eseguita per prima, le password vengono sottoposte a hash in modo corretto e tutte le notifiche vengono inviate senza alcuna ambiguità riguardo alle funzionalità attivate.

Conclusione

Elimina il codice invece di commentarlo. Il tuo sistema di controllo delle versioni conserva ogni riga mai scritta, accessibile tramite git log e git blame quando ne hai bisogno. Mantenere il codice commentato nel repository non fa altro che creare confusione, oscurando la logica effettiva e rendendo più difficile orientarsi nel codice.

Domande frequenti

Hai delle domande?

E se avessi bisogno della vecchia implementazione per un rollback?

Utilizza i feature flag o i rami del controllo di versione, non i commenti. Se dovessi tornare alla logica precedente, implementala tramite un feature flag che puoi attivare o disattivare. Per le modifiche permanenti, elimina il codice precedente e affidati alla cronologia di Git. Puoi sempre recuperare il codice eliminato con `git log -p` o `git show` quando necessario.

Come devo gestire il codice sperimentale durante lo sviluppo?

Conserva gli esperimenti in rami separati oppure utilizzi dei flag di funzionalità. Se stai testando due approcci, crea un ramo per ciascuno oppure usa un flag di configurazione per passare da uno all'altro. Il codice commentato nei rami principali suggerisce che non sei sicuro di cosa debba essere messo in produzione, il che è un problema di pianificazione, non un problema di controllo delle versioni.

E che ne dici di disabilitare temporaneamente il codice durante il debug?

Va bene per le sessioni di debug locali, ma non eseguire mai il commit. Usa `git add -p` per controllare ed escludere il codice di debug commentato prima di eseguire il commit. Se devi disabilitare temporaneamente del codice a livello di team, usa i feature flag o le impostazioni di configurazione invece dei commenti.

Devo rimuovere anche le note esplicative commentate?

No, questa regola riguarda i blocchi di codice commentati, non i commenti di documentazione. I commenti esplicativi che descrivono il perché o il come di un funzionamento sono preziosi. Il problema sono i blocchi di codice eseguibile commentati che potrebbero non essere più rilevanti.

E se il codice commentato documentasse vecchi approcci di implementazione?

Documenta l'approccio in un commento che lo descriva, senza conservare codice inattivo. Scrivi "in precedenza si utilizzava l'approccio X, poi si è passati a Y perché Z" invece di mantenere entrambe le implementazioni commentate. Il contesto storico va riportato nei messaggi di commit e nei documenti di progettazione, non in blocchi di codice inattivi.

Metti in sicurezza ora

Metti in sicurezza il tuo codice, il cloud e il runtime in un unico sistema centralizzato.
Trova e risolvi le vulnerabilità rapidamente e automaticamente.

Nessuna carta di credito richiesta | Risultati della scansione in 32 secondi.